@absolutejs/absolute 0.19.0-beta.1077 → 0.19.0-beta.1079

package/dist/src/build/maskLiterals.d.ts

@@ -0,0 +1,25 @@
+/** Shields non-code spans from the regex/text-based import rewriters.
+ *
+ *  The import rewriters (rewriteReactImports, rewriteImportsPlugin, the native
+ *  Zig scanner, and compile's runtime-specifier rewrite) replace `from "X"` /
+ *  `import "X"` / `import("X")` / `require("X")` across the whole file text. That
+ *  text scan can't tell a real import from the *text* `from 'X'` sitting inside a
+ *  template literal / data string (an example-code snippet a page renders) or a
+ *  comment — so it rewrites the snippet's specifier too. The browser bundle then
+ *  diverges from the SSR pre-render → React hydration mismatch on the code block.
+ *
+ *  Fix: before rewriting, replace template literals, comments, and non-specifier
+ *  string literals with opaque placeholders; rewrite; then restore them verbatim.
+ *  String literals that ARE real import specifiers (those right after
+ *  `from`/`import`, or inside `import(`/`require(`) are left untouched, so real
+ *  import rewriting is unaffected. Regex literals are skipped (copied verbatim)
+ *  so their contents can't be misread as strings/templates.
+ *
+ *  Usage: `const { masked, restore } = maskLiterals(src)`, run the existing
+ *  rewriter on `masked`, then `restore(rewritten)`.
+ */
+export type MaskedSource = {
+    masked: string;
+    restore: (rewritten: string) => string;
+};
+export declare const maskLiterals: (src: string) => MaskedSource;

package/dist/svelte/index.js

@@ -2760,6 +2760,240 @@ var init_islandSsr = __esm(() => {
   LEADING_HOISTED_RESOURCE_RE = /^\s*(?:<link\b[^>]*\/?>|<meta\b[^>]*\/?>|<title\b[^>]*>[\s\S]*?<\/title>|<style\b[^>]*>[\s\S]*?<\/style>|<script\b[^>]*>[\s\S]*?<\/script>)/i;
 });
 
+// src/build/maskLiterals.ts
+var SENTINEL, isIdentChar = (c) => /[A-Za-z0-9_$]/.test(c), REGEX_OK_AFTER_CHAR, REGEX_OK_AFTER_WORD, maskLiterals = (src) => {
+  const n = src.length;
+  const pieces = [];
+  let out = "";
+  let i = 0;
+  let prevChar = "";
+  let prevWord = "";
+  let prevWasSpace = false;
+  let wordBeforeParen = "";
+  const mask = (text) => {
+    out += SENTINEL + pieces.length + SENTINEL;
+    pieces.push(text);
+    prevChar = ")";
+    prevWord = "";
+    prevWasSpace = false;
+  };
+  const endOfString = (start) => {
+    const q = src[start];
+    let j = start + 1;
+    while (j < n) {
+      const c = src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === q)
+        return j + 1;
+      if (c === `
+`)
+        return j;
+      j++;
+    }
+    return j;
+  };
+  const endOfInterp = (start) => {
+    let j = start;
+    let depth = 1;
+    while (j < n && depth > 0) {
+      const c = src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === "`") {
+        j = endOfTemplate(j);
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        j = endOfString(j);
+        continue;
+      }
+      if (c === "/" && src[j + 1] === "/") {
+        const nl = src.indexOf(`
+`, j);
+        j = nl < 0 ? n : nl;
+        continue;
+      }
+      if (c === "/" && src[j + 1] === "*") {
+        const e = src.indexOf("*/", j + 2);
+        j = e < 0 ? n : e + 2;
+        continue;
+      }
+      if (c === "{")
+        depth++;
+      else if (c === "}")
+        depth--;
+      j++;
+    }
+    return j;
+  };
+  function endOfTemplate(start) {
+    let j = start + 1;
+    while (j < n) {
+      const c = src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === "`")
+        return j + 1;
+      if (c === "$" && src[j + 1] === "{") {
+        j = endOfInterp(j + 2);
+        continue;
+      }
+      j++;
+    }
+    return j;
+  }
+  const endOfRegex = (start) => {
+    let j = start + 1;
+    let inClass = false;
+    while (j < n) {
+      const c = src[j];
+      if (c === "\\") {
+        j += 2;
+        continue;
+      }
+      if (c === `
+`)
+        return -1;
+      if (c === "[")
+        inClass = true;
+      else if (c === "]")
+        inClass = false;
+      else if (c === "/" && !inClass) {
+        j++;
+        break;
+      }
+      j++;
+    }
+    while (j < n && /[a-z]/i.test(src[j] ?? ""))
+      j++;
+    return j;
+  };
+  while (i < n) {
+    const c = src[i];
+    const c2 = src[i + 1];
+    if (c === "/" && c2 === "/") {
+      out += "//";
+      i += 2;
+      const s = i;
+      while (i < n && src[i] !== `
+`)
+        i++;
+      mask(src.slice(s, i));
+      continue;
+    }
+    if (c === "/" && c2 === "*") {
+      out += "/*";
+      i += 2;
+      const e = src.indexOf("*/", i);
+      const end = e < 0 ? n : e;
+      mask(src.slice(i, end));
+      i = end < n ? end + 2 : n;
+      if (end < n)
+        out += "*/";
+      continue;
+    }
+    if (c === "`") {
+      const end = endOfTemplate(i);
+      mask(src.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const end = endOfString(i);
+      const isSpecifier = prevWord === "from" || prevWord === "import" || prevChar === "(" && (wordBeforeParen === "import" || wordBeforeParen === "require");
+      if (isSpecifier) {
+        out += src.slice(i, end);
+        prevChar = '"';
+        prevWord = "";
+        prevWasSpace = false;
+      } else {
+        mask(src.slice(i, end));
+      }
+      i = end;
+      continue;
+    }
+    if (c === "/" && (prevChar === "" || REGEX_OK_AFTER_CHAR.has(prevChar) || REGEX_OK_AFTER_WORD.has(prevWord))) {
+      const end = endOfRegex(i);
+      if (end > 0) {
+        out += src.slice(i, end);
+        i = end;
+        prevChar = ")";
+        prevWord = "";
+        prevWasSpace = false;
+        continue;
+      }
+    }
+    out += c;
+    i++;
+    if (c === " " || c === "\t" || c === "\r" || c === `
+`) {
+      prevWasSpace = true;
+      continue;
+    }
+    if (isIdentChar(c)) {
+      const contiguous = isIdentChar(prevChar) && !prevWasSpace;
+      prevWord = contiguous ? prevWord + c : c;
+    } else {
+      if (c === "(")
+        wordBeforeParen = prevWord;
+      prevWord = "";
+    }
+    prevChar = c;
+    prevWasSpace = false;
+  }
+  const restoreRegex = new RegExp(`${SENTINEL}(\\d+)${SENTINEL}`, "g");
+  const restore = (rewritten) => rewritten.replace(restoreRegex, (_m, d) => pieces[Number(d)] ?? "");
+  return { masked: out, restore };
+};
+var init_maskLiterals = __esm(() => {
+  SENTINEL = String.fromCharCode(57344);
+  REGEX_OK_AFTER_CHAR = new Set([
+    "(",
+    ",",
+    "=",
+    ":",
+    "[",
+    "!",
+    "&",
+    "|",
+    "?",
+    "{",
+    "}",
+    ";",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "^",
+    "~",
+    "<",
+    ">"
+  ]);
+  REGEX_OK_AFTER_WORD = new Set([
+    "return",
+    "typeof",
+    "instanceof",
+    "in",
+    "of",
+    "new",
+    "delete",
+    "void",
+    "do",
+    "else",
+    "yield",
+    "await",
+    "case"
+  ]);
+});
+
 // src/build/nativeRewrite.ts
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import { platform, arch } from "os";
@@ -2850,8 +3084,9 @@ var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewrite
   if (Object.keys(vendorPaths).length === 0)
     return content;
   const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
-  const native = nativeRewriteImports(content, replacements);
-  return native ?? jsRewriteImports(content, replacements);
+  const { masked, restore } = maskLiterals(content);
+  const native = nativeRewriteImports(masked, replacements);
+  return restore(native ?? jsRewriteImports(masked, replacements));
 }, fixMissingReExportNamespacesInContent = (content) => {
   const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
   REEXPORT_PATTERN.lastIndex = 0;
@@ -2997,6 +3232,7 @@ ${content}`;
   return result;
 };
 var init_rewriteImportsPlugin = __esm(() => {
+  init_maskLiterals();
   init_nativeRewrite();
 });
 
@@ -4413,5 +4649,5 @@ export {
   createTypedIsland
 };
 
-//# debugId=6FD656B7D1771C9464756E2164756E21
+//# debugId=60861DEB9D7F3C6864756E2164756E21
 //# sourceMappingURL=index.js.map