@xuda.io/xuda-worker-bundle-min 1.3.2439 → 1.3.2441

package/index.js

@@ -5,6 +5,49 @@ if (typeof IS_DOCKER === 'undefined' || typeof IS_PROCESS_SERVER === 'undefined'
   var DOCS_OBJ = {};
 }
 
+// Minimal jQuery shim for plugins that still reference $
+if (typeof $ === 'undefined' && typeof document !== 'undefined') {
+  var $ = function (selector) {
+    var nodes = typeof selector === 'string'
+      ? Array.from(document.querySelectorAll(selector))
+      : selector?.nodeType ? [selector] : (selector?.length ? Array.from(selector) : []);
+    var obj = {
+      0: nodes[0], length: nodes.length,
+      toArray: function () { return nodes.slice(); },
+      find: function (s) { var r = []; for (var i = 0; i < nodes.length; i++) { r.push.apply(r, Array.from(nodes[i].querySelectorAll(s))); } return $(r); },
+      each: function (fn) { for (var i = 0; i < nodes.length; i++) { fn.call(nodes[i], i, nodes[i]); } return obj; },
+      on: function (ev, fn) { for (var i = 0; i < nodes.length; i++) nodes[i].addEventListener(ev, fn); return obj; },
+      off: function (ev, fn) { for (var i = 0; i < nodes.length; i++) nodes[i].removeEventListener(ev, fn); return obj; },
+      addClass: function (c) { for (var i = 0; i < nodes.length; i++) nodes[i].classList?.add(c); return obj; },
+      removeClass: function (c) { for (var i = 0; i < nodes.length; i++) nodes[i].classList?.remove(c); return obj; },
+      hasClass: function (c) { return nodes[0]?.classList?.contains(c) || false; },
+      attr: function (k, v) { if (typeof v === 'undefined') return nodes[0]?.getAttribute(k); for (var i = 0; i < nodes.length; i++) nodes[i].setAttribute(k, v); return obj; },
+      css: function (k, v) { for (var i = 0; i < nodes.length; i++) nodes[i].style[k] = v; return obj; },
+      data: function () { return nodes[0]?.__xuData || (nodes[0] ? (nodes[0].__xuData = {}) : {}); },
+      val: function (v) { if (typeof v === 'undefined') return nodes[0]?.value; for (var i = 0; i < nodes.length; i++) nodes[i].value = v; return obj; },
+      html: function (v) { if (typeof v === 'undefined') return nodes[0]?.innerHTML; for (var i = 0; i < nodes.length; i++) nodes[i].innerHTML = v; return obj; },
+      text: function (v) { if (typeof v === 'undefined') return nodes[0]?.textContent; for (var i = 0; i < nodes.length; i++) nodes[i].textContent = v; return obj; },
+      show: function () { for (var i = 0; i < nodes.length; i++) nodes[i].style.display = ''; return obj; },
+      hide: function () { for (var i = 0; i < nodes.length; i++) nodes[i].style.display = 'none'; return obj; },
+      remove: function () { for (var i = 0; i < nodes.length; i++) nodes[i].remove?.(); return obj; },
+      empty: function () { for (var i = 0; i < nodes.length; i++) nodes[i].innerHTML = ''; return obj; },
+      append: function (c) { var n = c?.nodeType ? c : c?.[0]; if (n && nodes[0]) nodes[0].appendChild(n); return obj; },
+      parent: function () { return $(nodes[0]?.parentElement ? [nodes[0].parentElement] : []); },
+      children: function () { return $(nodes[0] ? Array.from(nodes[0].children) : []); },
+      trigger: function (ev, d) { for (var i = 0; i < nodes.length; i++) nodes[i].dispatchEvent(new CustomEvent(ev, { detail: d })); return obj; },
+      is: function (s) { return nodes[0]?.matches?.(s) || false; },
+      prop: function (k, v) { if (typeof v === 'undefined') return nodes[0]?.[k]; for (var i = 0; i < nodes.length; i++) nodes[i][k] = v; return obj; },
+      unbind: function () { return obj; },
+      clone: function () { return $(nodes[0]?.cloneNode(true) ? [nodes[0].cloneNode(true)] : []); },
+    };
+    obj[Symbol.iterator] = function () { var i = 0; return { next: function () { return i < nodes.length ? { value: nodes[i++], done: false } : { done: true }; } }; };
+    return obj;
+  };
+  $.each = function (o, fn) { if (Array.isArray(o)) { for (var i = 0; i < o.length; i++) fn(i, o[i]); } else { Object.keys(o || {}).forEach(function (k) { fn(k, o[k]); }); } };
+  $.cookie = function () { return null; };
+  var jQuery = $;
+}
+
 var glb = {};
 var func = {};
 func.UI = {};
@@ -21,6 +64,51 @@ func.runtime.ui = {};
 func.runtime.widgets = {};
 glb.IS_STUDIO = null;
 
+// Lodash replacement utilities
+var xu_isEmpty = function (val) {
+  if (val == null) return true;
+  if (typeof val === 'boolean' || typeof val === 'number') return !val;
+  if (typeof val === 'string' || Array.isArray(val)) return val.length === 0;
+  if (val instanceof Map || val instanceof Set) return val.size === 0;
+  return Object.keys(val).length === 0;
+};
+
+var xu_isEqual = function (a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  if (typeof a !== 'object') return false;
+  var keysA = Object.keys(a);
+  var keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (var i = 0; i < keysA.length; i++) {
+    if (!Object.prototype.hasOwnProperty.call(b, keysA[i]) || !xu_isEqual(a[keysA[i]], b[keysA[i]])) return false;
+  }
+  return true;
+};
+
+var xu_get = function (obj, path, defaultVal) {
+  var keys = typeof path === 'string' ? path.split('.') : path;
+  var result = obj;
+  for (var i = 0; i < keys.length; i++) {
+    if (result == null) return defaultVal;
+    result = result[keys[i]];
+  }
+  return result === undefined ? defaultVal : result;
+};
+
+var xu_set = function (obj, path, value) {
+  var keys = typeof path === 'string' ? path.split('.') : path;
+  var current = obj;
+  for (var i = 0; i < keys.length - 1; i++) {
+    if (current[keys[i]] == null) current[keys[i]] = {};
+    current = current[keys[i]];
+  }
+  current[keys[keys.length - 1]] = value;
+  return obj;
+};
+
 var PROJECT_OBJ = {};
 
 var APP_OBJ = {};
@@ -185,6 +273,105 @@ func.runtime.platform = {
     return true;
   },
 };
+
+// ── Platform-agnostic event bus ──
+// Works in browser, worker, and Node environments.
+// In browser, bridge DOM events into this bus so core code never touches $(document) directly.
+func.runtime.platform._event_bus = {};
+func.runtime.platform.on = function (name, handler) {
+  if (!func.runtime.platform._event_bus[name]) {
+    func.runtime.platform._event_bus[name] = [];
+  }
+  func.runtime.platform._event_bus[name].push(handler);
+};
+func.runtime.platform.off = function (name, handler) {
+  const handlers = func.runtime.platform._event_bus[name];
+  if (!handlers) return;
+  if (!handler) {
+    delete func.runtime.platform._event_bus[name];
+    return;
+  }
+  const index = handlers.indexOf(handler);
+  if (index !== -1) {
+    handlers.splice(index, 1);
+  }
+};
+func.runtime.platform._emitting = {};
+func.runtime.platform.emit = function (name, data) {
+  // re-entrancy guard: prevent infinite loops when DOM bridge triggers the same event
+  if (func.runtime.platform._emitting[name]) return;
+  func.runtime.platform._emitting[name] = true;
+  try {
+    const handlers = func.runtime.platform._event_bus[name];
+    if (handlers) {
+      for (let i = 0; i < handlers.length; i++) {
+        handlers[i](data);
+      }
+    }
+    // also fire on DOM if in browser (for backward compatibility with custom event listeners)
+    if (func.runtime.platform.has_document()) {
+      document.dispatchEvent(new CustomEvent(name, { detail: Array.isArray(data) ? data : [data] }));
+    }
+  } finally {
+    func.runtime.platform._emitting[name] = false;
+  }
+};
+
+// ── Platform helpers for DOM-independent resource loading ──
+func.runtime.platform.load_script = function (url, type, callback) {
+  if (typeof document !== 'undefined') {
+    const script = document.createElement('script');
+    script.src = url;
+    if (type) script.type = type;
+    script.onload = callback;
+    document.head.appendChild(script);
+  } else if (callback) {
+    callback();
+  }
+};
+func.runtime.platform.load_css = function (href) {
+  if (typeof document === 'undefined') return;
+  try {
+    if (document.querySelector('link[href="' + href + '"]')) return;
+  } catch (err) {
+    return;
+  }
+  const link = document.createElement('link');
+  link.rel = 'stylesheet';
+  link.type = 'text/css';
+  link.href = href;
+  document.head.insertBefore(link, document.head.firstChild);
+};
+func.runtime.platform.remove_js_css = function (filename, filetype) {
+  if (typeof document === 'undefined') return;
+  const tagName = filetype === 'js' ? 'script' : filetype === 'css' ? 'link' : 'none';
+  const attr = filetype === 'js' ? 'src' : filetype === 'css' ? 'href' : 'none';
+  const elements = document.getElementsByTagName(tagName);
+  for (let i = elements.length - 1; i >= 0; i--) {
+    if (elements[i] && elements[i].getAttribute(attr) != null && elements[i].getAttribute(attr).indexOf(filename) !== -1) {
+      elements[i].parentNode.removeChild(elements[i]);
+    }
+  }
+};
+func.runtime.platform.inject_css = function (cssText) {
+  if (typeof document === 'undefined' || !cssText) return;
+  const style = document.createElement('style');
+  style.type = 'text/css';
+  style.textContent = cssText;
+  document.head.appendChild(style);
+};
+func.runtime.platform.set_title = function (title) {
+  if (typeof document !== 'undefined') {
+    document.title = title;
+  }
+};
+func.runtime.platform.set_cursor = function (element, cursor) {
+  const node = func.runtime.ui?.get_first_node ? func.runtime.ui.get_first_node(element) : element;
+  if (node?.style) {
+    node.style.cursor = cursor;
+  }
+};
+
 func.runtime.env = {
   get_url_params: function () {
     const search = func.runtime.platform.get_url_search();
@@ -623,18 +810,17 @@ func.runtime.bind.get_field_type = function (field_prop) {
 };
 func.runtime.bind.toggle_array_value = function (arr_value_before_cast, value_from_getter) {
   if (arr_value_before_cast.includes(value_from_getter)) {
-    return arr_value_before_cast.filter((item) => !_.isEqual(item, value_from_getter));
+    return arr_value_before_cast.filter((item) => !xu_isEqual(item, value_from_getter));
   }
   arr_value_before_cast.push(value_from_getter);
   return arr_value_before_cast;
 };
 func.runtime.bind.get_cast_value = async function (SESSION_ID, field_prop, input_field_type, raw_value) {
   const field_type = func.runtime.bind.get_field_type(field_prop);
-  var value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', field_type, raw_value);
   if (field_type === 'object') {
-    value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', input_field_type, raw_value);
+    return await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', input_field_type, raw_value);
   }
-  return value;
+  return await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', field_type, raw_value);
 };
 func.runtime.bind.get_source_value = function (_ds, bind_field_id, is_dynamic_field) {
   if (is_dynamic_field) {
@@ -645,7 +831,7 @@ func.runtime.bind.get_source_value = function (_ds, bind_field_id, is_dynamic_fi
 };
 func.runtime.bind.format_display_value = function ($elm, field_prop, bind_field_id, expression_value, value, input_field_type) {
   const field_type = func.runtime.bind.get_field_type(field_prop);
-  const elm_value = $elm.attr('value');
+  const elm_value = func.runtime.ui.get_attr($elm, 'value');
 
   if (field_type === 'array' && input_field_type === 'checkbox' && elm_value) {
     return value.includes(elm_value);
@@ -671,7 +857,7 @@ func.runtime.bind.update_reference_source_array = async function (options) {
 
   const arr_idx = Number(options.iterate_info._key);
   const dataset_arr = await func.datasource.get_value(options.SESSION_ID, reference_source_obj.fieldIdP, options.dsSessionP, reference_source_obj.currentRecordId);
-  let new_arr = _.cloneDeep(dataset_arr.ret.value);
+  let new_arr = structuredClone(dataset_arr.ret.value);
 
   if (field_type === 'object' && options.val_is_reference_field) {
     let obj_item = new_arr[arr_idx];
@@ -683,15 +869,15 @@ func.runtime.bind.update_reference_source_array = async function (options) {
   }
 
   let datasource_changes = func.runtime.bind.build_datasource_changes(options.dsSessionP, options.currentRecordId, reference_source_obj.fieldIdP, new_arr);
-  await func.datasource.update(options.SESSION_ID, datasource_changes, null, true);
+  await func.datasource.update(options.SESSION_ID, datasource_changes);
   return true;
 };
 func.runtime.resources.load_cdn = async function (SESSION_ID, resource) {
   let normalized_resource = resource;
-  if (!_.isObject(normalized_resource) && _.isString(normalized_resource)) {
+  if (!(typeof normalized_resource === 'object' && normalized_resource !== null) && typeof normalized_resource === 'string') {
     normalized_resource = { src: normalized_resource, type: 'js' };
   }
-  if (!_.isObject(normalized_resource)) {
+  if (!(typeof normalized_resource === 'object' && normalized_resource !== null)) {
     throw new Error('cdn resource in wrong format');
   }
 
@@ -737,7 +923,7 @@ func.runtime.resources.load_plugin_runtime_css = async function (SESSION_ID, plu
   return true;
 };
 func.runtime.resources.resolve_plugin_properties = async function (SESSION_ID, dsSessionP, attributes, properties) {
-  let resolved_properties = _.cloneDeep(properties);
+  let resolved_properties = structuredClone(properties);
   for await (let [prop_name, prop_val] of Object.entries(resolved_properties || {})) {
     prop_val.value = attributes?.[prop_name];
     if (attributes?.[`xu-exp:${prop_name}`]) {
@@ -763,7 +949,7 @@ func.runtime.resources.run_ui_plugin = async function (SESSION_ID, paramsP, $elm
   const plugin_runtime_src = await func.runtime.resources.get_plugin_module_url(SESSION_ID, plugin_name, plugin, 'runtime.mjs');
   const plugin_runtime_resources = await import(plugin_runtime_src);
 
-  if (plugin_runtime_resources.cdn && _.isArray(plugin_runtime_resources.cdn)) {
+  if (plugin_runtime_resources.cdn && Array.isArray(plugin_runtime_resources.cdn)) {
     for await (const resource of plugin_runtime_resources.cdn) {
       await func.runtime.resources.load_cdn(SESSION_ID, resource);
     }
@@ -895,12 +1081,12 @@ func.runtime.widgets.build_params = function (context, $containerP, plugin_setup
   };
 };
 func.common.find_item_by_key = function (arr, key, val) {
-  return _.find(arr, function (e) {
+  return arr.find(function (e) {
     return e.data[key] === val;
   });
 };
 func.common.find_item_by_key_root = function (arr, key, val) {
-  return _.find(arr, function (e) {
+  return arr.find(function (e) {
     return e[key] === val;
   });
 };
@@ -1160,7 +1346,7 @@ func.common.db = async function (SESSION_ID, serviceP, dataP, opt = {}, dsSessio
           }
 
           await db.get(row_id);
-          let _data = _.cloneDeep(dataP);
+          let _data = structuredClone(dataP);
           _data.ids = [row_id];
           return await func.db.pouch['dbs_delete'](SESSION_ID, _data);
         } catch (err) {
@@ -1249,7 +1435,7 @@ func.common.db = async function (SESSION_ID, serviceP, dataP, opt = {}, dsSessio
 
     const get_white_spaced_data = function (data) {
       var e = {};
-      _.forEach(data, function (val, key) {
+      for (const [key, val] of Object.entries(data)) {
         if (!val) {
           if (typeof val === 'boolean') {
             e[key] = 'false';
@@ -1263,7 +1449,7 @@ func.common.db = async function (SESSION_ID, serviceP, dataP, opt = {}, dsSessio
             e[key] = val;
           }
         }
-      });
+      }
 
       if (data.fields && !data.fields.length) {
         e.fields = '';
@@ -1512,14 +1698,14 @@ var UI_FRAMEWORK_PLUGIN = {};
 func.common.get_cast_val = async function (SESSION_ID, source, attributeP, typeP, valP, errorP) {
   const report_conversion_error = function (res) {
     if (errorP) {
-      return func.utils.debug_report(SESSION_ID, _.capitalize(source), errorP, 'W');
+      return func.utils.debug_report(SESSION_ID, source.charAt(0).toUpperCase() + source.slice(1).toLowerCase(), errorP, 'W');
     }
     var msg = `error converting  ${attributeP} from ${valP} to ${typeP}`;
-    func.utils.debug_report(SESSION_ID, _.capitalize(source), msg, 'E');
+    func.utils.debug_report(SESSION_ID, source.charAt(0).toUpperCase() + source.slice(1).toLowerCase(), msg, 'E');
   };
   const report_conversion_warn = function (msg) {
     var msg = `type mismatch auto conversion made to ${attributeP} from value ${valP} to ${typeP}`;
-    func.utils.debug_report(SESSION_ID, _.capitalize(source), msg, 'W');
+    func.utils.debug_report(SESSION_ID, source.charAt(0).toUpperCase() + source.slice(1).toLowerCase(), msg, 'W');
   };
   const module = await func.common.get_module(SESSION_ID, `xuda-get-cast-util-module.mjs`);
   return module.cast(typeP, valP, report_conversion_error, report_conversion_warn);
@@ -1537,11 +1723,17 @@ var WEBSOCKET_PROCESS_PID = null;
 glb.worker_queue_num = 0;
 glb.websocket_queue_num = 0;
 
+func.common._import_cache = func.common._import_cache || {};
+
 func.common.get_module = async function (SESSION_ID, module, paramsP = {}) {
   let ret;
 
   const get_ret = async function (src) {
-    const module_ret = await import(src);
+    // Cache the import() result to avoid repeated dynamic imports
+    if (!func.common._import_cache[src]) {
+      func.common._import_cache[src] = await import(src);
+    }
+    const module_ret = func.common._import_cache[src];
     var params = get_params();
 
     const ret = module_ret.XudaModule ? new module_ret.XudaModule(params) : await invoke_init_module(module_ret, params);
@@ -1558,7 +1750,6 @@ func.common.get_module = async function (SESSION_ID, module, paramsP = {}) {
       PROJECT_OBJ,
       DOCS_OBJ,
       SESSION_OBJ,
-      _,
       ...paramsP,
     };
     if (typeof IS_PROCESS_SERVER !== 'undefined') params.IS_PROCESS_SERVER = IS_PROCESS_SERVER;
@@ -1592,7 +1783,7 @@ func.common.get_module = async function (SESSION_ID, module, paramsP = {}) {
   }
 
   const rep = function () {
-    return _.endsWith(module, '.js') ? module.replace('.js', '.min.js') : module.replace('.mjs', '.min.mjs');
+    return module.endsWith('.js') ? module.replace('.js', '.min.js') : module.replace('.mjs', '.min.mjs');
   };
 
   if (typeof IS_DOCKER !== 'undefined' || typeof IS_PROCESS_SERVER !== 'undefined') {
@@ -1750,7 +1941,7 @@ func.api.watch = function (path, cb, opt = {}) {
   _session.watchers[path] = { ...opt, handler: cb };
 
   if (opt.immediate) {
-    const value = _.get(SESSION_OBJ[SESSION_ID].DS_GLB[0], path);
+    const value = xu_get(SESSION_OBJ[SESSION_ID].DS_GLB[0], path);
     cb({ path, newValue: value, oldValue: value, timestamp: Date.now(), opt });
 
     if (opt.once) {
@@ -1902,10 +2093,12 @@ func.common.get_data_from_websocket = async function (SESSION_ID, serviceP, data
       } else {
         if (RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED) {
           RUNTIME_SERVER_WEBSOCKET.emit('message', obj);
-          $('body').on('get_ws_data_response_' + glb.websocket_queue_num, (e, data) => {
+          const _ws_event = 'get_ws_data_response_' + glb.websocket_queue_num;
+          const _ws_handler = function (data) {
             resolve(data.data);
-            $('body').off('get_ws_data_response_' + data.e.websocket_queue_num);
-          });
+            func.runtime.platform.off('get_ws_data_response_' + data.e.websocket_queue_num, _ws_handler);
+          };
+          func.runtime.platform.on(_ws_event, _ws_handler);
         } else {
           throw new Error('fail to fetch from ws websocket inactive');
         }
@@ -1919,10 +2112,11 @@ func.common.get_data_from_websocket = async function (SESSION_ID, serviceP, data
 
       if (RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED) {
         RUNTIME_SERVER_WEBSOCKET.emit('message', obj);
-        $('body').on('heartbeat_response', (e, data) => {
+        const _hb_handler = function (data) {
           resolve(data.data);
-          $('body').off('heartbeat_response');
-        });
+          func.runtime.platform.off('heartbeat_response', _hb_handler);
+        };
+        func.runtime.platform.on('heartbeat_response', _hb_handler);
       } else {
         throw new Error('fail to fetch from ws websocket inactive');
       }
@@ -2157,6 +2351,395 @@ glb.run_xu_before = [
 glb.run_xu_after = ['xu-bind', 'xu-class', 'xu-script', 'xu-ui-plugin', 'xu-ref'];
 glb.attr_abbreviations_arr = ['xu-click', 'xu-dblclick', 'xu-contextmenu', 'xu-focus', 'xu-keyup', 'xu-change', 'xu-blur', 'xu-init'];
 glb.solid_attributes = ['disabled'];
+ // ── Headless/SSR DOM adapter ──
+// Provides a no-op / in-memory implementation of func.runtime.ui
+// for environments without a DOM (Node.js, workers, SSR).
+// Elements are plain objects; metadata lives in _meta_store.
+
+func.runtime = func.runtime || {};
+func.runtime.ui = func.runtime.ui || {};
+func.runtime.render = func.runtime.render || {};
+func.runtime.widgets = func.runtime.widgets || {};
+func.runtime.ui.ui_id_hash_cache = func.runtime.ui.ui_id_hash_cache || new Map();
+func.runtime.ui.node_snapshot_cache = func.runtime.ui.node_snapshot_cache || new WeakMap();
+func.runtime.ui.node_child_items_cache = func.runtime.ui.node_child_items_cache || new WeakMap();
+func.runtime.ui.node_children_by_id_cache = func.runtime.ui.node_children_by_id_cache || new WeakMap();
+
+// ── Metadata store (shared with browser adapter) ──
+func.runtime.ui._meta_store = func.runtime.ui._meta_store || {};
+func.runtime.ui._element_id_to_xu_ui_id = func.runtime.ui._element_id_to_xu_ui_id || {};
+
+func.runtime.ui.set_meta = function (xu_ui_id, key, value) {
+  if (!xu_ui_id) return;
+  if (!func.runtime.ui._meta_store[xu_ui_id]) {
+    func.runtime.ui._meta_store[xu_ui_id] = {};
+  }
+  func.runtime.ui._meta_store[xu_ui_id][key] = value;
+};
+func.runtime.ui.get_meta = function (xu_ui_id, key) {
+  const entry = func.runtime.ui._meta_store[xu_ui_id];
+  if (!entry) return undefined;
+  return key ? entry[key] : entry;
+};
+func.runtime.ui.delete_meta = function (xu_ui_id) {
+  delete func.runtime.ui._meta_store[xu_ui_id];
+  for (const id in func.runtime.ui._element_id_to_xu_ui_id) {
+    if (func.runtime.ui._element_id_to_xu_ui_id[id] === xu_ui_id) {
+      delete func.runtime.ui._element_id_to_xu_ui_id[id];
+    }
+  }
+};
+func.runtime.ui.register_element_id = function (element_id, xu_ui_id) {
+  if (element_id && xu_ui_id) {
+    func.runtime.ui._element_id_to_xu_ui_id[element_id] = xu_ui_id;
+  }
+};
+func.runtime.ui.get_meta_by_element_id = function (element_id) {
+  if (!element_id) return undefined;
+  const clean_id = element_id.startsWith('#') ? element_id.substring(1) : element_id;
+  const xu_ui_id = func.runtime.ui._element_id_to_xu_ui_id[clean_id];
+  if (xu_ui_id) {
+    return func.runtime.ui._meta_store[xu_ui_id];
+  }
+  return undefined;
+};
+func.runtime.ui.find_element_by_id = function () {
+  return null;
+};
+func.runtime.ui.get_session_root = function () {
+  return null;
+};
+func.runtime.ui.clear_screen_blockers = function () {
+  // no-op in headless
+};
+
+// ── Virtual element representation ──
+var _next_id = 1;
+function create_virtual_element(tag, attrs) {
+  return {
+    _v_id: _next_id++,
+    tag: tag || 'div',
+    attrs: attrs || {},
+    children: [],
+    parent: null,
+    style: {},
+    classList: [],
+    textContent: '',
+    innerHTML: '',
+    hidden: false,
+    _data: {},
+  };
+}
+
+// ── Core adapter methods ──
+func.runtime.ui.as_jquery = function (target) {
+  if (!target) return { length: 0, data: function () { return {}; }, toArray: function () { return []; }, attr: function () { return undefined; } };
+  if (target._v_id) return target;
+  return target;
+};
+func.runtime.ui.get_first_node = function (target) {
+  if (!target) return null;
+  if (target._v_id) return target;
+  if (Array.isArray(target)) return target[0] || null;
+  return null;
+};
+func.runtime.ui.get_data = function (target) {
+  if (!target) return {};
+  if (target._v_id) {
+    const xu_ui_id = target.attrs?.['xu-ui-id'];
+    if (xu_ui_id) {
+      const meta = func.runtime.ui._meta_store[xu_ui_id];
+      if (meta) return meta;
+    }
+    return target._data;
+  }
+  return {};
+};
+func.runtime.ui.get_parent = function (target) {
+  if (target?._v_id) return target.parent;
+  return null;
+};
+func.runtime.ui.get_children = function (target) {
+  if (target?._v_id) return target.children.slice();
+  return [];
+};
+func.runtime.ui.find_by_selector = function () {
+  return { length: 0, toArray: function () { return []; } };
+};
+func.runtime.ui.insert_before = function ($element) { return $element; };
+func.runtime.ui.insert_after = function ($element) { return $element; };
+func.runtime.ui.has_selector = function () { return false; };
+func.runtime.ui.append_html = function (target) { return target; };
+func.runtime.ui.set_style = function (target, prop, value) {
+  if (target?._v_id) target.style[prop] = value;
+  return target;
+};
+func.runtime.ui.get_attr = function (target, key) {
+  if (target?._v_id) return target.attrs[key];
+  return undefined;
+};
+func.runtime.ui.set_attr = function (target, key, value) {
+  if (target?._v_id) target.attrs[key] = value;
+  return target;
+};
+func.runtime.ui.set_data = function (target, key, value) {
+  if (target?._v_id) {
+    target._data[key] = value;
+    const xu_ui_id = target.attrs?.['xu-ui-id'];
+    if (xu_ui_id) {
+      func.runtime.ui.set_meta(xu_ui_id, key, value);
+    }
+  }
+  return target;
+};
+func.runtime.ui.clear_data = function (target) {
+  if (target?._v_id) {
+    target._data = {};
+    const xu_ui_id = target.attrs?.['xu-ui-id'];
+    if (xu_ui_id) func.runtime.ui.delete_meta(xu_ui_id);
+  }
+  return target;
+};
+func.runtime.ui.add_class = function (target, cls) {
+  if (target?._v_id && cls && !target.classList.includes(cls)) target.classList.push(cls);
+  return target;
+};
+func.runtime.ui.remove_class = function (target, cls) {
+  if (target?._v_id) {
+    const idx = target.classList.indexOf(cls);
+    if (idx !== -1) target.classList.splice(idx, 1);
+  }
+  return target;
+};
+func.runtime.ui.set_html = function (target, value) {
+  if (target?._v_id) target.innerHTML = value;
+  return target;
+};
+func.runtime.ui.set_text = function (target, value) {
+  if (target?._v_id) target.textContent = value;
+  return target;
+};
+func.runtime.ui.show = function (target) {
+  if (target?._v_id) target.hidden = false;
+  return target;
+};
+func.runtime.ui.hide = function (target) {
+  if (target?._v_id) target.hidden = true;
+  return target;
+};
+func.runtime.ui.append = function ($target, $element) {
+  if ($target?._v_id && $element?._v_id) {
+    $target.children.push($element);
+    $element.parent = $target;
+  }
+  return $element;
+};
+func.runtime.ui.append_to = function ($element, $target) {
+  return func.runtime.ui.append($target, $element);
+};
+func.runtime.ui.empty = function (target) {
+  if (target?._v_id) target.children = [];
+  return target;
+};
+func.runtime.ui.remove = function (target) {
+  if (target?._v_id) {
+    const xu_ui_id = target.attrs?.['xu-ui-id'];
+    if (xu_ui_id) func.runtime.ui.delete_meta(xu_ui_id);
+    if (target.parent?._v_id) {
+      const idx = target.parent.children.indexOf(target);
+      if (idx !== -1) target.parent.children.splice(idx, 1);
+    }
+  }
+  return true;
+};
+func.runtime.ui.set_display_contents = function ($element) {
+  return func.runtime.ui.set_style($element, 'display', 'contents');
+};
+func.runtime.ui.create_xurender = function (xu_ui_id, $target, hidden) {
+  const el = create_virtual_element('xurender', { 'xu-ui-id': xu_ui_id });
+  if (hidden) el.hidden = true;
+  return func.runtime.ui.append_to(el, $target);
+};
+func.runtime.ui.replace_with = function ($source, $target) {
+  if ($source?._v_id && $source.parent?._v_id) {
+    const idx = $source.parent.children.indexOf($source);
+    if (idx !== -1 && $target?._v_id) {
+      $source.parent.children[idx] = $target;
+      $target.parent = $source.parent;
+    }
+  }
+  return $target;
+};
+func.runtime.ui.remove_xu_ui = function (xu_ui_id) {
+  func.runtime.ui.delete_meta(xu_ui_id);
+  return true;
+};
+func.runtime.ui.build_debug_info = function (nodeP, $container, items) {
+  const container_data = func.runtime.ui.get_data($container);
+  return {
+    id: nodeP.id,
+    parent_id: container_data?.xuData?.ui_id,
+    items: items,
+  };
+};
+func.runtime.ui.get_node_snapshot = function (nodeP) {
+  if (!nodeP) return nodeP;
+  if (func.runtime.ui.node_snapshot_cache.has(nodeP)) {
+    return func.runtime.ui.node_snapshot_cache.get(nodeP);
+  }
+  const snapshot = structuredClone(nodeP);
+  func.runtime.ui.node_snapshot_cache.set(nodeP, snapshot);
+  return snapshot;
+};
+func.runtime.ui.get_node_child_items = function (nodeP) {
+  if (!nodeP?.children?.length) return [];
+  if (func.runtime.ui.node_child_items_cache.has(nodeP)) {
+    return func.runtime.ui.node_child_items_cache.get(nodeP);
+  }
+  const items = nodeP.children.map(function (val) { return val.xu_tree_id || val.id; });
+  func.runtime.ui.node_child_items_cache.set(nodeP, items);
+  return items;
+};
+func.runtime.ui.get_node_children_by_id = function (nodeP) {
+  if (!nodeP?.children?.length) return {};
+  if (func.runtime.ui.node_children_by_id_cache.has(nodeP)) {
+    return func.runtime.ui.node_children_by_id_cache.get(nodeP);
+  }
+  const children_by_id = {};
+  for (let i = 0; i < nodeP.children.length; i++) {
+    const child = nodeP.children[i];
+    if (child?.id) children_by_id[child.id] = child;
+  }
+  func.runtime.ui.node_children_by_id_cache.set(nodeP, children_by_id);
+  return children_by_id;
+};
+func.runtime.ui.build_container_xu_data = function (options) {
+  const container_data = func.runtime.ui.get_data(options.$container);
+  const containerXuData = container_data?.xuData;
+  return {
+    SESSION_ID: options.SESSION_ID,
+    prog_id: options.paramsP.prog_id,
+    nodeid: options.nodeP.id,
+    ui_type: options.nodeP.tagName,
+    recordid: options.currentRecordId,
+    paramsP: options.paramsP,
+    key: options.keyP,
+    key_path: options.key_path,
+    screenId: options.paramsP.screenId,
+    parent_container: containerXuData?.ui_id,
+    elem_key: options.elem_key,
+    properties: options.prop,
+    node: options.nodeP,
+    node_org: func.runtime.ui.get_node_snapshot(options.nodeP),
+    is_panelP: options.paramsP.is_panelP,
+    ui_id: options.ui_id,
+    elem_prop: options.elem_propP,
+    debug_info: func.runtime.ui.build_debug_info(options.nodeP, options.$container, options.items),
+    parent_node: options.parent_nodeP,
+    currentRecordId: options.currentRecordId,
+    $root_container: options.$root_container,
+    parent_element_ui_id: containerXuData?.ui_id,
+    is_placeholder: !!options.is_placeholder,
+  };
+};
+func.runtime.ui.apply_container_meta = function ($div, options) {
+  if ($div?._v_id) $div.attrs['xu-ui-id'] = options.ui_id;
+  const xuData = func.runtime.ui.build_container_xu_data(options);
+  if (options.parent_infoP?.iterate_info) {
+    xuData.iterate_info = options.parent_infoP.iterate_info;
+  }
+  if ($div?._v_id) {
+    $div._data.xuData = xuData;
+    $div._data.xuAttributes = {};
+  }
+  func.runtime.ui.set_meta(options.ui_id, 'xuData', xuData);
+  func.runtime.ui.set_meta(options.ui_id, 'xuAttributes', {});
+  if (options.is_placeholder && $div?._v_id) $div.classList.push('display_none');
+  if (options.classP && $div?._v_id) $div.classList.push(options.classP);
+  return $div;
+};
+func.runtime.ui.get_append_target = function ($container, $appendToP) {
+  return $appendToP || $container || null;
+};
+func.runtime.ui.create_element = function (tag_name) {
+  return create_virtual_element(tag_name);
+};
+func.runtime.ui.create_svg_element = function () {
+  return create_virtual_element('svg');
+};
+func.runtime.ui.create_container_element = function (div_typeP) {
+  return create_virtual_element(div_typeP || 'div');
+};
+func.runtime.ui.build_xu_ui_id_seed = function (nodeP, dsSessionP, key_path, currentRecordId) {
+  const nodeId = nodeP.xu_tree_id || nodeP.id;
+  const elem_key = `${nodeId}-${key_path}-${currentRecordId}`;
+  return `${nodeP.id}-${elem_key}-${dsSessionP?.toString() || ''}`;
+};
+func.runtime.ui.generate_xu_ui_id = async function (SESSION_ID, nodeP, $container, paramsP, keyP, precomputed) {
+  precomputed = precomputed || {};
+  const dsSessionP = paramsP.dsSessionP;
+  const _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  const containerXuData = precomputed.container_xu_data || func.runtime.ui.get_data($container)?.xuData;
+  const currentRecordId = typeof precomputed.currentRecordId !== 'undefined' ? precomputed.currentRecordId : containerXuData?.recordid || _ds?.currentRecordId || '';
+  const key_path = precomputed.key_path || `${containerXuData?.key_path || '0'}-${keyP || '0'}`;
+  const ui_id = func.runtime.ui.build_xu_ui_id_seed(nodeP, dsSessionP, key_path, currentRecordId);
+
+  if (func.runtime.ui.ui_id_hash_cache.has(ui_id)) {
+    return func.runtime.ui.ui_id_hash_cache.get(ui_id);
+  }
+
+  const hashed_ui_id = await func.common.fastHash(ui_id);
+  func.runtime.ui.ui_id_hash_cache.set(ui_id, hashed_ui_id);
+  return hashed_ui_id;
+};
+func.runtime.ui.create_container = async function (options) {
+  const _paramsP = structuredClone(options.paramsP);
+  const _ds = SESSION_OBJ[options.SESSION_ID].DS_GLB[_paramsP.dsSessionP];
+  const $appendTo = func.runtime.ui.get_append_target(options.$container, options.$appendToP);
+  if (!$appendTo) return null;
+  const container_data = func.runtime.ui.get_data(options.$container);
+  const container_xu_data = container_data?.xuData;
+  const items = func.runtime.ui.get_node_child_items(options.nodeP);
+  const currentRecordId = container_xu_data?.recordid || (_ds ? _ds.currentRecordId : '');
+
+  try {
+    const key_path = `${container_xu_data?.key_path || '0'}-${options.keyP || '0'}`;
+    const elem_key = `${options.nodeP.xu_tree_id || options.nodeP.id}-${key_path}-${currentRecordId}`;
+    const $div = func.runtime.ui.create_container_element(options.div_typeP);
+    const new_ui_id = await func.runtime.ui.generate_xu_ui_id(options.SESSION_ID, options.nodeP, options.$container, options.paramsP, options.keyP, {
+      container_xu_data,
+      currentRecordId,
+      key_path,
+    });
+
+    func.runtime.ui.apply_container_meta($div, {
+      ui_id: new_ui_id,
+      paramsP: _paramsP,
+      nodeP: options.nodeP,
+      currentRecordId,
+      keyP: options.keyP,
+      key_path,
+      $container: options.$container,
+      prop: options.prop,
+      elem_key,
+      elem_propP: options.elem_propP,
+      items,
+      parent_nodeP: options.parent_nodeP,
+      $root_container: options.$root_container,
+      parent_infoP: options.parent_infoP,
+      is_placeholder: options.is_placeholder,
+      classP: options.classP,
+      SESSION_ID: options.SESSION_ID,
+    });
+
+    func.runtime.ui.append_to($div, $appendTo);
+    return $div;
+  } catch (e) {
+    console.error(e);
+  }
+
+  return null;
+};
  func.datasource = {};
 func.datasource.create = async function (
   SESSION_ID,
@@ -2351,7 +2934,7 @@ func.datasource.create = async function (
     }
     // vvvv run at worker vvvv
     if (_ds) IS_DATASOURCE_REFRESH = true;
-    var data = _.assignIn(
+    var data = Object.assign(
       {
         session_id: SESSION_ID,
         dataSourceSessionGlobal: SESSION_OBJ[SESSION_ID].dataSourceSessionGlobal,
@@ -2406,7 +2989,7 @@ func.datasource.prepare = async function (SESSION_ID, prog_id, dataSourceNoP, pa
       // &&
       // glb.PARAMETER_NODES_ARR.includes(screenInfo.properties.menuType)
     ) {
-      if (!_.isEmpty(screenInfo.properties.progParams)) {
+      if (!xu_isEmpty(screenInfo.properties.progParams)) {
         _ds.in_parameters = {};
         _ds.out_parameters = {};
 
@@ -2538,7 +3121,7 @@ func.datasource.prepare = async function (SESSION_ID, prog_id, dataSourceNoP, pa
       _ds.refreshed = true;
 
       if (_ds.watcher) {
-        _.set(_ds, _ds.watcher.path, _ds.watcher.newValue);
+        xu_set(_ds, _ds.watcher.path, _ds.watcher.newValue);
       }
       try {
         if (!_ds.v) _ds.v = {};
@@ -2548,7 +3131,7 @@ func.datasource.prepare = async function (SESSION_ID, prog_id, dataSourceNoP, pa
         _ds.data_feed = {};
 
         // _ds.v.old_dataSource = _.cloneDeep(_ds);
-        _ds.v.old_dataSource = klona.klona(_ds);
+        _ds.v.old_dataSource = structuredClone(_ds);
       } catch (err) {
         console.error('function: init_existing_dataSource - error');
         return;
@@ -3525,7 +4108,7 @@ func.datasource.execute_field_init_events = async function (SESSION_ID, dataSour
       var expression = undefined;
       if (val.eventInfo.props.condition) expression = val.eventInfo.props.condition;
       var expCond = {};
-      if (expression && !_.isEmpty(expression)) {
+      if (expression && !xu_isEmpty(expression)) {
         // check if expression exist
         expCond = await func.expression.get(SESSION_ID, expression, dataSourceSession, 'condition', rowIdP, null, null, val.fieldId); // execute expression
         cond = expCond.result;
@@ -3669,7 +4252,7 @@ func.datasource.get_view_events_count = async function (SESSION_ID, dataSourceSe
 
   _ds.viewEventExec_arr[index] = [];
 
-  if (!_prog.progEvents || _.isEmpty(_prog.progEvents)) return 0;
+  if (!_prog.progEvents || xu_isEmpty(_prog.progEvents)) return 0;
 
   for (const event_obj of _prog.progEvents) {
     if (event_obj.data.type !== typeP) continue; // was false?? changed to true 020317
@@ -3682,7 +4265,7 @@ func.datasource.get_view_events_count = async function (SESSION_ID, dataSourceSe
       }
     }
 
-    if (_.isEmpty(event_obj.workflow)) continue;
+    if (xu_isEmpty(event_obj.workflow)) continue;
     for (const trigger_obj of event_obj.workflow) {
       if (trigger_obj.data.enabled) {
         var expression;
@@ -3735,7 +4318,7 @@ func.datasource.execute_view_events = async function (SESSION_ID, dataSourceSess
   var index = typeP;
   if (eventIdP) index = typeP + '_' + eventIdP;
   var arr = _ds.viewEventExec_arr[index];
-  if (_.isEmpty(arr)) return;
+  if (xu_isEmpty(arr)) return;
 
   for await (const val of arr) {
     if (!glb.IS_WORKER || !func.utils.is_onscreen_event(val.eventInfo.data.action) || (glb.IS_WORKER && _ds.v.run_at === 'server' && !func.utils.is_onscreen_event(val.eventInfo.data.action))) {
@@ -3748,7 +4331,8 @@ func.datasource.execute_view_events = async function (SESSION_ID, dataSourceSess
       if (cond) {
         var elem_params = undefined;
         if (!glb.IS_WORKER) {
-          elem_params = $('#' + _ds.containerId).data('params');
+          const container_meta = func.runtime.ui.get_meta_by_element_id(_ds.containerId);
+          elem_params = container_meta?.params;
         }
         const ret = await func.events.execute(
           SESSION_ID,
@@ -3866,12 +4450,12 @@ func.datasource.clean_all = function (SESSION_ID, dsP) {
 
   var get_child_ds = function (ds) {
     var arr = [];
-    _.forEach(SESSION_OBJ[SESSION_ID].DS_GLB, function (val, key) {
+    for (const [key, val] of Object.entries(SESSION_OBJ[SESSION_ID].DS_GLB)) {
       if (val.parentDataSourceNo == ds) {
         arr.push(key);
         arr = arr.concat(get_child_ds(key));
       }
-    });
+    }
     return arr;
   };
 
@@ -3884,13 +4468,13 @@ func.datasource.clean = function (SESSION_ID, screenIdP) {
   var arr = [];
   for (const [key, val] of Object.entries(SESSION_OBJ[SESSION_ID].DS_GLB)) {
     try {
+      const _screen_el = val.screenId ? document.getElementById(val.screenId) : null;
+      const screen_parent_id = _screen_el?.parentElement?.id || null;
       if (
         Number(key) > 0 &&
         (val.screenId === screenIdP ||
           val.rootScreenId === screenIdP ||
-          $('#' + val.screenId)
-            .parent()
-            .attr('id') === screenIdP ||
+          screen_parent_id === screenIdP ||
           (val && val.parentDataSourceNo && arr.includes(val.parentDataSourceNo.toString())))
       ) {
         arr.push(key);
@@ -3956,14 +4540,12 @@ func.datasource.del = function (SESSION_ID, dsP) {
 
   var delete_pending_jobs = function () {
     var arr = [];
-    _.forEach(SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs, function (val, key) {
+    for (const [key, val] of Object.entries(SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs)) {
       if (val && val.dsSessionP == dsP) {
         arr.push(key);
-        for (const [key, val] of Object.entries($('.screen_blocker'))) {
-          $(val).remove();
-        }
+        func.runtime.ui.clear_screen_blockers();
       }
-    });
+    }
     for (let val of arr.reverse()) {
       SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs.splice(val, 1);
     }
@@ -3982,8 +4564,9 @@ func.datasource.del = function (SESSION_ID, dsP) {
         }
       }
     }
-    if ($(SESSION_OBJ[SESSION_ID].root_element).find('xu-nav').length) {
-      var ds_obj = $(SESSION_OBJ[SESSION_ID].root_element).find('xu-nav')?.data()?.xuData.nav_params;
+    const _nav_node = func.runtime.ui.get_first_node(SESSION_OBJ[SESSION_ID].root_element)?.querySelector?.('xu-nav');
+    if (_nav_node) {
+      var ds_obj = func.runtime.ui.get_data(_nav_node)?.xuData?.nav_params;
       if (ds_obj) {
         delete ds_obj[dsP];
       }
@@ -4090,7 +4673,7 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
         for (const [field_id, value] of Object.entries(fields_data)) {
           // mechanism to make update directly on the datasource object
           if (record_id === 'datasource_main') {
-            _.set(_ds, field_id, value);
+            xu_set(_ds, field_id, value);
             const ret = update_xu_ref(dataSource);
             if (ret) {
               fields_changed.push(field_id);
@@ -4119,7 +4702,7 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
 
               await func.runtime.ui.refresh_screen({
                 SESSION_ID,
-                fields_changed_arr: klona.klona(fields_changed),
+                fields_changed_arr: structuredClone(fields_changed),
                 datasource_changed: datasource_changed[0],
                 fields_changed_datasource: datasource_changed[0],
                 watcher: value,
@@ -4138,7 +4721,7 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
             try {
               const row_idx = func.common.find_ROWID_idx(_ds, record_id);
               // if (_ds.data_feed.rows[row_idx][field_id] !== value) {
-              if (!_.isEqual(_ds.data_feed.rows[row_idx][field_id], value)) {
+              if (!xu_isEqual(_ds.data_feed.rows[row_idx][field_id], value)) {
                 _ds.data_feed.rows[row_idx][field_id] = value;
                 await set_fieldComputed_dependencies(dataSource, field_id, null);
 
@@ -4211,11 +4794,11 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
     }
 
     if (glb.IS_WORKER) {
-      if (!update_local_scope_only && !_.isEmpty(client_datasource_changes)) {
+      if (!update_local_scope_only && !xu_isEmpty(client_datasource_changes)) {
         func.utils.post_back_to_client(SESSION_ID, 'update_client_eventChangesResults_from_worker', _session.worker_id, client_datasource_changes);
       }
     } else {
-      if (!update_local_scope_only && !_.isEmpty(server_datasource_changes)) {
+      if (!update_local_scope_only && !xu_isEmpty(server_datasource_changes)) {
         const ret = await func.index.call_worker(SESSION_ID, {
           service: 'update_datasource_changes_from_client',
           data: {
@@ -4234,7 +4817,7 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
         // await func.UI.screen.refresh_xu_attributes(SESSION_ID, _.cloneDeep(fields_changed), null, null, findMin(datasource_changed), avoid_xu_for_refresh, trigger);
         await func.runtime.ui.refresh_xu_attributes({
           SESSION_ID,
-          fields_arr: klona.klona(fields_changed),
+          fields_arr: structuredClone(fields_changed),
           jobNoP: null,
           $elm_to_search: null,
           dsSession_changed: findMin(datasource_changed),
@@ -4245,7 +4828,7 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
         // await removed from the below function cause to dead lock Mar 3 25
         await func.runtime.ui.refresh_screen({
           SESSION_ID,
-          fields_changed_arr: klona.klona(fields_changed),
+          fields_changed_arr: structuredClone(fields_changed),
           datasource_changed: null,
           fields_changed_datasource: datasource_changed[0],
         });
@@ -4316,7 +4899,7 @@ func.datasource.callback = async function (SESSION_ID, dsSessionP, rowIdP, jobNo
     dsSession: dsSessionP,
     prop: _ds.log_prop + ' ' + 'adapter',
   });
-  if (!glb.IS_WORKER) $(_session.root_element).css('cursor', 'default');
+  if (!glb.IS_WORKER) func.runtime.platform.set_cursor(_session.root_element, 'default');
 
   if (_ds.prog_id) {
     let _ds = _session.DS_GLB[dsSessionP];
@@ -4868,7 +5451,7 @@ func.datasource.get_viewLoops = async function (SESSION_ID, dataSourceSession, d
   // var v = _ds.v;
   var ret = default_limit;
 
-  if (batch_source === 'db_data') ret = _.size(data.rows);
+  if (batch_source === 'db_data') ret = data.rows.length;
   if (batch_source === 'array' || batch_source === 'csv') ret = data.length;
   if (batch_source === 'json') ret = Object.keys(data).length;
   if (_ds.progDataSource?.dataSourceLimit) {
@@ -4895,7 +5478,7 @@ func.datasource.set_VIEW_data = async function (SESSION_ID, args, _ds) {
   };
   _ds.viewEventExec_arr = {};
 
-  var view = _.cloneDeep(await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id));
+  var view = structuredClone(await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id));
   // var view = klona.klona(await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id));
 
   _ds.v.dataSourceSrcType = view.dataSourceSrcType;
@@ -4941,11 +5524,11 @@ func.datasource.get_cast_val = async function (SESSION_ID, source, dsSession, va
     if (error) {
       return func.utils.debug_report(SESSION_ID, msg, '', 'W');
     }
-    func.utils.debug_report(SESSION_ID, msg + ' ' + _.capitalize(source) + prog_info, '', 'E');
+    func.utils.debug_report(SESSION_ID, msg + ' ' + (source.charAt(0).toUpperCase() + source.slice(1).toLowerCase()) + prog_info, '', 'E');
   };
   const report_conversion_warn = function (res) {
     var msg = `type mismatch auto conversion from value ${valP} to ${typeP}`;
-    func.utils.debug_report(SESSION_ID, msg + ' ' + _.capitalize(source) + prog_info, '', 'W');
+    func.utils.debug_report(SESSION_ID, msg + ' ' + (source.charAt(0).toUpperCase() + source.slice(1).toLowerCase()) + prog_info, '', 'W');
   };
   // var ret = valP;
   if (error) {
@@ -5014,7 +5597,7 @@ func.datasource.update_changes_for_out_parameter = async function (SESSION_ID, d
         }
       }
     }
-    if (!_.isEmpty(data)) {
+    if (!xu_isEmpty(data)) {
       let datasource_changes = {
         [calling_dsP]: { [_calling_ds.currentRecordId]: data },
       };
@@ -5125,7 +5708,7 @@ func.utils.DOCS_OBJ.get = async function (SESSION_ID, idP) {
 
     if (idP !== 'system') {
       DOCS_OBJ[_app_id][idP] = await module.DOCS_OBJ_get(SESSION_ID, idP);
-      if (DOCS_OBJ[_app_id][idP] && _.isEmpty(DOCS_OBJ[_app_id][idP])) {
+      if (DOCS_OBJ[_app_id][idP] && xu_isEmpty(DOCS_OBJ[_app_id][idP])) {
         await func.utils.remove_cached_objects(SESSION_ID);
 
         delete DOCS_OBJ[_app_id][idP];
@@ -5137,7 +5720,7 @@ func.utils.DOCS_OBJ.get = async function (SESSION_ID, idP) {
     if (APP_OBJ[_app_id].app_imported_projects) {
       for await (const imported_app_id of APP_OBJ[_app_id].app_imported_projects) {
         var view_ret = await module.DOCS_OBJ_get(SESSION_ID, 'global_' + imported_app_id);
-        DOCS_OBJ[_app_id][idP] = _.merge(DOCS_OBJ[_app_id][idP], view_ret);
+        DOCS_OBJ[_app_id][idP] = Object.assign(DOCS_OBJ[_app_id][idP], view_ret);
       }
     }
     return DOCS_OBJ[_app_id][idP];
@@ -5219,13 +5802,13 @@ func.utils.get_dateTime = async function (SESSION_ID, typeP, dateP) {
     let ts = await get_server_ts();
     sysDate = new Date(ts);
   }
-  var day = _.padStart(sysDate.getDate(), 2, '0');
-  var month = _.padStart(sysDate.getMonth() + 1, 2, '0');
+  var day = String(sysDate.getDate()).padStart(2, '0');
+  var month = String(sysDate.getMonth() + 1).padStart(2, '0');
   var year = sysDate.getFullYear();
-  var week = _.padStart(getWeekNumber(sysDate), 2, '0');
-  var hour = _.padStart(sysDate.getHours(), 2, '0');
-  var minute = _.padStart(sysDate.getMinutes(), 2, '0');
-  var second = _.padStart(sysDate.getSeconds(), 2, '0');
+  var week = String(getWeekNumber(sysDate)).padStart(2, '0');
+  var hour = String(sysDate.getHours()).padStart(2, '0');
+  var minute = String(sysDate.getMinutes()).padStart(2, '0');
+  var second = String(sysDate.getSeconds()).padStart(2, '0');
   if (typeP === 'SYS_DATE') return year + '-' + month + '-' + day;
   if (typeP === 'SYS_DATE_TIME') return year + '-' + month + '-' + day + 'T' + hour + ':' + minute;
   if (typeP === 'SYS_DATE_VALUE') return sysDate.valueOf();
@@ -5263,7 +5846,7 @@ func.utils.clean_returned_datasource = function (SESSION_ID, DS) {
   var _session = SESSION_OBJ[SESSION_ID];
   if (!_session.DS_GLB[DS]) return;
 
-  var obj = _.clone(_session.DS_GLB[DS]);
+  var obj = { ..._session.DS_GLB[DS] };
 
   delete obj.screen_params;
 
@@ -5283,7 +5866,7 @@ func.utils.clean_returned_datasource = function (SESSION_ID, DS) {
 
   const clean_empty_objects = function () {
     for (const [key, val] of Object.entries(obj)) {
-      if (typeof val === 'object' && !Array.isArray(val) && _.isEmpty(val)) {
+      if (typeof val === 'object' && !Array.isArray(val) && xu_isEmpty(val)) {
         delete obj[key];
       }
     }
@@ -5386,7 +5969,7 @@ func.utils.job_worker = function (session_id) {
     func.utils.debug_report(SESSION_ID, 'utils.worker.reset', 'worker not responding', 'E', '', _session.WORKER_OBJ.jobs);
     _session.WORKER_OBJ.jobs = [];
     _session.WORKER_OBJ.stat = null;
-    $('.screen_blocker').remove();
+    func.runtime.ui.clear_screen_blockers();
   };
   return {
     _interval: null,
@@ -5527,8 +6110,9 @@ func.utils.makeid = function (length) {
 func.utils.get_device = function () {
   var device;
   try {
-    if (window.cordova) {
-      device = window.cordova.platformId;
+    const win = func.runtime.platform.get_window();
+    if (win?.cordova) {
+      device = win.cordova.platformId;
     }
   } catch (e) {
     console.error('error using ui element in server side request');
@@ -5673,7 +6257,7 @@ func.utils.ws_worker.functions = {
     });
   },
   update_datasource_changes_from_client: async function (params, promise_queue_id) {
-    if (_.isEmpty(SESSION_OBJ)) return;
+    if (xu_isEmpty(SESSION_OBJ)) return;
     var SESSION_ID = params.session_id;
     var _session = SESSION_OBJ[SESSION_ID];
     if (!_session) {
@@ -5869,16 +6453,8 @@ func.utils.clean_stringify_null = function (key, value) {
 
 func.utils.load_js_on_demand = async function (js_src, type) {
   const get_script = function (callback) {
-    function getScript(scriptUrl, callback) {
-      const script = document.createElement('script');
-      script.src = scriptUrl;
-      if (type) script.type = type;
-      script.onload = callback;
-
-      document.head.appendChild(script);
-    }
     if (glb.IS_WORKER) {
-      callback(script);
+      callback();
       return;
     }
     function isScriptLoaded(src) {
@@ -5888,8 +6464,7 @@ func.utils.load_js_on_demand = async function (js_src, type) {
     if (isScriptLoaded(js_src)) {
       callback(false);
     } else {
-      getScript(js_src, function (response, status) {
-        // console.log(response,status)
+      func.runtime.platform.load_script(js_src, type, function () {
         callback(true);
         GLB_JS_SCRIPTS_LOADED.push(js_src);
       });
@@ -5902,33 +6477,11 @@ func.utils.load_js_on_demand = async function (js_src, type) {
 };
 
 func.utils.load_css_on_demand = function (css_href) {
-  function isCssLoaded(src) {
-    try {
-      return document.querySelector('link[href="' + src + '"]') ? true : false;
-    } catch (err) {
-      console.warn(`load css ${css_href} failed`);
-      return true;
-    }
-  }
-
-  if (isCssLoaded(css_href)) {
-    return;
-  }
-  return $('<link/>', {
-    rel: 'stylesheet',
-    type: 'text/css',
-    href: css_href,
-  }).prependTo('head');
+  func.runtime.platform.load_css(css_href);
 };
 
 func.utils.remove_js_css_file = function (filename, filetype) {
-  var targetelement = filetype == 'js' ? 'script' : filetype == 'css' ? 'link' : 'none'; //determine element type to create nodelist from
-  var targetattr = filetype == 'js' ? 'src' : filetype == 'css' ? 'href' : 'none'; //determine corresponding attribute to test for
-  var allsuspects = document.getElementsByTagName(targetelement);
-  for (var i = allsuspects.length; i >= 0; i--) {
-    //search backwards within node list for matching elements to remove
-    if (allsuspects[i] && allsuspects[i].getAttribute(targetattr) != null && allsuspects[i].getAttribute(targetattr).indexOf(filename) != -1) allsuspects[i].parentNode.removeChild(allsuspects[i]); //remove element by calling parentNode.removeChild()
-  }
+  func.runtime.platform.remove_js_css(filename, filetype);
 };
 
 func.utils.replace_studio_drive_url = function (SESSION_ID, val) {
@@ -6275,7 +6828,7 @@ func.utils.alerts.popup = function (title, message, alert_type) {
     },
   ];
 
-  popup.create(_.upperFirst(alert_type), title, message, buttons);
+  popup.create(alert_type.charAt(0).toUpperCase() + alert_type.slice(1), title, message, buttons);
 };
 
 func.utils.get_system_error_msg = function () {
@@ -6922,7 +7475,7 @@ func.utils.call_plugin_api = function (SESSION_ID, plugin_nameP, dataP) {
       app_token: _session.app_token,
     };
 
-    data = _.assignIn(data, dataP);
+    data = Object.assign(data, dataP);
 
     fetch(`https://xuda.ai/ppi/${plugin_nameP}`, {
       method: 'POST',
@@ -7080,7 +7633,7 @@ func.utils.get_resource_filename = function (build, filename) {
 };
 
 func.utils.set_SYS_GLOBAL_OBJ_WIDGET_INFO = async function (SESSION_ID, docP) {
-  var obj = _.clone(docP);
+  var obj = { ...docP };
   obj.date = await func.utils.get_dateTime(SESSION_ID, 'SYS_DATE', docP.date);
   obj.time = await func.utils.get_dateTime(SESSION_ID, 'SYS_TIME', docP.date);
 
@@ -7195,7 +7748,7 @@ func.events.validate = async function (SESSION_ID, triggerP, dsSessionP, eventId
 
                   let value = await func.common.get_cast_val(SESSION_ID, 'events', fieldId, field_info.props.fieldType, args[fieldId].value);
 
-                  if (!_.isEmpty(args[fieldId].fx)) {
+                  if (!xu_isEmpty(args[fieldId].fx)) {
                     const fx_ret = await func.expression.get(SESSION_ID, args[fieldId].fx, dsSessionP, 'update');
                     value = fx_ret.result;
                   }
@@ -7217,7 +7770,7 @@ func.events.validate = async function (SESSION_ID, triggerP, dsSessionP, eventId
                 if (_event.workflow) {
                   // check if event property exist
 
-                  if (!_event.workflow || _.isEmpty(_event.workflow)) return;
+                  if (!_event.workflow || xu_isEmpty(_event.workflow)) return;
                   // check events has rows
                   for (const trigger_obj of _event.workflow) {
                     //run events rows
@@ -7237,17 +7790,19 @@ func.events.validate = async function (SESSION_ID, triggerP, dsSessionP, eventId
                       if (_ds.panel_div_id) {
                         try {
                           container = '#' + _ds.panel_div_id;
-                          if ($(container).data().xuData.panel_info) {
-                            screen_prop = $(container).data().xuData.panel_info.paramsP;
+                          const panel_meta = func.runtime.ui.get_meta_by_element_id(_ds.panel_div_id);
+                          if (panel_meta?.xuData?.panel_info) {
+                            screen_prop = panel_meta.xuData.panel_info.paramsP;
                           } else {
                             ///////////////
                             container = '#' + _session.DS_GLB[dsSessionP].screenId;
+                            const screen_meta = func.runtime.ui.get_meta_by_element_id(_session.DS_GLB[dsSessionP].screenId);
 
-                            if ($(container) && $(container).data()) {
-                              screen_prop = $(container).data().xuData.paramsP;
+                            if (screen_meta?.xuData) {
+                              screen_prop = screen_meta.xuData.paramsP;
                             }
 
-                            if (!$(container) || !$(container).length) {
+                            if (!screen_meta) {
                               container = '#' + _session.DS_GLB[dsSessionP].containerId;
                             }
                             //////////////
@@ -7257,12 +7812,13 @@ func.events.validate = async function (SESSION_ID, triggerP, dsSessionP, eventId
                         }
                       } else {
                         container = '#' + _ds.screenId;
+                        const screen_meta = func.runtime.ui.get_meta_by_element_id(_ds.screenId);
 
-                        if ($(container) && $(container).data()) {
-                          screen_prop = $(container).data().xuData.paramsP;
+                        if (screen_meta?.xuData) {
+                          screen_prop = screen_meta.xuData.paramsP;
                         }
 
-                        if (!$(container) || !$(container).length) {
+                        if (!screen_meta) {
                           container = '#' + _ds.containerId;
                         }
                       }
@@ -7433,12 +7989,12 @@ func.events.find_job_index = function (SESSION_ID, jobNoP) {
   var _session = SESSION_OBJ[SESSION_ID];
   var ret = null;
   if (!_session.WORKER_OBJ) return ret;
-  _.forEach(_session.WORKER_OBJ.jobs, function (val, key) {
+  for (const [key, val] of Object.entries(_session.WORKER_OBJ.jobs)) {
     if (val && val.job_num == jobNoP) {
       ret = key;
-      return false;
+      break;
     }
-  });
+  }
   return ret;
 };
 func.events.execute = async function (
@@ -7500,7 +8056,7 @@ func.events.execute = async function (
   var field_elm = elementP;
 
   var calling_field_id = field_elm;
-  if (field_elm && typeof field_elm === 'object') calling_field_id = field_elm.attr('xu-ui-id');
+  if (field_elm && typeof field_elm === 'object') calling_field_id = func.runtime.ui.get_attr(field_elm, 'xu-ui-id');
 
   var log_nodeId;
   var log_prog_id;
@@ -7663,7 +8219,7 @@ func.events.execute = async function (
       var $calling_container;
       if (_session.WORKER_OBJ.jobs[job_index]) {
         if (_session.WORKER_OBJ.jobs[job_index].paramsP) {
-          $calling_container = $('#' + _session.WORKER_OBJ.jobs[job_index].paramsP.callingContainerP);
+          $calling_container = func.runtime.ui.find_element_by_id(_session.WORKER_OBJ.jobs[job_index].paramsP.callingContainerP);
         } else {
           $calling_container = ''; // calling from datasource 0
           _session.WORKER_OBJ.jobs[job_index].paramsP = {};
@@ -7679,7 +8235,7 @@ func.events.execute = async function (
       return await func.runtime.ui.init_screen({
         SESSION_ID,
         prog_id: await get_prog_id(),
-        sourceScreenP: $(containerP)?.data()?.xuData.screenId,
+        sourceScreenP: func.runtime.ui.get_data(containerP)?.xuData?.screenId,
         callingDataSource_objP: _session.DS_GLB[dsSession],
         $callingContainerP: $calling_container,
         triggerIdP: eventIdP,
@@ -7711,7 +8267,7 @@ func.events.execute = async function (
       var _session = SESSION_OBJ[SESSION_ID];
 
       const set_SYS_GLOBAL_OBJ_WIDGET_INFO = async function (docP) {
-        var obj = _.clone(docP);
+        var obj = { ...docP };
         obj.date = await func.utils.get_dateTime(SESSION_ID, 'SYS_DATE', docP.date);
         obj.time = await func.utils.get_dateTime(SESSION_ID, 'SYS_TIME', docP.date);
 
@@ -7926,7 +8482,7 @@ func.events.execute = async function (
     emit_event: async function () {
       if (refIdP.value) {
         //  if (descP.value) {
-        $(document).trigger(refIdP.value, [_session.DS_GLB[dsSession]]);
+        func.runtime.platform.emit(refIdP.value, [_session.DS_GLB[dsSession]]);
       } else {
         func.utils.debug_report(SESSION_ID, 'func.events.execute', 'Event name missing', 'E');
       }
@@ -7998,7 +8554,7 @@ func.events.execute = async function (
 
         let _ds_new = _session.DS_GLB[ret.dsSessionP];
         let parameters = args?.calling_trigger_prop?.data?.name?.parameters;
-        if (parameters && !_.isEmpty(parameters)) {
+        if (parameters && !xu_isEmpty(parameters)) {
           await func.datasource.update_changes_for_out_parameter(SESSION_ID, _ds_new.dsSession, _ds.dsSession);
         }
 
@@ -8017,7 +8573,7 @@ func.events.execute = async function (
     },
     update: async function () {
       const obj_values_to_update = func.datasource.get_viewFields_for_update_function(SESSION_ID, calling_trigger_prop, null, dsSessionP);
-      if (!obj_values_to_update || _.isEmpty(obj_values_to_update)) {
+      if (!obj_values_to_update || xu_isEmpty(obj_values_to_update)) {
         func.utils.debug_report(SESSION_ID, 'Update values object is empty', '', 'W');
         if (jobNoP) func.events.delete_job(SESSION_ID, jobNoP);
         return;
@@ -8027,12 +8583,14 @@ func.events.execute = async function (
       for await (const [key, val] of Object.entries(obj_values_to_update)) {
         var $element;
 
+        var iterate_info = null;
         if (elementP) {
-          $element = $(`[xu-ui-id="${elementP}"]`).clone(true);
+          const element_meta = func.runtime.ui.get_meta(elementP, 'xuData');
+          iterate_info = element_meta?.iterate_info || null;
         }
 
-        let ret_field_id = await func.expression.get(SESSION_ID, val.id.trim(), dsSessionP, 'update', null, null, null, null, null, null, $element?.length ? $element?.data()?.xuData?.iterate_info : null);
-        let ret_value = await func.expression.get(SESSION_ID, val.val.trim(), dsSessionP, 'update', null, null, null, null, null, null, $element?.length ? $element?.data()?.xuData?.iterate_info : null);
+        let ret_field_id = await func.expression.get(SESSION_ID, val.id.trim(), dsSessionP, 'update', null, null, null, null, null, null, iterate_info);
+        let ret_value = await func.expression.get(SESSION_ID, val.val.trim(), dsSessionP, 'update', null, null, null, null, null, null, iterate_info);
         let _field_id = ret_field_id.result;
         let _value = ret_value.result;
 
@@ -8207,11 +8765,11 @@ func.events.execute = async function (
         if (error) {
           return func.utils.debug_report(SESSION_ID, msg, '', 'W');
         }
-        func.utils.debug_report(SESSION_ID, msg + ' ' + _.capitalize(source) + prog_info, '', 'E');
+        func.utils.debug_report(SESSION_ID, msg + ' ' + (source.charAt(0).toUpperCase() + source.slice(1).toLowerCase()) + prog_info, '', 'E');
       };
       const report_conversion_warn = function (res) {
         var msg = `${elementP} >${triggerP} >${functionP} > type mismatch auto conversion from value ${valP} to ${typeP}`;
-        func.utils.debug_report(SESSION_ID, msg + ' ' + _.capitalize(source) + prog_info, '', 'W');
+        func.utils.debug_report(SESSION_ID, msg + ' ' + (source.charAt(0).toUpperCase() + source.slice(1).toLowerCase()) + prog_info, '', 'W');
       };
       // var ret = valP;
       if (error) {
@@ -8226,8 +8784,7 @@ func.events.execute = async function (
       //   report_conversion_warn
       // );
 
-      var payload = _.reduce(
-        payload_arr,
+      var payload = payload_arr.reduce(
         (ret, val, key) => {
           ret[val.key] = module.cast(val.type, val.val, report_conversion_error, report_conversion_warn);
 
@@ -8344,12 +8901,12 @@ func.events.check_jobs_idle = async function (SESSION_ID, jobsP) {
     var listener = setInterval(function () {
       var found;
       for (const [key, val] of Object.entries(jobsP)) {
-        _.forEach(_session.WORKER_OBJ.jobs, function (val2, key2) {
+        for (const [key2, val2] of Object.entries(_session.WORKER_OBJ.jobs)) {
           if (key2 === val) {
             found = true;
-            return false;
+            break;
           }
-        });
+        }
       }
       if (!found) {
         do_callback();
@@ -8357,7 +8914,7 @@ func.events.check_jobs_idle = async function (SESSION_ID, jobsP) {
       }
     }, 100);
     var do_callback = function () {
-      window.clearInterval(listener);
+      clearInterval(listener);
       resolve();
     };
   });
@@ -8369,7 +8926,7 @@ setInterval(function () {
 }, 1000);
 
 func.events.set_browser_changes = function (dsP, fieldsChangedP) {
-  if (fieldsChangedP.includes('SYS_GLOBAL_STR_BROWSER_TITLE')) document.title = dsP.dataset_new['SYS_GLOBAL_STR_BROWSER_TITLE'];
+  if (fieldsChangedP.includes('SYS_GLOBAL_STR_BROWSER_TITLE')) func.runtime.platform.set_title(dsP.dataset_new['SYS_GLOBAL_STR_BROWSER_TITLE']);
 };
 
 func.events.execute_PENDING_OPEN_URL_EVENTS = async function () {
@@ -8392,7 +8949,7 @@ func.events.execute_PENDING_OPEN_URL_EVENTS = async function () {
           prog_id: params_obj.prog,
           sourceScreenP: null,
           callingDataSource_objP: null,
-          $callingContainerP: $('#embed_' + SESSION_ID),
+          $callingContainerP: func.runtime.ui.get_session_root(SESSION_ID),
           triggerIdP: null,
           rowIdP: null,
           jobNoP: null,
@@ -8418,7 +8975,7 @@ func.events.invoke = async function (event_id) {
   var ds;
   for await (const [ds_key, val] of Object.entries(_session.DS_GLB)) {
     const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, val.prog_id);
-    if (_.isEmpty(_view_obj.progEvents)) continue;
+    if (xu_isEmpty(_view_obj.progEvents)) continue;
     if (ds) break;
     for await (const [key, val] of Object.entries(_view_obj.progEvents)) {
       if (val?.data?.type === 'user_defined' && val.data.event_name === event_id) {
@@ -8475,7 +9032,7 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
         }
       }
 
-      ret = ret.replace(/\&amp;/g, '&');
+      if (ret.includes('&amp;')) ret = ret.replace(/\&amp;/g, '&');
       ret = func.utils.replace_studio_drive_url(SESSION_ID, ret);
 
       const end_results = function () {
@@ -8539,13 +9096,13 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
       const variable_not_exist = async function () {
         try {
           if (sourceP !== 'arguments') {
-            if (ret && ret.substr(0, 6) === '_DATE_') {
-              ret = ret.substr(6);
+            if (ret && ret.startsWith('_DATE_')) {
+              ret = ret.slice(6);
             } else if (
-              (ret && ret.length === 10 && ret.substr(4, 1) === '-' && ret.substr(7, 1) === '-') ||
-              ret === 'self' // bypass eval for date 2017-03-22
+              ret === 'self' || // bypass eval for 'self'
+              (ret && ret.length === 10 && ret[4] === '-' && ret[7] === '-') // bypass eval for date 2017-03-22
             ) {
-              ret = ret;
+              // date or 'self' — skip eval, return as-is
             } else {
               ret = await func.expression.secure_eval(SESSION_ID, sourceP, ret, jobNo, dsSessionP, js_script_callback);
             }
@@ -8579,8 +9136,10 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
       var var_Arr = [];
       const split = func.expression.parse(ret) || [];
       // console.log(valP, split);
-      for await (const [arr_key, val] of Object.entries(split)) {
+      const split_entries = Object.entries(split);
+      for (let entry_i = 0; entry_i < split_entries.length; entry_i++) {
         // run each field
+        const [arr_key, val] = split_entries[entry_i];
         const key = Number(arr_key);
         var_Arr[key] = {};
         var_Arr[key].value = val.value;
@@ -8625,14 +9184,16 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
                 var prevData = var_Arr[key - 1].value;
                 var_Arr[key].value = prevData[data]; //  @objB[@var]
                 if (val.value.indexOf('.') > -1) {
-                  property2 = await func.expression.get_property(val.value).property2; //val.value.substr(val.value.indexOf(".") + 1, val.value.length); // get .
+                  const props_split = await func.expression.get_property(val.value);
+                  property2 = props_split.property2;
                   if (prevData[data]) set_value(prevData[data][property2]);
                   //                                    var_Arr[key].value = prevData[data][property2]; //@objB[@var].property
                 }
                 delete var_Arr[key - 1];
               } else {
-                property1 = await func.expression.get_property(val.value).property1;
-                property2 = await func.expression.get_property(val.value).property2;
+                const props = await func.expression.get_property(val.value);
+                property1 = props.property1;
+                property2 = props.property2;
                 if (property1) {
                   var_Arr[key].value = data[property1]; // @var["value"] or @var.property
                   if (property2) {
@@ -8680,7 +9241,7 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
         var exp_exist;
         var var_error_found;
         // merge arr values
-        _.forEach(var_Arr, function (val, key) {
+        var_Arr.forEach(function (val, key) {
           if (sourceP === 'UI Property EXP') {
             let ret = func.utils.get_drive_url(SESSION_ID, val.value, true);
             if (ret.changed) {
@@ -8756,7 +9317,7 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
           if (exp.res) res = exp.res;
           // do second pass when exp exist
           else res = [exp.result];
-          fields = _.assignIn(exp.fields, fieldsP);
+          fields = Object.assign(exp.fields, fieldsP);
         }
         var result = join(res);
 
@@ -9078,9 +9639,15 @@ func.expression.get = async function (SESSION_ID, valP, dsSessionP, sourceP, row
 //   return res;
 // };
 
+func.expression._parse_cache = new Map();
+
 func.expression.parse = function (input) {
   if (typeof input !== 'string') return [];
 
+  if (func.expression._parse_cache.has(input)) {
+    return func.expression._parse_cache.get(input).map(function (s) { return Object.assign({}, s); });
+  }
+
   const segments = [];
   let pos = 0;
 
@@ -9103,7 +9670,14 @@ func.expression.parse = function (input) {
     pos += part.length;
   }
 
-  return segments;
+  // Evict oldest entry if cache exceeds limit
+  if (func.expression._parse_cache.size >= 500) {
+    const firstKey = func.expression._parse_cache.keys().next().value;
+    func.expression._parse_cache.delete(firstKey);
+  }
+  func.expression._parse_cache.set(input, segments);
+
+  return segments.map(function (s) { return Object.assign({}, s); });
 };
 
 func.expression.get_property = async function (valP) {