@domql/element 3.0.7 → 3.1.1

package/dist/esm/__tests__/throughUpdatedDefine.test.js

@@ -0,0 +1,69 @@
+import { throughUpdatedDefine } from "../iterate";
+describe("throughUpdatedDefine", () => {
+  let element, ref;
+  beforeEach(() => {
+    ref = {
+      __exec: {},
+      __defineCache: {}
+    };
+    element = {
+      __ref: ref,
+      define: {},
+      state: { testState: true },
+      context: { testContext: true }
+    };
+  });
+  it("should merge local and global define objects", async () => {
+    element.define = { localProp: () => "local" };
+    element.context.define = { globalProp: () => "global" };
+    await throughUpdatedDefine(element);
+    expect(element.localProp).toBe("local");
+    expect(element.globalProp).toBe("global");
+  });
+  it("should update element properties using cached exec functions", async () => {
+    ref.__exec.testProp = () => "cached value";
+    element.define.testProp = (cached) => `updated ${cached}`;
+    await throughUpdatedDefine(element);
+    expect(element.testProp).toBe("updated cached value");
+    expect(ref.__defineCache.testProp).toBe("cached value");
+  });
+  it("should handle non-function cached values", async () => {
+    ref.__defineCache.testProp = "static value";
+    element.define.testProp = (cached) => `updated ${cached}`;
+    await throughUpdatedDefine(element);
+    expect(element.testProp).toBe("updated static value");
+  });
+  it("should skip updates for undefined or null results", async () => {
+    ref.__exec.testProp = () => "cached value";
+    element.define.testProp = () => null;
+    element.testProp = "original value";
+    await throughUpdatedDefine(element);
+    expect(element.testProp).toBe("original value");
+  });
+  it("should handle empty define objects", async () => {
+    const originalElement = { ...element };
+    await throughUpdatedDefine(element);
+    expect(element).toEqual(originalElement);
+  });
+  it("should pass correct arguments to define functions", async () => {
+    element.define.testProp = (cached, el, state, context) => ({
+      cachedMatch: cached === "cached value",
+      elMatch: el === element,
+      stateMatch: state === element.state,
+      contextMatch: context === element.context
+    });
+    ref.__defineCache.testProp = "cached value";
+    await throughUpdatedDefine(element);
+    expect(element.testProp).toEqual({
+      cachedMatch: true,
+      elMatch: true,
+      stateMatch: true,
+      contextMatch: true
+    });
+  });
+  it("should return an empty changes object", async () => {
+    element.define.testProp = () => "updated value";
+    const changes = await throughUpdatedDefine(element);
+    expect(changes).toEqual({});
+  });
+});

package/dist/esm/__tests__/throughUpdatedExec.test.js

@@ -0,0 +1,84 @@
+import { throughUpdatedExec } from "../iterate";
+describe("throughUpdatedExec", () => {
+  let element, ref;
+  beforeEach(() => {
+    ref = {
+      __exec: {},
+      __defineCache: {}
+    };
+    element = {
+      __ref: ref,
+      state: { testState: true },
+      context: { testContext: true }
+    };
+  });
+  it("should skip execution for params in __defineCache", () => {
+    ref.__defineCache.cachedParam = true;
+    ref.__exec.cachedParam = () => "should not execute";
+    element.cachedParam = "original";
+    const changes = throughUpdatedExec(element);
+    expect(element.cachedParam).toBe("original");
+    expect(changes).toEqual({});
+  });
+  it("should update element properties when newExec differs from current value", () => {
+    ref.__exec.testParam = () => "new value";
+    element.testParam = "old value";
+    const changes = throughUpdatedExec(element);
+    expect(element.testParam).toBe("new value");
+    expect(changes).toEqual({ testParam: "old value" });
+  });
+  it("should overwrite text property for nodes when exec returns string or number", () => {
+    const node = { node: true, text: "old text" };
+    ref.__exec.testParam = () => "new text";
+    element.testParam = node;
+    const changes = throughUpdatedExec(element);
+    expect(element.testParam.text).toBe("new text");
+    expect(changes).toEqual({});
+  });
+  it("should handle component naming matches and overwrite with context component", () => {
+    const contextComponent = { extends: "Component", prop: "value" };
+    element.context.components = { TestComponent: contextComponent };
+    ref.__exec.TestComponent = () => contextComponent;
+    element.TestComponent = { oldProp: "oldValue" };
+    const changes = throughUpdatedExec(element);
+    expect(element.TestComponent).toEqual({
+      oldProp: "oldValue",
+      prop: "value"
+    });
+    expect(changes).toEqual({});
+  });
+  it("should not update element properties when newExec matches current value", () => {
+    ref.__exec.testParam = () => "same value";
+    element.testParam = "same value";
+    const changes = throughUpdatedExec(element);
+    expect(element.testParam).toBe("same value");
+    expect(changes).toEqual({});
+  });
+  it("should handle non-string/non-number exec returns for non-node properties", () => {
+    const newValue = { complex: "object" };
+    ref.__exec.testParam = () => newValue;
+    element.testParam = "old value";
+    const changes = throughUpdatedExec(element);
+    expect(element.testParam).toBe(newValue);
+    expect(changes).toEqual({ testParam: "old value" });
+  });
+  it("should return an empty changes object when no updates occur", () => {
+    ref.__exec.testParam = () => "same value";
+    element.testParam = "same value";
+    const changes = throughUpdatedExec(element);
+    expect(changes).toEqual({});
+  });
+  it("should handle multiple properties and return correct changes", () => {
+    ref.__exec.param1 = () => "new value 1";
+    ref.__exec.param2 = () => "new value 2";
+    element.param1 = "old value 1";
+    element.param2 = "old value 2";
+    const changes = throughUpdatedExec(element);
+    expect(element.param1).toBe("new value 1");
+    expect(element.param2).toBe("new value 2");
+    expect(changes).toEqual({
+      param1: "old value 1",
+      param2: "old value 2"
+    });
+  });
+});

package/dist/esm/__tests__/tree.test.js

@@ -0,0 +1,11 @@
+import { ROOT, TREE } from "../tree";
+describe("ROOT/TREE initialization and report()", () => {
+  it("initializes ROOT with :root key and document.body node", () => {
+    expect(ROOT.key).toBe(":root");
+    expect(ROOT.node).toBe(document.body);
+  });
+  it("assigns TREE to reference ROOT", () => {
+    expect(TREE).toBe(ROOT);
+    expect(TREE.node).toBe(document.body);
+  });
+});

package/dist/esm/__tests__/update.test.js

@@ -0,0 +1,222 @@
+import { update } from "../update";
+describe("update()", () => {
+  let element, params, opts;
+  beforeEach(() => {
+    element = {
+      __ref: {
+        __if: true,
+        __execProps: {},
+        __exec: {},
+        __defineCache: {},
+        __propsStack: [],
+        __props: [],
+        __state: "state"
+      },
+      state: "string",
+      props: {},
+      parent: {
+        props: {}
+      },
+      context: {},
+      define: {},
+      node: document.createElement("div"),
+      key: "testElement",
+      on: {},
+      update
+    };
+    opts = {
+      preventUpdate: [],
+      preventDefineUpdate: [],
+      preventBeforeStateUpdateListener: false,
+      preventListeners: false,
+      preventStateUpdateListener: false
+    };
+    params = {};
+  });
+  it("does not modify opts when params and opts are empty", async () => {
+    await element.update({}, opts);
+    expect(opts).toEqual({
+      calleeElement: false,
+      cleanExec: true,
+      currentSnapshot: false,
+      exclude: [],
+      preventRecursive: false,
+      stackChanges: false,
+      preventUpdate: [],
+      preventDefineUpdate: [],
+      preventBeforeStateUpdateListener: false,
+      preventListeners: false,
+      preventStateUpdateListener: false
+    });
+  });
+  it("initializes options with UPDATE_DEFAULT_OPTIONS when opts is empty", async () => {
+    await element.update({}, opts);
+    expect(opts.calleeElement).toBe(false);
+    expect(element.__ref).toBeDefined();
+  });
+  it("merges opts with UPDATE_DEFAULT_OPTIONS using deepMerge", async () => {
+    opts.customOption = true;
+    await element.update({}, opts);
+    expect(opts.customOption).toBe(true);
+  });
+  it("converts string params to { text: params }", async () => {
+    await element.update("testString", opts);
+    expect(element.text).toBe("testString");
+  });
+  it("converts number params to { text: params }", async () => {
+    await element.update(123, opts);
+    expect(element.text).toBe(123);
+  });
+  it("returns early if preventInheritAtCurrentState matches element", async () => {
+    opts.preventInheritAtCurrentState = { __element: element };
+    await element.update({}, opts);
+    expect(element.__ref.__currentSnapshot).toBe(6);
+  });
+  it("initializes __ref if not present", async () => {
+    delete element.__ref;
+    await element.update({}, opts);
+    expect(element.__ref).toBeDefined();
+  });
+  it("merges options with UPDATE_DEFAULT_OPTIONS when exclude is missing", async () => {
+    await element.update({}, opts);
+    expect(opts.exclude).toBeDefined();
+  });
+  it("does not throw or modify opts when params is undefined", async () => {
+    await element.update(void 0, opts);
+    expect(opts).toEqual({
+      calleeElement: false,
+      cleanExec: true,
+      currentSnapshot: false,
+      exclude: [],
+      preventRecursive: false,
+      preventUpdate: [],
+      preventDefineUpdate: [],
+      stackChanges: false,
+      preventBeforeStateUpdateListener: false,
+      preventListeners: false,
+      preventStateUpdateListener: false
+    });
+  });
+  it("does not throw when opts is undefined", async () => {
+    await element.update({}, void 0);
+    expect(element.__ref).toBeDefined();
+  });
+  it("does not throw when opts is null", async () => {
+    await element.update({}, null);
+    expect(element.__ref).toBeDefined();
+  });
+  it("does not modify the params object", async () => {
+    params = { key: "value" };
+    await element.update(params, opts);
+    expect(params).toEqual({ key: "value" });
+  });
+  it("does modify opts when params is an empty object", async () => {
+    await element.update({}, opts);
+    expect(opts).toEqual({
+      calleeElement: false,
+      cleanExec: true,
+      currentSnapshot: false,
+      exclude: [],
+      preventRecursive: false,
+      stackChanges: false,
+      preventUpdate: [],
+      preventDefineUpdate: [],
+      preventBeforeStateUpdateListener: false,
+      preventListeners: false,
+      preventStateUpdateListener: false
+    });
+  });
+  it("moves regular properties to element.props", async () => {
+    params = { props: { title: "Test", description: "Content" } };
+    await element.update(params, opts);
+    expect(element.props).toEqual({
+      title: "Test",
+      description: "Content"
+    });
+    expect(element.title).toBeUndefined();
+  });
+  it("keeps element-rooted properties", async () => {
+    params = { Header: {}, Footer: {}, 0: "index" };
+    await element.update(params, opts);
+    expect(element.Header).toBeDefined();
+    expect(element.Footer).toBeDefined();
+    expect(element["0"]).toBe("index");
+    expect(element.props).toEqual({});
+  });
+  it("preserves built-in properties on element", async () => {
+    params = { props: { className: "container", hidden: true } };
+    await element.update(params, opts);
+    expect(element.props.className).toBe("container");
+    expect(element.props.hidden).toBe(true);
+    expect(element.props).toEqual({ className: "container", hidden: true });
+  });
+  it("moves element-like properties from props to root", async () => {
+    params = { props: { Header: {} } };
+    await element.update(params, opts);
+    expect(element.Header).toBeDefined();
+    expect(element.props.Header).toBeUndefined();
+  });
+  it("exits early when inheritStateUpdates returns false", async () => {
+    element.__ref.__stateBlocked = true;
+    await element.update({ props: { shouldChange: true } }, opts);
+    expect(element.props.shouldChange).toBe(true);
+    expect(element.__ref.__stateBlocked).toBe(true);
+  });
+  it("exits early when checkIfOnUpdate fails", async () => {
+    element.parent.props.ifCondition = false;
+    await element.update({ state: { newState: true } }, opts);
+    expect(element.state.newState).toBe(true);
+  });
+  it("updates props from parent key match", async () => {
+    element.parent.props.testKey = { inherited: true };
+    await element.update({}, opts);
+    expect(element.props.inherited).toBeUndefined();
+  });
+  it("updates props when functions exist in __props", async () => {
+    element.__ref.__props.push(() => "dynamic");
+    await element.update({}, opts);
+    expect(element.props).toEqual(expect.any(Object));
+  });
+  it("skips props update when preventPropsUpdate=true", async () => {
+    opts.preventPropsUpdate = true;
+    opts.preventUpdateAfter = true;
+    element.parent.props.testKey = { shouldExist: true };
+    await element.update({}, opts);
+    expect(element.props.shouldExist).toBeUndefined();
+  });
+  it("should not skips props update when preventPropsUpdate=false", async () => {
+    opts.preventPropsUpdate = false;
+    opts.lazyLoad = true;
+    opts.onEachUpdate = () => {
+      return true;
+    };
+    element.parent.props.testKey = { shouldExist: true };
+    element.__ref.__propsStack = [];
+    element.__ref.__if = true;
+    element.off = { text: "off" };
+    await element.update({}, opts);
+    expect(element.props.shouldExist).toBeUndefined();
+  });
+  it("should set preventUpdateAfterCount to 1 when is not a number", async () => {
+    opts.preventPropsUpdate = true;
+    opts.preventUpdateAfter = 2;
+    opts.preventUpdateAfterCount = void 0;
+    element.parent.props.testKey = { shouldExist: true };
+    await element.update({}, opts);
+    expect(element.props.shouldExist).toBeUndefined();
+  });
+  it("processes parent.childProps", async () => {
+    element.parent.props.childProps = { global: true };
+    await element.update({}, opts);
+    expect(element.props.global).toBe(true);
+  });
+  it("processes function props", async () => {
+    await element.update({ props: { calc: () => 42 } }, opts);
+    expect(element.props.calc()).toBe(42);
+  });
+  it("returns element when beforeUpdate rejects", async () => {
+    element.on.beforeUpdate = () => false;
+    const result = await element.update({}, opts);
+    expect(result).toBe(element);
+  });
+});

package/dist/esm/create.js

@@ -30,7 +30,7 @@ const create = async (props, parentEl, passedKey, options = OPTIONS.create || {}
   const { key, parent, __ref: ref } = element;
   createRoot(element, parent);
   applyExtends(element, parent, options);
-  propertizeElement(element, parent);
+  propertizeElement.call(element, element);
   await triggerEventOn("start", element, options);
   if (options.onlyResolveExtends) {
     return onlyResolveExtends(element, parent, key, options);
@@ -77,7 +77,7 @@ const addElementIntoParentChildren = (element, parent) => {
 };
 const visitedElements = /* @__PURE__ */ new WeakMap();
 const renderElement = async (element, parent, options, attachOptions) => {
-  var _a, _b, _c, _d;
+  var _a, _b, _c;
   if (visitedElements.has(element)) {
     if (ENV === "test" || ENV === "development") {
       console.warn("Cyclic rendering detected:", element.__ref.path);
@@ -114,15 +114,6 @@ const renderElement = async (element, parent, options, attachOptions) => {
       if ((_c = element.on) == null ? void 0 : _c.error) {
         element.on.error(e, element, element.state, element.context, options);
       }
-      if ((_d = element.props) == null ? void 0 : _d.onError) {
-        element.props.onError(
-          e,
-          element,
-          element.state,
-          element.context,
-          options
-        );
-      }
     }
   }
   if (!ref.__if) {

package/dist/esm/iterate.js

@@ -7,16 +7,17 @@ import {
   matchesComponentNaming,
   isContextComponent,
   isMethod,
-  overwrite
+  overwrite,
+  execPromise
 } from "@domql/utils";
-const throughInitialExec = (element, exclude = {}) => {
+const throughInitialExec = async (element, exclude = {}) => {
   const { __ref: ref } = element;
   for (const param in element) {
     if (exclude[param]) continue;
     const prop = element[param];
     if (isFunction(prop) && !isMethod(param, element)) {
       ref.__exec[param] = prop;
-      element[param] = prop(element, element.state, element.context);
+      element[param] = await prop(element, element.state, element.context);
     }
   }
 };
@@ -47,23 +48,23 @@ const throughUpdatedExec = (element, options = {}) => {
   }
   return changes;
 };
-const throughExecProps = (element) => {
+const throughExecProps = async (element) => {
   const { __ref: ref } = element;
   const { props } = element;
   for (const k in props) {
     const isDefine = k.startsWith("is") || k.startsWith("has") || k.startsWith("use");
     const cachedExecProp = ref.__execProps[k];
     if (isFunction(cachedExecProp)) {
-      props[k] = exec(cachedExecProp, element);
+      props[k] = await execPromise(cachedExecProp, element);
     } else if (isDefine && isFunction(props[k])) {
       ref.__execProps[k] = props[k];
-      props[k] = exec(props[k], element);
+      props[k] = await execPromise(props[k], element);
     }
   }
 };
 const isPropertyInDefines = (key, element) => {
 };
-const throughInitialDefine = (element) => {
+const throughInitialDefine = async (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
   const hasGlobalDefine = context && isObject(context.define);
@@ -73,13 +74,13 @@ const throughInitialDefine = (element) => {
     let elementProp = element[param];
     if (isFunction(elementProp) && !isMethod(param, element)) {
       ref.__exec[param] = elementProp;
-      const execParam2 = elementProp = exec(elementProp, element);
+      const execParam2 = elementProp = await execPromise(elementProp, element);
       if (execParam2) {
         elementProp = element[param] = execParam2.parse ? execParam2.parse() : execParam2;
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](
+    const execParam = await defineObj[param](
       elementProp,
       element,
       element.state,
@@ -89,7 +90,7 @@ const throughInitialDefine = (element) => {
   }
   return element;
 };
-const throughUpdatedDefine = (element) => {
+const throughUpdatedDefine = async (element) => {
   const { context, define, __ref: ref } = element;
   const changes = {};
   let obj = {};
@@ -98,13 +99,13 @@ const throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam) {
-      ref.__defineCache[param] = execParam(
+      ref.__defineCache[param] = await execParam(
         element,
         element.state,
         element.context
       );
     }
-    const cached = exec(ref.__defineCache[param], element);
+    const cached = await execPromise(ref.__defineCache[param], element);
     const newExecParam = typeof obj[param] === "function" ? obj[param](cached, element, element.state, element.context) : void 0;
     if (newExecParam) element[param] = newExecParam;
   }

package/dist/esm/update.js

@@ -10,13 +10,13 @@ import {
   merge,
   overwriteDeep,
   deepClone,
-  propertizeElement,
   isMethod,
   findInheritedState,
   deepMerge,
   OPTIONS,
   updateProps,
-  captureSnapshot
+  captureSnapshot,
+  propertizeUpdate
 } from "@domql/utils";
 import { applyEvent, triggerEventOn, triggerEventOnUpdate } from "@domql/event";
 import { createState } from "@domql/state";
@@ -66,7 +66,7 @@ const update = async function(params = {}, opts) {
   if (isString(params) || isNumber(params)) {
     params = { text: params };
   }
-  params = propertizeElement(params);
+  params = propertizeUpdate.call(element, params);
   const inheritState = await inheritStateUpdates(element, options);
   if (inheritState === false) return;
   const ifFails = await checkIfOnUpdate(element, parent, options);
@@ -78,10 +78,11 @@ const update = async function(params = {}, opts) {
     if (props) updateProps(props, element, parent);
   }
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
+    const simulate = { ...params, ...element };
     const beforeUpdateReturns = await triggerEventOnUpdate(
       "beforeUpdate",
       params,
-      element,
+      simulate,
       options
     );
     if (beforeUpdateReturns === false) return element;

package/iterate.js

@@ -9,17 +9,18 @@ import {
   matchesComponentNaming,
   isContextComponent,
   isMethod,
-  overwrite
+  overwrite,
+  execPromise
 } from '@domql/utils'
 
-export const throughInitialExec = (element, exclude = {}) => {
+export const throughInitialExec = async (element, exclude = {}) => {
   const { __ref: ref } = element
   for (const param in element) {
     if (exclude[param]) continue
     const prop = element[param]
     if (isFunction(prop) && !isMethod(param, element)) {
       ref.__exec[param] = prop
-      element[param] = prop(element, element.state, element.context)
+      element[param] = await prop(element, element.state, element.context)
     }
   }
 }
@@ -57,7 +58,7 @@ export const throughUpdatedExec = (element, options = {}) => {
   return changes
 }
 
-export const throughExecProps = element => {
+export const throughExecProps = async element => {
   const { __ref: ref } = element
   const { props } = element
   for (const k in props) {
@@ -65,17 +66,17 @@ export const throughExecProps = element => {
       k.startsWith('is') || k.startsWith('has') || k.startsWith('use')
     const cachedExecProp = ref.__execProps[k]
     if (isFunction(cachedExecProp)) {
-      props[k] = exec(cachedExecProp, element)
+      props[k] = await execPromise(cachedExecProp, element)
     } else if (isDefine && isFunction(props[k])) {
       ref.__execProps[k] = props[k]
-      props[k] = exec(props[k], element)
+      props[k] = await execPromise(props[k], element)
     }
   }
 }
 
 export const isPropertyInDefines = (key, element) => {}
 
-export const throughInitialDefine = element => {
+export const throughInitialDefine = async element => {
   const { define, context, __ref: ref } = element
 
   let defineObj = {}
@@ -88,7 +89,7 @@ export const throughInitialDefine = element => {
 
     if (isFunction(elementProp) && !isMethod(param, element)) {
       ref.__exec[param] = elementProp
-      const execParam = (elementProp = exec(elementProp, element))
+      const execParam = (elementProp = await execPromise(elementProp, element))
 
       if (execParam) {
         elementProp = element[param] = execParam.parse
@@ -98,7 +99,7 @@ export const throughInitialDefine = element => {
       }
     }
 
-    const execParam = defineObj[param](
+    const execParam = await defineObj[param](
       elementProp,
       element,
       element.state,
@@ -109,7 +110,7 @@ export const throughInitialDefine = element => {
   return element
 }
 
-export const throughUpdatedDefine = element => {
+export const throughUpdatedDefine = async element => {
   const { context, define, __ref: ref } = element
   const changes = {}
 
@@ -120,13 +121,13 @@ export const throughUpdatedDefine = element => {
   for (const param in obj) {
     const execParam = ref.__exec[param]
     if (execParam) {
-      ref.__defineCache[param] = execParam(
+      ref.__defineCache[param] = await execParam(
         element,
         element.state,
         element.context
       )
     }
-    const cached = exec(ref.__defineCache[param], element)
+    const cached = await execPromise(ref.__defineCache[param], element)
     const newExecParam =
       typeof obj[param] === 'function'
         ? obj[param](cached, element, element.state, element.context)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "3.0.7",
+  "version": "3.1.1",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -21,20 +21,19 @@
   ],
   "scripts": {
     "copy:package:cjs": "cp ../../build/package-cjs.json dist/cjs/package.json",
-    "build:esm": "npx esbuild \"*.js\" \"utils/**/*.js\" \"mixins/**/*.js\" \"methods/**/*.js\" --target=es2019 --format=esm --outdir=dist/esm",
-    "build:cjs": "npx esbuild \"*.js\" \"utils/**/*.js\" \"mixins/**/*.js\" \"methods/**/*.js\" --target=node16 --format=cjs --outdir=dist/cjs",
-    "build": "rimraf -I dist; npm run build:cjs; npm run build:esm",
-    "prepublish": "rimraf -I dist && npm run build && npm run copy:package:cjs"
+    "build:esm": "npx esbuild *.js **/*.js --target=es2019 --format=esm --outdir=dist/esm",
+    "build:cjs": "npx esbuild *.js **/*.js --target=node16 --format=cjs --outdir=dist/cjs",
+    "build": "npx rimraf -I dist; npm run build:cjs; npm run build:esm",
+    "prepublish": "npx rimraf -I dist && npm run build && npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^3.0.7",
-    "@domql/render": "^3.0.7",
-    "@domql/report": "^3.0.0",
-    "@domql/state": "^3.0.7",
-    "@domql/utils": "^3.0.7"
+    "@domql/event": "^3.1.1",
+    "@domql/render": "^3.1.1",
+    "@domql/state": "^3.1.1",
+    "@domql/utils": "^3.1.1"
   },
-  "gitHead": "ad8d42d52cce0024e5df6b2e364f660e0e4dd02d",
+  "gitHead": "39fb7a8c07355468ccce79e2f787ca3fa0715692",
   "devDependencies": {
-    "@babel/core": "^7.12.0"
+    "@babel/core": "^7.26.0"
   }
 }