marko 6.0.156 → 6.0.157

package/dist/common/errors.d.ts

@@ -1,6 +1,8 @@
+import { type Scope } from "./types";
 export declare function _el_read_error(): void;
 export declare function _hoist_read_error(): void;
 export declare function _assert_hoist(value: unknown): void;
+export declare function _assert_init(scope: Scope, accessor: string): any;
 export declare function assertExclusiveAttrs(attrs: Record<string, unknown> | undefined, onError?: typeof throwErr): void;
 export declare function assertValidTagName(tagName: string): void;
 declare function throwErr(msg: string): void;

package/dist/debug/dom.js

@@ -23,6 +23,7 @@ __export(dom_exports, {
   $signal: () => $signal,
   $signalReset: () => $signalReset,
   _assert_hoist: () => _assert_hoist,
+  _assert_init: () => _assert_init,
   _attr: () => _attr,
   _attr_class: () => _attr_class,
   _attr_class_item: () => _attr_class_item,
@@ -159,6 +160,21 @@ function _assert_hoist(value) {
     );
   }
 }
+function _assert_init(scope, accessor) {
+  if (scope["#Creating" /* Creating */] || !(accessor in scope)) {
+    try {
+      __UNINITIALIZED__;
+      const __UNINITIALIZED__ = 1;
+    } catch (err) {
+      err.message = err.message.replaceAll("__UNINITIALIZED__", accessor);
+      throw err;
+    }
+    throw new ReferenceError(
+      `Cannot access "${accessor}" before initialization.`
+    );
+  }
+  return scope[accessor];
+}
 function assertExclusiveAttrs(attrs, onError = throwErr) {
   if (attrs) {
     let exclusiveAttrs;
@@ -619,11 +635,6 @@ function _closure(...closureSignals) {
 function _closure_get(valueAccessor, fn, getOwnerScope, resumeId) {
   if (false) valueAccessor = decodeAccessor(valueAccessor);
   const closureSignal = ((scope) => {
-    if (true) {
-      if (!(valueAccessor in (getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */]))) {
-        throwUninitialized(valueAccessor);
-      }
-    }
     scope[closureSignal.___signalIndexAccessor] = closureSignal.___index;
     fn(scope);
     subscribeToScopeSet(
@@ -708,16 +719,6 @@ function _hoist(...path) {
 function _hoist_resume(id, ...path) {
   return _resume(id, _hoist(...path));
 }
-function throwUninitialized(name) {
-  try {
-    __UNINITIALIZED__;
-    let __UNINITIALIZED__;
-  } catch (err) {
-    err.message = err.message.replaceAll("__UNINITIALIZED__", name);
-    throw err;
-  }
-  throw new ReferenceError(`Cannot access '${name}' before initialization`);
-}
 
 // src/dom/walker.ts
 var walker = /* @__PURE__ */ document.createTreeWalker(document);

package/dist/debug/dom.mjs

@@ -44,6 +44,21 @@ function _assert_hoist(value) {
     );
   }
 }
+function _assert_init(scope, accessor) {
+  if (scope["#Creating" /* Creating */] || !(accessor in scope)) {
+    try {
+      __UNINITIALIZED__;
+      const __UNINITIALIZED__ = 1;
+    } catch (err) {
+      err.message = err.message.replaceAll("__UNINITIALIZED__", accessor);
+      throw err;
+    }
+    throw new ReferenceError(
+      `Cannot access "${accessor}" before initialization.`
+    );
+  }
+  return scope[accessor];
+}
 function assertExclusiveAttrs(attrs, onError = throwErr) {
   if (attrs) {
     let exclusiveAttrs;
@@ -504,11 +519,6 @@ function _closure(...closureSignals) {
 function _closure_get(valueAccessor, fn, getOwnerScope, resumeId) {
   if (false) valueAccessor = decodeAccessor(valueAccessor);
   const closureSignal = ((scope) => {
-    if (true) {
-      if (!(valueAccessor in (getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */]))) {
-        throwUninitialized(valueAccessor);
-      }
-    }
     scope[closureSignal.___signalIndexAccessor] = closureSignal.___index;
     fn(scope);
     subscribeToScopeSet(
@@ -593,16 +603,6 @@ function _hoist(...path) {
 function _hoist_resume(id, ...path) {
   return _resume(id, _hoist(...path));
 }
-function throwUninitialized(name) {
-  try {
-    __UNINITIALIZED__;
-    let __UNINITIALIZED__;
-  } catch (err) {
-    err.message = err.message.replaceAll("__UNINITIALIZED__", name);
-    throw err;
-  }
-  throw new ReferenceError(`Cannot access '${name}' before initialization`);
-}
 
 // src/dom/walker.ts
 var walker = /* @__PURE__ */ document.createTreeWalker(document);
@@ -2592,6 +2592,7 @@ export {
   $signal,
   $signalReset,
   _assert_hoist,
+  _assert_init,
   _attr,
   _attr_class,
   _attr_class_item,

package/dist/dom.d.ts

@@ -1,5 +1,5 @@
 export { attrTag, attrTags } from "./common/attr-tag";
-export { _assert_hoist } from "./common/errors";
+export { _assert_hoist, _assert_init } from "./common/errors";
 export { forIn, forOf, forTo, forUntil } from "./common/for";
 export { _call } from "./common/helpers";
 export { $signal, $signalReset } from "./dom/abort-signal";

package/dist/dom.js

@@ -20,6 +20,7 @@ __export(dom_exports, {
   $signal: () => $signal,
   $signalReset: () => $signalReset,
   _assert_hoist: () => _assert_hoist,
+  _assert_init: () => _assert_init,
   _attr: () => _attr,
   _attr_class: () => _attr_class,
   _attr_class_item: () => _attr_class_item,
@@ -125,6 +126,9 @@ function* attrTagIterator() {
 // src/common/errors.ts
 function _assert_hoist(value) {
 }
+function _assert_init(scope, accessor) {
+  return scope[accessor];
+}
 
 // src/common/for.ts
 function forIn(obj, cb) {

package/dist/dom.mjs

@@ -13,6 +13,9 @@ function* attrTagIterator() {
 // src/common/errors.ts
 function _assert_hoist(value) {
 }
+function _assert_init(scope, accessor) {
+  return scope[accessor];
+}
 
 // src/common/for.ts
 function forIn(obj, cb) {
@@ -1575,6 +1578,7 @@ export {
   $signal,
   $signalReset,
   _assert_hoist,
+  _assert_init,
   _attr,
   _attr_class,
   _attr_class_item,

package/dist/html/writer.d.ts

@@ -34,7 +34,7 @@ export declare function getScopeById(scopeId: number | undefined): PartialScope
 export declare function _set_serialize_reason(reason: undefined | 0 | 1): void;
 export declare function _scope_reason(): 0 | 1 | undefined;
 export declare function _serialize_if(condition: undefined | 1 | Record<string, 1>, key: string): 1 | undefined;
-export declare function _serialize_guard(condition: undefined | 1 | Record<string, 1>, key: string): 1 | 0;
+export declare function _serialize_guard(condition: undefined | 1 | Record<string, 1>, key: string): 0 | 1;
 export declare function _el_resume(scopeId: number, accessor: Accessor, shouldResume?: 0 | 1): string;
 export declare function _sep(shouldResume: 0 | 1): "" | "<!>";
 export declare function _el(scopeId: number, id: string): () => void;

package/dist/translator/index.js

@@ -133,33 +133,33 @@ var AccessorPrefix = /* @__PURE__ */ ((AccessorPrefix4) => {
   AccessorPrefix4["TagVariableChange"] = "TagVariableChange:";
   return AccessorPrefix4;
 })(AccessorPrefix || {});
-var AccessorProp = /* @__PURE__ */ ((AccessorProp5) => {
-  AccessorProp5["Global"] = "$global";
-  AccessorProp5["Owner"] = "_";
-  AccessorProp5["AbortControllers"] = "#AbortControllers";
-  AccessorProp5["AbortScopes"] = "#AbortScopes";
-  AccessorProp5["AwaitCounter"] = "#AwaitCounter";
-  AccessorProp5["BranchAccessor"] = "#BranchAccessor";
-  AccessorProp5["BranchScopes"] = "#BranchScopes";
-  AccessorProp5["CatchContent"] = "#CatchContent";
-  AccessorProp5["ClosestBranch"] = "#ClosestBranch";
-  AccessorProp5["ClosestBranchId"] = "#ClosestBranchId";
-  AccessorProp5["Creating"] = "#Creating";
-  AccessorProp5["Destroyed"] = "#Destroyed";
-  AccessorProp5["DetachedAwait"] = "#DetachedAwait";
-  AccessorProp5["EndNode"] = "#EndNode";
-  AccessorProp5["Id"] = "#Id";
-  AccessorProp5["LoopKey"] = "#LoopKey";
-  AccessorProp5["ParentBranch"] = "#ParentBranch";
-  AccessorProp5["PendingEffects"] = "#PendingEffects";
-  AccessorProp5["PendingRenders"] = "#PendingRenders";
-  AccessorProp5["PlaceholderBranch"] = "#PlaceholderBranch";
-  AccessorProp5["PlaceholderContent"] = "#PlaceholderContent";
-  AccessorProp5["Renderer"] = "#Renderer";
-  AccessorProp5["StartNode"] = "#StartNode";
-  AccessorProp5["TagVariable"] = "#TagVariable";
-  AccessorProp5["TagVariableChange"] = "#TagVariableChange";
-  return AccessorProp5;
+var AccessorProp = /* @__PURE__ */ ((AccessorProp6) => {
+  AccessorProp6["Global"] = "$global";
+  AccessorProp6["Owner"] = "_";
+  AccessorProp6["AbortControllers"] = "#AbortControllers";
+  AccessorProp6["AbortScopes"] = "#AbortScopes";
+  AccessorProp6["AwaitCounter"] = "#AwaitCounter";
+  AccessorProp6["BranchAccessor"] = "#BranchAccessor";
+  AccessorProp6["BranchScopes"] = "#BranchScopes";
+  AccessorProp6["CatchContent"] = "#CatchContent";
+  AccessorProp6["ClosestBranch"] = "#ClosestBranch";
+  AccessorProp6["ClosestBranchId"] = "#ClosestBranchId";
+  AccessorProp6["Creating"] = "#Creating";
+  AccessorProp6["Destroyed"] = "#Destroyed";
+  AccessorProp6["DetachedAwait"] = "#DetachedAwait";
+  AccessorProp6["EndNode"] = "#EndNode";
+  AccessorProp6["Id"] = "#Id";
+  AccessorProp6["LoopKey"] = "#LoopKey";
+  AccessorProp6["ParentBranch"] = "#ParentBranch";
+  AccessorProp6["PendingEffects"] = "#PendingEffects";
+  AccessorProp6["PendingRenders"] = "#PendingRenders";
+  AccessorProp6["PlaceholderBranch"] = "#PlaceholderBranch";
+  AccessorProp6["PlaceholderContent"] = "#PlaceholderContent";
+  AccessorProp6["Renderer"] = "#Renderer";
+  AccessorProp6["StartNode"] = "#StartNode";
+  AccessorProp6["TagVariable"] = "#TagVariable";
+  AccessorProp6["TagVariableChange"] = "#TagVariableChange";
+  return AccessorProp6;
 })(AccessorProp || {});
 
 // src/translator/util/evaluate.ts
@@ -253,6 +253,7 @@ function isNullableExpr(expr) {
 // src/translator/util/references.ts
 var import_compiler38 = require("@marko/compiler");
 var import_babel_utils26 = require("@marko/compiler/babel-utils");
+var import_config = require("@marko/compiler/config");
 
 // src/common/helpers.ts
 function classValue(classValue2) {
@@ -1298,33 +1299,33 @@ var AccessorPrefix2 = /* @__PURE__ */ ((AccessorPrefix4) => {
   AccessorPrefix4["TagVariableChange"] = "M";
   return AccessorPrefix4;
 })(AccessorPrefix2 || {});
-var AccessorProp2 = /* @__PURE__ */ ((AccessorProp5) => {
-  AccessorProp5["Global"] = "$";
-  AccessorProp5["Owner"] = "_";
-  AccessorProp5["AbortControllers"] = "A";
-  AccessorProp5["AbortScopes"] = "B";
-  AccessorProp5["AwaitCounter"] = "O";
-  AccessorProp5["BranchAccessor"] = "C";
-  AccessorProp5["BranchScopes"] = "D";
-  AccessorProp5["CatchContent"] = "E";
-  AccessorProp5["ClosestBranch"] = "F";
-  AccessorProp5["ClosestBranchId"] = "G";
-  AccessorProp5["Creating"] = "H";
-  AccessorProp5["Destroyed"] = "I";
-  AccessorProp5["DetachedAwait"] = "V";
-  AccessorProp5["EndNode"] = "K";
-  AccessorProp5["Id"] = "L";
-  AccessorProp5["LoopKey"] = "M";
-  AccessorProp5["ParentBranch"] = "N";
-  AccessorProp5["PendingEffects"] = "J";
-  AccessorProp5["PendingRenders"] = "W";
-  AccessorProp5["PlaceholderBranch"] = "P";
-  AccessorProp5["PlaceholderContent"] = "Q";
-  AccessorProp5["Renderer"] = "R";
-  AccessorProp5["StartNode"] = "S";
-  AccessorProp5["TagVariable"] = "T";
-  AccessorProp5["TagVariableChange"] = "U";
-  return AccessorProp5;
+var AccessorProp2 = /* @__PURE__ */ ((AccessorProp6) => {
+  AccessorProp6["Global"] = "$";
+  AccessorProp6["Owner"] = "_";
+  AccessorProp6["AbortControllers"] = "A";
+  AccessorProp6["AbortScopes"] = "B";
+  AccessorProp6["AwaitCounter"] = "O";
+  AccessorProp6["BranchAccessor"] = "C";
+  AccessorProp6["BranchScopes"] = "D";
+  AccessorProp6["CatchContent"] = "E";
+  AccessorProp6["ClosestBranch"] = "F";
+  AccessorProp6["ClosestBranchId"] = "G";
+  AccessorProp6["Creating"] = "H";
+  AccessorProp6["Destroyed"] = "I";
+  AccessorProp6["DetachedAwait"] = "V";
+  AccessorProp6["EndNode"] = "K";
+  AccessorProp6["Id"] = "L";
+  AccessorProp6["LoopKey"] = "M";
+  AccessorProp6["ParentBranch"] = "N";
+  AccessorProp6["PendingEffects"] = "J";
+  AccessorProp6["PendingRenders"] = "W";
+  AccessorProp6["PlaceholderBranch"] = "P";
+  AccessorProp6["PlaceholderContent"] = "Q";
+  AccessorProp6["Renderer"] = "R";
+  AccessorProp6["StartNode"] = "S";
+  AccessorProp6["TagVariable"] = "T";
+  AccessorProp6["TagVariableChange"] = "U";
+  return AccessorProp6;
 })(AccessorProp2 || {});
 
 // src/translator/util/marko-config.ts
@@ -2169,87 +2170,6 @@ function isStaticRoot(path7) {
   }
 }
 
-// src/translator/util/for-each-identifier.ts
-function forEachIdentifier(node, cb) {
-  switch (node.type) {
-    case "ObjectPattern":
-      for (const prop of node.properties) {
-        switch (prop.type) {
-          case "ObjectProperty":
-            if (prop.value.type === "AssignmentPattern") {
-              forEachIdentifier(prop.value.left, cb);
-            } else {
-              forEachIdentifier(prop.value, cb);
-            }
-            break;
-          case "RestElement":
-            forEachIdentifier(prop.argument, cb);
-            break;
-        }
-      }
-      break;
-    case "ArrayPattern":
-      for (const el of node.elements) {
-        if (el != null) {
-          switch (el.type) {
-            case "RestElement":
-              forEachIdentifier(el.argument, cb);
-              break;
-            case "AssignmentPattern":
-              forEachIdentifier(el.left, cb);
-              break;
-            default:
-              forEachIdentifier(el, cb);
-              break;
-          }
-        }
-      }
-      break;
-    case "Identifier":
-      cb(node);
-      break;
-  }
-}
-function forEachIdentifierPath(nodePath, cb) {
-  if (nodePath.isIdentifier()) {
-    cb(nodePath);
-  } else if (nodePath.isObjectPattern()) {
-    for (const prop of nodePath.get("properties")) {
-      if (prop.isObjectProperty()) {
-        const value = prop.get("value");
-        if (value.isAssignmentPattern()) {
-          forEachIdentifierPath(value.get("left"), cb);
-        } else {
-          forEachIdentifierPath(value, cb);
-        }
-      } else if (prop.isRestElement()) {
-        forEachIdentifierPath(prop.get("argument"), cb);
-      }
-    }
-  } else if (nodePath.isArrayPattern()) {
-    for (const el of nodePath.get("elements")) {
-      if (el) {
-        if (el.isRestElement()) {
-          forEachIdentifierPath(el.get("argument"), cb);
-        } else if (el.isAssignmentPattern()) {
-          forEachIdentifierPath(el.get("left"), cb);
-        } else {
-          forEachIdentifierPath(el, cb);
-        }
-      }
-    }
-  }
-}
-
-// src/translator/util/is-event-or-change-handler.ts
-function isEventOrChangeHandler(prop) {
-  return /^on[-A-Z][a-zA-Z0-9_$]|[a-zA-Z_$][a-zA-Z0-9_$]*Change$/.test(prop);
-}
-
-// src/translator/util/known-tag.ts
-var import_compiler37 = require("@marko/compiler");
-var import_babel_utils25 = require("@marko/compiler/babel-utils");
-
 // src/translator/visitors/program/index.ts
 var import_compiler27 = require("@marko/compiler");
 var import_babel_utils17 = require("@marko/compiler/babel-utils");
@@ -2619,8 +2539,8 @@ function getHTMLRuntime() {
   };
 }
 function getRuntimePath(output) {
-  const { optimize } = getMarkoOpts();
-  return `${runtime_info_default.name}/${optimize ? "" : "debug/"}${output === "html" ? "html" : "dom"}`;
+  const { optimize: optimize2 } = getMarkoOpts();
+  return `${runtime_info_default.name}/${optimize2 ? "" : "debug/"}${output === "html" ? "html" : "dom"}`;
 }
 function filterArguments(args) {
   const filteredArgs = [];
@@ -3305,6 +3225,78 @@ var return_default = {
   ]
 };
 
+// src/translator/util/for-each-identifier.ts
+function forEachIdentifier(node, cb) {
+  switch (node.type) {
+    case "ObjectPattern":
+      for (const prop of node.properties) {
+        switch (prop.type) {
+          case "ObjectProperty":
+            if (prop.value.type === "AssignmentPattern") {
+              forEachIdentifier(prop.value.left, cb);
+            } else {
+              forEachIdentifier(prop.value, cb);
+            }
+            break;
+          case "RestElement":
+            forEachIdentifier(prop.argument, cb);
+            break;
+        }
+      }
+      break;
+    case "ArrayPattern":
+      for (const el of node.elements) {
+        if (el != null) {
+          switch (el.type) {
+            case "RestElement":
+              forEachIdentifier(el.argument, cb);
+              break;
+            case "AssignmentPattern":
+              forEachIdentifier(el.left, cb);
+              break;
+            default:
+              forEachIdentifier(el, cb);
+              break;
+          }
+        }
+      }
+      break;
+    case "Identifier":
+      cb(node);
+      break;
+  }
+}
+function forEachIdentifierPath(nodePath, cb) {
+  if (nodePath.isIdentifier()) {
+    cb(nodePath);
+  } else if (nodePath.isObjectPattern()) {
+    for (const prop of nodePath.get("properties")) {
+      if (prop.isObjectProperty()) {
+        const value = prop.get("value");
+        if (value.isAssignmentPattern()) {
+          forEachIdentifierPath(value.get("left"), cb);
+        } else {
+          forEachIdentifierPath(value, cb);
+        }
+      } else if (prop.isRestElement()) {
+        forEachIdentifierPath(prop.get("argument"), cb);
+      }
+    }
+  } else if (nodePath.isArrayPattern()) {
+    for (const el of nodePath.get("elements")) {
+      if (el) {
+        if (el.isRestElement()) {
+          forEachIdentifierPath(el.get("argument"), cb);
+        } else if (el.isAssignmentPattern()) {
+          forEachIdentifierPath(el.get("left"), cb);
+        } else {
+          forEachIdentifierPath(el, cb);
+        }
+      }
+    }
+  }
+}
+
 // src/translator/util/get-defined-binding-expression.ts
 var import_compiler18 = require("@marko/compiler");
 function getDeclaredBindingExpression(binding) {
@@ -3344,7 +3336,7 @@ function createScopeReadExpression(reference, section = reference.section) {
   );
   if (section === reference.section && reference.type !== 0 /* dom */) {
     const exprExtra = expr.extra ??= {};
-    exprExtra.read = createRead(reference, void 0, void 0);
+    exprExtra.read = createRead(reference, void 0);
     exprExtra.section = section;
   }
   return expr;
@@ -4997,31 +4989,44 @@ function normalizeTag(tag) {
   }
   for (let i = 0; i < attributes.length; i++) {
     const attr = attributes[i];
-    if (import_compiler26.types.isMarkoAttribute(attr) && attr.bound) {
-      attr.bound = false;
-      attributes.splice(++i, 0, getChangeHandler(tag, attr));
+    if (import_compiler26.types.isMarkoAttribute(attr)) {
+      if (attr.bound) {
+        attributes.splice(++i, 0, getChangeHandler(tag, attr));
+        attr.bound = false;
+      } else if (attr.modifier != null) {
+        attr.name += ":" + attr.modifier;
+      }
+      attr.modifier = null;
     }
   }
 }
 function getChangeHandler(tag, attr) {
   const attrName = attr.name;
   const changeAttrName = attrName + "Change";
+  const modifier = attr.modifier == null ? void 0 : withPreviousLocation(import_compiler26.types.identifier(attr.modifier), attr);
   if (import_compiler26.types.isIdentifier(attr.value)) {
     const binding = tag.scope.getBinding(attr.value.name);
     if (!binding)
       return import_compiler26.types.markoAttribute(
         changeAttrName,
-        buildChangeHandlerFunction(attr.value)
+        buildChangeHandlerFunction(attr.value, modifier)
       );
     const existingChangedAttr = BINDING_CHANGE_HANDLER.get(binding.identifier);
     if (!existingChangedAttr) {
       const bindingIdentifierPath = binding.path.getOuterBindingIdentifierPaths()[binding.identifier.name];
-      const changeAttrExpr = bindingIdentifierPath ? bindingIdentifierPath.parentPath === binding.path ? buildChangeHandlerFunction(attr.value) : bindingIdentifierPath.parentPath.isObjectProperty() ? getChangeHandlerFromObjectPattern(
+      let changeAttrExpr = bindingIdentifierPath ? bindingIdentifierPath.parentPath === binding.path ? buildChangeHandlerFunction(attr.value, modifier) : bindingIdentifierPath.parentPath.isObjectProperty() ? getChangeHandlerFromObjectPattern(
         bindingIdentifierPath.parentPath
       ) : void 0 : void 0;
       if (!changeAttrExpr) {
         throw tag.hub.buildError(attr.value, "Unable to bind to value.");
       }
+      if (modifier && import_compiler26.types.isIdentifier(changeAttrExpr)) {
+        changeAttrExpr = import_compiler26.types.logicalExpression(
+          "&&",
+          changeAttrExpr,
+          buildChangeHandlerFunction(attr.value, modifier)
+        );
+      }
       const changeHandlerAttr = import_compiler26.types.markoAttribute(
         changeAttrName,
         changeAttrExpr
@@ -5073,10 +5078,26 @@ function getChangeHandler(tag, attr) {
         import_compiler26.types.stringLiteral("Change")
       );
       const computed = memberProp.type !== "Identifier";
-      return import_compiler26.types.markoAttribute(
-        changeAttrName,
-        attr.value.optional ? import_compiler26.types.optionalMemberExpression(memberObj, memberProp, computed, true) : import_compiler26.types.memberExpression(memberObj, memberProp, computed)
-      );
+      let changeAttrExpr = attr.value.optional ? import_compiler26.types.optionalMemberExpression(memberObj, memberProp, computed, true) : import_compiler26.types.memberExpression(memberObj, memberProp, computed);
+      if (modifier) {
+        const newValueId = generateUid("next");
+        changeAttrExpr = import_compiler26.types.logicalExpression(
+          "&&",
+          changeAttrExpr,
+          import_compiler26.types.arrowFunctionExpression(
+            [import_compiler26.types.identifier(newValueId)],
+            import_compiler26.types.blockStatement([
+              import_compiler26.types.expressionStatement(
+                import_compiler26.types.callExpression(
+                  import_compiler26.types.memberExpression(memberObj, memberProp, computed),
+                  [import_compiler26.types.callExpression(modifier, [import_compiler26.types.identifier(newValueId)])]
+                )
+              )
+            ])
+          )
+        );
+      }
+      return import_compiler26.types.markoAttribute(changeAttrName, changeAttrExpr);
     }
   }
   throw tag.hub.buildError(
@@ -5084,8 +5105,12 @@ function getChangeHandler(tag, attr) {
     "Attributes may only be bound to identifiers or member expressions"
   );
 }
-function buildChangeHandlerFunction(id) {
+function buildChangeHandlerFunction(id, modifier) {
   const newId = "_new_" + id.name;
+  let newValue = withPreviousLocation(import_compiler26.types.identifier(newId), id);
+  if (modifier) {
+    newValue = import_compiler26.types.callExpression(modifier, [newValue]);
+  }
   return import_compiler26.types.arrowFunctionExpression(
     [withPreviousLocation(import_compiler26.types.identifier(newId), id)],
     import_compiler26.types.blockStatement([
@@ -5093,7 +5118,7 @@ function buildChangeHandlerFunction(id) {
         import_compiler26.types.assignmentExpression(
           "=",
           withPreviousLocation(import_compiler26.types.identifier(id.name), id),
-          withPreviousLocation(import_compiler26.types.identifier(newId), id)
+          newValue
         )
       )
     ])
@@ -5326,6 +5351,15 @@ function resolveRelativeToEntry(entryFile, file, req) {
   );
 }
 
+// src/translator/util/is-event-or-change-handler.ts
+function isEventOrChangeHandler(prop) {
+  return /^on[-A-Z][a-zA-Z0-9_$]|[a-zA-Z_$][a-zA-Z0-9_$]*Change$/.test(prop);
+}
+
+// src/translator/util/known-tag.ts
+var import_compiler37 = require("@marko/compiler");
+var import_babel_utils25 = require("@marko/compiler/babel-utils");
+
 // src/translator/util/nested-attribute-tags.ts
 var import_compiler28 = require("@marko/compiler");
 var import_babel_utils18 = require("@marko/compiler/babel-utils");
@@ -8701,9 +8735,30 @@ function trackParamsReferences(body, type) {
     return paramsBinding;
   }
 }
+function getMarkoRootAsTag(path7) {
+  const tag = path7.isMarkoTag() ? path7 : getMarkoRoot(path7)?.parentPath;
+  if (tag?.isMarkoTag()) {
+    return tag;
+  }
+}
+function isReferenceInOwnBody(bindingPath, reference) {
+  const tag = getMarkoRootAsTag(bindingPath);
+  if (!tag) {
+    return false;
+  }
+  const body = tag.get("body");
+  let cur = reference;
+  while (cur) {
+    if (cur === body) {
+      return true;
+    }
+    cur = cur.parentPath;
+  }
+  return false;
+}
 function isReferenceHoisted(bindingPath, reference) {
-  const tag = bindingPath.isMarkoTag() ? bindingPath : getMarkoRoot(bindingPath)?.parentPath;
-  if (!tag?.isMarkoTag()) {
+  const tag = getMarkoRootAsTag(bindingPath);
+  if (!tag) {
     return false;
   }
   const body = tag.parentPath;
@@ -9456,7 +9511,7 @@ var [getFunctionReadsByExpression] = createProgramState(
 );
 function addRead(exprExtra, extra, binding, section, getter) {
   const readsByExpression = getReadsByExpression();
-  const read = { binding, extra, getter };
+  const read = { binding, extra, getter, ownVar: false };
   binding.reads.add(exprExtra);
   exprExtra.section = section;
   readsByExpression.set(
@@ -9501,6 +9556,10 @@ function addReadToExpression(root, binding, getter) {
     section,
     getter
   );
+  if (!getter && binding.type === 5 /* derived */) {
+    const babelBinding = root.scope.getBinding(binding.name);
+    read.ownVar = !!babelBinding && babelBinding.kind !== "param" && isReferenceInOwnBody(babelBinding.path, root);
+  }
   if (root.parent.type === "MarkoSpreadAttribute") {
     exprExtra.spreadFrom = binding;
   }
@@ -9636,6 +9695,12 @@ function getReadReplacement(node, signal) {
               [getScopeExpression(extra.section, readBinding.section)]
             );
           }
+        } else if (!import_config.optimize && read.ownVar) {
+          replacement = callRuntime(
+            "_assert_init",
+            extra.section ? getScopeExpression(extra.section, readBinding.section) : scopeIdentifier,
+            getScopeAccessorLiteral(readBinding)
+          );
         } else {
           replacement = createScopeReadExpression(readBinding, extra.section);
         }
@@ -9847,7 +9912,7 @@ function resolveReferencedBindings(expr, reads, intersectionsBySection) {
       const { extra, getter } = read;
       if (getter) {
         extra.section = expr.section;
-        extra.read = createRead(binding, void 0, getter);
+        extra.read = createGetterRead(binding, void 0, getter);
         addBindingGetter(binding, getter);
         if (getter.hoisted) {
           binding.hoists = sectionUtil.add(binding.hoists, getter.hoisted);
@@ -9870,20 +9935,23 @@ function resolveReferencedBindings(expr, reads, intersectionsBySection) {
       allBindings = bindingUtil.add(allBindings, binding);
     }
   } else if (reads) {
-    const { binding, extra, getter } = reads;
+    const { binding, extra, getter, ownVar } = reads;
     if (getter) {
+      extra.read = createGetterRead(binding, void 0, getter);
       addBindingGetter(binding, getter);
       if (getter.hoisted) {
         binding.hoists = sectionUtil.add(binding.hoists, getter.hoisted);
         hoistedBindings = bindingUtil.add(hoistedBindings, binding);
       }
-    } else if (binding.type === 6 /* constant */) {
-      constantBindings = binding;
-    } else if (binding.type !== 0 /* dom */) {
-      referencedBindings = binding;
+    } else {
+      extra.read = createRead(binding, void 0, ownVar);
+      if (binding.type === 6 /* constant */) {
+        constantBindings = binding;
+      } else if (binding.type !== 0 /* dom */) {
+        referencedBindings = binding;
+      }
     }
     extra.section = expr.section;
-    extra.read = createRead(binding, void 0, getter);
     allBindings = binding;
   }
   if (Array.isArray(referencedBindings)) {
@@ -9930,7 +9998,7 @@ function resolveReferencedBindings(expr, reads, intersectionsBySection) {
 function resolveExpressionReference(rootBindings, readBinding) {
   const upstreamRoot = readBinding.upstreamAlias && findClosestReference(readBinding.upstreamAlias, rootBindings);
   if (!upstreamRoot) {
-    return createRead(readBinding, void 0, void 0);
+    return createRead(readBinding, void 0);
   }
   let curBinding = readBinding;
   let props;
@@ -9943,15 +10011,18 @@ function resolveExpressionReference(rootBindings, readBinding) {
   if (Array.isArray(props)) {
     props.reverse();
   }
-  return createRead(upstreamRoot, props, void 0);
+  return createRead(upstreamRoot, props);
 }
 function isSupersetSources(a, b) {
   if (!b.sources) return true;
   if (!a.sources) return false;
   return bindingUtil.isSuperset(a.sources.state, b.sources.state) && bindingUtil.isSuperset(a.sources.param, b.sources.param);
 }
-function createRead(binding, props, getter) {
-  return { binding, props, getter };
+function createRead(binding, props, ownVar = false) {
+  return { binding, props, ownVar, getter: void 0 };
+}
+function createGetterRead(binding, props, getter) {
+  return { binding, props, ownVar: false, getter };
 }
 function getMemberExpressionPropString(expr) {
   switch (expr.property.type) {
@@ -12976,15 +13047,6 @@ var tag_default = {
               `Unsupported arguments on the \`${attr.node.name}\` attribute.`
             );
           }
-          if (attr.node.modifier) {
-            if ((0, import_babel_utils51.isNativeTag)(attr.parentPath)) {
-              attr.node.name += `:${attr.node.modifier}`;
-            } else {
-              throw attr.buildCodeFrameError(
-                `Unsupported modifier \`${attr.node.modifier}\`.`
-              );
-            }
-          }
         }
       }
       switch (analyzeTagNameType(tag)) {
@@ -13215,9 +13277,6 @@ function scanTag(state, tag) {
             attr.get("arguments")[0]
           );
           break;
-        } else if (attr.node.modifier) {
-          addFeature(state, "class" /* Class */, "Attribute modifier", attr);
-          break;
         } else if (attr.node.bound) {
           addFeature(state, "tags" /* Tags */, "Bound attribute", attr);
           break;
@@ -13289,10 +13348,10 @@ function createInteropTranslator(translate5) {
       import_compiler65.taglib.resolveOptionalTaglibs(translate5.optionalTaglibs).concat(translate5.taglibs),
       taglibs
     ),
-    getRuntimeEntryFiles(output, optimize) {
+    getRuntimeEntryFiles(output, optimize2) {
       return [
-        ...translate5.getRuntimeEntryFiles(output, optimize),
-        ...getRuntimeEntryFiles(output, optimize)
+        ...translate5.getRuntimeEntryFiles(output, optimize2),
+        ...getRuntimeEntryFiles(output, optimize2)
       ];
     }
   };
@@ -13572,9 +13631,9 @@ var taglibs = [
     }
   ]
 ];
-function getRuntimeEntryFiles(output, optimize) {
+function getRuntimeEntryFiles(output, optimize2) {
   return [
-    `${runtime_info_default.name}${optimize ? "" : "/debug"}/${output === "html" ? "html" : "dom"}`
+    `${runtime_info_default.name}${optimize2 ? "" : "/debug"}/${output === "html" ? "html" : "dom"}`
   ];
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/translator/util/references.d.ts

@@ -63,11 +63,13 @@ export interface Getter {
 interface Read {
     binding: Binding;
     extra: t.NodeExtra;
+    ownVar: boolean;
     getter: Getter | undefined;
 }
 interface ExtraRead {
     binding: Binding;
     props: Opt<string>;
+    ownVar: boolean;
     getter: Getter | undefined;
 }
 declare module "@marko/compiler/dist/types" {
@@ -107,6 +109,7 @@ export declare function getOrCreatePropertyAlias(binding: Binding, property: str
 export declare function trackDomVarReferences(tag: t.NodePath<t.MarkoTag>, binding: Binding): Binding | undefined;
 export declare function trackVarReferences(tag: t.NodePath<t.MarkoTag>, type: BindingType, upstreamAlias?: Binding["upstreamAlias"]): Binding | undefined;
 export declare function trackParamsReferences(body: t.NodePath<t.MarkoTagBody | t.Program>, type: BindingType): Binding | undefined;
+export declare function isReferenceInOwnBody(bindingPath: t.NodePath, reference: t.NodePath): boolean;
 export declare function isReferenceHoisted(bindingPath: t.NodePath, reference: t.NodePath): boolean;
 export declare function setReferencesScope(path: t.NodePath<any>): void;
 export declare function mergeReferences<T extends t.Node>(section: Section, target: T, nodes: (t.Node | undefined)[]): NonNullable<T["extra"]> & ReferencedExtra;
@@ -139,7 +142,8 @@ export declare function getSectionInstancesAccessorLiteral(section: Section): t.
 export declare function getReadReplacement(node: t.Identifier | t.MemberExpression | t.OptionalMemberExpression, signal?: Signal): t.Expression | undefined;
 export declare function hasNonConstantPropertyAlias(ref: Binding): boolean;
 export declare function pruneBinding(binding: Binding): boolean;
-export declare function createRead(binding: Binding, props: Opt<string>, getter: Getter | undefined): ExtraRead;
+export declare function createRead(binding: Binding, props: Opt<string>, ownVar?: boolean): ExtraRead;
+export declare function createGetterRead(binding: Binding, props: Opt<string>, getter: Getter): ExtraRead;
 export declare function getObjectPropertyKeyString(expr: t.ObjectProperty | t.ObjectMethod): string | undefined;
 export interface ReferencedExtra extends t.NodeExtra {
     section: Section;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.0.156",
+  "version": "6.0.157",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -49,7 +49,7 @@
     "build": "node -r ~ts ./scripts/bundle.ts"
   },
   "dependencies": {
-    "@marko/compiler": "^5.39.60",
+    "@marko/compiler": "^5.39.61",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"