regor 1.6.6 → 1.6.8

package/dist/regor.es2015.esm.js

@@ -4178,7 +4178,7 @@ var isDeepRef = (value) => {
 };
 
 // src/reactivity/ref.ts
-var ref = (value) => {
+function ref(value) {
   if (isRaw(value)) return value;
   let result;
   if (isRef(value)) {
@@ -4209,7 +4209,7 @@ var ref = (value) => {
     value[key] = ref(val);
   }
   return result;
-};
+}
 
 // src/app/RegorConfig.ts
 var _RegorConfig = class _RegorConfig {
@@ -6211,19 +6211,50 @@ var parseTagNameRange = (tagText, isClosing) => {
   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",
@@ -6240,12 +6271,62 @@ var voidElements = /* @__PURE__ */ new Set([
   "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) => {
-  var _a;
+  var _a, _b;
   let i = 0;
   const out = [];
   const stack = [];
+  const ignoredClosingTags = [];
   let tableScopeDepth = 0;
   while (i < template.length) {
     const lt = template.indexOf("<", i);
@@ -6284,12 +6365,21 @@ var preprocess = (template) => {
       continue;
     }
     const tagName = rawTag.slice(range.start, range.end);
+    const nativeTagName = range.hasUppercase ? "" : tagName;
     if (isClosing) {
+      const ignoredClosing = ignoredClosingTags[ignoredClosingTags.length - 1];
+      if ((ignoredClosing == null ? void 0 : 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);
       }
@@ -6300,35 +6390,47 @@ var preprocess = (template) => {
     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((_a = parent == null ? void 0 : parent.effectiveTag) != null ? _a : "")) {
-      replacementHost = tagName === "tr" ? null : "tr";
+      replacementHost = getTableAliasHost(nativeTagName);
+    } else if (isRowParentTag((_a = parent == null ? void 0 : parent.effectiveTag) != null ? _a : "")) {
+      replacementHost = nativeTagName === "tr" ? null : "tr";
     } else if ((parent == null ? void 0 : parent.effectiveTag) === "table") {
-      replacementHost = tableDirectAllowed.has(tagName) ? null : "tr";
+      replacementHost = isTableDirectAllowed(nativeTagName) ? null : "tr";
     } else if ((parent == null ? void 0 : 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 == null ? void 0 : 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 != null ? replacementHost : nativeTagName)) {
+      const effectiveTag = (_b = aliasTag != null ? aliasTag : replacementHost) != null ? _b : nativeTagName || tagName;
       stack.push({
         replacementHost,
-        effectiveTag
+        effectiveTag,
+        isTableAlias
       });
-      if (tableScopeTags.has(effectiveTag)) ++tableScopeDepth;
+      if (!isTableAlias && isTableScopeTag(effectiveTag)) ++tableScopeDepth;
     }
     i = tagEnd + 1;
   }