@xpell/core 2.0.0-alpha.10

package/dist/xpell-core.es.js

@@ -0,0 +1,1428 @@
+class X {
+  /**
+   * Create ignore list for parser to ignore spell words
+   * @param list - comma-separated list of words
+   * @param reservedWords - base reserved words map (mutated)
+   */
+  createIgnoreList(t, e) {
+    if (!t) return e;
+    const s = t.split(",").map((i) => i.trim()).filter(Boolean);
+    for (const i of s) e[i] = "";
+    return e;
+  }
+  /**
+   * GUID / UUID v4 (cross-platform)
+   *
+   * Preference order:
+   * 1) globalThis.crypto.randomUUID()
+   * 2) globalThis.crypto.getRandomValues() (RFC4122 v4)
+   * 3) Math.random() fallback (NOT crypto-secure, legacy fallback only)
+   */
+  guid() {
+    const e = globalThis.crypto;
+    if (e && typeof e.randomUUID == "function")
+      return e.randomUUID();
+    if (e && typeof e.getRandomValues == "function") {
+      const r = new Uint8Array(16);
+      e.getRandomValues(r), r[6] = r[6] & 15 | 64, r[8] = r[8] & 63 | 128;
+      const a = Array.from(r, (c) => c.toString(16).padStart(2, "0"));
+      return a.slice(0, 4).join("") + "-" + a.slice(4, 6).join("") + "-" + a.slice(6, 8).join("") + "-" + a.slice(8, 10).join("") + "-" + a.slice(10, 16).join("");
+    }
+    const s = "0123456789abcdef".split(""), i = [];
+    let n;
+    i[8] = i[13] = i[18] = i[23] = "-", i[14] = "4";
+    for (let r = 0; r < 36; r++)
+      i[r] || (n = (0 | Math.random() * 16) >>> 0, i[r] = s[r === 19 ? n & 3 | 8 : n & 15]);
+    return i.join("");
+  }
+  /**
+   * Merge defaults into data object (mutates data)
+   * @param data - target data
+   * @param defaults - defaults object
+   * @param force - overwrite existing values
+   */
+  mergeDefaultsWithData(t, e, s = !1) {
+    if (!t) return e;
+    t._id || (t._id = t.id ?? this.guid());
+    for (const i of Object.keys(e))
+      (!(i in t) || s) && (t[i] = e[i]);
+    return t;
+  }
+  /**
+   * Encode string to Base64 (UTF-8 safe, cross-platform)
+   */
+  encode(t) {
+    const e = globalThis;
+    if (typeof e.btoa == "function") {
+      const s = encodeURIComponent(String(t)).replace(
+        /%([0-9A-F]{2})/g,
+        (i, n) => String.fromCharCode(parseInt(n, 16))
+      );
+      return e.btoa(s);
+    }
+    if (e.Buffer && typeof e.Buffer.from == "function")
+      return e.Buffer.from(String(t), "utf8").toString("base64");
+    throw new Error("Base64 encode not supported in this environment");
+  }
+  /**
+   * Decode Base64 string to UTF-8 (cross-platform)
+   */
+  decode(t) {
+    const e = globalThis;
+    if (typeof e.atob == "function") {
+      const s = e.atob(String(t)), i = Array.prototype.map.call(s, (n) => "%" + n.charCodeAt(0).toString(16).padStart(2, "0")).join("");
+      return decodeURIComponent(i);
+    }
+    if (e.Buffer && typeof e.Buffer.from == "function")
+      return e.Buffer.from(String(t), "base64").toString("utf8");
+    throw new Error("Base64 decode not supported in this environment");
+  }
+  /**
+   * Returns a random integer between min and max (inclusive)
+   * NOTE: Not cryptographically secure (OK for UI, NOT for IDs)
+   */
+  getRandomInt(t, e) {
+    return t = Math.ceil(t), e = Math.floor(e), Math.floor(Math.random() * (e - t + 1)) + t;
+  }
+  /**
+   * Extract parameter from XCommand
+   */
+  getParam(t, e, s = 0) {
+    return t?._params?.[e] ?? s;
+  }
+  /**
+   * Default frame scheduler (cross-platform)
+   * - Browser: requestAnimationFrame
+   * - Node / non-DOM: setImmediate (fast) or setTimeout (paced by target fps)
+   */
+  createDefaultScheduler(t) {
+    const e = globalThis;
+    if (typeof e.requestAnimationFrame == "function")
+      return (n) => e.requestAnimationFrame(n);
+    const s = typeof t == "number" && isFinite(t) && t > 0 ? t : 60;
+    if (typeof e.setImmediate == "function" && (!t || t >= 60))
+      return (n) => e.setImmediate(n);
+    const i = Math.max(1, Math.round(1e3 / s));
+    return (n) => e.setTimeout(n, i);
+  }
+}
+const p = new X();
+class k {
+  #t = 0;
+  // displayed fps (stable)
+  #e = 0;
+  // EMA of ms/frame
+  #s = 0;
+  #i;
+  // weight of new samples (0..1)
+  #n;
+  // minimum integer change to update displayed fps
+  constructor(t = 0.05, e = 1) {
+    const s = Number(t);
+    this.#i = Number.isFinite(s) ? Math.min(1, Math.max(1e-3, s)) : 0.05;
+    const i = Number(e);
+    this.#n = Number.isFinite(i) ? Math.max(0, Math.floor(i)) : 1;
+  }
+  now() {
+    const t = globalThis.performance;
+    return t && typeof t.now == "function" ? t.now() : Date.now();
+  }
+  calc() {
+    const t = this.now();
+    if (this.#s === 0)
+      return this.#s = t, this.#t;
+    const e = t - this.#s;
+    if (this.#s = t, !Number.isFinite(e) || e <= 0) return this.#t;
+    this.#e === 0 ? this.#e = e : this.#e = (1 - this.#i) * this.#e + this.#i * e;
+    const s = 1e3 / this.#e;
+    if (!Number.isFinite(s) || s <= 0) return this.#t;
+    const i = Math.round(s);
+    return this.#t !== 0 && this.#n > 0 && Math.abs(i - this.#t) < this.#n ? this.#t : (this.#t = i, this.#t);
+  }
+  reset() {
+    this.#t = 0, this.#e = 0, this.#s = 0;
+  }
+}
+class F {
+  constructor(t) {
+    this._enabled = !0, this._show_date = !1, this._show_time = !0, this._debug = !1, t && this.configure(t);
+  }
+  configure(t) {
+    typeof t._enabled == "boolean" && (this._enabled = t._enabled), typeof t._show_date == "boolean" && (this._show_date = t._show_date), typeof t._show_time == "boolean" && (this._show_time = t._show_time), typeof t._debug == "boolean" && (this._debug = t._debug);
+  }
+  _dt() {
+    const t = /* @__PURE__ */ new Date(), e = this._show_date ? `${t.getDate()}.${t.getMonth()}.${t.getFullYear()} ` : "", s = this._show_time ? `${t.getHours()}:${t.getMinutes()}:${t.getSeconds()}.${t.getMilliseconds()}|` : "";
+    return e + s;
+  }
+  log(t, ...e) {
+    this._enabled && console.log(this._dt(), t, ...e);
+  }
+  warn(t, ...e) {
+    this._enabled && console.warn(this._dt(), t, ...e);
+  }
+  error(t, ...e) {
+    this._enabled && console.error(this._dt(), t, ...e);
+  }
+  debug(t, ...e) {
+    !this._enabled || !this._debug || console.debug(this._dt(), t, ...e);
+  }
+}
+const _ = new F(), x = typeof process < "u" && !!process?.env && process.env.NODE_ENV === "production";
+x || console.info(
+  "[Xpell] _xlog is redirected to console in development mode. Tip: enable 'Show timestamps' in DevTools → Console for timed logs."
+);
+const y = x ? _ : console;
+class S {
+  constructor() {
+    this._objects = {}, this._listeners = /* @__PURE__ */ new Map(), this._any_listeners = /* @__PURE__ */ new Set(), this._compat_writes = !0, this._warn_legacy_writes = !0, this._verbose = !1, this._compat_legacy_keys = !0, this._o_proxy = null, this._objects = {};
+  }
+  /**
+   * Shared memory view.
+   * Reads are always supported.
+   * Writes are supported in compat mode (optional) and should be migrated to set()/delete()/touch().
+   */
+  get _o() {
+    return !this._compat_writes && !this._warn_legacy_writes ? this._objects : (this._o_proxy || (this._o_proxy = new Proxy(this._objects, {
+      set: (t, e, s) => {
+        const i = String(e);
+        return this._warn_legacy_writes && console.warn(
+          `[XData] Legacy write: _o["${i}"] = ... ; prefer XData.set("${i}", value).`
+        ), this._compat_writes ? this.set(i, s, { source: "legacy:_o" }) : t[i] = s, !0;
+      },
+      deleteProperty: (t, e) => {
+        const s = String(e);
+        return this._warn_legacy_writes && console.warn(
+          `[XData] Legacy delete: delete _o["${s}"] ; prefer XData.delete("${s}").`
+        ), this._compat_writes ? this.delete(s, { source: "legacy:_o" }) : delete t[s], !0;
+      }
+    })), this._o_proxy);
+  }
+  /** Preferred read API */
+  get(t) {
+    return this._objects[t];
+  }
+  /** Preferred write API */
+  set(t, e, s) {
+    const i = this._objects[t];
+    this._objects[t] = e, this._emit({ key: t, value: e, prev: i, ts: Date.now(), op: "set", meta: s });
+  }
+  /** Shallow merge helper (nice for state objects) */
+  patch(t, e, s) {
+    const i = this._objects[t], r = { ...i && typeof i == "object" ? i : {}, ...e };
+    this._objects[t] = r, this._emit({ key: t, value: r, prev: i, ts: Date.now(), op: "patch", meta: s });
+  }
+  /** In-place mutation notifier */
+  touch(t, e) {
+    const s = this._objects[t];
+    this._emit({ key: t, value: s, prev: s, ts: Date.now(), op: "touch", meta: e });
+  }
+  has(t) {
+    return Object.prototype.hasOwnProperty.call(this._objects, t);
+  }
+  delete(t, e) {
+    const s = this._objects[t];
+    delete this._objects[t], this._emit({ key: t, value: void 0, prev: s, ts: Date.now(), op: "delete", meta: e });
+  }
+  pick(t, e) {
+    const s = this._objects[t];
+    return this.delete(t, e), s;
+  }
+  clean() {
+    this._objects = {};
+  }
+  // ----------------------------
+  // Subscriptions
+  // ----------------------------
+  on(t, e) {
+    let s = this._listeners.get(t);
+    return s || this._listeners.set(t, s = /* @__PURE__ */ new Set()), s.add(e), () => this.off(t, e);
+  }
+  off(t, e) {
+    const s = this._listeners.get(t);
+    s && (s.delete(e), s.size === 0 && this._listeners.delete(t));
+  }
+  onAny(t) {
+    return this._any_listeners.add(t), () => this._any_listeners.delete(t);
+  }
+  // ----------------------------
+  // Emit
+  // ----------------------------
+  _emit(t) {
+    this._verbose && t.meta?.trace && (t.stack = new Error().stack);
+    const e = this._listeners.get(t.key);
+    if (e) for (const s of e) s(t);
+    for (const s of this._any_listeners) s(t);
+  }
+}
+const u = new S();
+class M {
+  constructor(t) {
+    t && Object.keys(t).forEach((e) => {
+      this[e] = t[e];
+    }), this.d || (this.d = Date.now());
+  }
+  /**
+   * Gets th parameter value from the XCommand whether it has a name or just a position
+   * There are 2 ways to send XCommand with parameters: 
+   *  1. <module> <op> <param-0> <param-1> <param-2>     // position is for this case
+   *  2. <module> <op> param-name:param-value            // name is for this case
+   * @param position the position of the parameter if no name is send 
+   * @param name the name of the parameter 
+   * @param defaultValue the default value if none above exists
+   * @returns {any} the actual parameter value
+   */
+  getParam(t, e, s) {
+    return this._params?.hasOwnProperty(e) ? this._params[e] : this._params?.hasOwnProperty(t) ? this._params[t] : s;
+  }
+}
+const w = {
+  type: "_type",
+  children: "_children"
+}, f = class f {
+  /**
+   * Adds HTML-Xpell Mapping item
+   * @param htmlElement HTML element to change from
+   * @param xpellElement Xpell element to change to 
+   */
+  static addHtml2XpellMapItem(t, e) {
+    f.html2XMap.elements[t] = e;
+  }
+  /**
+   * convert text command to Xpell json command
+   * @param {string} txt 
+   */
+  static parse(t, e) {
+    const s = t.split(" ");
+    let i = new M();
+    if (e ? (i._module = e, i._op = s[0]) : (i._module = s[0], i._op = s[1]), i._params = {}, s.length > 1)
+      for (let n = 2; n < s.length; ++n) {
+        const r = s[n];
+        if (r.indexOf(":") > -1) {
+          const c = r.split(":");
+          i._params[c[0]] = c[1];
+        } else
+          i._params[n - 1] = s[n];
+      }
+    return i;
+  }
+  static replaceSpacesInQuotes(t, e = "_%20_") {
+    return t.replace(/(['"])(.*?)\1/g, (s, i, n) => {
+      const r = String(n).replace(/\s/g, e);
+      return `${i}${r}${i}`;
+    });
+  }
+  static parseObjectCommand(t, e) {
+    t = f.replaceSpacesInQuotes(t);
+    const s = t.trim().split(/\s+/), i = e || s.shift();
+    if (!i) throw new Error("Missing module name");
+    let n;
+    if (s[0]?.startsWith("#") && (n = s.shift().slice(1), !n))
+      throw new Error("Invalid object selector '#'. Use '#<id>'");
+    const r = s.shift();
+    if (!r) throw new Error("Missing operation");
+    const a = {};
+    let c = null, h = null;
+    if (s.forEach((l) => {
+      if (h) {
+        if (h += ` ${l}`, l.endsWith(h[0])) {
+          const m = h.slice(1, -1).replace(/_%20_/g, " ");
+          a[c] = m, h = null;
+        }
+        return;
+      }
+      if (l.startsWith('"') || l.startsWith("'")) {
+        if (h = l, l.endsWith(l[0]) && l.length > 1) {
+          const m = l.slice(1, -1).replace(/_%20_/g, " ");
+          a[c] = m, h = null;
+        }
+        return;
+      }
+      if (l.includes(":")) {
+        const m = l.split(":"), D = m[0], E = m.slice(1).join(":").replace(/_%20_/g, " ");
+        a[D] = E, c = null;
+        return;
+      }
+      c = l.replace(/_%20_/g, " ");
+    }), h) throw new Error("Unclosed quoted parameter value");
+    return {
+      _module: i,
+      _object: n,
+      _op: r,
+      _params: a
+    };
+  }
+  /**
+   * Converts XML/HTML string to XCommand
+   * @param xmlString XML string
+   * @returns 
+   */
+  static xmlString2Xpell(t) {
+    const s = new DOMParser().parseFromString(t, "text/xml");
+    return s.childNodes.length > 0 ? f.xml2Xpell(s.childNodes[0]) : {};
+  }
+  /**
+   * Converts XML/HTML Document to Xpell JSON
+   * @param xmlNode XML Document Node
+   * @param forceXhtml force Xpell XHTML for every unknown object
+   * @returns {} Xpell JSON
+   */
+  static xml2Xpell(t, e) {
+    const s = f.html2XMap;
+    let i = {};
+    i._children = [];
+    const n = t.nodeName, r = t.nodeName;
+    let a = e;
+    if (e ? (i[w.type] = "xhtml", i._html_ns = "http://www.w3.org/2000/svg") : i._type = s.elements[n] ? s.elements[n] : n, t.attributes)
+      for (let c = 0; c < t.attributes.length; ++c) {
+        const h = t.attributes[c], l = s.attributes[h.name] ? s.attributes[h.name] : h.name;
+        i[l] = h.value;
+      }
+    if (t?.firstChild?.nodeValue && (i.text = t?.firstChild.nodeValue.trim()), i[w.type] == "xhtml" ? i._html_tag = r : i[w.type] == "svg" && (a = !0, i._html_ns = "http://www.w3.org/2000/svg"), t?.childNodes.length > 0)
+      for (let c = 0; c < t.childNodes.length; ++c) {
+        const h = t.childNodes[c];
+        h.nodeName.startsWith("#") || i[w.children].push(f.xml2Xpell(h, a));
+      }
+    return i;
+  }
+};
+f.html2XMap = {
+  elements: {
+    div: "view",
+    a: "link",
+    b: "xhtml",
+    h1: "xhtml",
+    h2: "xhtml",
+    h3: "xhtml",
+    h4: "xhtml",
+    h5: "xhtml",
+    p: "xhtml",
+    small: "xhtml",
+    aside: "xhtml",
+    span: "xhtml",
+    table: "xhtml",
+    th: "xhtml",
+    td: "xhtml",
+    tr: "xhtml",
+    thead: "xhtml",
+    tbody: "xhtml",
+    ul: "xhtml",
+    li: "xhtml",
+    ol: "xhtml",
+    canvas: "xhtml",
+    img: "image"
+  },
+  attributes: {
+    id: "_id"
+  }
+};
+let g = f;
+class I {
+  constructor() {
+    this._log_rules = {
+      register: !1,
+      remove: !1,
+      fire: !1
+    }, this._events = {}, this._listener_index = {};
+  }
+  /**
+   * Register a listener on an event name (runtime bus only).
+   *
+   * Backward compatible:
+   * - Canonical: on(name, cb, { _once, _owner, _tag })
+   * - Legacy:   on(name, cb, { _once }, owner)
+   */
+  on(t, e, s = {}, i) {
+    this._events[t] || (this._events[t] = []);
+    const n = s?._owner ?? i, r = p.guid(), a = {
+      _id: r,
+      _callback: e,
+      _options: s,
+      _owner: n,
+      _tag: s?._tag
+    };
+    return this._events[t].push(a), this._listener_index[r] = t, this._log_rules.register && y.log("XEM Register", t, r), r;
+  }
+  /**
+   * Register a listener that will be removed after first fire.
+   */
+  once(t, e, s) {
+    return this.on(t, e, { _once: !0, _owner: s });
+  }
+  /**
+   * Fire an event with optional payload.
+   */
+  async fire(t, e) {
+    const s = this._events[t];
+    if (!s || s.length === 0) return;
+    this._log_rules.fire && y.log("XEM Fire", t, e);
+    const i = s.slice(), n = [];
+    for (const r of i) {
+      try {
+        r && r._callback && r._callback(e);
+      } catch (a) {
+        y.error(a);
+      }
+      r?._options?._once && n.push(r._id);
+    }
+    for (const r of n) this.remove(r);
+  }
+  /**
+   * Remove a listener by id.
+   */
+  remove(t) {
+    const e = this._listener_index[t];
+    if (!e) return;
+    const s = this._events[e];
+    if (s && s.length) {
+      const i = s.findIndex((n) => n?._id === t);
+      i >= 0 && s.splice(i, 1), s.length === 0 && delete this._events[e];
+    }
+    delete this._listener_index[t], this._log_rules.remove && y.log("XEM Remove", e, t);
+  }
+  /**
+   * Remove all listeners for a given owner reference.
+   */
+  removeOwner(t) {
+    if (!t) return;
+    const e = [];
+    for (const s of Object.values(this._events))
+      for (const i of s)
+        (i?._owner ?? i?._options?._owner) === t && e.push(i._id);
+    e.forEach((s) => this.remove(s));
+  }
+  /**
+   * Clear the entire event bus (mostly for tests / hard reset).
+   */
+  clear() {
+    this._events = {}, this._listener_index = {};
+  }
+}
+const b = new I();
+class P {
+  #t;
+  #e;
+  #s;
+  constructor() {
+    this.#t = {}, this.#e = {}, this.#s = {};
+  }
+  get _objects() {
+    return this.#e;
+  }
+  /**
+   * Checks if an object is found in the object manager
+   * @param xObjectId 
+   * @returns 
+   */
+  hasObject(t) {
+    return this.#e.hasOwnProperty(t);
+  }
+  /**
+   * Register multiple classes dictionary into the object manager
+   * @param xObjects - key value list -> \{"view":XView,...\}
+   */
+  registerObjects(t) {
+    Object.keys(t).forEach((s) => this.registerObject(s, t[s]));
+  }
+  /**
+   * Registers single XObject
+   * @param name - name of the object
+   * @param xObjects The object class
+   */
+  registerObject(t, e) {
+    this.#t[t] = e;
+  }
+  /**
+   * Checks if a class (name) is found in the object manager classes dictionary
+   * @param name - class name
+   * @returns {boolean} 
+   */
+  hasObjectClass(t) {
+    return this.#t.hasOwnProperty(t);
+  }
+  /**
+   * Retrieves XObject class instance
+   * @param name class name
+   * @returns {XObject}
+   */
+  getObjectClass(t) {
+    return this.#t[t];
+  }
+  /**
+   * Retrieves all the classes dictionary
+   * @returns XObjectManagerIndex
+   */
+  getAllClasses() {
+    return this.#t;
+  }
+  get _classes() {
+    return this.#t;
+  }
+  /**
+   * Add XObject instance to the manager
+   * @param xObject XObject to maintain
+   */
+  addObject(t) {
+    t && t._id ? (this.#e[t._id] = t, (!t._name || t._name.length == 0) && (t._name = t._id), this.#s[t._name] = t._id) : _.log("unable to add object");
+  }
+  /**
+   * Remove XObject from the manager 
+   * @param xObjectId object id to remove
+   */
+  removeObject(t) {
+    const e = this.#e[t];
+    e && (delete this.#s[e?._name], delete this.#e[t]);
+  }
+  /**
+   * Retrieves XObject instance
+   * @param xObjectId XObject id 
+   * @returns {XObject}
+   */
+  getObject(t) {
+    return this.#e[t];
+  }
+  /**
+   * alias to getObject
+   * @param id 
+   * @returns 
+   */
+  go(t) {
+    return this.getObject(t);
+  }
+  /**
+   * Retrieves XObject instance
+   * @param objectName XObject name 
+   * @returns {XObject}
+   */
+  getObjectByName(t) {
+    return this.#s[t] ? this.getObject(this.#s[t]) : null;
+  }
+}
+const A = {
+  info: (o, t) => {
+    _.log("XObject id " + t?._id);
+  },
+  log: (o, t) => {
+    o._params && o._params[1] ? _.log(o._params[1]) : _.log(t);
+  },
+  fire: (o, t) => {
+    o._params && o._params[1] ? b.fire(o._params[1], o._params[2]) : o._params && o._params.event && b.fire(o._params.event, o._params.data);
+  }
+}, j = { _children: "child nodes" };
+class v {
+  /**
+   * XObject constructor is creating the object and adding all the data keys to the XObject instance
+   * @param data constructor input data (object)
+   * @param defaults - defaults to merge with data
+   * @param skipParse - skip data parsing 
+   * if override this method make sure to call super.init(data,skipParse) and to set skipParse to true
+   */
+  constructor(t, e, s) {
+    this._children = [], this._parent = null, this._on = {}, this._once = {}, this._process_frame = !0, this._process_data = !0, this._nano_commands = {}, this._event_listeners_ids = {}, this._event_parsed = !1, this._mounted = !1, this._xporter = {
+      _ignore_fields: [
+        "_to_xdata_ignore_fields",
+        "_xporter",
+        "_children",
+        "_on",
+        "_once",
+        "_on_create",
+        "_on_mount",
+        "_on_frame",
+        "_on_data",
+        "_process_frame",
+        "_process_data",
+        "_parent",
+        "_event_listeners_ids",
+        "_event_parsed",
+        "_mounted",
+        "_debug"
+      ],
+      _instance_xporters: {}
+    }, e && p.mergeDefaultsWithData(t, e), this._id = t && t._id ? t._id : "xo-" + p.guid(), this._type = "object", this._children = [], this._nano_commands = {}, this.addNanoCommandPack(A), t && t.hasOwnProperty("_nano_commands") && t._nano_commands && (this.addNanoCommandPack(t._nano_commands), delete t._nano_commands), this.addXporterDataIgnoreFields(["_nano_commands"]), this.addXporterInstanceXporter(v, (i) => i.toXData()), this._xem_options = {
+      // _instance:_xem
+      // _object: this
+      // _support_html: true
+    }, !s && t && this.parse(t, j);
+  }
+  log(t, ...e) {
+    this._debug && t && _.log(this._type + "->" + this._id + "]", t, ...e);
+  }
+  /**
+   * Initialize the XObject
+   * @param data - data to parse (XObjectData)
+   * @param skipParse - skip data parsing
+   * @deprecated - use parse method instead
+   */
+  init(t, e) {
+    !e && t && this.parse(t, j);
+  }
+  parseEvents(t) {
+    if (!this._event_parsed) {
+      t || (t = this._xem_options), Object.keys(this._on).forEach((s) => {
+        this.addEventListener(s, this._on[s], t);
+      });
+      const e = {};
+      Object.assign(e, t), e._once = !0, Object.keys(this._once).forEach((s) => {
+        this.addEventListener(s, this._once[s], e);
+      }), this._event_parsed = !0;
+    }
+  }
+  addEventListener(t, e, s) {
+    s || (s = this._xem_options);
+    let i;
+    if (typeof e == "function")
+      i = async (r) => {
+        e(this, r);
+      };
+    else if (typeof e == "string")
+      i = async (r) => {
+        const a = this._id + " " + e + " event-data='" + JSON.stringify(r).replace(/'/g, "\\'") + "'";
+        await this.run(a);
+      };
+    else
+      throw new Error("event handler must be a function");
+    const n = b.on(t, i, s, this);
+    this._event_listeners_ids[t] || (this._event_listeners_ids[t] = []), this._event_listeners_ids[t].push(n);
+  }
+  removeEventListener(t) {
+    const e = this._event_listeners_ids[t];
+    e && e.length && (e.forEach((s) => {
+      b.remove(s);
+    }), delete this._event_listeners_ids[t]);
+  }
+  removeAllEventListeners() {
+    Object.keys(this._event_listeners_ids).forEach((e) => this.removeEventListener(e));
+  }
+  /**
+   * Append a child XObject to this XObject
+   * @param xobject 
+   */
+  append(t) {
+    this._children?.push(t), t._parent = this;
+  }
+  /**
+   * Add single nano command to the object
+   * @param commandName - the nano command name
+   * @param nanoCommandFunction 
+   */
+  addNanoCommand(t, e) {
+    typeof e == "function" && (this._nano_commands[t] = e);
+  }
+  addNanoCommandPack(t) {
+    t && Object.keys(t).forEach((e) => {
+      this.addNanoCommand(e, t[e]);
+    });
+  }
+  /**
+   * List of fields to ignore when exporting the xobject to XData or string format
+   * @param <string[]> ignoreFields - an array with all the fields to ignore 
+   */
+  addXporterDataIgnoreFields(t) {
+    this._xporter._ignore_fields = this._xporter._ignore_fields.concat(t);
+  }
+  /**
+   * Add XData Xporter instance handler
+   * @param <XDataInstanceXporter> ie - the instance exporter object
+   */
+  addXporterInstanceXporter(t, e) {
+    const s = p.guid();
+    this._xporter._instance_xporters[s] = {
+      cls: t,
+      handler: e
+    };
+  }
+  /**
+   * Parse data to the XObject
+   * @param data data to parse
+   * @param ignore - lis of words to ignore in the parse process
+   */
+  parse(t, e = j) {
+    Object.keys(t).forEach((i) => {
+      !e.hasOwnProperty(i) && t.hasOwnProperty(i) && (this[i] = t[i]);
+    });
+  }
+  /**
+   * Parse data to the XObject
+   * @param data data to parse
+   * @param {object} fields- object with fields and default values (IXData format)
+   * 
+   * fields example = {
+   *  _name : "default-name",
+   * ...
+   * }
+   */
+  parseFieldsFromXDataObject(t, e) {
+    Object.keys(e).forEach((i) => {
+      t.hasOwnProperty(i) ? this[i] = t[i] : this[i] = e[i];
+    });
+  }
+  /**
+   * Parse list of fields from IXObjectData to the class
+   * @param {IXObjectData} data -  the data
+   * @param {Array<string>} fields - array of field names (string)
+   * @param checkNonXParams - also check non Xpell fields (fields that not starting with "_" sign)
+   */
+  parseFields(t, e, s) {
+    e.forEach((i) => {
+      if (t.hasOwnProperty(i))
+        this[i] = t[i];
+      else if (s && i.startsWith("_")) {
+        const n = i.substring(1);
+        t.hasOwnProperty(n) && (this[i] = t[n], this[n] = t[n]);
+      }
+    });
+  }
+  /**
+   * this method triggered after the HTML DOM object has been created and added to the parent element
+   * support external _on_create anonymous function in the , example:
+   * _on_create: async (xObject) => {
+   *      // xObject -> The XObject parent of the _on_create function, use instead of this keyword
+   *      // write code that will be executed each frame.
+   *      // make sure to write async anonymous function. 
+   * }
+   * 
+  */
+  async onCreate() {
+    this._on_create ? this.checkAndRunInternalFunction(this._on_create) : this._on && this._on.create ? this.checkAndRunInternalFunction(this._on.create) : this._once && this._once.create && this.checkAndRunInternalFunction(this._once.create);
+  }
+  async checkAndRunInternalFunction(t, ...e) {
+    if (typeof t == "function")
+      await t(this, ...e);
+    else if (typeof t == "string")
+      if (e.length > 0) {
+        const s = e[0], i = JSON.stringify(s).replace(/'/g, "\\'");
+        await this.run(`${this._id} ${t} data:'${i}'`);
+      } else
+        await this.run(`${this._id} ${t}`);
+  }
+  /**
+   * Triggers when the object is being mounted to other element
+   * support external _on_create anonymous function in the , example:
+   * _on_mount: async (xObject) => {
+   *      // xObject -> The XObject parent of the _on_mount function, use instead of this keyword
+   *      // write code that will be executed each frame.
+   *      // make sure to write async anonymous function. 
+   * }
+   */
+  async onMount() {
+    if (!this._mounted) {
+      this.parseEvents(this._xem_options), this._process_data && typeof this._data_source == "string" && this._data_source.length > 0 && this.bindDataSource(this._data_source, { initial: !0 }), this._on_mount ? await this.checkAndRunInternalFunction(this._on_mount) : this._on && this._on.mount ? await this.checkAndRunInternalFunction(this._on.mount) : this._once && this._once.mount && await this.checkAndRunInternalFunction(this._once.mount), this._mounted = !0;
+      for (const t of this._children)
+        t.onMount && typeof t.onMount == "function" && t.onMount();
+    }
+  }
+  emptyDataSource() {
+    const t = this._data_source;
+    if (typeof t != "string" || t.length === 0) return;
+    const e = this._type ?? this.constructor.name, s = this._id ?? "no-id";
+    u.delete(t, { source: `${e}#${s}.emptyDataSource` });
+  }
+  /**
+   * Triggers when new data is being received from the data source
+   * @param data - the data
+   * if override this method make sure to call super.onData(data) to run the _on_data attribute
+   */
+  async onData(t) {
+    this._process_data && (this._on_data ? this.checkAndRunInternalFunction(this._on_data, t) : this._on && this._on.data ? this.checkAndRunInternalFunction(this._on.data, t) : this._once && this._once.data && this.checkAndRunInternalFunction(this._once.data, t));
+  }
+  /**
+   * Triggers from Xpell frame every frame
+   * Support _on_frame atrribute that can be XCommand string or function
+   * @param {number} frameNumber 
+   * 
+   * XObject supports
+   * 1. External _on_frame anonymous function in the , example:
+   * _on_frame: async (xObject,frameNumber) => {
+   *      // xObject -> The XObject parent of the _on_frame function, use instead of this keyword
+   *      // frameNumber = Xpell current frame number 
+   *      // write code that will be executed each frame.
+   *      // make sure to write async anonymous function. 
+   *      // be wise with the function execution and try to keep it in the 15ms running time to support 60 FPS
+   * }
+   * 
+   * 2. String execution of nano commands
+   * 
+   * _on_frame: "nano command text"
+   * 
+   */
+  async onFrame(t) {
+    this._process_frame && (this._on_frame ? this.checkAndRunInternalFunction(this._on_frame, t) : this._on && this._on.frame ? this.checkAndRunInternalFunction(this._on.frame, t) : this._once && this._once.frame && this.checkAndRunInternalFunction(this._once.frame, t));
+    for (const e of this._children)
+      e.onFrame && typeof e.onFrame == "function" && e.onFrame(t);
+  }
+  /**
+   * Runs object nano commands
+   * @param nanoCommand - object nano command (string)
+   * @param cache - cache last command to prevent multiple parsing on the same command
+   */
+  async run(t, e = !0) {
+    let s = this._cache_cmd_txt && this._cache_cmd_txt == t ? this._cache_jcmd : g.parseObjectCommand(t);
+    e && (this._cache_cmd_txt = t, this._cache_jcmd = s), await this.execute(s);
+  }
+  /**
+   * Execute XCommand within the XObject Nano Commands
+   * @param xCommand XCommand to execute
+   * 
+   * Nano command example:
+   * 
+   * "set-text" : (xCommand,xObject) => {
+   *      xObject.setText(xCommands.params.text)
+   * }
+   * 
+   */
+  async execute(t) {
+    if (t._op && this._nano_commands[t._op])
+      try {
+        await this._nano_commands[t._op](t, this);
+      } catch (e) {
+        _.error(this._id + " has error with command name " + t._op + " " + e);
+      }
+    else
+      _.error(this._id + " has no command name " + t._op);
+  }
+  /**
+   * Return an IXObjectData JSON representation of the XObject
+   * @returns IXObjectData
+   */
+  toXData() {
+    const t = {};
+    return Object.keys(this).forEach((e) => {
+      if (!this._xporter._ignore_fields.includes(e) && this.hasOwnProperty(e) && this[e] !== void 0) {
+        const s = this[e];
+        if (typeof s == "function")
+          return;
+        if (typeof s == "object") {
+          const i = Object.keys(this._xporter._instance_xporters);
+          let n = !0;
+          i.forEach((r) => {
+            this._xporter._instance_xporters[r], s instanceof this._xporter._instance_xporters[r].cls && (t[e] = this._xporter._instance_xporters[r].handler(s), n = !1);
+          }), n && (t[e] = s);
+        } else
+          t[e] = s;
+      }
+    }), t._children = [], this._children.length > 0 && this._children.forEach((e) => {
+      typeof e.toXData == "function" && t._children?.push(e.toXData());
+    }), t;
+  }
+  /**
+   * Return a string representation of the XObject
+   * @returns string
+   */
+  toString() {
+    return JSON.stringify(this.toXData());
+  }
+  clearAttributes(t) {
+    t.forEach((e) => {
+      this.hasOwnProperty(e) && (this[e] = null, delete this[e]);
+    });
+  }
+  bindDataSource(t, e) {
+    const s = e?.initial ?? !0, i = t ?? this._data_source;
+    typeof i != "string" || i.length === 0 || this._process_data && (this._xd_bound_key === i && this._xd_unsub || (this.unbindDataSource(), this._data_source = i, this._xd_bound_key = i, this._type ?? this.constructor.name, this._id, this._xd_unsub = u.on(i, async (n) => {
+      await this.onData(n.value);
+    }), s && u.has(i) && this.onData(u.get(i))));
+  }
+  unbindDataSource() {
+    this._xd_unsub?.(), this._xd_unsub = void 0, this._xd_bound_key = void 0;
+  }
+  /**
+   * Dispose the XObject and all its children
+   */
+  async dispose() {
+    if (this.unbindDataSource(), this._parent) {
+      const t = this._parent._children.indexOf(this);
+      t > -1 && this._parent._children.splice(t, 1);
+    }
+    this._process_data = !1, this._process_frame = !1, this.removeAllEventListeners(), this.clearAttributes(["_cache_cmd_txt", "_cache_jcmd", "_nano_commands", "_event_listeners_ids", "_parent", "_on", "_once", "_xem_options", "_xporter"]), this._children && this._children.forEach((t) => {
+      typeof t.dispose == "function" && t.dispose();
+    }), this._children = [];
+  }
+  /**
+   * Remove a child from the XObject )
+   * @param child - the child to
+   * @returns void
+      */
+  removeChild(t, e = !1) {
+    if (e)
+      t.dispose();
+    else {
+      const s = this._children.indexOf(t);
+      s > -1 && this._children.splice(s, 1), t._parent = null;
+    }
+  }
+  /**
+   * @param child - the child to add
+   * @deprecated use append method instead
+   */
+  addChild(t) {
+    this.append(t);
+  }
+}
+class B {
+  /**
+   * Get all registered object in this ObjectPack
+   * @returns XObject dictionary
+   */
+  static getObjects() {
+    return {
+      object: v
+    };
+  }
+}
+const $ = "engine:module:num-of-objects:";
+class C {
+  //engine: any;  //deprecated remove after spell3d
+  constructor(t) {
+    this._log_rules = {
+      createObject: !1,
+      removeObject: !1
+    }, this.#t = new P(), this._name = t._name, this._id = p.guid();
+  }
+  #t;
+  load() {
+    _.log("Module " + this._name + " loaded");
+  }
+  /**
+   * Creates new XObject from data object
+   * @param data - The data of the new object (JSON)
+   * @return {XObject|*}
+   */
+  create(t) {
+    let e;
+    if (t.hasOwnProperty("_type"))
+      if (this.#t.hasObjectClass(t._type)) {
+        let s = this.#t.getObjectClass(t._type);
+        s.hasOwnProperty("defaults") && p.mergeDefaultsWithData(t, s.defaults), e = new s(t);
+      } else
+        throw "Xpell object '" + t._type + "' not found";
+    else
+      e = new v(t);
+    return this.#t.addObject(e), t._children && t._children.forEach((s) => {
+      const i = this.create(s);
+      e.append(i);
+    }), e.onCreate(), e;
+  }
+  /**
+   * removes and XObject from the object manager
+   * @param objectId op
+   */
+  remove(t) {
+    const e = this.#t.getObject(t);
+    if (!e) return;
+    const s = [], i = (n) => {
+      n?._id && (s.push(n._id), (n._children ?? []).forEach((r) => i(r)));
+    };
+    i(e), typeof e.dispose == "function" && e.dispose(), s.reverse().forEach((n) => this.#t.removeObject(n));
+  }
+  _info(t) {
+    _.log("module info");
+  }
+  //xpell interpreter 
+  /**
+   * Run xpell command - 
+   * CLI mode, parse the command to XCommand JSON format and call execute method
+   * @param {string} XCommand input - text 
+   * @returns command execution result
+   */
+  async run(t) {
+    if (t) {
+      let e = t.trim();
+      e.startsWith(this._name) || (e = this._name + " " + e);
+      let s = g.parse(e);
+      return await this.execute(s);
+    } else
+      throw "Unable to parse Xpell Command";
+  }
+  /**
+   * execute xpell command - CLI mode
+   * @param {XCommand} XCommand input (JSON)
+   * @returns command execution result
+   */
+  // inside XModule class
+  async execute(t) {
+    if (!t || !t._op)
+      throw new Error(`Invalid XCommand: missing _op (module: ${this._name})`);
+    const e = t._object;
+    if (e) {
+      const n = this.#t.getObject(e);
+      if (!n)
+        throw new Error(`Module '${this._name}' cant find object id: ${e}`);
+      return await n.execute(t);
+    }
+    const s = "_" + t._op.replaceAll("-", "_"), i = this[s];
+    if (typeof i == "function")
+      return await i.call(this, t);
+    throw new Error(`Module '${this._name}' cant find op: ${t._op}`);
+  }
+  /**
+   * This method triggers every frame from the Xpell engine.
+   * The method can be override by the extending module to support extended onFrame functionality
+   * @param frameNumber Current frame number
+   */
+  async onFrame(t) {
+    const e = this.#t._objects, s = Object.keys(e);
+    s.forEach((i) => {
+      const n = e[i];
+      n && n.onFrame && typeof n.onFrame == "function" && n?.onFrame(t);
+    }), u.set($ + this._id, s.length, {
+      source: "xmodule"
+    });
+  }
+  /**
+   * X Object Manager
+   */
+  /**
+   * getter for om (object manager) instance
+   * @returns {XObjectManager}
+   * @deprecated - use _object_manager instead
+   * If you wish to get an object from the object manager use
+   * getObject directly on the module instead of om.getObject 
+   */
+  get om() {
+    return this.#t;
+  }
+  get _object_manager() {
+    return this.#t;
+  }
+  /**
+   * Returns the XObject instance from the module Object Manager
+   * @param objectId 
+   * @returns XObject
+   */
+  getObject(t) {
+    return this.#t.getObject(t);
+  }
+  /**
+   * Returns the XObject instance from the module Object Manager
+   * Usage:
+   * xmodule._o["object-id"] is equivalent to xmodule.getObject("object-id")
+   */
+  get _o() {
+    return this.#t._objects;
+  }
+  /**
+   * Imports external object pack to the engine
+   * The object class should be like XObjects with static implementation of getObjects() method
+   * @param {XObjects} xObjectPack 
+   */
+  importObjectPack(t) {
+    this.#t.registerObjects(t.getObjects());
+  }
+  /**
+   * Imports external object pack to the engine
+   * @deprecated - use importObjectPack instead
+   * @param xObjectPack 
+   */
+  importObjects(t) {
+    this.importObjectPack(t);
+  }
+  /**
+   * Imports external objects to the engine
+   * The object class should be like XObjects with static implementation of getObjects() method
+   * @param xObjectName 
+   * @param xObject 
+   */
+  importObject(t, e) {
+    this.#t.registerObject(t, e);
+  }
+  // In XModule
+  async _help(t) {
+    const e = t?._params?._op ?? t?._params?._command ?? "";
+    return this.help(e);
+  }
+  /**
+   * Override in modules to provide help text.
+   * @param op optional: specific command name (e.g. "navigate")
+   */
+  help(t) {
+    return {
+      module: this._name,
+      usage: `${this._name} help`,
+      ops: ["help"],
+      note: "No help() implemented for this module."
+    };
+  }
+}
+class L {
+  /* -------------------------------------------------- */
+  /* core helpers                                       */
+  /* -------------------------------------------------- */
+  static get(t, e, s) {
+    if (!t?._params) return s;
+    const i = t._params[e];
+    return i !== void 0 ? i : s;
+  }
+  static has(t, e) {
+    return t?._params && t._params[e] !== void 0;
+  }
+  static str(t, ...e) {
+    for (const s of e) {
+      const i = t?._params?.[s];
+      if (i != null)
+        return String(i);
+    }
+  }
+  /* -------------------------------------------------- */
+  /* typed params                                       */
+  /* -------------------------------------------------- */
+  static bool(t, e, s = !1) {
+    const i = this.get(t, e, s);
+    if (typeof i == "boolean") return i;
+    if (typeof i == "number") return i !== 0;
+    if (typeof i == "string") {
+      const n = i.toLowerCase();
+      if (["1", "true", "yes", "on"].includes(n)) return !0;
+      if (["0", "false", "no", "off"].includes(n)) return !1;
+    }
+    return !!i;
+  }
+  static int(t, e, s = 0) {
+    const i = this.get(t, e, s), n = parseInt(String(i), 10);
+    return Number.isFinite(n) ? n : s;
+  }
+  static json(t, e, s) {
+    const i = this.get(t, e, s);
+    if (i == null) return s;
+    if (typeof i == "object") return i;
+    if (typeof i == "string")
+      try {
+        return JSON.parse(i);
+      } catch {
+        return s;
+      }
+    return s;
+  }
+}
+class O extends Error {
+  constructor(t, e, s) {
+    super(e), this.name = "XError", this._code = t, this._level = s?._level ?? "error", this._meta = s?._meta, this._cause = s?._cause;
+  }
+  toXData() {
+    return {
+      _code: this._code,
+      _level: this._level,
+      _meta: this._meta,
+      _cause: this._cause,
+      // optional: include name/message if you want them in protocol too
+      name: this.name,
+      message: this.message
+    };
+  }
+  toJSON() {
+    return {
+      ...this.toXData(),
+      stack: this.stack
+      // debug-only
+    };
+  }
+}
+class d {
+  constructor(t) {
+    this._ok = !1, this._ts = Date.now(), this._pt = 0, t && this.setXData(t);
+  }
+  // ---------------------------------------------------------------------------
+  // Factories
+  // ---------------------------------------------------------------------------
+  static create(t) {
+    return new d(t);
+  }
+  static ok(t) {
+    return new d({ _ok: !0, _result: t });
+  }
+  static error(t) {
+    if (t instanceof O)
+      return new d({
+        _ok: !1,
+        _result: t.toXData()
+      });
+    const e = new O(
+      "E_INTERNAL",
+      t?.message ?? String(t),
+      { _cause: t }
+    );
+    return new d({
+      _ok: !1,
+      _result: e.toXData()
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  stopProcessTimeCounter() {
+    this._pt = Date.now() - this._ts;
+  }
+  // ---------------------------------------------------------------------------
+  // Protocol
+  // ---------------------------------------------------------------------------
+  /**
+   * Convert to wire-safe object.
+   * NOTE: serialize == finalize timing
+   */
+  toXData() {
+    return this.stopProcessTimeCounter(), {
+      _ok: this._ok,
+      _ts: this._ts,
+      _pt: this._pt,
+      _result: this._result
+    };
+  }
+  toString() {
+    return JSON.stringify(this.toXData());
+  }
+  setXData(t) {
+    t && ("_ok" in t && (this._ok = !!t._ok), "_ts" in t && typeof t._ts == "number" && (this._ts = t._ts), "_pt" in t && typeof t._pt == "number" && (this._pt = t._pt), "_result" in t && (this._result = t._result));
+  }
+}
+class T extends d {
+  constructor(t) {
+    super(d.error(t).toXData());
+  }
+}
+class W extends d {
+  constructor(t) {
+    super({ _ok: !0, _result: t });
+  }
+}
+const R = "engine:frame-number", N = "engine:fps";
+class U {
+  constructor(t) {
+    this._log_rules = {}, this._modules = {}, this._schedule_frame = t?._schedule_frame ?? p.createDefaultScheduler(t?._target_fps), this._version = "0.0.1", this._engine_id = p.guid(), this._frame_number = 0, this._fps_calc = new k(), this.parser = g, this._modules = {}, b.fire("xpell-init"), _._enabled = !1;
+  }
+  /**
+   * @deprecated use _verbose instead
+   * Enable Xpell logs to console
+   */
+  set verbose(t) {
+    _._enabled = t;
+  }
+  /**
+   * Enable Xpell logs to console
+   */
+  set _verbose(t) {
+    _._enabled = t;
+  }
+  /**
+   * Logs message to console using Xpell logger
+   * make sure to enable verbose mode to see the logs
+   * this method is a wrapper for XLogger.log
+   * @param msg 
+   * @param optionalParams
+   */
+  log(t, ...e) {
+    _.log(t, ...e);
+  }
+  /**
+   * Delay the execution of the next command
+   * @param ms - delay in milliseconds
+   * @returns 
+   */
+  async delay(t) {
+    return new Promise((e) => setTimeout(e, t));
+  }
+  /**
+   * Loads Xpell module into the engine
+   * @param {XModule} xModule 
+   */
+  loadModule(t) {
+    this._modules.hasOwnProperty(t._name) ? _.log("Module " + t._name + " already loaded") : (this._modules[t._name] = t, t.load());
+  }
+  /**
+   * Loads multiple module at ones
+   * @param {Array<XModule>} xModulesArray 
+   */
+  loadModules(...t) {
+    t.forEach((e) => this.loadModule(e));
+  }
+  /**
+   * Display information about the Xpell engine to the console
+   */
+  info() {
+    _.log(`Xpell information:
+- Engine Id: ` + this._engine_id + `
+- Version ` + this._version);
+  }
+  /**
+  * Run textual xCommand -
+  * @param {cmd} - text command
+  */
+  run(t) {
+    if (t?.length > 2) {
+      let e = g.parse(t);
+      return this.execute(e);
+    } else
+      throw "Unable to parse Xpell command";
+  }
+  /**
+   * Execute Xpell Command 
+   * @param {XCommand} 
+   */
+  execute(t) {
+    if (t && t._module && this._modules[t._module])
+      return this._modules[t._module].execute(t);
+    throw "Xpell module " + t._module + " not loaded";
+  }
+  /**
+   * Main onFrame method
+   * calls all the sub-modules onFrame methods (if implemented)
+   */
+  onFrame() {
+    this._frame_number++;
+    for (const e of Object.keys(this._modules)) {
+      const s = this._modules[e];
+      s?.onFrame && typeof s.onFrame == "function" && s.onFrame(this._frame_number);
+    }
+    const t = this._fps_calc.calc();
+    u.set(R, this._frame_number, { source: "engine" }), u.set(N, t, { source: "engine" }), u._compat_legacy_keys && (u.set("frame-number", this._frame_number, { source: "engine:legacy" }), u.set("fps", t, { source: "engine:legacy" })), this._schedule_frame(() => this.onFrame());
+  }
+  /**
+   * Gets Xpell module by name
+   * @param {string} moduleName - name of the loaded module
+   * @returns {XModule}
+   */
+  getModule(t) {
+    return this._modules[t];
+  }
+  /**
+   * Start Xpell engine for web browsers using requestAnimationFrame
+   */
+  start() {
+    _.log("Starting Xpell"), this.onFrame();
+  }
+  /**
+   * deprecated - use XData._o directly
+   */
+  getParam(t, e) {
+    return t in u._o ? u._o[t] : e;
+  }
+}
+const J = new U();
+export {
+  M as XCommand,
+  N as XD_FPS,
+  R as XD_FRAME_NUMBER,
+  u as XData,
+  O as XError,
+  b as XEventManager,
+  _ as XLogger,
+  C as XModule,
+  v as XObject,
+  P as XObjectManager,
+  B as XObjectPack,
+  L as XParams,
+  g as XParser,
+  d as XResponse,
+  T as XResponseError,
+  W as XResponseOK,
+  p as XUtils,
+  J as Xpell,
+  U as XpellEngine,
+  S as _XData,
+  I as _XEventManager,
+  F as _XLogger,
+  X as _XUtils,
+  J as _x,
+  u as _xd,
+  b as _xem,
+  _ as _xlog,
+  p as _xu,
+  J as default
+};