@marko/runtime-tags 0.3.0 → 0.3.1

package/dist/translator/index.js

@@ -6,8 +6,8 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -39,56 +39,16 @@ __export(translator_exports, {
 });
 module.exports = __toCommonJS(translator_exports);
 
-// src/translator/util/is-core-tag.ts
-var import_babel_utils = require("@marko/compiler/babel-utils");
-
-// src/translator/util/get-tag-name.ts
-function getTagName(tag) {
-  return tag.node.name.value;
-}
-
-// src/translator/util/is-core-tag.ts
-var taglibId = "marko-core";
-var htmlTaglibId = "marko-html";
-var interopTaglibId = "@marko/translator-interop-class-tags";
-function isCoreTag(tag) {
-  if (tag.isMarkoTag()) {
-    const tagDef = (0, import_babel_utils.getTagDef)(tag);
-    if (tagDef) {
-      switch (tagDef.taglibId) {
-        case taglibId:
-        case interopTaglibId:
-          return true;
-        case htmlTaglibId:
-          switch (tagDef.name) {
-            case "script":
-            case "style":
-              return true;
-          }
-          break;
-      }
-    }
-  }
-  return false;
-}
-function isCoreTagName(tag, name) {
-  return isCoreTag(tag) && getTagName(tag) === name;
-}
-function isConditionTag(tag) {
-  if (isCoreTag(tag)) {
-    switch (getTagName(tag)) {
-      case "if":
-      case "else-if":
-      case "else":
-        return true;
-    }
-  }
-  return false;
-}
+// src/translator/util/runtime-info.ts
+var import_package = require("../../package.json");
+var runtime_info_default = {
+  name: import_package.name,
+  taglibId: "marko-core"
+};
 
 // src/translator/core/attrs.ts
 var import_compiler = require("@marko/compiler");
-var import_babel_utils2 = require("@marko/compiler/babel-utils");
+var import_babel_utils = require("@marko/compiler/babel-utils");
 
 // src/translator/util/assert.ts
 function assertNoSpreadAttrs(tag) {
@@ -112,12 +72,12 @@ function assertNoBodyContent(tag) {
 var attrs_default = {
   migrate: [
     (tag) => {
-      (0, import_babel_utils2.assertNoArgs)(tag);
-      (0, import_babel_utils2.assertNoParams)(tag);
-      (0, import_babel_utils2.assertNoAttributes)(tag);
+      (0, import_babel_utils.assertNoArgs)(tag);
+      (0, import_babel_utils.assertNoParams)(tag);
+      (0, import_babel_utils.assertNoAttributes)(tag);
       assertNoBodyContent(tag);
-      (0, import_babel_utils2.assertNoAttributeTags)(tag);
-      (0, import_babel_utils2.diagnosticDeprecate)(tag, {
+      (0, import_babel_utils.assertNoAttributeTags)(tag);
+      (0, import_babel_utils.diagnosticDeprecate)(tag, {
         label: "The `attrs` tag is deprecated, prefer destructuring `input` via the `const` tag.",
         fix() {
           const tagVar = tag.node.var;
@@ -148,7 +108,7 @@ var attrs_default = {
 
 // src/translator/core/client.ts
 var import_compiler2 = require("@marko/compiler");
-var import_babel_utils3 = require("@marko/compiler/babel-utils");
+var import_babel_utils2 = require("@marko/compiler/babel-utils");
 var client_default = {
   parse(tag) {
     const {
@@ -158,7 +118,7 @@ var client_default = {
     const rawValue = node.rawValue;
     const code = rawValue.replace(/^client\s*/, "").trim();
     const start = node.name.start + (rawValue.length - code.length);
-    let body = (0, import_babel_utils3.parseStatements)(file, code, start, start + code.length);
+    let body = (0, import_babel_utils2.parseStatements)(file, code, start, start + code.length);
     if (body.length === 1 && import_compiler2.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
@@ -182,14 +142,14 @@ var import_compiler24 = require("@marko/compiler");
 var import_babel_utils12 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/evaluate.ts
-var import_babel_utils4 = require("@marko/compiler/babel-utils");
+var import_babel_utils3 = require("@marko/compiler/babel-utils");
 function evaluate(value) {
   let { extra } = value;
   if (!extra) {
     extra = value.extra = {};
   }
   if (extra.confident === void 0) {
-    const computed = (0, import_babel_utils4.computeNode)(value);
+    const computed = (0, import_babel_utils3.computeNode)(value);
     if (computed) {
       extra.computed = computed.value;
       extra.confident = true;
@@ -220,7 +180,7 @@ function bindingHasDownstreamExpressions(binding) {
 
 // src/translator/util/entry-builder.ts
 var import_compiler3 = require("@marko/compiler");
-var import_babel_utils5 = require("@marko/compiler/babel-utils");
+var import_babel_utils4 = require("@marko/compiler/babel-utils");
 var kState = Symbol();
 var entry_builder_default = {
   build(entryFile) {
@@ -238,7 +198,7 @@ var entry_builder_default = {
         import_compiler3.types.importDeclaration(
           [import_compiler3.types.importSpecifier(import_compiler3.types.identifier("init"), import_compiler3.types.identifier("init"))],
           import_compiler3.types.stringLiteral(
-            `@marko/runtime-tags/${entryFile.markoOpts.optimize ? "" : "debug/"}dom`
+            `${runtime_info_default.name}/${entryFile.markoOpts.optimize ? "" : "debug/"}dom`
           )
         )
       );
@@ -255,7 +215,7 @@ var entry_builder_default = {
     };
     const { analyzedTags } = file.metadata.marko;
     state.imports.push(
-      (0, import_babel_utils5.resolveRelativePath)(entryFile, file.opts.filename)
+      (0, import_babel_utils4.resolveRelativePath)(entryFile, file.opts.filename)
     );
     state.init ||= file.path.node.extra.hasInteractiveChild || file.path.node.extra.isInteractive || false;
     for (const tag of analyzedTags || []) {
@@ -583,6 +543,53 @@ function joinRepeatable(compare, a, b) {
 var import_compiler5 = require("@marko/compiler");
 var import_babel_utils7 = require("@marko/compiler/babel-utils");
 
+// src/translator/util/is-core-tag.ts
+var import_babel_utils5 = require("@marko/compiler/babel-utils");
+
+// src/translator/util/get-tag-name.ts
+function getTagName(tag) {
+  return tag.node.name.value;
+}
+
+// src/translator/util/is-core-tag.ts
+var { taglibId } = runtime_info_default;
+var htmlTaglibId = "marko-html";
+var interopTaglibId = "@marko/translator-interop-class-tags";
+function isCoreTag(tag) {
+  if (tag.isMarkoTag()) {
+    const tagDef = (0, import_babel_utils5.getTagDef)(tag);
+    if (tagDef) {
+      switch (tagDef.taglibId) {
+        case taglibId:
+        case interopTaglibId:
+          return true;
+        case htmlTaglibId:
+          switch (tagDef.name) {
+            case "script":
+            case "style":
+              return true;
+          }
+          break;
+      }
+    }
+  }
+  return false;
+}
+function isCoreTagName(tag, name2) {
+  return isCoreTag(tag) && getTagName(tag) === name2;
+}
+function isConditionTag(tag) {
+  if (isCoreTag(tag)) {
+    switch (getTagName(tag)) {
+      case "if":
+      case "else-if":
+      case "else":
+        return true;
+    }
+  }
+  return false;
+}
+
 // src/translator/util/state.ts
 var createProgramState = (init) => {
   const map2 = /* @__PURE__ */ new WeakMap();
@@ -631,26 +638,26 @@ var TAG_NAME_IDENTIFIER_REG = /^[A-Z][a-zA-Z0-9_$]*$/;
 function analyzeTagNameType(tag) {
   const extra = tag.node.extra ??= {};
   if (extra.tagNameType === void 0) {
-    const name = tag.get("name");
-    if (name.isStringLiteral()) {
-      extra.tagNameType = name.node.value[0] === "@" ? 3 /* AttributeTag */ : (0, import_babel_utils6.isNativeTag)(tag) ? 0 /* NativeTag */ : 1 /* CustomTag */;
+    const name2 = tag.get("name");
+    if (name2.isStringLiteral()) {
+      extra.tagNameType = name2.node.value[0] === "@" ? 3 /* AttributeTag */ : (0, import_babel_utils6.isNativeTag)(tag) ? 0 /* NativeTag */ : 1 /* CustomTag */;
       if (extra.tagNameType === 1 /* CustomTag */) {
-        const bindingName = name.node.value;
+        const bindingName = name2.node.value;
         const bindingIdentifier = tag.scope.getBinding(bindingName)?.identifier;
         if (bindingIdentifier && TAG_NAME_IDENTIFIER_REG.test(bindingIdentifier.name)) {
           const tagIdentifier = withPreviousLocation(
             import_compiler4.types.identifier(bindingName),
-            name.node
+            name2.node
           );
           tagIdentifier.extra = {
             referencedBindings: bindingIdentifier.extra?.binding
           };
-          analyzeExpressionTagName(name.replaceWith(tagIdentifier)[0], extra);
+          analyzeExpressionTagName(name2.replaceWith(tagIdentifier)[0], extra);
         }
       }
       extra.tagNameNullable = extra.tagNameNullable = false;
     } else {
-      analyzeExpressionTagName(name, extra);
+      analyzeExpressionTagName(name2, extra);
     }
     if (extra.tagNameType === void 0) {
       extra.tagNameType = 2 /* DynamicTag */;
@@ -667,8 +674,8 @@ function analyzeTagNameType(tag) {
   }
   return extra.tagNameType;
 }
-function analyzeExpressionTagName(name, extra) {
-  const pending = [name];
+function analyzeExpressionTagName(name2, extra) {
+  const pending = [name2];
   let path4;
   let type;
   let nullable = false;
@@ -707,7 +714,7 @@ function analyzeExpressionTagName(name, extra) {
       if (binding.kind === "module") {
         const decl = binding.path.parent;
         if (MARKO_FILE_REG.test(decl.source.value) && decl.specifiers.some((it) => import_compiler4.types.isImportDefaultSpecifier(it))) {
-          const resolvedImport = (0, import_babel_utils6.resolveTagImport)(name, decl.source.value) || decl.source.value;
+          const resolvedImport = (0, import_babel_utils6.resolveTagImport)(name2, decl.source.value) || decl.source.value;
           if (type === 0 /* NativeTag */ || tagNameImported && tagNameImported !== resolvedImport) {
             type = 2 /* DynamicTag */;
             tagNameImported = void 0;
@@ -913,16 +920,16 @@ var checkStatefulClosures = (section, immediateOnly) => {
 
 // src/translator/util/to-property-name.ts
 var import_compiler6 = require("@marko/compiler");
-function toPropertyName(name) {
-  if (/^[a-z_$][a-z0-9_$]*$/i.test(name)) {
-    return import_compiler6.types.identifier(name);
-  } else if (/^(?:0|[1-9][0-9]*)$/.test(name)) {
-    return import_compiler6.types.numericLiteral(parseInt(name, 10));
+function toPropertyName(name2) {
+  if (/^[a-z_$][a-z0-9_$]*$/i.test(name2)) {
+    return import_compiler6.types.identifier(name2);
+  } else if (/^(?:0|[1-9][0-9]*)$/.test(name2)) {
+    return import_compiler6.types.numericLiteral(parseInt(name2, 10));
   }
-  return import_compiler6.types.stringLiteral(name);
+  return import_compiler6.types.stringLiteral(name2);
 }
-function toObjectProperty(name, value) {
-  return import_compiler6.types.objectProperty(toPropertyName(name), value);
+function toObjectProperty(name2, value) {
+  return import_compiler6.types.objectProperty(toPropertyName(name2), value);
 }
 function toMemberExpression(object, key, optional) {
   const prop = toPropertyName(key);
@@ -933,11 +940,11 @@ function toMemberExpression(object, key, optional) {
 // src/translator/util/references.ts
 var [getBindings] = createProgramState(() => /* @__PURE__ */ new Set());
 var [getNextBindingId, setNextBindingId] = createProgramState(() => 0);
-function createBinding(name, type, section, upstreamAlias, upstreamExpression, property, declared = false) {
+function createBinding(name2, type, section, upstreamAlias, upstreamExpression, property, declared = false) {
   const id = getNextBindingId();
   const binding = {
     id,
-    name,
+    name: name2,
     type,
     section,
     property,
@@ -1278,10 +1285,10 @@ function finalizeReferences() {
     }
   }
   for (const binding of bindings) {
-    const { name, section } = binding;
+    const { name: name2, section } = binding;
     if (binding.type !== 0 /* dom */) {
-      if (find(section.bindings, ({ name: name2 }) => name2 === binding.name)) {
-        binding.name = currentProgramPath.scope.generateUid(name);
+      if (find(section.bindings, ({ name: name3 }) => name3 === binding.name)) {
+        binding.name = currentProgramPath.scope.generateUid(name2);
       }
     }
     section.bindings = bindingUtil.add(section.bindings, binding);
@@ -1585,7 +1592,391 @@ var import_compiler20 = require("@marko/compiler");
 // src/translator/util/runtime.ts
 var import_compiler8 = require("@marko/compiler");
 var import_babel_utils8 = require("@marko/compiler/babel-utils");
-var import_html = require("@marko/runtime-tags/html");
+
+// src/common/attr-tag.ts
+var rest = false ? Symbol("Attribute Tag") : Symbol();
+
+// src/common/helpers.ts
+function classValue(value) {
+  return toDelimitedString(value, " ", stringifyClassObject);
+}
+function stringifyClassObject(name2, value) {
+  return value ? name2 : "";
+}
+function styleValue(value) {
+  return toDelimitedString(value, ";", stringifyStyleObject);
+}
+var NON_DIMENSIONAL = /^(--|ta|or|li|z)|n-c|i(do|nk|m|t)|w$|we/;
+function stringifyStyleObject(name2, value) {
+  return value || value === 0 ? `${name2}:${typeof value === "number" && value && !NON_DIMENSIONAL.test(name2) ? value + "px" : value}` : "";
+}
+function toDelimitedString(val, delimiter, stringify) {
+  switch (typeof val) {
+    case "string":
+      return val;
+    case "object":
+      if (val !== null) {
+        let result = "";
+        let curDelimiter = "";
+        if (Array.isArray(val)) {
+          for (const v of val) {
+            const part = toDelimitedString(v, delimiter, stringify);
+            if (part !== "") {
+              result += curDelimiter + part;
+              curDelimiter = delimiter;
+            }
+          }
+        } else {
+          for (const name2 in val) {
+            const v = val[name2];
+            const part = stringify(name2, v);
+            if (part !== "") {
+              result += curDelimiter + part;
+              curDelimiter = delimiter;
+            }
+          }
+        }
+        return result;
+      }
+  }
+  return "";
+}
+function isEventHandler(name2) {
+  return /^on[A-Z-]/.test(name2);
+}
+function getEventHandlerName(name2) {
+  return name2[2] === "-" ? name2.slice(3) : name2.slice(2).toLowerCase();
+}
+function isVoid(value) {
+  return value == null || value === false;
+}
+
+// src/html/content.ts
+function toString(val) {
+  return val ? val + "" : val === 0 ? "0" : "";
+}
+var unsafeXMLReg = /[<&]/g;
+var replaceUnsafeXML = (c) => c === "&" ? "&amp;" : "&lt;";
+var escapeXMLStr = (str) => unsafeXMLReg.test(str) ? str.replace(unsafeXMLReg, replaceUnsafeXML) : str;
+function escapeXML(val) {
+  return val ? escapeXMLStr(val + "") : val === 0 ? "0" : "&zwj;";
+}
+var unsafeScriptReg = /<\/script/g;
+var escapeScriptStr = (str) => unsafeScriptReg.test(str) ? str.replace(unsafeScriptReg, "\\x3C/script") : str;
+function escapeScript(val) {
+  return val ? escapeScriptStr(val + "") : val === 0 ? "0" : "";
+}
+var unsafeStyleReg = /<\/style/g;
+var escapeStyleStr = (str) => unsafeStyleReg.test(str) ? str.replace(unsafeStyleReg, "\\3C/style") : str;
+function escapeStyle(val) {
+  return val ? escapeStyleStr(val + "") : val === 0 ? "0" : "";
+}
+
+// src/html/serializer.ts
+var { hasOwnProperty } = {};
+var Generator = function* () {
+}().constructor;
+var AsyncGenerator = async function* () {
+}().constructor;
+var KNOWN_SYMBOLS = (() => {
+  const KNOWN_SYMBOLS2 = /* @__PURE__ */ new Map();
+  for (const name2 of Object.getOwnPropertyNames(Symbol)) {
+    const symbol = Symbol[name2];
+    if (typeof symbol === "symbol") {
+      KNOWN_SYMBOLS2.set(symbol, "Symbol." + name2);
+    }
+  }
+  return KNOWN_SYMBOLS2;
+})();
+var KNOWN_FUNCTIONS = /* @__PURE__ */ new Map([
+  // This is by no means an exhaustive list,
+  // but it should cover most of the built-in functions.
+  [AggregateError, "AggregateError"],
+  [Array, "Array"],
+  [Array.from, "Array.from"],
+  [Array.isArray, "Array.isArray"],
+  [Array.of, "Array.of"],
+  [ArrayBuffer, "ArrayBuffer"],
+  [ArrayBuffer.isView, "ArrayBuffer.isView"],
+  [Atomics.add, "Atomics.add"],
+  [Atomics.and, "Atomics.and"],
+  [Atomics.compareExchange, "Atomics.compareExchange"],
+  [Atomics.exchange, "Atomics.exchange"],
+  [Atomics.isLockFree, "Atomics.isLockFree"],
+  [Atomics.load, "Atomics.load"],
+  [Atomics.notify, "Atomics.notify"],
+  [Atomics.or, "Atomics.or"],
+  [Atomics.store, "Atomics.store"],
+  [Atomics.sub, "Atomics.sub"],
+  [Atomics.wait, "Atomics.wait"],
+  [BigInt, "BigInt"],
+  [BigInt.asIntN, "BigInt.asIntN"],
+  [BigInt.asUintN, "BigInt.asUintN"],
+  [BigInt64Array, "BigInt64Array"],
+  [BigInt64Array.from, "BigInt64Array.from"],
+  [BigInt64Array.of, "BigInt64Array.of"],
+  [BigUint64Array, "BigUint64Array"],
+  [BigUint64Array.from, "BigUint64Array.from"],
+  [BigUint64Array.of, "BigUint64Array.of"],
+  [Boolean, "Boolean"],
+  [console.assert, "console.assert"],
+  [console.clear, "console.clear"],
+  [console.count, "console.count"],
+  [console.countReset, "console.countReset"],
+  [console.debug, "console.debug"],
+  [console.dir, "console.dir"],
+  [console.dirxml, "console.dirxml"],
+  [console.error, "console.error"],
+  [console.group, "console.group"],
+  [console.groupCollapsed, "console.groupCollapsed"],
+  [console.groupEnd, "console.groupEnd"],
+  [console.info, "console.info"],
+  [console.log, "console.log"],
+  [console.table, "console.table"],
+  [console.time, "console.time"],
+  [console.timeEnd, "console.timeEnd"],
+  [console.timeLog, "console.timeLog"],
+  [console.timeStamp, "console.timeStamp"],
+  [console.trace, "console.trace"],
+  [console.warn, "console.warn"],
+  [DataView, "DataView"],
+  [Date, "Date"],
+  [Date.now, "Date.now"],
+  [Date.parse, "Date.parse"],
+  [Date.UTC, "Date.UTC"],
+  [decodeURI, "decodeURI"],
+  [decodeURIComponent, "decodeURIComponent"],
+  [encodeURI, "encodeURI"],
+  [encodeURIComponent, "encodeURIComponent"],
+  [Error, "Error"],
+  [EvalError, "EvalError"],
+  [Float32Array, "Float32Array"],
+  [Float32Array.from, "Float32Array.from"],
+  [Float32Array.of, "Float32Array.of"],
+  [Float64Array, "Float64Array"],
+  [Float64Array.from, "Float64Array.from"],
+  [Float64Array.of, "Float64Array.of"],
+  [Function, "Function"],
+  [globalThis.atob, "atob"],
+  [globalThis.btoa, "btoa"],
+  [globalThis.clearImmediate, "clearImmediate"],
+  [globalThis.clearInterval, "clearInterval"],
+  [globalThis.clearTimeout, "clearTimeout"],
+  [globalThis.crypto?.getRandomValues, "crypto.getRandomValues"],
+  [globalThis.crypto?.randomUUID, "crypto.randomUUID"],
+  [globalThis.fetch, "fetch"],
+  [globalThis.performance?.now, "performance.now"],
+  [globalThis.queueMicrotask, "queueMicrotask"],
+  [globalThis.setImmediate, "setImmediate"],
+  [globalThis.setInterval, "setInterval"],
+  [globalThis.setTimeout, "setTimeout"],
+  [globalThis.structuredClone, "structuredClone"],
+  [globalThis.URL, "URL"],
+  [globalThis.URLSearchParams, "URLSearchParams"],
+  [globalThis.WritableStream, "WritableStream"],
+  [Int16Array, "Int16Array"],
+  [Int16Array.from, "Int16Array.from"],
+  [Int16Array.of, "Int16Array.of"],
+  [Int32Array, "Int32Array"],
+  [Int32Array.from, "Int32Array.from"],
+  [Int32Array.of, "Int32Array.of"],
+  [Int8Array, "Int8Array"],
+  [Int8Array.from, "Int8Array.from"],
+  [Int8Array.of, "Int8Array.of"],
+  [Intl.Collator, "Intl.Collator"],
+  [Intl.DateTimeFormat, "Intl.DateTimeFormat"],
+  [Intl.DisplayNames, "Intl.DisplayNames"],
+  [Intl.getCanonicalLocales, "Intl.getCanonicalLocales"],
+  [Intl.ListFormat, "Intl.ListFormat"],
+  [Intl.Locale, "Intl.Locale"],
+  [Intl.NumberFormat, "Intl.NumberFormat"],
+  [Intl.PluralRules, "Intl.PluralRules"],
+  [Intl.RelativeTimeFormat, "Intl.RelativeTimeFormat"],
+  [Intl.Segmenter, "Intl.Segmenter"],
+  [Intl.supportedValuesOf, "Intl.supportedValuesOf"],
+  [isFinite, "isFinite"],
+  [isNaN, "isNaN"],
+  [JSON.parse, "JSON.parse"],
+  [JSON.stringify, "JSON.stringify"],
+  [Map, "Map"],
+  [Map.groupBy, "Map.groupBy"],
+  [Math.abs, "Math.abs"],
+  [Math.acos, "Math.acos"],
+  [Math.acosh, "Math.acosh"],
+  [Math.asin, "Math.asin"],
+  [Math.asinh, "Math.asinh"],
+  [Math.atan, "Math.atan"],
+  [Math.atan2, "Math.atan2"],
+  [Math.atanh, "Math.atanh"],
+  [Math.cbrt, "Math.cbrt"],
+  [Math.ceil, "Math.ceil"],
+  [Math.clz32, "Math.clz32"],
+  [Math.cos, "Math.cos"],
+  [Math.cosh, "Math.cosh"],
+  [Math.exp, "Math.exp"],
+  [Math.expm1, "Math.expm1"],
+  [Math.floor, "Math.floor"],
+  [Math.fround, "Math.fround"],
+  [Math.hypot, "Math.hypot"],
+  [Math.imul, "Math.imul"],
+  [Math.log, "Math.log"],
+  [Math.log10, "Math.log10"],
+  [Math.log1p, "Math.log1p"],
+  [Math.log2, "Math.log2"],
+  [Math.max, "Math.max"],
+  [Math.min, "Math.min"],
+  [Math.pow, "Math.pow"],
+  [Math.random, "Math.random"],
+  [Math.round, "Math.round"],
+  [Math.sign, "Math.sign"],
+  [Math.sin, "Math.sin"],
+  [Math.sinh, "Math.sinh"],
+  [Math.sqrt, "Math.sqrt"],
+  [Math.tan, "Math.tan"],
+  [Math.tanh, "Math.tanh"],
+  [Math.trunc, "Math.trunc"],
+  [Number, "Number"],
+  [Number.isFinite, "Number.isFinite"],
+  [Number.isInteger, "Number.isInteger"],
+  [Number.isNaN, "Number.isNaN"],
+  [Number.isSafeInteger, "Number.isSafeInteger"],
+  [Number.parseFloat, "Number.parseFloat"],
+  [Number.parseInt, "Number.parseInt"],
+  [Object, "Object"],
+  [Object.assign, "Object.assign"],
+  [Object.create, "Object.create"],
+  [Object.defineProperties, "Object.defineProperties"],
+  [Object.defineProperty, "Object.defineProperty"],
+  [Object.entries, "Object.entries"],
+  [Object.freeze, "Object.freeze"],
+  [Object.fromEntries, "Object.fromEntries"],
+  [Object.getOwnPropertyDescriptor, "Object.getOwnPropertyDescriptor"],
+  [Object.getOwnPropertyDescriptors, "Object.getOwnPropertyDescriptors"],
+  [Object.getOwnPropertyNames, "Object.getOwnPropertyNames"],
+  [Object.getOwnPropertySymbols, "Object.getOwnPropertySymbols"],
+  [Object.getPrototypeOf, "Object.getPrototypeOf"],
+  [Object.is, "Object.is"],
+  [Object.isExtensible, "Object.isExtensible"],
+  [Object.isFrozen, "Object.isFrozen"],
+  [Object.isSealed, "Object.isSealed"],
+  [Object.keys, "Object.keys"],
+  [Object.preventExtensions, "Object.preventExtensions"],
+  [Object.seal, "Object.seal"],
+  [Object.setPrototypeOf, "Object.setPrototypeOf"],
+  [Object.values, "Object.values"],
+  [parseFloat, "parseFloat"],
+  [parseInt, "parseInt"],
+  [Promise, "Promise"],
+  [Proxy, "Proxy"],
+  [RangeError, "RangeError"],
+  [ReferenceError, "ReferenceError"],
+  [Reflect.apply, "Reflect.apply"],
+  [Reflect.construct, "Reflect.construct"],
+  [Reflect.defineProperty, "Reflect.defineProperty"],
+  [Reflect.deleteProperty, "Reflect.deleteProperty"],
+  [Reflect.get, "Reflect.get"],
+  [Reflect.getOwnPropertyDescriptor, "Reflect.getOwnPropertyDescriptor"],
+  [Reflect.getPrototypeOf, "Reflect.getPrototypeOf"],
+  [Reflect.has, "Reflect.has"],
+  [Reflect.isExtensible, "Reflect.isExtensible"],
+  [Reflect.ownKeys, "Reflect.ownKeys"],
+  [Reflect.preventExtensions, "Reflect.preventExtensions"],
+  [Reflect.set, "Reflect.set"],
+  [Reflect.setPrototypeOf, "Reflect.setPrototypeOf"],
+  [RegExp, "RegExp"],
+  [Set, "Set"],
+  [String, "String"],
+  [String.fromCharCode, "String.fromCharCode"],
+  [String.fromCodePoint, "String.fromCodePoint"],
+  [String.raw, "String.raw"],
+  [Symbol, "Symbol"],
+  [Symbol.for, "Symbol.for"],
+  [SyntaxError, "SyntaxError"],
+  [TypeError, "TypeError"],
+  [Uint16Array, "Uint16Array"],
+  [Uint16Array.from, "Uint16Array.from"],
+  [Uint16Array.of, "Uint16Array.of"],
+  [Uint32Array, "Uint32Array"],
+  [Uint32Array.from, "Uint32Array.from"],
+  [Uint32Array.of, "Uint32Array.of"],
+  [Uint8Array, "Uint8Array"],
+  [Uint8Array.from, "Uint8Array.from"],
+  [Uint8Array.of, "Uint8Array.of"],
+  [Uint8ClampedArray, "Uint8ClampedArray"],
+  [Uint8ClampedArray.from, "Uint8ClampedArray.from"],
+  [Uint8ClampedArray.of, "Uint8ClampedArray.of"],
+  [URIError, "URIError"],
+  [WeakMap, "WeakMap"],
+  [WeakSet, "WeakSet"]
+]);
+var KNOWN_OBJECTS = /* @__PURE__ */ new Map([
+  [Atomics, "Atomics"],
+  [console, "console"],
+  [globalThis, "globalThis"],
+  [globalThis.crypto, "crypto"],
+  [Intl, "Intl"],
+  [JSON, "JSON"],
+  [Math, "Math"],
+  [Reflect, "Reflect"]
+]);
+
+// src/html/writer.ts
+var K_SCOPE_ID = Symbol("Scope ID");
+var kPendingContexts = Symbol("Pending Contexts");
+var tick = globalThis.setImmediate || globalThis.setTimeout || globalThis.queueMicrotask || ((cb) => Promise.resolve().then(cb));
+
+// src/html/attrs.ts
+function classAttr(val) {
+  return stringAttr("class", classValue(val));
+}
+function styleAttr(val) {
+  return stringAttr("style", styleValue(val));
+}
+var kSelectedValue = Symbol("selectedValue");
+function attr(name2, val) {
+  return isVoid(val) ? "" : nonVoidAttr(name2, val);
+}
+function stringAttr(name2, val) {
+  return val && ` ${name2}=${escapeAttrValue(val)}`;
+}
+function nonVoidAttr(name2, val) {
+  switch (typeof val) {
+    case "string":
+      return ` ${name2 + attrAssignment(val)}`;
+    case "boolean":
+      return ` ${name2}`;
+    case "number":
+      return ` ${name2}=${val}`;
+    case "object":
+      if (val instanceof RegExp) {
+        return ` ${name2 + attrAssignment(val.source)}`;
+      }
+      break;
+  }
+  return ` ${name2 + attrAssignment(val + "")}`;
+}
+function attrAssignment(val) {
+  return val ? `=${escapeAttrValue(val)}` : "";
+}
+var unsafeAttrChars = /["'>\s]/g;
+function escapeAttrValue(str) {
+  if (unsafeAttrChars.test(str)) {
+    const c = str[unsafeAttrChars.lastIndex - 1];
+    unsafeAttrChars.lastIndex = 0;
+    return c === '"' ? `'${str.replace(/'/g, "&#39;")}'` : `"${str.replace(/"/g, "&#34;")}"`;
+  }
+  return str;
+}
+
+// src/common/compat-meta.ts
+var prefix = false ? "$compat_" : "$C_";
+var RENDERER_REGISTER_ID = prefix + (false ? "renderer" : "r");
+var SET_SCOPE_REGISTER_ID = prefix + (false ? "setScope" : "s");
+
+// src/html/compat.ts
+var K_TAGS_API_STATE = Symbol();
+
+// src/translator/util/runtime.ts
 var pureFunctions = [
   "createTemplate",
   "createRenderer",
@@ -1600,21 +1991,19 @@ var pureFunctions = [
   "loopTo",
   "conditional"
 ];
-function importRuntime(name) {
+function importRuntime(name2) {
   const { output } = getMarkoOpts();
   return toMemberExpression(
     (0, import_babel_utils8.importStar)(currentProgramPath.hub.file, getRuntimePath(output), "$"),
-    name
+    name2
   );
 }
-function callRuntime(name, ...args) {
+function callRuntime(name2, ...args) {
   const callExpression2 = import_compiler8.types.callExpression(
-    importRuntime(name),
+    importRuntime(name2),
     filterArguments(args)
   );
-  if (pureFunctions.includes(
-    name
-  )) {
+  if (pureFunctions.includes(name2)) {
     callExpression2.leadingComments = [
       {
         type: "CommentBlock",
@@ -1626,18 +2015,18 @@ function callRuntime(name, ...args) {
 }
 function getHTMLRuntime() {
   return {
-    escapeXML: import_html.escapeXML,
-    toString: import_html.toString,
-    attr: import_html.attr,
-    classAttr: import_html.classAttr,
-    styleAttr: import_html.styleAttr,
-    escapeScript: import_html.escapeScript,
-    escapeStyle: import_html.escapeStyle
+    escapeXML,
+    toString,
+    attr,
+    classAttr,
+    styleAttr,
+    escapeScript,
+    escapeStyle
   };
 }
 function getRuntimePath(output) {
   const { optimize } = getMarkoOpts();
-  return `@marko/runtime-tags/${optimize ? "" : "debug/"}${output === "html" ? "html" : "dom"}`;
+  return `${runtime_info_default.name}/${optimize ? "" : "debug/"}${output === "html" ? "html" : "dom"}`;
 }
 function filterArguments(args) {
   const filteredArgs = [];
@@ -1653,22 +2042,20 @@ function filterArguments(args) {
 // src/translator/util/signals.ts
 var import_compiler19 = require("@marko/compiler");
 var import_babel_utils10 = require("@marko/compiler/babel-utils");
-var import_types3 = require("@marko/runtime-tags/common/types");
 
 // src/translator/core/return.ts
 var import_compiler13 = require("@marko/compiler");
 var import_babel_utils9 = require("@marko/compiler/babel-utils");
-var import_types2 = require("@marko/runtime-tags/common/types");
 
 // src/translator/util/get-known-attr-values.ts
 function getKnownAttrValues(tag) {
-  const attrs = {};
+  const attrs2 = {};
   for (const attr2 of tag.attributes) {
     if (attr2.type === "MarkoAttribute") {
-      attrs[attr2.name] = attr2.value;
+      attrs2[attr2.name] = attr2.value;
     }
   }
-  return attrs;
+  return attrs2;
 }
 
 // src/translator/util/plugin-hooks.ts
@@ -1713,12 +2100,12 @@ function extractVisitors(visitors2) {
     translate: {}
   };
   for (const _name in visitors2) {
-    const name = _name;
-    const value = visitors2[name];
-    if (value.migrate) result.migrate[name] = value.migrate;
-    if (value.transform) result.transform[name] = value.transform;
-    if (value.analyze) result.analyze[name] = value.analyze;
-    if (value.translate) result.translate[name] = value.translate;
+    const name2 = _name;
+    const value = visitors2[name2];
+    if (value.migrate) result.migrate[name2] = value.migrate;
+    if (value.transform) result.transform[name2] = value.transform;
+    if (value.analyze) result.analyze[name2] = value.analyze;
+    if (value.translate) result.translate[name2] = value.translate;
   }
   return result;
 }
@@ -1793,7 +2180,6 @@ function shiftItems(list, start, offset) {
 
 // src/translator/util/walks.ts
 var import_compiler11 = require("@marko/compiler");
-var import_types = require("@marko/runtime-tags/common/types");
 var [getWalks] = createSectionState(
   "walks",
   () => [""]
@@ -1804,19 +2190,19 @@ var [getWalkComment] = createSectionState(
 );
 var [getSteps] = createSectionState("steps", () => []);
 var walkCodeToName = {
-  [import_types.WalkCode.Get]: "get",
-  [import_types.WalkCode.Inside]: "inside",
-  [import_types.WalkCode.Replace]: "replace",
-  [import_types.WalkCode.EndChild]: "endChild",
-  [import_types.WalkCode.BeginChild]: "beginChild",
-  [import_types.WalkCode.Next]: "next",
-  [import_types.WalkCode.Over]: "over",
-  [import_types.WalkCode.Out]: "out",
-  [import_types.WalkCode.Multiplier]: "multiplier",
-  [import_types.WalkCode.NextEnd]: "nextEnd",
-  [import_types.WalkCode.OverEnd]: "overEnd",
-  [import_types.WalkCode.OutEnd]: "outEnd",
-  [import_types.WalkCode.MultiplierEnd]: "multiplierEnd"
+  [32 /* Get */]: "get",
+  [36 /* Inside */]: "inside",
+  [37 /* Replace */]: "replace",
+  [38 /* EndChild */]: "endChild",
+  [47 /* BeginChild */]: "beginChild",
+  [67 /* Next */]: "next",
+  [97 /* Over */]: "over",
+  [107 /* Out */]: "out",
+  [117 /* Multiplier */]: "multiplier",
+  [91 /* NextEnd */]: "nextEnd",
+  [106 /* OverEnd */]: "overEnd",
+  [116 /* OutEnd */]: "outEnd",
+  [126 /* MultiplierEnd */]: "multiplierEnd"
 };
 function enter2(path4) {
   getSteps(getSection(path4)).push(0 /* Enter */);
@@ -1831,12 +2217,12 @@ function injectWalks(path4, expr) {
   const walks = getWalks(getSection(path4));
   const walkComment = getWalkComment(getSection(path4));
   walkComment.push(
-    `${walkCodeToName[import_types.WalkCode.BeginChild]}`,
+    `${walkCodeToName[47 /* BeginChild */]}`,
     expr.name,
-    walkCodeToName[import_types.WalkCode.EndChild]
+    walkCodeToName[38 /* EndChild */]
   );
-  appendLiteral(walks, String.fromCharCode(import_types.WalkCode.BeginChild));
-  walks.push(expr, String.fromCharCode(import_types.WalkCode.EndChild));
+  appendLiteral(walks, String.fromCharCode(47 /* BeginChild */));
+  walks.push(expr, String.fromCharCode(38 /* EndChild */));
 }
 function visit(path4, code) {
   if (isOutputHTML()) {
@@ -1853,15 +2239,15 @@ function visit(path4, code) {
     for (const step of steps) {
       if (step === 0 /* Enter */) {
         depth++;
-        walkCodes.push(import_types.WalkCode.Next);
+        walkCodes.push(67 /* Next */);
       } else {
         depth--;
         if (depth >= 0) {
-          walkCodes.length = walkCodes.lastIndexOf(import_types.WalkCode.Next);
-          walkCodes.push(import_types.WalkCode.Over);
+          walkCodes.length = walkCodes.lastIndexOf(67 /* Next */);
+          walkCodes.push(97 /* Over */);
         } else {
-          walkCodes.length = walkCodes.lastIndexOf(import_types.WalkCode.Out) + 1;
-          walkCodes.push(import_types.WalkCode.Out);
+          walkCodes.length = walkCodes.lastIndexOf(107 /* Out */) + 1;
+          walkCodes.push(107 /* Out */);
           depth = 0;
         }
       }
@@ -1883,7 +2269,7 @@ function visit(path4, code) {
     steps.length = 0;
   }
   if (code !== void 0) {
-    if (code !== import_types.WalkCode.Get) {
+    if (code !== 32 /* Get */) {
       writeTo(path4)`<!>`;
     }
     walkComment.push(`${walkCodeToName[code]}`);
@@ -1893,12 +2279,12 @@ function visit(path4, code) {
 }
 function nCodeString(code, number) {
   switch (code) {
-    case import_types.WalkCode.Next:
-      return toCharString(number, code, import_types.WalkRangeSize.Next);
-    case import_types.WalkCode.Over:
-      return toCharString(number, code, import_types.WalkRangeSize.Over);
-    case import_types.WalkCode.Out:
-      return toCharString(number, code, import_types.WalkRangeSize.Out);
+    case 67 /* Next */:
+      return toCharString(number, code, 20 /* Next */);
+    case 97 /* Over */:
+      return toCharString(number, code, 10 /* Over */);
+    case 107 /* Out */:
+      return toCharString(number, code, 10 /* Out */);
     default:
       throw new Error(`Unexpected walk code: ${code}`);
   }
@@ -1909,8 +2295,8 @@ function toCharString(number, startCode, rangeSize) {
     const multiplier = Math.floor(number / rangeSize);
     result += toCharString(
       multiplier,
-      import_types.WalkCode.Multiplier,
-      import_types.WalkRangeSize.Multiplier
+      117 /* Multiplier */,
+      10 /* Multiplier */
     );
     number -= multiplier * rangeSize;
   }
@@ -1918,10 +2304,10 @@ function toCharString(number, startCode, rangeSize) {
   return result;
 }
 function getWalkString(section) {
-  const prefix = section.content?.startType === 1 /* Dynamic */ ? String.fromCharCode(import_types.WalkCode.Next + 1) : "";
-  const postfix = section.content?.endType === 1 /* Dynamic */ ? String.fromCharCode(import_types.WalkCode.Next + 1) : "";
+  const prefix2 = section.content?.startType === 1 /* Dynamic */ ? String.fromCharCode(67 /* Next */ + 1) : "";
+  const postfix = section.content?.endType === 1 /* Dynamic */ ? String.fromCharCode(67 /* Next */ + 1) : "";
   const walks = getWalks(section);
-  const walkLiteral = normalizeStringExpression([prefix, ...walks, postfix]) || import_compiler11.types.stringLiteral("");
+  const walkLiteral = normalizeStringExpression([prefix2, ...walks, postfix]) || import_compiler11.types.stringLiteral("");
   if (walkLiteral.value !== "") {
     walkLiteral.leadingComments = [
       {
@@ -2042,20 +2428,20 @@ var return_default = {
     html: {
       exit(tag) {
         const section = getSection(tag);
-        const attrs = getKnownAttrValues(tag.node);
+        const attrs2 = getKnownAttrValues(tag.node);
         flushBefore(tag);
-        if (attrs.valueChange) {
+        if (attrs2.valueChange) {
           getSerializedScopeProperties(section).set(
-            import_compiler13.types.stringLiteral(import_types2.AccessorChar.TagVariableChange),
-            attrs.valueChange
+            import_compiler13.types.stringLiteral("@" /* TagVariableChange */),
+            attrs2.valueChange
           );
         }
-        if (attrs.value) {
+        if (attrs2.value) {
           const returnId2 = currentProgramPath.scope.generateUidIdentifier("return");
           _setReturnId(section, returnId2);
           tag.replaceWith(
             import_compiler13.types.variableDeclaration("const", [
-              import_compiler13.types.variableDeclarator(returnId2, attrs.value)
+              import_compiler13.types.variableDeclarator(returnId2, attrs2.value)
             ])
           )[0].skip();
         }
@@ -2064,27 +2450,27 @@ var return_default = {
     dom: {
       exit(tag) {
         const section = getSection(tag);
-        const attrs = getKnownAttrValues(tag.node);
-        if (attrs.value) {
+        const attrs2 = getKnownAttrValues(tag.node);
+        if (attrs2.value) {
           addValue(
             section,
-            attrs.value.extra?.referencedBindings,
+            attrs2.value.extra?.referencedBindings,
             {
               identifier: importRuntime("tagVarSignal"),
               hasDownstreamIntersections: () => true
             },
-            attrs.value
+            attrs2.value
           );
         }
-        if (attrs.valueChange) {
+        if (attrs2.valueChange) {
           addValue(
             section,
-            attrs.valueChange.extra?.referencedBindings,
+            attrs2.valueChange.extra?.referencedBindings,
             {
               identifier: importRuntime("setTagVarChange"),
               hasDownstreamIntersections: () => false
             },
-            attrs.valueChange
+            attrs2.valueChange
           );
         }
         tag.remove();
@@ -2283,7 +2669,7 @@ var [getSerializedScopeProperties] = createSectionState("serializedScopeProperti
 var unimplementedBuild = () => {
   return import_compiler19.types.stringLiteral("SIGNAL NOT INITIALIZED");
 };
-function getSignal(section, referencedBindings, name = generateSignalName(referencedBindings)) {
+function getSignal(section, referencedBindings, name2 = generateSignalName(referencedBindings)) {
   const signals = getSignals(section);
   let signal = signals.get(referencedBindings);
   if (!signal) {
@@ -2292,7 +2678,7 @@ function getSignal(section, referencedBindings, name = generateSignalName(refere
       referencedBindings,
       signal = {
         identifier: exportName ? import_compiler19.types.identifier(exportName) : currentProgramPath.scope.generateUidIdentifier(
-          name + section.name.replace("_", "$")
+          name2 + section.name.replace("_", "$")
         ),
         referencedBindings,
         section,
@@ -2544,20 +2930,20 @@ function subscribe(provider, subscriber) {
   );
 }
 function generateSignalName(referencedBindings) {
-  let name;
+  let name2;
   if (referencedBindings) {
     if (Array.isArray(referencedBindings)) {
-      name = "expr";
+      name2 = "expr";
       for (const ref of referencedBindings) {
-        name += `_${ref.name}`;
+        name2 += `_${ref.name}`;
       }
     } else {
-      name = referencedBindings.name;
+      name2 = referencedBindings.name;
     }
   } else {
-    name = "setup";
+    name2 = "setup";
   }
-  return name;
+  return name2;
 }
 function finalizeSignalArgs(args) {
   for (let i = args.length - 1; i >= 0; i--) {
@@ -2619,26 +3005,26 @@ function getResumeRegisterId(section, referencedBindings, type) {
     markoOpts,
     opts: { filename }
   } = currentProgramPath.hub.file;
-  let name = "";
+  let name2 = "";
   if (referencedBindings) {
     if (typeof referencedBindings === "string") {
-      name += `_${referencedBindings}`;
+      name2 += `_${referencedBindings}`;
     } else if (Array.isArray(referencedBindings)) {
       for (const ref of referencedBindings) {
-        name += `_${ref.name}`;
+        name2 += `_${ref.name}`;
       }
     } else {
-      name += `_${referencedBindings.name}`;
+      name2 += `_${referencedBindings.name}`;
     }
   }
   return (0, import_babel_utils10.getTemplateId)(
     markoOpts,
     filename,
-    `${section.id}${name}${type ? "/" + type : ""}`
+    `${section.id}${name2}${type ? "/" + type : ""}`
   );
 }
 var usedRegisterIdsBySection = /* @__PURE__ */ new WeakMap();
-function getRegisterUID(section, name) {
+function getRegisterUID(section, name2) {
   const {
     markoOpts,
     opts: { filename }
@@ -2648,7 +3034,7 @@ function getRegisterUID(section, name) {
   const baseId = (0, import_babel_utils10.getTemplateId)(
     markoOpts,
     filename,
-    `${section.id}/${name}`
+    `${section.id}/${name2}`
   );
   let count = 0;
   let id = baseId;
@@ -2886,7 +3272,7 @@ function writeHTMLResumeStatements(path4, tagVarIdentifier) {
   if (tagVarIdentifier && returnId(section) !== void 0) {
     serializedProperties.push(
       import_compiler19.types.objectProperty(
-        import_compiler19.types.stringLiteral(import_types3.AccessorChar.TagVariable),
+        import_compiler19.types.stringLiteral("/" /* TagVariable */),
         tagVarIdentifier
       )
     );
@@ -3547,7 +3933,7 @@ var const_default = {
       descriptionMoreURL: "https://markojs.com/docs/core-tags/#const"
     }
   ],
-  types: "@marko/runtime-tags/tag-types/const.d.marko"
+  types: runtime_info_default.name + "/tag-types/const.d.marko"
 };
 
 // src/translator/core/debug.ts
@@ -3590,7 +3976,7 @@ var debug_default = {
       descriptionMoreURL: "https://markojs.com/docs/core-tags/#debug"
     }
   ],
-  types: "@marko/runtime-tags/tag-types/debug.d.marko"
+  types: runtime_info_default.name + "/tag-types/debug.d.marko"
 };
 
 // src/translator/core/define.ts
@@ -3604,7 +3990,6 @@ var import_babel_utils17 = require("@marko/compiler/babel-utils");
 // src/translator/core/for.ts
 var import_compiler27 = require("@marko/compiler");
 var import_babel_utils15 = require("@marko/compiler/babel-utils");
-var import_types5 = require("@marko/runtime-tags/common/types");
 
 // src/translator/util/get-parent-tag.ts
 function getParentTag(tag) {
@@ -3617,18 +4002,16 @@ function getParentTag(tag) {
 // src/translator/visitors/tag/native-tag.ts
 var import_compiler26 = require("@marko/compiler");
 var import_babel_utils14 = require("@marko/compiler/babel-utils");
-var import_helpers = require("@marko/runtime-tags/common/helpers");
-var import_types4 = require("@marko/runtime-tags/common/types");
 var kNativeTagBinding = Symbol("native tag binding");
 var kSerializeMarker = Symbol("serialize marker");
 var kGetterId = Symbol("node getter id");
 var htmlSelectArgs = /* @__PURE__ */ new WeakMap();
-function assertExclusiveControllableGroups(tag, attrs) {
+function assertExclusiveControllableGroups(tag, attrs2) {
   const exclusiveGroups = [
-    attrs.open || attrs.openChange,
-    attrs.checked || attrs.checkedChange,
-    attrs.checkedValue || attrs.checkedValueChange,
-    attrs.valueChange
+    attrs2.open || attrs2.openChange,
+    attrs2.checked || attrs2.checkedChange,
+    attrs2.checkedValue || attrs2.checkedValueChange,
+    attrs2.valueChange
   ].filter(Boolean);
   if (exclusiveGroups.length > 1) {
     throw tag.get("name").buildCodeFrameError(
@@ -3636,56 +4019,56 @@ function assertExclusiveControllableGroups(tag, attrs) {
     );
   }
 }
-function getRelatedControllable(tagName, attrs) {
+function getRelatedControllable(tagName, attrs2) {
   switch (tagName) {
     case "input":
-      if (attrs.checked || attrs.checkedChange) {
+      if (attrs2.checked || attrs2.checkedChange) {
         return {
           special: false,
           helper: "controllable_input_checked",
-          attrs: [attrs.checked, attrs.checkedChange]
+          attrs: [attrs2.checked, attrs2.checkedChange]
         };
       }
-      if (attrs.checkedValue || attrs.checkedValueChange) {
+      if (attrs2.checkedValue || attrs2.checkedValueChange) {
         return {
           special: true,
           helper: "controllable_input_checkedValue",
-          attrs: [attrs.checkedValue, attrs.checkedValueChange, attrs.value]
+          attrs: [attrs2.checkedValue, attrs2.checkedValueChange, attrs2.value]
         };
       }
-      if (attrs.value || attrs.valueChange) {
+      if (attrs2.value || attrs2.valueChange) {
         return {
           special: false,
           helper: "controllable_input_value",
-          attrs: [attrs.value, attrs.valueChange]
+          attrs: [attrs2.value, attrs2.valueChange]
         };
       }
       break;
     case "select":
-      if (attrs.value || attrs.valueChange) {
+      if (attrs2.value || attrs2.valueChange) {
         return {
           special: true,
           helper: "controllable_select_value",
-          attrs: [attrs.value, attrs.valueChange]
+          attrs: [attrs2.value, attrs2.valueChange]
         };
       }
       break;
     case "textarea":
-      if (attrs.value || attrs.valueChange) {
+      if (attrs2.value || attrs2.valueChange) {
         return {
           special: true,
           helper: "controllable_textarea_value",
-          attrs: [attrs.value, attrs.valueChange]
+          attrs: [attrs2.value, attrs2.valueChange]
         };
       }
       break;
     case "details":
     case "dialog":
-      if (attrs.open || attrs.openChange) {
+      if (attrs2.open || attrs2.openChange) {
         return {
           special: false,
           helper: "controllable_detailsOrDialog_open",
-          attrs: [attrs.open, attrs.openChange]
+          attrs: [attrs2.open, attrs2.openChange]
         };
       }
       break;
@@ -3745,7 +4128,7 @@ var native_tag_default = {
             continue;
           }
           seen[attr2.name] = attr2;
-          if ((0, import_helpers.isEventHandler)(attr2.name) || isChangeHandler(attr2.name)) {
+          if (isEventHandler(attr2.name) || isChangeHandler(attr2.name)) {
             (attr2.value.extra ??= {}).isEffect = true;
             hasEventHandlers = true;
           } else if (!evaluate(attr2.value).confident) {
@@ -3811,11 +4194,11 @@ var native_tag_default = {
     enter(tag) {
       const tagName = getTagName(tag);
       const extra = tag.node.extra;
-      const nodeRef = extra[kNativeTagBinding];
+      const nodeRef2 = extra[kNativeTagBinding];
       const isHTML = isOutputHTML();
-      const name = tag.get("name");
+      const name2 = tag.get("name");
       const tagDef = (0, import_babel_utils14.getTagDef)(tag);
-      const write = writeTo(tag);
+      const write2 = writeTo(tag);
       const section = getSection(tag);
       if (isHTML && extra.tagNameNullable) {
         flushBefore(tag);
@@ -3863,7 +4246,7 @@ var native_tag_default = {
                   callRuntime(
                     "nodeRef",
                     import_compiler26.types.stringLiteral(getterId),
-                    getScopeAccessorLiteral(nodeRef)
+                    getScopeAccessorLiteral(nodeRef2)
                   )
                 )
               ])
@@ -3874,7 +4257,7 @@ var native_tag_default = {
             if (reference.parentPath?.isCallExpression()) {
               reference.parentPath.replaceWith(
                 import_compiler26.types.expressionStatement(
-                  createScopeReadExpression(referenceSection, nodeRef)
+                  createScopeReadExpression(referenceSection, nodeRef2)
                 )
               );
             } else if (getterFnIdentifier) {
@@ -3888,22 +4271,22 @@ var native_tag_default = {
         }
       }
       let visitAccessor;
-      if (nodeRef) {
-        visitAccessor = getScopeAccessorLiteral(nodeRef);
-        visit(tag, import_types4.WalkCode.Get);
+      if (nodeRef2) {
+        visitAccessor = getScopeAccessorLiteral(nodeRef2);
+        visit(tag, 32 /* Get */);
       }
-      write`<${name.node}`;
+      write2`<${name2.node}`;
       const usedAttrs = getUsedAttrs(tagName, tag.node);
       const { staticAttrs, staticControllable, skipExpression } = usedAttrs;
       let { spreadExpression } = usedAttrs;
       if (staticControllable) {
-        const { helper, attrs } = staticControllable;
-        const firstAttr = attrs.find(Boolean);
+        const { helper, attrs: attrs2 } = staticControllable;
+        const firstAttr = attrs2.find(Boolean);
         const referencedBindings = firstAttr.value.extra?.referencedBindings;
-        const values = attrs.map((attr2) => attr2?.value);
+        const values = attrs2.map((attr2) => attr2?.value);
         if (isHTML) {
           if (tagName !== "select" && tagName !== "textarea") {
-            write`${callRuntime(helper, getScopeIdIdentifier(section), visitAccessor, ...values)}`;
+            write2`${callRuntime(helper, getScopeIdIdentifier(section), visitAccessor, ...values)}`;
           }
           addHTMLEffectCall(section, void 0);
         } else {
@@ -3976,7 +4359,7 @@ var native_tag_default = {
             writeAtStartOfBody = callRuntime(
               "controllable_textarea_value",
               getScopeIdIdentifier(getSection(tag)),
-              getScopeAccessorLiteral(nodeRef),
+              getScopeAccessorLiteral(nodeRef2),
               value,
               valueChange
             );
@@ -3984,21 +4367,21 @@ var native_tag_default = {
         }
       }
       for (const attr2 of staticAttrs) {
-        const { name: name2, value } = attr2;
+        const { name: name3, value } = attr2;
         const { confident, computed } = value.extra || {};
         const valueReferences = value.extra?.referencedBindings;
-        if (isHTML && tagName === "option" && name2 === "value") {
-          write`${callRuntime("optionValueAttr", value)}`;
+        if (isHTML && tagName === "option" && name3 === "value") {
+          write2`${callRuntime("optionValueAttr", value)}`;
           continue;
         }
-        switch (name2) {
+        switch (name3) {
           case "class":
           case "style": {
-            const helper = `${name2}Attr`;
+            const helper = `${name3}Attr`;
             if (confident) {
-              write`${getHTMLRuntime()[helper](computed)}`;
+              write2`${getHTMLRuntime()[helper](computed)}`;
             } else if (isHTML) {
-              write`${callRuntime(helper, value)}`;
+              write2`${callRuntime(helper, value)}`;
             } else {
               addStatement(
                 "render",
@@ -4017,14 +4400,14 @@ var native_tag_default = {
           }
           default:
             if (confident) {
-              write`${getHTMLRuntime().attr(name2, computed)}`;
+              write2`${getHTMLRuntime().attr(name3, computed)}`;
             } else if (isHTML) {
-              if ((0, import_helpers.isEventHandler)(name2)) {
+              if (isEventHandler(name3)) {
                 addHTMLEffectCall(section, valueReferences);
               } else {
-                write`${callRuntime("attr", import_compiler26.types.stringLiteral(name2), value)}`;
+                write2`${callRuntime("attr", import_compiler26.types.stringLiteral(name3), value)}`;
               }
-            } else if ((0, import_helpers.isEventHandler)(name2)) {
+            } else if (isEventHandler(name3)) {
               addStatement(
                 "effect",
                 section,
@@ -4033,7 +4416,7 @@ var native_tag_default = {
                   callRuntime(
                     "on",
                     import_compiler26.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                    import_compiler26.types.stringLiteral((0, import_helpers.getEventHandlerName)(name2)),
+                    import_compiler26.types.stringLiteral(getEventHandlerName(name3)),
                     value
                   )
                 )
@@ -4047,7 +4430,7 @@ var native_tag_default = {
                   callRuntime(
                     "attr",
                     import_compiler26.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                    import_compiler26.types.stringLiteral(name2),
+                    import_compiler26.types.stringLiteral(name3),
                     value
                   )
                 )
@@ -4060,9 +4443,9 @@ var native_tag_default = {
         if (isHTML) {
           addHTMLEffectCall(section, extra.referencedBindings);
           if (skipExpression) {
-            write`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), name.node)}`;
+            write2`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), name2.node)}`;
           } else {
-            write`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), name.node)}`;
+            write2`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), name2.node)}`;
           }
         } else {
           if (skipExpression) {
@@ -4110,26 +4493,26 @@ var native_tag_default = {
         switch (tagDef.htmlType) {
           case "svg":
           case "math":
-            write`/>`;
+            write2`/>`;
             break;
           default:
-            write`>`;
+            write2`>`;
             break;
         }
       } else {
-        write`>`;
+        write2`>`;
       }
       if (isHTML && extra.tagNameNullable) {
-        tag.insertBefore(import_compiler26.types.ifStatement(name.node, consumeHTML(tag)))[0].skip();
+        tag.insertBefore(import_compiler26.types.ifStatement(name2.node, consumeHTML(tag)))[0].skip();
       }
       if (writeAtStartOfBody) {
-        write`${writeAtStartOfBody}`;
+        write2`${writeAtStartOfBody}`;
       }
       enter2(tag);
     },
     exit(tag) {
       const extra = tag.node.extra;
-      const nodeRef = extra[kNativeTagBinding];
+      const nodeRef2 = extra[kNativeTagBinding];
       const isHTML = isOutputHTML();
       const openTagOnly = (0, import_babel_utils14.getTagDef)(tag)?.parseOptions?.openTagOnly;
       const selectArgs = isHTML && htmlSelectArgs.get(tag.node);
@@ -4145,7 +4528,7 @@ var native_tag_default = {
             callRuntime(
               "controllable_select_value",
               getScopeIdIdentifier(getSection(tag)),
-              getScopeAccessorLiteral(nodeRef),
+              getScopeAccessorLiteral(nodeRef2),
               selectArgs.value,
               selectArgs.valueChange,
               import_compiler26.types.arrowFunctionExpression(
@@ -4169,10 +4552,10 @@ var native_tag_default = {
           import_compiler26.types.ifStatement(tag.node.name, consumeHTML(tag))
         )[0].skip();
       }
-      if (nodeRef && (extra[kSerializeMarker] || isStatefulReferences(extra.referencedBindings) || tag.node.attributes.some(
+      if (nodeRef2 && (extra[kSerializeMarker] || isStatefulReferences(extra.referencedBindings) || tag.node.attributes.some(
         (attr2) => isStatefulReferences(attr2.value.extra?.referencedBindings)
       ))) {
-        markNode(tag, nodeRef);
+        markNode(tag, nodeRef2);
       }
       exit2(tag);
       tag.remove();
@@ -4240,8 +4623,8 @@ function getUsedAttrs(tagName, tag) {
         }
       }
     }
-    for (const { name } of staticAttrs) {
-      (skipProps ||= []).push(toObjectProperty(name, import_compiler26.types.numericLiteral(1)));
+    for (const { name: name2 } of staticAttrs) {
+      (skipProps ||= []).push(toObjectProperty(name2, import_compiler26.types.numericLiteral(1)));
     }
     if (skipProps) {
       skipExpression = import_compiler26.types.objectExpression(skipProps);
@@ -4334,7 +4717,7 @@ var for_default = {
         const isStateful = isStatefulReferences(tagExtra.referencedBindings);
         setSectionParentIsOwner(bodySection, true);
         if (!isOnlyChildInParent(tag)) {
-          visit(tag, import_types5.WalkCode.Replace);
+          visit(tag, 37 /* Replace */);
           enterShallow(tag);
         }
         flushBefore(tag);
@@ -4356,7 +4739,7 @@ var for_default = {
         const tagExtra = node.extra;
         const isStateful = isStatefulReferences(tagExtra.referencedBindings);
         const parentTag = getParentTag(tag);
-        const nodeRef = isOnlyChildInParent(tag) ? parentTag.node.extra[kNativeTagBinding] : tag.node.extra[kForMarkerBinding];
+        const nodeRef2 = isOnlyChildInParent(tag) ? parentTag.node.extra[kNativeTagBinding] : tag.node.extra[kForMarkerBinding];
         const forAttrs = getKnownAttrValues(node);
         const forType = getForType(node);
         const params = node.body.params;
@@ -4429,7 +4812,7 @@ var for_default = {
           } else {
             keyExpression = params[defaultByParamIndex];
           }
-          const write = writeTo(tag);
+          const write2 = writeTo(tag);
           const forScopeIdsIdentifier = tag.scope.generateUidIdentifier("forScopeIds");
           const forScopesIdentifier = getScopeIdentifier(bodySection);
           statements.push(
@@ -4460,23 +4843,23 @@ var for_default = {
                   )
                 )
               );
-              write`${callRuntime(
+              write2`${callRuntime(
                 "markResumeControlSingleNodeEnd",
                 getScopeIdIdentifier(tagSection),
-                getScopeAccessorLiteral(nodeRef),
+                getScopeAccessorLiteral(nodeRef2),
                 forScopeIdsIdentifier
               )}`;
             } else {
-              write`${callRuntime(
+              write2`${callRuntime(
                 "markResumeControlEnd",
                 getScopeIdIdentifier(tagSection),
-                getScopeAccessorLiteral(nodeRef)
+                getScopeAccessorLiteral(nodeRef2)
               )}`;
             }
           }
           getSerializedScopeProperties(tagSection).set(
             import_compiler27.types.stringLiteral(
-              getScopeAccessorLiteral(nodeRef).value + import_types5.AccessorChar.LoopScopeMap
+              getScopeAccessorLiteral(nodeRef2).value + "(" /* LoopScopeMap */
             ),
             import_compiler27.types.conditionalExpression(
               import_compiler27.types.memberExpression(forScopesIdentifier, import_compiler27.types.identifier("size")),
@@ -4527,7 +4910,7 @@ var for_default = {
         }
         setSectionParentIsOwner(bodySection, true);
         if (!isOnlyChildInParent(tag)) {
-          visit(tag, import_types5.WalkCode.Replace);
+          visit(tag, 37 /* Replace */);
           enterShallow(tag);
         }
       },
@@ -4539,20 +4922,20 @@ var for_default = {
         const { node } = tag;
         const tagExtra = node.extra;
         const { referencedBindings } = tagExtra;
-        const nodeRef = isOnlyChildInParent(tag) ? getParentTag(tag).node.extra[kNativeTagBinding] : tag.node.extra[kForMarkerBinding];
+        const nodeRef2 = isOnlyChildInParent(tag) ? getParentTag(tag).node.extra[kNativeTagBinding] : tag.node.extra[kForMarkerBinding];
         setSubscriberBuilder(tag, (signal2) => {
           return callRuntime(
             "inLoopScope",
             signal2,
-            getScopeAccessorLiteral(nodeRef)
+            getScopeAccessorLiteral(nodeRef2)
           );
         });
         const forType = getForType(node);
-        const signal = getSignal(tagSection, nodeRef, "for");
+        const signal = getSignal(tagSection, nodeRef2, "for");
         signal.build = () => {
           return callRuntime(
             forTypeToDOMRuntime(forType),
-            getScopeAccessorLiteral(nodeRef),
+            getScopeAccessorLiteral(nodeRef2),
             import_compiler27.types.identifier(bodySection.name)
           );
         };
@@ -4652,11 +5035,11 @@ var for_default = {
     }
   ]
 };
-function buildForRuntimeCall(type, attrs, params, statements) {
+function buildForRuntimeCall(type, attrs2, params, statements) {
   return import_compiler27.types.expressionStatement(
     callRuntime(
       forTypeToRuntime(type),
-      ...getBaseArgsInForTag(type, attrs),
+      ...getBaseArgsInForTag(type, attrs2),
       import_compiler27.types.arrowFunctionExpression(params, import_compiler27.types.blockStatement(statements))
     )
   );
@@ -4703,17 +5086,17 @@ function forTypeToHTMLByRuntime(type) {
       return "forToBy";
   }
 }
-function getBaseArgsInForTag(type, attrs) {
+function getBaseArgsInForTag(type, attrs2) {
   switch (type) {
     case "in":
-      return [attrs.in];
+      return [attrs2.in];
     case "of":
-      return [attrs.of];
+      return [attrs2.of];
     case "to":
       return [
-        attrs.to,
-        attrs.from || import_compiler27.types.numericLiteral(0),
-        attrs.step || import_compiler27.types.numericLiteral(1)
+        attrs2.to,
+        attrs2.from || import_compiler27.types.numericLiteral(0),
+        attrs2.step || import_compiler27.types.numericLiteral(1)
       ];
   }
 }
@@ -4734,53 +5117,53 @@ var import_compiler28 = require("@marko/compiler");
 var import_babel_utils16 = require("@marko/compiler/babel-utils");
 var attrTagToIdentifierLookup = /* @__PURE__ */ new WeakMap();
 function getAttrTagIdentifier(meta) {
-  let name = attrTagToIdentifierLookup.get(meta);
-  if (!name) {
-    name = currentProgramPath.scope.generateUid(meta.name);
-    attrTagToIdentifierLookup.set(meta, name);
+  let name2 = attrTagToIdentifierLookup.get(meta);
+  if (!name2) {
+    name2 = currentProgramPath.scope.generateUid(meta.name);
+    attrTagToIdentifierLookup.set(meta, name2);
   }
-  return import_compiler28.types.identifier(name);
+  return import_compiler28.types.identifier(name2);
 }
 function analyzeAttributeTags(tag) {
   if (tag.node.extra?.attributeTags) return tag.node.extra.attributeTags;
-  const attrTags = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
-  if (!attrTags.length) return;
+  const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
+  if (!attrTags2.length) return;
   const tagExtra = tag.node.extra ??= {};
   const lookup = tagExtra.attributeTags = {};
   const attrTagNodesByName = {};
   const sampleAttrTagsForControlFlow = /* @__PURE__ */ new Map();
-  for (const child of attrTags) {
+  for (const child of attrTags2) {
     if (child.isMarkoTag()) {
       if ((0, import_babel_utils16.isAttributeTag)(child)) {
-        const name = getTagName(child);
-        lookup[name] ||= createAttrTagMeta(name, [name]);
+        const name2 = getTagName(child);
+        lookup[name2] ||= createAttrTagMeta(name2, [name2]);
         analyzeAttributeTags(child);
       } else {
         const isRepeated = (0, import_babel_utils16.isLoopTag)(child);
         let curGroup;
-        for (const name of crawlAttrTags(child, attrTagNodesByName)) {
-          const oldMeta = lookup[name];
+        for (const name2 of crawlAttrTags(child, attrTagNodesByName)) {
+          const oldMeta = lookup[name2];
           if (oldMeta) {
             if (!curGroup) {
               curGroup = oldMeta.group;
             } else if (curGroup !== oldMeta.group) {
-              for (const name2 of oldMeta.group) {
-                lookup[name2].group = curGroup;
-                curGroup.push(name2);
+              for (const name3 of oldMeta.group) {
+                lookup[name3].group = curGroup;
+                curGroup.push(name3);
               }
             }
           }
-          let attrTagMeta = lookup[name];
+          let attrTagMeta = lookup[name2];
           if (!attrTagMeta) {
-            attrTagMeta = lookup[name] = createAttrTagMeta(name, []);
+            attrTagMeta = lookup[name2] = createAttrTagMeta(name2, []);
             curGroup = attrTagMeta.group;
-            curGroup.push(name);
+            curGroup.push(name2);
           }
           attrTagMeta.dynamic = true;
           if (isRepeated) {
             attrTagMeta.repeated = true;
           }
-          sampleAttrTagsForControlFlow.set(child, name);
+          sampleAttrTagsForControlFlow.set(child, name2);
         }
       }
     }
@@ -4788,10 +5171,10 @@ function analyzeAttributeTags(tag) {
   for (const [controlFlowTag, sampleAttrName] of sampleAttrTagsForControlFlow) {
     (controlFlowTag.node.extra ??= {}).attributeTagGroup = lookup[sampleAttrName].group;
   }
-  for (const name in attrTagNodesByName) {
-    const attrTagMeta = lookup[name];
+  for (const name2 in attrTagNodesByName) {
+    const attrTagMeta = lookup[name2];
     if (!attrTagMeta.repeated) {
-      const attrTagNodes = attrTagNodesByName[name];
+      const attrTagNodes = attrTagNodesByName[name2];
       if (attrTagNodes.length > 1) {
         attrTagMeta.repeated = !attrTagMeta.dynamic || hasRepeatedDynamicAttrTags(attrTagNodes);
       }
@@ -4799,17 +5182,17 @@ function analyzeAttributeTags(tag) {
   }
   return lookup;
 }
-function createAttrTagMeta(name, group) {
+function createAttrTagMeta(name2, group) {
   return {
-    name: name.slice(1),
+    name: name2.slice(1),
     dynamic: false,
     repeated: false,
     group
   };
 }
 function crawlAttrTags(tag, attrTagNodesByName, attrTagNames = /* @__PURE__ */ new Set()) {
-  const attrTags = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
-  for (const child of attrTags) {
+  const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
+  for (const child of attrTags2) {
     if (child.isMarkoTag()) {
       if ((0, import_babel_utils16.isAttributeTag)(child)) {
         const tagName = getTagName(child);
@@ -4823,11 +5206,11 @@ function crawlAttrTags(tag, attrTagNodesByName, attrTagNames = /* @__PURE__ */ n
   }
   return attrTagNames;
 }
-function hasRepeatedDynamicAttrTags(attrTags) {
+function hasRepeatedDynamicAttrTags(attrTags2) {
   let conditionRoot;
   const seenBranches = /* @__PURE__ */ new Set();
-  for (const attrTag of attrTags) {
-    const parentTag = getParentTag(attrTag);
+  for (const attrTag2 of attrTags2) {
+    const parentTag = getParentTag(attrTag2);
     if (seenBranches.has(parentTag) || !isConditionTag(parentTag)) {
       return true;
     }
@@ -4857,8 +5240,8 @@ function translateAttrs(tag, templateExports, statements = []) {
   const properties = [];
   const attrTagLookup = tag.node.extra?.attributeTags;
   if (attrTagLookup) {
-    for (const name in attrTagLookup) {
-      const attrTagMeta = attrTagLookup[name];
+    for (const name2 in attrTagLookup) {
+      const attrTagMeta = attrTagLookup[name2];
       if (usesExport(templateExports, attrTagMeta.name)) {
         seen.add(attrTagMeta.name);
         if (attrTagMeta.dynamic) {
@@ -4876,15 +5259,15 @@ function translateAttrs(tag, templateExports, statements = []) {
         }
       }
     }
-    const attrTags = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
-    for (let i = 0; i < attrTags.length; i++) {
-      const child = attrTags[i];
+    const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
+    for (let i = 0; i < attrTags2.length; i++) {
+      const child = attrTags2[i];
       if (child.isMarkoTag()) {
         if ((0, import_babel_utils17.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
           if (attrTagMeta.dynamic) {
             i = addDynamicAttrTagStatements(
-              attrTags,
+              attrTags2,
               i,
               attrTagLookup,
               statements,
@@ -4929,7 +5312,7 @@ function translateAttrs(tag, templateExports, statements = []) {
           }
         } else {
           i = addDynamicAttrTagStatements(
-            attrTags,
+            attrTags2,
             i,
             attrTagLookup,
             statements,
@@ -4972,8 +5355,8 @@ function getTranslatedRenderBodyProperty(props) {
     }
   }
 }
-function addDynamicAttrTagStatements(attrTags, index, attrTagLookup, statements, templateExports) {
-  const tag = attrTags[index];
+function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements, templateExports) {
+  const tag = attrTags2[index];
   if (tag.isMarkoTag()) {
     if ((0, import_babel_utils17.isAttributeTag)(tag)) {
       const attrTagMeta = attrTagLookup[getTagName(tag)];
@@ -5016,7 +5399,7 @@ function addDynamicAttrTagStatements(attrTags, index, attrTagLookup, statements,
       switch (getTagName(tag)) {
         case "if":
           return translateIfAttrTag(
-            attrTags,
+            attrTags2,
             index,
             attrTagLookup,
             statements,
@@ -5024,7 +5407,7 @@ function addDynamicAttrTagStatements(attrTags, index, attrTagLookup, statements,
           );
         case "for": {
           return translateForAttrTag(
-            attrTags,
+            attrTags2,
             index,
             attrTagLookup,
             statements,
@@ -5039,8 +5422,8 @@ function addDynamicAttrTagStatements(attrTags, index, attrTagLookup, statements,
 function propsToExpression(props) {
   return props.length === 1 && import_compiler29.types.isSpreadElement(props[0]) ? props[0].argument : import_compiler29.types.objectExpression(props);
 }
-function translateForAttrTag(attrTags, index, attrTagLookup, statements, templateExports) {
-  const forTag = attrTags[index];
+function translateForAttrTag(attrTags2, index, attrTagLookup, statements, templateExports) {
+  const forTag = attrTags2[index];
   const bodyStatements = [];
   addAllAttrTagsAsDynamic(
     forTag,
@@ -5058,8 +5441,8 @@ function translateForAttrTag(attrTags, index, attrTagLookup, statements, templat
   );
   return index;
 }
-function translateIfAttrTag(attrTags, index, attrTagLookup, statements, templateExports) {
-  const ifTag = attrTags[index];
+function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templateExports) {
+  const ifTag = attrTags2[index];
   const consequentStatements = [];
   let ifStatement = import_compiler29.types.ifStatement(
     getConditionTestValue(ifTag),
@@ -5073,8 +5456,8 @@ function translateIfAttrTag(attrTags, index, attrTagLookup, statements, template
     templateExports
   );
   let nextIndex = index + 1;
-  while (nextIndex < attrTags.length) {
-    const nextTag = attrTags[nextIndex];
+  while (nextIndex < attrTags2.length) {
+    const nextTag = attrTags2[nextIndex];
     if (nextTag.isMarkoTag()) {
       switch (getTagName(nextTag)) {
         case "else-if":
@@ -5106,10 +5489,10 @@ function translateIfAttrTag(attrTags, index, attrTagLookup, statements, template
   return nextIndex - 1;
 }
 function addAllAttrTagsAsDynamic(tag, attrTagLookup, statements, templateExports) {
-  const attrTags = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
-  for (let i = 0; i < attrTags.length; i++) {
+  const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
+  for (let i = 0; i < attrTags2.length; i++) {
     i = addDynamicAttrTagStatements(
-      attrTags,
+      attrTags2,
       i,
       attrTagLookup,
       statements,
@@ -5117,20 +5500,20 @@ function addAllAttrTagsAsDynamic(tag, attrTagLookup, statements, templateExports
     );
   }
 }
-function usesExport(templateExports, name) {
-  return !templateExports || !!templateExports[name];
+function usesExport(templateExports, name2) {
+  return !templateExports || !!templateExports[name2];
 }
-function findObjectProperty(name, props) {
+function findObjectProperty(name2, props) {
   for (const prop of props) {
     if (prop.type === "ObjectProperty") {
       switch (prop.key.type) {
         case "StringLiteral":
-          if (prop.key.value === name) {
+          if (prop.key.value === name2) {
             return prop;
           }
           break;
         case "Identifier":
-          if (prop.key.name === name) {
+          if (prop.key.name === name2) {
             return prop;
           }
           break;
@@ -5239,7 +5622,7 @@ var define_default = {
       descriptionMoreURL: "https://markojs.com/docs/core-tags/#define"
     }
   ],
-  types: "@marko/runtime-tags/tag-types/define.d.marko"
+  types: runtime_info_default.name + "/tag-types/define.d.marko"
 };
 
 // src/translator/core/effect.ts
@@ -5273,7 +5656,7 @@ var effect_default = {
     }
   ],
   attributes: {},
-  types: "@marko/runtime-tags/tag-types/effect.d.marko"
+  types: runtime_info_default.name + "/tag-types/effect.d.marko"
 };
 
 // src/translator/core/export.ts
@@ -5299,7 +5682,6 @@ var export_default = {
 // src/translator/core/html-comment.ts
 var import_compiler32 = require("@marko/compiler");
 var import_babel_utils21 = require("@marko/compiler/babel-utils");
-var import_types6 = require("@marko/runtime-tags/common/types");
 var kCommentTagBinding = Symbol("comment tag binding");
 var kGetterId2 = Symbol("node getter id");
 var html_comment_default = {
@@ -5406,17 +5788,17 @@ var html_comment_default = {
       }
     }
     if (tagExtra[kCommentTagBinding]) {
-      visit(tag, import_types6.WalkCode.Get);
+      visit(tag, 32 /* Get */);
     }
-    const write = writeTo(tag);
+    const write2 = writeTo(tag);
     enter2(tag);
-    write`<!--`;
+    write2`<!--`;
     if (isOutputHTML()) {
       for (const child of tag.node.body.body) {
         if (import_compiler32.types.isMarkoText(child)) {
-          write`${child.value}`;
+          write2`${child.value}`;
         } else if (import_compiler32.types.isMarkoPlaceholder(child)) {
-          write`${callRuntime("escapeXML", child.value)}`;
+          write2`${callRuntime("escapeXML", child.value)}`;
         }
       }
     } else {
@@ -5433,7 +5815,7 @@ var html_comment_default = {
         }
       }
       if (templateExpressions.length === 0) {
-        write`${currentQuasi}`;
+        write2`${currentQuasi}`;
       } else {
         templateQuasis.push(import_compiler32.types.templateElement({ raw: currentQuasi }));
         addStatement(
@@ -5455,7 +5837,7 @@ var html_comment_default = {
       }
     }
     exit2(tag);
-    write`-->`;
+    write2`-->`;
     if (commentBinding) {
       markNode(tag, commentBinding);
     }
@@ -5476,8 +5858,6 @@ var html_comment_default = {
 // src/translator/core/html-script.ts
 var import_compiler33 = require("@marko/compiler");
 var import_babel_utils22 = require("@marko/compiler/babel-utils");
-var import_helpers2 = require("@marko/runtime-tags/common/helpers");
-var import_types7 = require("@marko/runtime-tags/common/types");
 var kGetterId3 = Symbol("node getter id");
 var html_script_default = {
   analyze(tag) {
@@ -5503,7 +5883,7 @@ var html_script_default = {
           continue;
         }
         seen[attr2.name] = attr2;
-        if ((0, import_helpers2.isEventHandler)(attr2.name)) {
+        if (isEventHandler(attr2.name)) {
           (attr2.value.extra ??= {}).isEffect = true;
           hasEventHandlers = true;
         } else if (!evaluate(attr2.value).confident) {
@@ -5565,9 +5945,9 @@ var html_script_default = {
   },
   translate(tag) {
     const tagExtra = tag.node.extra;
-    const nodeRef = tagExtra[kNativeTagBinding];
+    const nodeRef2 = tagExtra[kNativeTagBinding];
     const isHTML = isOutputHTML();
-    const write = writeTo(tag);
+    const write2 = writeTo(tag);
     const section = getSection(tag);
     const hasVar = !!tag.node.var;
     if (hasVar) {
@@ -5611,7 +5991,7 @@ var html_script_default = {
                 callRuntime(
                   "nodeRef",
                   import_compiler33.types.stringLiteral(getterId),
-                  getScopeAccessorLiteral(nodeRef)
+                  getScopeAccessorLiteral(nodeRef2)
                 )
               )
             ])
@@ -5622,7 +6002,7 @@ var html_script_default = {
           if (reference.parentPath?.isCallExpression()) {
             reference.parentPath.replaceWith(
               import_compiler33.types.expressionStatement(
-                createScopeReadExpression(referenceSection, nodeRef)
+                createScopeReadExpression(referenceSection, nodeRef2)
               )
             );
           } else if (getterFnIdentifier) {
@@ -5636,25 +6016,25 @@ var html_script_default = {
       }
     }
     let visitAccessor;
-    if (nodeRef) {
-      visitAccessor = getScopeAccessorLiteral(nodeRef);
-      visit(tag, import_types7.WalkCode.Get);
+    if (nodeRef2) {
+      visitAccessor = getScopeAccessorLiteral(nodeRef2);
+      visit(tag, 32 /* Get */);
     }
-    write`<script`;
+    write2`<script`;
     const usedAttrs = getUsedAttrs2(tag.node);
     const { staticAttrs, skipExpression, spreadExpression } = usedAttrs;
     for (const attr2 of staticAttrs) {
-      const { name, value } = attr2;
+      const { name: name2, value } = attr2;
       const { confident, computed } = value.extra || {};
       const valueReferences = value.extra?.referencedBindings;
-      switch (name) {
+      switch (name2) {
         case "class":
         case "style": {
-          const helper = `${name}Attr`;
+          const helper = `${name2}Attr`;
           if (confident) {
-            write`${getHTMLRuntime()[helper](computed)}`;
+            write2`${getHTMLRuntime()[helper](computed)}`;
           } else if (isHTML) {
-            write`${callRuntime(helper, value)}`;
+            write2`${callRuntime(helper, value)}`;
           } else {
             addStatement(
               "render",
@@ -5673,14 +6053,14 @@ var html_script_default = {
         }
         default:
           if (confident) {
-            write`${getHTMLRuntime().attr(name, computed)}`;
+            write2`${getHTMLRuntime().attr(name2, computed)}`;
           } else if (isHTML) {
-            if ((0, import_helpers2.isEventHandler)(name)) {
+            if (isEventHandler(name2)) {
               addHTMLEffectCall(section, valueReferences);
             } else {
-              write`${callRuntime("attr", import_compiler33.types.stringLiteral(name), value)}`;
+              write2`${callRuntime("attr", import_compiler33.types.stringLiteral(name2), value)}`;
             }
-          } else if ((0, import_helpers2.isEventHandler)(name)) {
+          } else if (isEventHandler(name2)) {
             addStatement(
               "effect",
               section,
@@ -5689,7 +6069,7 @@ var html_script_default = {
                 callRuntime(
                   "on",
                   import_compiler33.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  import_compiler33.types.stringLiteral((0, import_helpers2.getEventHandlerName)(name)),
+                  import_compiler33.types.stringLiteral(getEventHandlerName(name2)),
                   value
                 )
               )
@@ -5703,7 +6083,7 @@ var html_script_default = {
                 callRuntime(
                   "attr",
                   import_compiler33.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  import_compiler33.types.stringLiteral(name),
+                  import_compiler33.types.stringLiteral(name2),
                   value
                 )
               )
@@ -5716,9 +6096,9 @@ var html_script_default = {
       if (isHTML) {
         addHTMLEffectCall(section, tagExtra.referencedBindings);
         if (skipExpression) {
-          write`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler33.types.stringLiteral("script"))}`;
+          write2`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler33.types.stringLiteral("script"))}`;
         } else {
-          write`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler33.types.stringLiteral("script"))}`;
+          write2`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler33.types.stringLiteral("script"))}`;
         }
       } else {
         if (skipExpression) {
@@ -5762,14 +6142,14 @@ var html_script_default = {
         );
       }
     }
-    write`>`;
+    write2`>`;
     enter2(tag);
     if (isOutputHTML()) {
       for (const child of tag.node.body.body) {
         if (import_compiler33.types.isMarkoText(child)) {
-          write`${child.value}`;
+          write2`${child.value}`;
         } else if (import_compiler33.types.isMarkoPlaceholder(child)) {
-          write`${callRuntime("escapeScript", child.value)}`;
+          write2`${callRuntime("escapeScript", child.value)}`;
         }
       }
     } else {
@@ -5788,7 +6168,7 @@ var html_script_default = {
         }
       }
       if (!referencePlaceholder) {
-        write`${currentQuasi}`;
+        write2`${currentQuasi}`;
       } else {
         templateQuasis.push(import_compiler33.types.templateElement({ raw: currentQuasi }));
         addStatement(
@@ -5805,9 +6185,9 @@ var html_script_default = {
         );
       }
     }
-    write`</script>`;
-    if (nodeRef) {
-      markNode(tag, nodeRef);
+    write2`</script>`;
+    if (nodeRef2) {
+      markNode(tag, nodeRef2);
     }
     exit2(tag);
     tag.remove();
@@ -5855,8 +6235,8 @@ function getUsedAttrs2(tag) {
   const staticAttrs = [...maybeStaticAttrs].reverse();
   if (spreadProps) {
     spreadProps.reverse();
-    for (const { name } of staticAttrs) {
-      (skipProps ||= []).push(toObjectProperty(name, import_compiler33.types.numericLiteral(1)));
+    for (const { name: name2 } of staticAttrs) {
+      (skipProps ||= []).push(toObjectProperty(name2, import_compiler33.types.numericLiteral(1)));
     }
     if (skipProps) {
       skipExpression = import_compiler33.types.objectExpression(skipProps);
@@ -5873,8 +6253,6 @@ function getUsedAttrs2(tag) {
 // src/translator/core/html-style.ts
 var import_compiler34 = require("@marko/compiler");
 var import_babel_utils23 = require("@marko/compiler/babel-utils");
-var import_helpers3 = require("@marko/runtime-tags/common/helpers");
-var import_types8 = require("@marko/runtime-tags/common/types");
 var kGetterId4 = Symbol("node getter id");
 var html_style_default = {
   analyze(tag) {
@@ -5900,7 +6278,7 @@ var html_style_default = {
           continue;
         }
         seen[attr2.name] = attr2;
-        if ((0, import_helpers3.isEventHandler)(attr2.name)) {
+        if (isEventHandler(attr2.name)) {
           (attr2.value.extra ??= {}).isEffect = true;
           hasEventHandlers = true;
         } else if (!evaluate(attr2.value).confident) {
@@ -5962,9 +6340,9 @@ var html_style_default = {
   },
   translate(tag) {
     const tagExtra = tag.node.extra;
-    const nodeRef = tagExtra[kNativeTagBinding];
+    const nodeRef2 = tagExtra[kNativeTagBinding];
     const isHTML = isOutputHTML();
-    const write = writeTo(tag);
+    const write2 = writeTo(tag);
     const section = getSection(tag);
     const hasVar = !!tag.node.var;
     if (hasVar) {
@@ -6008,7 +6386,7 @@ var html_style_default = {
                 callRuntime(
                   "nodeRef",
                   import_compiler34.types.stringLiteral(getterId),
-                  getScopeAccessorLiteral(nodeRef)
+                  getScopeAccessorLiteral(nodeRef2)
                 )
               )
             ])
@@ -6019,7 +6397,7 @@ var html_style_default = {
           if (reference.parentPath?.isCallExpression()) {
             reference.parentPath.replaceWith(
               import_compiler34.types.expressionStatement(
-                createScopeReadExpression(referenceSection, nodeRef)
+                createScopeReadExpression(referenceSection, nodeRef2)
               )
             );
           } else if (getterFnIdentifier) {
@@ -6033,25 +6411,25 @@ var html_style_default = {
       }
     }
     let visitAccessor;
-    if (nodeRef) {
-      visitAccessor = getScopeAccessorLiteral(nodeRef);
-      visit(tag, import_types8.WalkCode.Get);
+    if (nodeRef2) {
+      visitAccessor = getScopeAccessorLiteral(nodeRef2);
+      visit(tag, 32 /* Get */);
     }
-    write`<style`;
+    write2`<style`;
     const usedAttrs = getUsedAttrs3(tag.node);
     const { staticAttrs, skipExpression, spreadExpression } = usedAttrs;
     for (const attr2 of staticAttrs) {
-      const { name, value } = attr2;
+      const { name: name2, value } = attr2;
       const { confident, computed } = value.extra || {};
       const valueReferences = value.extra?.referencedBindings;
-      switch (name) {
+      switch (name2) {
         case "class":
         case "style": {
-          const helper = `${name}Attr`;
+          const helper = `${name2}Attr`;
           if (confident) {
-            write`${getHTMLRuntime()[helper](computed)}`;
+            write2`${getHTMLRuntime()[helper](computed)}`;
           } else if (isHTML) {
-            write`${callRuntime(helper, value)}`;
+            write2`${callRuntime(helper, value)}`;
           } else {
             addStatement(
               "render",
@@ -6070,14 +6448,14 @@ var html_style_default = {
         }
         default:
           if (confident) {
-            write`${getHTMLRuntime().attr(name, computed)}`;
+            write2`${getHTMLRuntime().attr(name2, computed)}`;
           } else if (isHTML) {
-            if ((0, import_helpers3.isEventHandler)(name)) {
+            if (isEventHandler(name2)) {
               addHTMLEffectCall(section, valueReferences);
             } else {
-              write`${callRuntime("attr", import_compiler34.types.stringLiteral(name), value)}`;
+              write2`${callRuntime("attr", import_compiler34.types.stringLiteral(name2), value)}`;
             }
-          } else if ((0, import_helpers3.isEventHandler)(name)) {
+          } else if (isEventHandler(name2)) {
             addStatement(
               "effect",
               section,
@@ -6086,7 +6464,7 @@ var html_style_default = {
                 callRuntime(
                   "on",
                   import_compiler34.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  import_compiler34.types.stringLiteral((0, import_helpers3.getEventHandlerName)(name)),
+                  import_compiler34.types.stringLiteral(getEventHandlerName(name2)),
                   value
                 )
               )
@@ -6100,7 +6478,7 @@ var html_style_default = {
                 callRuntime(
                   "attr",
                   import_compiler34.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  import_compiler34.types.stringLiteral(name),
+                  import_compiler34.types.stringLiteral(name2),
                   value
                 )
               )
@@ -6113,9 +6491,9 @@ var html_style_default = {
       if (isHTML) {
         addHTMLEffectCall(section, tagExtra.referencedBindings);
         if (skipExpression) {
-          write`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler34.types.stringLiteral("style"))}`;
+          write2`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler34.types.stringLiteral("style"))}`;
         } else {
-          write`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler34.types.stringLiteral("style"))}`;
+          write2`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler34.types.stringLiteral("style"))}`;
         }
       } else {
         if (skipExpression) {
@@ -6159,14 +6537,14 @@ var html_style_default = {
         );
       }
     }
-    write`>`;
+    write2`>`;
     enter2(tag);
     if (isOutputHTML()) {
       for (const child of tag.node.body.body) {
         if (import_compiler34.types.isMarkoText(child)) {
-          write`${child.value}`;
+          write2`${child.value}`;
         } else if (import_compiler34.types.isMarkoPlaceholder(child)) {
-          write`${callRuntime("escapeStyle", child.value)}`;
+          write2`${callRuntime("escapeStyle", child.value)}`;
         }
       }
     } else {
@@ -6185,7 +6563,7 @@ var html_style_default = {
         }
       }
       if (!referencePlaceholder) {
-        write`${currentQuasi}`;
+        write2`${currentQuasi}`;
       } else {
         templateQuasis.push(import_compiler34.types.templateElement({ raw: currentQuasi }));
         addStatement(
@@ -6202,9 +6580,9 @@ var html_style_default = {
         );
       }
     }
-    write`</style>`;
-    if (nodeRef) {
-      markNode(tag, nodeRef);
+    write2`</style>`;
+    if (nodeRef2) {
+      markNode(tag, nodeRef2);
     }
     exit2(tag);
     tag.remove();
@@ -6247,8 +6625,8 @@ function getUsedAttrs3(tag) {
   const staticAttrs = [...maybeStaticAttrs].reverse();
   if (spreadProps) {
     spreadProps.reverse();
-    for (const { name } of staticAttrs) {
-      (skipProps ||= []).push(toObjectProperty(name, import_compiler34.types.numericLiteral(1)));
+    for (const { name: name2 } of staticAttrs) {
+      (skipProps ||= []).push(toObjectProperty(name2, import_compiler34.types.numericLiteral(1)));
     }
     if (skipProps) {
       skipExpression = import_compiler34.types.objectExpression(skipProps);
@@ -6308,13 +6686,12 @@ var id_default = {
       descriptionMoreURL: "https://markojs.com/docs/core-tags/#id"
     }
   ],
-  types: "@marko/runtime-tags/tag-types/id.d.marko"
+  types: runtime_info_default.name + "/tag-types/id.d.marko"
 };
 
 // src/translator/core/if.ts
 var import_compiler37 = require("@marko/compiler");
 var import_babel_utils25 = require("@marko/compiler/babel-utils");
-var import_types9 = require("@marko/runtime-tags/common/types");
 
 // src/translator/util/to-first-statement-or-block.ts
 var import_compiler36 = require("@marko/compiler");
@@ -6374,7 +6751,7 @@ var IfTag = {
         const isStateful = isStatefulReferences(rootExtra.referencedBindings);
         const singleNodeOptimization = rootExtra.singleNodeOptimization;
         if (isRoot(tag)) {
-          visit(tag, import_types9.WalkCode.Replace);
+          visit(tag, 37 /* Replace */);
         }
         enterShallow(tag);
         flushBefore(tag);
@@ -6395,7 +6772,7 @@ var IfTag = {
         const bodySection = getSectionForBody(tagBody);
         const [isLast, branches] = getBranches(tag, bodySection);
         const rootExtra = branches[0][0].node.extra;
-        const nodeRef = rootExtra[kBinding];
+        const nodeRef2 = rootExtra[kBinding];
         const isStateful = isStatefulReferences(rootExtra.referencedBindings);
         const singleNodeOptimization = rootExtra.singleNodeOptimization;
         const hasStatefulClosures = bodySection && checkStatefulClosures(bodySection, true);
@@ -6409,7 +6786,7 @@ var IfTag = {
           writeHTMLResumeStatements(tagBody);
         }
         if (isLast) {
-          const write = writeTo(tag);
+          const write2 = writeTo(tag);
           const nextTag = tag.getNextSibling();
           const ifScopeIdIdentifier = tag.scope.generateUidIdentifier("ifScopeId");
           const ifRendererIdentifier = tag.scope.generateUidIdentifier("ifRenderer");
@@ -6482,29 +6859,29 @@ var IfTag = {
             ]);
             if (isStateful) {
               if (singleNodeOptimization) {
-                write`${callRuntime(
+                write2`${callRuntime(
                   "markResumeControlSingleNodeEnd",
                   getScopeIdIdentifier(section),
-                  getScopeAccessorLiteral(nodeRef),
+                  getScopeAccessorLiteral(nodeRef2),
                   ifScopeIdIdentifier
                 )}`;
               } else {
-                write`${callRuntime(
+                write2`${callRuntime(
                   "markResumeControlEnd",
                   getScopeIdIdentifier(section),
-                  getScopeAccessorLiteral(nodeRef)
+                  getScopeAccessorLiteral(nodeRef2)
                 )}`;
               }
               getSerializedScopeProperties(section).set(
                 import_compiler37.types.stringLiteral(
-                  getScopeAccessorLiteral(nodeRef).value + import_types9.AccessorChar.ConditionalRenderer
+                  getScopeAccessorLiteral(nodeRef2).value + "(" /* ConditionalRenderer */
                 ),
                 ifRendererIdentifier
               );
             }
             getSerializedScopeProperties(section).set(
               import_compiler37.types.stringLiteral(
-                getScopeAccessorLiteral(nodeRef).value + import_types9.AccessorChar.ConditionalScope
+                getScopeAccessorLiteral(nodeRef2).value + "!" /* ConditionalScope */
               ),
               callRuntime("getScopeById", ifScopeIdIdentifier)
             );
@@ -6521,7 +6898,7 @@ var IfTag = {
           setSectionParentIsOwner(bodySection, true);
         }
         if (isRoot(tag)) {
-          visit(tag, import_types9.WalkCode.Replace);
+          visit(tag, 37 /* Replace */);
         }
         enterShallow(tag);
       },
@@ -6534,7 +6911,7 @@ var IfTag = {
         if (isLast) {
           const section = getSection(tag);
           const rootExtra = branches[0][0].node.extra;
-          const nodeRef = rootExtra[kBinding];
+          const nodeRef2 = rootExtra[kBinding];
           let expr = import_compiler37.types.nullLiteral();
           for (let i = branches.length; i--; ) {
             const [branchTag, branchBodySection] = branches[i];
@@ -6544,18 +6921,18 @@ var IfTag = {
               return callRuntime(
                 "inConditionalScope",
                 subscriber,
-                getScopeAccessorLiteral(nodeRef)
+                getScopeAccessorLiteral(nodeRef2)
                 /*t.identifier(section.name)*/
               );
             });
             branchTag.remove();
             expr = testAttr ? import_compiler37.types.conditionalExpression(testAttr.value, consequent, expr) : consequent;
           }
-          const signal = getSignal(section, nodeRef, "if");
+          const signal = getSignal(section, nodeRef2, "if");
           signal.build = () => {
             return callRuntime(
               "conditional",
-              getScopeAccessorLiteral(nodeRef),
+              getScopeAccessorLiteral(nodeRef2),
               getSignalFn(signal, [scopeIdentifier])
             );
           };
@@ -6712,7 +7089,6 @@ var import_default = {
 // src/translator/core/let.ts
 var import_compiler38 = require("@marko/compiler");
 var import_babel_utils27 = require("@marko/compiler/babel-utils");
-var import_types10 = require("@marko/runtime-tags/common/types");
 var let_default = {
   analyze(tag) {
     const { node } = tag;
@@ -6790,7 +7166,7 @@ var let_default = {
         if (valueChangeAttr) {
           getSerializedScopeProperties(section).set(
             import_compiler38.types.stringLiteral(
-              getScopeAccessorLiteral(binding).value + import_types10.AccessorChar.TagVariableChange
+              getScopeAccessorLiteral(binding).value + "@" /* TagVariableChange */
             ),
             valueChangeAttr.value
           );
@@ -6809,7 +7185,7 @@ var let_default = {
       descriptionMoreURL: "https://markojs.com/docs/core-tags/#let"
     }
   ],
-  types: "@marko/runtime-tags/tag-types/let.d.marko"
+  types: runtime_info_default.name + "/tag-types/let.d.marko"
 };
 
 // src/translator/core/lifecycle.ts
@@ -6889,7 +7265,7 @@ var lifecycle_default = {
       descriptionMoreURL: "https://markojs.com/docs/core-tags/#effect"
     }
   ],
-  types: "@marko/runtime-tags/tag-types/lifecycle.d.marko"
+  types: runtime_info_default.name + "/tag-types/lifecycle.d.marko"
 };
 
 // src/translator/core/log.ts
@@ -6941,7 +7317,7 @@ var log_default = {
       descriptionMoreURL: "https://markojs.com/docs/core-tags/#log"
     }
   ],
-  types: "@marko/runtime-tags/tag-types/log.d.marko"
+  types: runtime_info_default.name + "/tag-types/log.d.marko"
 };
 
 // src/translator/core/script.ts
@@ -7072,7 +7448,7 @@ var script_default = {
       descriptionMoreURL: "https://markojs.com/docs/core-tags/#script"
     }
   ],
-  types: "@marko/runtime-tags/tag-types/script.d.marko"
+  types: runtime_info_default.name + "/tag-types/script.d.marko"
 };
 function isAwaitExpression(node) {
   switch (node.type) {
@@ -7266,7 +7642,7 @@ var style_default = {
 
 // src/translator/core/index.ts
 var core_default = {
-  taglibId,
+  taglibId: runtime_info_default.taglibId,
   "<attrs>": attrs_default,
   "<client>": client_default,
   "<const>": const_default,
@@ -7351,7 +7727,7 @@ var function_default = {
     }
     const { node } = fn;
     const extra = node.extra ??= {};
-    const name = extra.name = fn.node.id?.name || (isMarkoAttribute(markoRoot) ? markoRoot.node.default ? import_compiler45.types.toIdentifier(
+    const name2 = extra.name = fn.node.id?.name || (isMarkoAttribute(markoRoot) ? markoRoot.node.default ? import_compiler45.types.toIdentifier(
       markoRoot.parentPath.has("var") ? markoRoot.parentPath.get("var") : markoRoot.parentPath.get("name")
     ) : markoRoot.node.name : import_compiler45.types.isVariableDeclarator(fn.parent) && import_compiler45.types.isIdentifier(fn.parent.id) ? fn.parent.id.name : "anonymous");
     if (isMarkoAttribute(markoRoot) && ((0, import_babel_utils34.isNativeTag)(markoRoot.parentPath) && /^on[A-Z-]/.test(markoRoot.node.name) || isCoreTagName(markoRoot.parentPath, "script") || isCoreTagName(markoRoot.parentPath, "lifecycle") || isCoreTagName(markoRoot.parentPath, "for"))) {
@@ -7367,10 +7743,10 @@ var function_default = {
       functionNameCounts = /* @__PURE__ */ new Map();
       functionIdsBySection.set(section, functionNameCounts);
     }
-    const index = functionNameCounts.get(name);
+    const index = functionNameCounts.get(name2);
     let id = "";
     if (index === void 0) {
-      functionNameCounts.set(name, 0);
+      functionNameCounts.set(name2, 0);
     } else {
       id = `_${index}`;
     }
@@ -7378,7 +7754,7 @@ var function_default = {
     extra.registerId = (0, import_babel_utils34.getTemplateId)(
       markoOpts,
       filename,
-      `${section.id}/${name + id}`
+      `${section.id}/${name2 + id}`
     );
   }
 };
@@ -7428,14 +7804,13 @@ var import_declaration_default = {
 
 // src/translator/visitors/placeholder.ts
 var import_compiler46 = require("@marko/compiler");
-var import_types11 = require("@marko/runtime-tags/common/types");
 var kBinding2 = Symbol("placeholder node binding");
 var kSiblingText = Symbol("placeholder has sibling text");
 var placeholder_default = {
   analyze(placeholder) {
     const { node } = placeholder;
     const { confident, computed } = evaluate(node.value);
-    if (!(confident && (node.escape || isVoid(computed)))) {
+    if (!(confident && (node.escape || isVoid2(computed)))) {
       (node.extra ??= {})[kBinding2] = createBinding(
         "#text",
         0 /* dom */,
@@ -7451,12 +7826,12 @@ var placeholder_default = {
       const { node } = placeholder;
       const { value } = node;
       const { confident, computed, referencedBindings } = evaluate(value);
-      if (confident && isVoid(computed)) {
+      if (confident && isVoid2(computed)) {
         placeholder.remove();
         return;
       }
       const isHTML = isOutputHTML();
-      const write = writeTo(placeholder);
+      const write2 = writeTo(placeholder);
       const extra = node.extra || {};
       const nodeBinding = extra[kBinding2];
       const canWriteHTML = isHTML || confident && node.escape;
@@ -7464,21 +7839,21 @@ var placeholder_default = {
       const isStateful = isStatefulReferences(referencedBindings);
       const siblingText = extra[kSiblingText];
       if (confident && canWriteHTML) {
-        write`${getHTMLRuntime()[method](computed)}`;
+        write2`${getHTMLRuntime()[method](computed)}`;
       } else {
         if (siblingText === 1 /* Before */) {
           if (isHTML && isStateful) {
-            write`<!>`;
+            write2`<!>`;
           }
-          visit(placeholder, import_types11.WalkCode.Replace);
+          visit(placeholder, 37 /* Replace */);
         } else if (siblingText === 2 /* After */) {
-          visit(placeholder, import_types11.WalkCode.Replace);
+          visit(placeholder, 37 /* Replace */);
         } else {
-          if (!isHTML) write` `;
-          visit(placeholder, import_types11.WalkCode.Get);
+          if (!isHTML) write2` `;
+          visit(placeholder, 32 /* Get */);
         }
         if (isHTML) {
-          write`${callRuntime(method, value)}`;
+          write2`${callRuntime(method, value)}`;
           if (isStateful) {
             markNode(placeholder, nodeBinding);
           }
@@ -7549,7 +7924,7 @@ function analyzeSiblingText(placeholder) {
   }
   return placeholderExtra[kSiblingText] = 0 /* None */;
 }
-function isVoid(value) {
+function isVoid2(value) {
   return value == null || value === false;
 }
 
@@ -7558,9 +7933,9 @@ var import_compiler47 = require("@marko/compiler");
 var abortIdsByExpressionForSection = /* @__PURE__ */ new WeakMap();
 var referenced_identifier_default = {
   migrate(identifier) {
-    const { name } = identifier.node;
-    if (identifier.scope.hasBinding(name)) return;
-    switch (name) {
+    const { name: name2 } = identifier.node;
+    if (identifier.scope.hasBinding(name2)) return;
+    switch (name2) {
       case "out":
         if (import_compiler47.types.isMemberExpression(identifier.parent) && import_compiler47.types.isIdentifier(identifier.parent.property) && identifier.parent.property.name === "global") {
           identifier.parentPath.replaceWith(import_compiler47.types.identifier("$global"));
@@ -7573,16 +7948,16 @@ var referenced_identifier_default = {
     }
   },
   analyze(identifier) {
-    const { name } = identifier.node;
-    if (identifier.scope.hasBinding(name)) return;
-    if (name === "$global" || name === "$signal") {
+    const { name: name2 } = identifier.node;
+    if (identifier.scope.hasBinding(name2)) return;
+    if (name2 === "$global" || name2 === "$signal") {
       setReferencesScope(identifier);
     }
   },
   translate(identifier) {
-    const { name } = identifier.node;
-    if (identifier.scope.hasBinding(name)) return;
-    switch (name) {
+    const { name: name2 } = identifier.node;
+    if (identifier.scope.hasBinding(name2)) return;
+    switch (name2) {
       case "$global":
         if (isOutputHTML()) {
           identifier.replaceWith(
@@ -7600,8 +7975,8 @@ var referenced_identifier_default = {
           if (!section.hasCleanup) {
             section.hasCleanup = true;
             const exprRoot = getExprRoot(identifier);
-            const write = writeTo(exprRoot);
-            write`${callRuntime("markResumeCleanup", getScopeIdIdentifier(section))}`;
+            const write2 = writeTo(exprRoot);
+            write2`${callRuntime("markResumeCleanup", getScopeIdIdentifier(section))}`;
           }
           identifier.replaceWith(
             import_compiler47.types.callExpression(
@@ -7882,7 +8257,7 @@ function translateDOM(tag) {
   const { node } = tag;
   const extra = node.extra;
   const childScopeBinding = extra[kChildScopeBinding];
-  const write = writeTo(tag);
+  const write2 = writeTo(tag);
   const { file } = tag.hub;
   const tagName = import_compiler49.types.isIdentifier(node.name) ? node.name.name : import_compiler49.types.isStringLiteral(node.name) ? node.name.value : "tag";
   const relativePath = getTagRelativePath(tag);
@@ -7903,7 +8278,7 @@ function translateDOM(tag) {
       childScopeBinding
     });
   }
-  write`${(0, import_babel_utils37.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
+  write2`${(0, import_babel_utils37.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
   injectWalks(
     tag,
     (0, import_babel_utils37.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
@@ -7997,8 +8372,8 @@ function analyzeAttrs(section, tag, templateExport) {
     for (const attrTagName in attrTagLookup) {
       seen.add(attrTagLookup[attrTagName].name);
     }
-    const attrTags = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
-    for (const child of attrTags) {
+    const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
+    for (const child of attrTags2) {
       if (child.isMarkoTag()) {
         if ((0, import_babel_utils37.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
@@ -8015,8 +8390,8 @@ function analyzeAttrs(section, tag, templateExport) {
         } else {
           const group = child.node.extra.attributeTagGroup;
           let childUsesGroupProp = false;
-          for (const name of group) {
-            if (templateExport.props[attrTagLookup[name].name]) {
+          for (const name2 of group) {
+            if (templateExport.props[attrTagLookup[name2].name]) {
               childUsesGroupProp = true;
               break;
             }
@@ -8117,10 +8492,10 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
   const seen = /* @__PURE__ */ new Set();
   const attrTagLookup = analyzeAttributeTags(tag);
   if (attrTagLookup) {
-    const attrTags = tag.get("attributeTags");
+    const attrTags2 = tag.get("attributeTags");
     const statementsByGroup = /* @__PURE__ */ new Map();
     const translateDynamicAttrTagChildInGroup = (group, index) => {
-      const child = attrTags[index];
+      const child = attrTags2[index];
       let statements = statementsByGroup.get(group)?.statements;
       if (!statements) {
         statements = [];
@@ -8130,7 +8505,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
         });
       }
       return addDynamicAttrTagStatements(
-        attrTags,
+        attrTags2,
         index,
         attrTagLookup,
         statements,
@@ -8140,8 +8515,8 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
     for (const attrTagName in attrTagLookup) {
       seen.add(attrTagLookup[attrTagName].name);
     }
-    for (let i = 0; i < attrTags.length; i++) {
-      const child = attrTags[i];
+    for (let i = 0; i < attrTags2.length; i++) {
+      const child = attrTags2[i];
       if (child.isMarkoTag()) {
         if ((0, import_babel_utils37.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
@@ -8171,8 +8546,8 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
       { referencedBindings, statements }
     ] of statementsByGroup) {
       const decls = [];
-      for (const name of group) {
-        const attrTagMeta = attrTagLookup[name];
+      for (const name2 of group) {
+        const attrTagMeta = attrTagLookup[name2];
         const childAttrExports = templateExport.props[attrTagMeta.name];
         if (!childAttrExports) continue;
         const attrExportIdentifier = importOrSelfReferenceName(
@@ -8268,33 +8643,33 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
     );
   }
   const missing = new Set(Object.keys(templateExport.props));
-  for (const name of seen) missing.delete(name);
+  for (const name2 of seen) missing.delete(name2);
   if (missing.size) {
     const referencedBindings = tag.node.extra?.referencedBindings;
     let getMissingPropValue = buildUndefined2;
     if (spreadProps) {
       const spreadId = tag.scope.generateUidIdentifier(`${importAlias}_spread`);
       spreadProps.reverse();
-      getMissingPropValue = (name) => toMemberExpression(spreadId, name);
+      getMissingPropValue = (name2) => toMemberExpression(spreadId, name2);
       addStatement("render", info.tagSection, referencedBindings, [
         import_compiler49.types.variableDeclaration("const", [
           import_compiler49.types.variableDeclarator(spreadId, propsToExpression(spreadProps))
         ])
       ]);
     }
-    for (const name of missing) {
-      const childAttrExports = templateExport.props[name];
+    for (const name2 of missing) {
+      const childAttrExports = templateExport.props[name2];
       const attrExportIdentifier = importOrSelfReferenceName(
         tag.hub.file,
         info.relativePath,
         childAttrExports.id,
-        `${importAlias}_${name}`
+        `${importAlias}_${name2}`
       );
       addValue(
         info.tagSection,
         referencedBindings,
         identifierToSignal(attrExportIdentifier),
-        getMissingPropValue(name),
+        getMissingPropValue(name2),
         createScopeReadExpression(info.tagSection, info.childScopeBinding),
         callRuntime(
           "inChild",
@@ -8305,11 +8680,11 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
     }
   }
 }
-function importOrSelfReferenceName(file, request, name, nameHint) {
+function importOrSelfReferenceName(file, request, name2, nameHint) {
   if (isCircularRequest(file, request)) {
-    return import_compiler49.types.identifier(name);
+    return import_compiler49.types.identifier(name2);
   }
-  return (0, import_babel_utils37.importNamed)(file, request, name, nameHint);
+  return (0, import_babel_utils37.importNamed)(file, request, name2, nameHint);
 }
 function isCircularRequest(file, request) {
   const { filename } = file.opts;
@@ -8337,7 +8712,6 @@ function always() {
 // src/translator/visitors/tag/dynamic-tag.ts
 var import_compiler50 = require("@marko/compiler");
 var import_babel_utils38 = require("@marko/compiler/babel-utils");
-var import_types12 = require("@marko/runtime-tags/common/types");
 var kDOMBinding = Symbol("dynamic tag dom binding");
 var dynamic_tag_default = {
   analyze: {
@@ -8363,7 +8737,7 @@ var dynamic_tag_default = {
   },
   translate: {
     enter(tag) {
-      visit(tag, import_types12.WalkCode.Replace);
+      visit(tag, 37 /* Replace */);
       enterShallow(tag);
       if (isOutputHTML()) {
         flushBefore(tag);
@@ -8372,7 +8746,7 @@ var dynamic_tag_default = {
     exit(tag) {
       const { node } = tag;
       const extra = node.extra;
-      const nodeRef = extra[kDOMBinding];
+      const nodeRef2 = extra[kDOMBinding];
       const section = getSection(tag);
       let tagExpression = node.name;
       if (import_compiler50.types.isStringLiteral(tagExpression)) {
@@ -8434,7 +8808,7 @@ var dynamic_tag_default = {
       if (isOutputHTML()) {
         flushInto(tag);
         writeHTMLResumeStatements(tag.get("body"));
-        const write = writeTo(tag);
+        const write2 = writeTo(tag);
         if (node.var) {
           if (!hasMultipleArgs && args.length === 1) {
             args.push(import_compiler50.types.unaryExpression("void", import_compiler50.types.numericLiteral(0)));
@@ -8480,20 +8854,20 @@ var dynamic_tag_default = {
             import_compiler50.types.variableDeclarator(node.var, dynamicTagExpr)
           ]) : import_compiler50.types.expressionStatement(dynamicTagExpr)
         );
-        write`${callRuntime(
+        write2`${callRuntime(
           "markResumeControlEnd",
           getScopeIdIdentifier(section),
-          getScopeAccessorLiteral(nodeRef)
+          getScopeAccessorLiteral(nodeRef2)
         )}`;
         getSerializedScopeProperties(section).set(
           import_compiler50.types.stringLiteral(
-            getScopeAccessorLiteral(nodeRef).value + import_types12.AccessorChar.ConditionalScope
+            getScopeAccessorLiteral(nodeRef2).value + "!" /* ConditionalScope */
           ),
           callRuntime("writeExistingScope", dynamicScopeIdentifier)
         );
         getSerializedScopeProperties(section).set(
           import_compiler50.types.stringLiteral(
-            getScopeAccessorLiteral(nodeRef).value + import_types12.AccessorChar.ConditionalRenderer
+            getScopeAccessorLiteral(nodeRef2).value + "(" /* ConditionalRenderer */
           ),
           callRuntime(
             "normalizeDynamicRenderer",
@@ -8506,11 +8880,11 @@ var dynamic_tag_default = {
       } else {
         const section2 = getSection(tag);
         const bodySection = getSectionForBody(tag.get("body"));
-        const signal = getSignal(section2, nodeRef, "dynamicTagName");
+        const signal = getSignal(section2, nodeRef2, "dynamicTagName");
         signal.build = () => {
           return callRuntime(
             "conditional",
-            getScopeAccessorLiteral(nodeRef),
+            getScopeAccessorLiteral(nodeRef2),
             getSignalFn(signal, [scopeIdentifier]),
             buildSignalIntersections(signal)
           );
@@ -8530,7 +8904,7 @@ var dynamic_tag_default = {
         );
         if (tag.node.var) {
           const childScopeLiteral = import_compiler50.types.stringLiteral(
-            getScopeAccessorLiteral(extra[kDOMBinding]).value + import_types12.AccessorChar.ConditionalScope
+            getScopeAccessorLiteral(extra[kDOMBinding]).value + "!" /* ConditionalScope */
           );
           const source = initValue(
             // TODO: support destructuring
@@ -8550,7 +8924,7 @@ var dynamic_tag_default = {
           addStatement(
             "render",
             section2,
-            nodeRef,
+            nodeRef2,
             import_compiler50.types.expressionStatement(
               callRuntime(
                 "setTagVar",
@@ -8586,7 +8960,7 @@ var dynamic_tag_default = {
                         id,
                         callRuntime(
                           "dynamicTagAttrs",
-                          getScopeAccessorLiteral(nodeRef),
+                          getScopeAccessorLiteral(nodeRef2),
                           bodySection && import_compiler50.types.identifier(bodySection.name),
                           hasMultipleArgs && import_compiler50.types.numericLiteral(1)
                         )
@@ -8615,9 +8989,9 @@ function getCompatRuntimeFile(markoOpts) {
 var tag_default = {
   transform: {
     enter(tag) {
-      const attrs = tag.get("attributes");
-      for (let i = 0; i < attrs.length; i++) {
-        const attr2 = attrs[i];
+      const attrs2 = tag.get("attributes");
+      for (let i = 0; i < attrs2.length; i++) {
+        const attr2 = attrs2[i];
         if (import_compiler51.types.isMarkoAttribute(attr2.node) && attr2.node.bound) {
           attr2.node.bound = false;
           const changeValue = getChangeHandler(tag, attr2);
@@ -8817,7 +9191,7 @@ var taglibs = [
 ];
 function getRuntimeEntryFiles(output, optimize) {
   return [
-    `@marko/runtime-tags${optimize ? "" : "/debug"}/${output === "html" ? "html" : "dom"}`
+    `${runtime_info_default.name}${optimize ? "" : "/debug"}/${output === "html" ? "html" : "dom"}`
   ];
 }
 // Annotate the CommonJS export names for ESM import in node: