regor 1.6.6 → 1.6.8

package/dist/regor.es2022.iife.js

@@ -4169,7 +4169,7 @@ var Regor = (() => {
   };
 
   // src/reactivity/ref.ts
-  var ref = (value) => {
+  function ref(value) {
     if (isRaw(value)) return value;
     let result;
     if (isRef(value)) {
@@ -4200,7 +4200,7 @@ var Regor = (() => {
       value[key] = ref(val);
     }
     return result;
-  };
+  }
 
   // src/app/RegorConfig.ts
   var RegorConfig = class _RegorConfig {
@@ -6188,19 +6188,50 @@ var Regor = (() => {
     while (i < tagText.length && (tagText[i] === " " || tagText[i] === "\n")) ++i;
     if (i >= tagText.length || !isNameChar(tagText[i])) return null;
     const start = i;
-    while (i < tagText.length && isNameChar(tagText[i])) ++i;
-    return { start, end: i };
-  };
-  var tableScopeTags = /* @__PURE__ */ new Set(["table", "thead", "tbody", "tfoot"]);
-  var rowParentTags = /* @__PURE__ */ new Set(["thead", "tbody", "tfoot"]);
-  var tableDirectAllowed = /* @__PURE__ */ new Set([
-    "caption",
-    "colgroup",
-    "thead",
-    "tbody",
-    "tfoot",
-    "tr"
-  ]);
+    let hasUppercase = false;
+    while (i < tagText.length && isNameChar(tagText[i])) {
+      const c = tagText.charCodeAt(i);
+      if (c >= 65 && c <= 90) {
+        hasUppercase = true;
+      }
+      ++i;
+    }
+    return { start, end: i, hasUppercase };
+  };
+  var isTableScopeTag = (tagName) => {
+    switch (tagName) {
+      case "table":
+      case "thead":
+      case "tbody":
+      case "tfoot":
+        return true;
+      default:
+        return false;
+    }
+  };
+  var isRowParentTag = (tagName) => {
+    switch (tagName) {
+      case "thead":
+      case "tbody":
+      case "tfoot":
+        return true;
+      default:
+        return false;
+    }
+  };
+  var isTableDirectAllowed = (tagName) => {
+    switch (tagName) {
+      case "caption":
+      case "colgroup":
+      case "thead":
+      case "tbody":
+      case "tfoot":
+      case "tr":
+        return true;
+      default:
+        return false;
+    }
+  };
   var voidElements = /* @__PURE__ */ new Set([
     "area",
     "base",
@@ -6217,11 +6248,61 @@ var Regor = (() => {
     "track",
     "wbr"
   ]);
+  var getTableAliasHost = (tagName) => {
+    switch (tagName) {
+      case "caption":
+        return "captionx";
+      case "thead":
+        return "theadx";
+      case "tbody":
+        return "tbodyx";
+      case "tfoot":
+        return "tfootx";
+      case "tr":
+        return "trx";
+      case "td":
+        return "tdx";
+      case "th":
+        return "thx";
+      case "colgroup":
+        return "colgroupx";
+      case "col":
+        return "colx";
+      default:
+        return null;
+    }
+  };
+  var getTableAliasTag = (host) => {
+    switch (host) {
+      case "captionx":
+        return "caption";
+      case "theadx":
+        return "thead";
+      case "tbodyx":
+        return "tbody";
+      case "tfootx":
+        return "tfoot";
+      case "trx":
+        return "tr";
+      case "tdx":
+        return "td";
+      case "thx":
+        return "th";
+      case "colgroupx":
+        return "colgroup";
+      case "colx":
+        return "col";
+      default:
+        return void 0;
+    }
+  };
+  var closeTag = (tagText, tagName) => `${tagText}</${tagName}>`;
   var expandSelfClosingTag = (tagText, tagName) => `${tagText.slice(0, tagText.length - 2)}></${tagName}>`;
   var preprocess = (template) => {
     let i = 0;
     const out = [];
     const stack = [];
+    const ignoredClosingTags = [];
     let tableScopeDepth = 0;
     while (i < template.length) {
       const lt = template.indexOf("<", i);
@@ -6260,12 +6341,21 @@ var Regor = (() => {
         continue;
       }
       const tagName = rawTag.slice(range.start, range.end);
+      const nativeTagName = range.hasUppercase ? "" : tagName;
       if (isClosing) {
+        const ignoredClosing = ignoredClosingTags[ignoredClosingTags.length - 1];
+        if (ignoredClosing?.tagName === tagName) {
+          ignoredClosingTags.pop();
+          if (ignoredClosing.emit) out.push(rawTag);
+          i = tagEnd + 1;
+          continue;
+        }
         const top = stack[stack.length - 1];
         if (top) {
           stack.pop();
           out.push(top.replacementHost ? `</${top.replacementHost}>` : rawTag);
-          if (tableScopeTags.has(top.effectiveTag)) --tableScopeDepth;
+          if (!top.isTableAlias && isTableScopeTag(top.effectiveTag))
+            --tableScopeDepth;
         } else {
           out.push(rawTag);
         }
@@ -6276,35 +6366,47 @@ var Regor = (() => {
       const parent = stack[stack.length - 1];
       let replacementHost = null;
       if (tableScopeDepth === 0) {
-        if (tagName === "tr") replacementHost = "trx";
-        else if (tagName === "td") replacementHost = "tdx";
-        else if (tagName === "th") replacementHost = "thx";
-      } else if (rowParentTags.has(parent?.effectiveTag ?? "")) {
-        replacementHost = tagName === "tr" ? null : "tr";
+        replacementHost = getTableAliasHost(nativeTagName);
+      } else if (isRowParentTag(parent?.effectiveTag ?? "")) {
+        replacementHost = nativeTagName === "tr" ? null : "tr";
       } else if (parent?.effectiveTag === "table") {
-        replacementHost = tableDirectAllowed.has(tagName) ? null : "tr";
+        replacementHost = isTableDirectAllowed(nativeTagName) ? null : "tr";
       } else if (parent?.effectiveTag === "tr") {
-        replacementHost = tagName === "td" || tagName === "th" ? null : "td";
-      }
-      const shouldExpandSelfClosing = selfClosing && !voidElements.has(replacementHost || tagName);
+        replacementHost = nativeTagName === "td" || nativeTagName === "th" ? null : "td";
+      } else if (parent?.effectiveTag === "colgroup") {
+        replacementHost = nativeTagName === "col" ? null : "col";
+      }
+      const aliasTag = getTableAliasTag(replacementHost);
+      const isTableAlias = aliasTag !== void 0;
+      const shouldExpandSelfClosing = selfClosing && !voidElements.has(replacementHost || nativeTagName);
+      const shouldCloseVoidAlias = !!replacementHost && aliasTag === nativeTagName && voidElements.has(nativeTagName);
+      const shouldIgnoreClosingTag = !selfClosing && !!replacementHost && voidElements.has(replacementHost) && !shouldCloseVoidAlias;
+      const shouldIgnoreNativeVoidClosingTag = !selfClosing && !replacementHost && voidElements.has(nativeTagName);
       if (replacementHost) {
-        const isAlias = replacementHost === "trx" || replacementHost === "tdx" || replacementHost === "thx";
-        const rewrittenTag = `${rawTag.slice(0, range.start)}${replacementHost} is="${isAlias ? `r-${tagName}` : `regor:${tagName}`}"${rawTag.slice(range.end)}`;
+        const rewrittenTag = `${rawTag.slice(0, range.start)}${replacementHost} is="${aliasTag ? `r-${aliasTag}` : `regor:${tagName}`}"${rawTag.slice(range.end)}`;
         out.push(
-          shouldExpandSelfClosing ? expandSelfClosingTag(rewrittenTag, replacementHost) : rewrittenTag
+          shouldExpandSelfClosing ? expandSelfClosingTag(rewrittenTag, replacementHost) : shouldCloseVoidAlias ? closeTag(rewrittenTag, replacementHost) : rewrittenTag
         );
       } else {
         out.push(
           shouldExpandSelfClosing ? expandSelfClosingTag(rawTag, tagName) : rawTag
         );
       }
-      if (!selfClosing) {
-        const effectiveTag = replacementHost === "trx" ? "tr" : replacementHost === "tdx" ? "td" : replacementHost === "thx" ? "th" : replacementHost || tagName;
+      if (shouldIgnoreClosingTag) {
+        ignoredClosingTags.push({ tagName, emit: false });
+      } else if (shouldCloseVoidAlias && !selfClosing) {
+        ignoredClosingTags.push({ tagName, emit: false });
+      } else if (shouldIgnoreNativeVoidClosingTag) {
+        ignoredClosingTags.push({ tagName, emit: true });
+      }
+      if (!selfClosing && !shouldCloseVoidAlias && !shouldIgnoreClosingTag && !shouldIgnoreNativeVoidClosingTag && !voidElements.has(replacementHost ?? nativeTagName)) {
+        const effectiveTag = aliasTag ?? replacementHost ?? (nativeTagName || tagName);
         stack.push({
           replacementHost,
-          effectiveTag
+          effectiveTag,
+          isTableAlias
         });
-        if (tableScopeTags.has(effectiveTag)) ++tableScopeDepth;
+        if (!isTableAlias && isTableScopeTag(effectiveTag)) ++tableScopeDepth;
       }
       i = tagEnd + 1;
     }