fastscript 2.0.0 → 3.0.1

package/node_modules/@fastscript/core-private/src/fs-error-codes.mjs

@@ -16,8 +16,8 @@ export const FS_ERROR_CODES = Object.freeze({
   },
   FS1004: {
     severity: "error",
-    message: "Type declarations are not valid runtime FastScript syntax.",
-    hint: "Move `type`, `interface`, and `enum` definitions to `.d.ts` files or remove them from `.fs` files.",
+    message: "Legacy compatibility frontend conflict.",
+    hint: "Ordinary TS type-only syntax in `.fs` should parse. If this appears, treat it as a FastScript compatibility bug.",
   },
   FS1005: {
     severity: "error",

package/node_modules/@fastscript/core-private/src/fs-normalize.mjs

@@ -1,91 +1,125 @@
-import { compileFastScript } from "./fs-parser.mjs";
-
-export function normalizeFastScript(source, options = {}) {
-  const { code } = compileFastScript(source, {
-    file: options.file || "",
-    mode: options.mode || "lenient",
-    recover: options.recover !== false,
-    inlineSourceMap: options.sourceMap === "inline",
-  });
-  return code;
-}
-
-export function normalizeFastScriptWithMetadata(source, options = {}) {
-  return compileFastScript(source, {
-    file: options.file || "",
-    mode: options.mode || "lenient",
-    recover: options.recover !== false,
-    inlineSourceMap: options.sourceMap === "inline",
-  });
-}
-
-export function stripTypeScriptHints(source) {
-  const lines = source.split(/\r?\n/);
-  const out = [];
-  let skippingBlock = false;
-  let blockDepth = 0;
-
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i];
-    let next = line;
-
-    if (skippingBlock) {
-      const opens = (next.match(/{/g) || []).length;
-      const closes = (next.match(/}/g) || []).length;
-      blockDepth += opens - closes;
-      if (blockDepth <= 0) {
-        skippingBlock = false;
-        blockDepth = 0;
-      }
-      continue;
-    }
-
-    if (/^\s*interface\s+[A-Za-z_$][\w$]*\s*[{]/.test(next) || /^\s*enum\s+[A-Za-z_$][\w$]*\s*[{]/.test(next)) {
-      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
-      skippingBlock = true;
-      const opens = (next.match(/{/g) || []).length;
-      const closes = (next.match(/}/g) || []).length;
-      blockDepth = Math.max(1, opens - closes);
-      continue;
-    }
-
-    if (/^\s*type\s+[A-Za-z_$][\w$]*\s*=/.test(next)) {
-      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
-      if (!next.includes(";") && next.includes("{")) {
-        skippingBlock = true;
-        const opens = (next.match(/{/g) || []).length;
-        const closes = (next.match(/}/g) || []).length;
-        blockDepth = Math.max(1, opens - closes);
-      }
-      continue;
-    }
-
-    next = next.replace(/\bimport\s+type\b/g, "import");
-    next = next.replace(/\bexport\s+type\b/g, "export");
-
-    next = next.replace(
-      /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*:\s*([^=;]+)([=;].*)$/,
-      "$1$2 $3 $5",
-    );
-
-    if (/\bfunction\b/.test(next) || /\)\s*=>/.test(next)) {
-      next = next.replace(/\(([^)]*)\)/, (_, params) => {
-        const cleaned = params.replace(
-          /([A-Za-z_$][\w$]*)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.]*)/g,
-          "$1",
-        );
-        return `(${cleaned})`;
-      });
-      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.]*)\s*\{/g, ") {");
-      next = next.replace(/\bfunction\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "function $1(");
-    }
-
-    next = next.replace(/^\s*<([A-Za-z_$][\w$,\s]*)>\s*\(/, "(");
-    next = next.replace(/\)\s*=>\s*<[A-Za-z_$][\w$<>\[\]\|&, ?.]*>/g, ") =>");
-    next = next.replace(/\sas\s+const\b/g, "");
-    next = next.replace(/\s+satisfies\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]*/g, "");
-    out.push(next);
-  }
-
-  return out.join("\n");
-}
+import { compileFastScript } from "./fs-parser.mjs";
+
+export function normalizeFastScript(source, options = {}) {
+  const prepared = stripTypeScriptHints(String(source ?? ""));
+  const { code } = compileFastScript(prepared, {
+    file: options.file || "",
+    mode: options.mode || "lenient",
+    recover: options.recover !== false,
+    inlineSourceMap: options.sourceMap === "inline",
+  });
+  return code;
+}
+
+export function normalizeFastScriptWithMetadata(source, options = {}) {
+  const prepared = stripTypeScriptHints(String(source ?? ""));
+  return compileFastScript(prepared, {
+    file: options.file || "",
+    mode: options.mode || "lenient",
+    recover: options.recover !== false,
+    inlineSourceMap: options.sourceMap === "inline",
+  });
+}
+
+export function stripTypeScriptHints(source) {
+  const lines = source.split(/\r?\n/);
+  const out = [];
+  let skippingBlock = false;
+  let blockDepth = 0;
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    let next = line;
+
+    if (skippingBlock) {
+      const opens = (next.match(/{/g) || []).length;
+      const closes = (next.match(/}/g) || []).length;
+      blockDepth += opens - closes;
+      if (blockDepth <= 0) {
+        skippingBlock = false;
+        blockDepth = 0;
+      }
+      continue;
+    }
+
+    if (/^\\s*interface\\s+[A-Za-z_$][\\w$]*(?:\\s*<[^>]+>)?\\s*[{]/.test(next) || /^\s*enum\s+[A-Za-z_$][\w$]*\s*[{]/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      skippingBlock = true;
+      const opens = (next.match(/{/g) || []).length;
+      const closes = (next.match(/}/g) || []).length;
+      blockDepth = Math.max(1, opens - closes);
+      continue;
+    }
+
+    if (/^\\s*type\\s+[A-Za-z_$][\\w$]*(?:\\s*<[^>]+>)?\\s*=/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      if (!next.includes(";") && next.includes("{")) {
+        skippingBlock = true;
+        const opens = (next.match(/{/g) || []).length;
+        const closes = (next.match(/}/g) || []).length;
+        blockDepth = Math.max(1, opens - closes);
+      }
+      continue;
+    }
+
+    if (/^\s*declare\s+(global|module|namespace)\b/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      if (next.includes("{")) {
+        skippingBlock = true;
+        const opens = (next.match(/{/g) || []).length;
+        const closes = (next.match(/}/g) || []).length;
+        blockDepth = Math.max(1, opens - closes);
+      }
+      continue;
+    }
+
+    if (/^\s*declare\s+/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      continue;
+    }
+
+    next = next.replace(/\bimport\s+type\b/g, "import");
+    next = next.replace(/\bexport\s+type\b/g, "export");
+    next = next.replace(/\btype\s+([A-Za-z_$][\w$]*)\s+as\s+/g, "$1 as ");
+    next = next.replace(/\b(?:public|private|protected|readonly|declare|override|abstract)\s+/g, "");
+    next = next.replace(/\s+implements\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]+/g, "");
+    next = next.replace(/([A-Za-z_$][\w$]*)!([?:;=,\)])/g, "$1$2");
+
+    next = next.replace(
+      /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*:\s*([^=;]+)([=;].*)$/,
+      "$1$2 $3 $5",
+    );
+    next = next.replace(
+      /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*=\s*/,
+      "$1$2 $3 = ",
+    );
+
+    if (/\bfunction\b/.test(next) || /\bfn\b/.test(next) || /\)\s*=>/.test(next)) {
+      next = next.replace(/\(([^)]*)\)/, (_, params) => {
+        const cleaned = params.replace(
+          /([A-Za-z_$][\w$]*)(\?)?\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)/g,
+          "$1",
+        );
+        return `(${cleaned})`;
+      });
+      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)\s*\{/g, ") {");
+      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)\s*=>/g, ") =>");
+      next = next.replace(/\bfunction\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "function $1(");
+      next = next.replace(/\bfn\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "fn $1(");
+      next = next.replace(/=\s*async\s*<[^>]+>\s*\(/g, "= async (");
+      next = next.replace(/=\s*<[^>]+>\s*\(/g, "= (");
+    }
+
+    next = next.replace(/^\s*<([A-Za-z_$][\w$,\s]*)>\s*\(/, "(");
+    next = next.replace(/\)\s*=>\s*<[A-Za-z_$][\w$<>\[\]\|&, ?.]*>/g, ") =>");
+    next = next.replace(/\s+as\s+const\b/g, "");
+    next = next.replace(/\s+as\s+[A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*/g, "");
+    next = next.replace(/\sas\s+const\b/g, "");
+    next = next.replace(/\s+satisfies\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]*/g, "");
+    out.push(next);
+  }
+
+  return out.join("\n");
+}
+
+

package/node_modules/@fastscript/core-private/src/fs-parser.mjs

@@ -1,10 +1,12 @@
 import { parse as acornParse, tokenizer as acornTokenizer } from "acorn";
+import * as esbuild from "esbuild";
 import { resolveErrorMeta } from "./fs-error-codes.mjs";
 
 export const FASTSCRIPT_AST_VERSION = "1.0.0";
 
 const STATEMENT_BOUNDARY_TOKENS = new Set([";", "{", "}"]);
-const TYPE_DECLARATION_KEYWORDS = new Set(["type", "interface", "enum"]);
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_LOOKUP = new Map(Array.from(BASE64).map((char, index) => [char, index]));
 
 function createLineStarts(source) {
   const text = String(source ?? "");
@@ -436,9 +438,23 @@ function collectRewriteOperations(source, { file = "", lineStarts, significant }
 
     if (token.value === "fn" && token.type === "identifier") {
       const prev = previousSignificant(significant, idx);
+      const asyncToken = prev?.value === "async" ? prev : null;
+      const asyncIndex = asyncToken ? idx - 1 : -1;
+      const beforeAsync = asyncToken ? previousSignificant(significant, asyncIndex) : null;
       const startsStatement = isStatementStart(significant, idx);
       const followsExport = prev?.value === "export" && prev.end.line === token.start.line;
-      if (startsStatement || followsExport) {
+      const followsDefaultExport =
+        prev?.value === "default" &&
+        previousSignificant(significant, idx - 1)?.value === "export" &&
+        previousSignificant(significant, idx - 1)?.end.line === token.start.line;
+      const followsAsync =
+        asyncToken &&
+        (
+          isStatementStart(significant, asyncIndex) ||
+          beforeAsync?.value === "export" ||
+          beforeAsync?.value === "default"
+        );
+      if (startsStatement || followsExport || followsDefaultExport || followsAsync) {
         const nameToken = nextSignificant(significant, idx, 1);
         const openParenToken = nextSignificant(significant, idx, 2);
         if (isIdentifierToken(nameToken) && openParenToken?.value === "(") {
@@ -465,40 +481,6 @@ function collectRewriteOperations(source, { file = "", lineStarts, significant }
       continue;
     }
 
-    if (TYPE_DECLARATION_KEYWORDS.has(token.value) && token.type === "identifier" && isStatementStart(significant, idx)) {
-      const nextToken = nextSignificant(significant, idx, 1);
-      if (!isIdentifierToken(nextToken)) continue;
-      const shouldHandleType = token.value === "type" && nextSignificant(significant, idx, 2)?.value === "=";
-      const shouldHandleBlock = (token.value === "interface" || token.value === "enum") && nextSignificant(significant, idx, 2);
-      if (!shouldHandleType && !shouldHandleBlock) continue;
-
-      const span = declarationSpanFromKeyword(source, lineStarts, sourceLength, significant, idx);
-      const snippet = source.slice(span.start, span.end).trim();
-      diagnostics.push(
-        createDiagnostic({
-          source,
-          lineStarts,
-          file,
-          code: "FS1004",
-          span,
-          fixes: [
-            {
-              message: "Remove declaration from runtime source.",
-              span,
-              text: "",
-            },
-          ],
-        }),
-      );
-      ops.push(
-        operation(
-          span.start,
-          span.end,
-          `/* ${snippet || token.value} (removed by fastscript compiler) */`,
-          "erase-type",
-        ),
-      );
-    }
   }
 
   const lexicalTodoPattern = /\bTODO_ERROR\b/g;
@@ -589,7 +571,104 @@ function applyRewriteOperations(source, ops) {
   return { code, mapGeneratedToSource, rewrites };
 }
 
-const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function decodeVlqValue(mapping, startIndex) {
+  let result = 0;
+  let shift = 0;
+  let index = startIndex;
+
+  while (index < mapping.length) {
+    const value = BASE64_LOOKUP.get(mapping[index]);
+    if (value == null) break;
+    index += 1;
+    const continuation = (value & 32) !== 0;
+    result |= (value & 31) << shift;
+    shift += 5;
+    if (!continuation) {
+      const signed = (result & 1) ? -(result >> 1) : result >> 1;
+      return { value: signed, next: index };
+    }
+  }
+
+  return { value: 0, next: index };
+}
+
+function decodeSourceMapMappings(mappings) {
+  const lines = [];
+  let sourceIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let generatedLine = 0;
+  let generatedColumn = 0;
+
+  for (const line of String(mappings || "").split(";")) {
+    const segments = [];
+    generatedColumn = 0;
+    if (line) {
+      for (const rawSegment of line.split(",")) {
+        if (!rawSegment) continue;
+        let cursor = 0;
+        const values = [];
+        while (cursor < rawSegment.length) {
+          const decoded = decodeVlqValue(rawSegment, cursor);
+          values.push(decoded.value);
+          cursor = decoded.next;
+        }
+        if (!values.length) continue;
+        generatedColumn += values[0];
+        if (values.length >= 4) {
+          sourceIndex += values[1];
+          sourceLine += values[2];
+          sourceColumn += values[3];
+          segments.push({ generatedLine, generatedColumn, sourceIndex, sourceLine, sourceColumn });
+        }
+      }
+    }
+    lines.push(segments);
+    generatedLine += 1;
+  }
+
+  return lines;
+}
+
+function buildGeneratedOffsetMapFromSourceMap({ generated, mapText, sourceLength }) {
+  const parsed = JSON.parse(String(mapText || "{}"));
+  const lineStarts = createLineStarts(generated);
+  const sourceLineStarts = createLineStarts(parsed?.sourcesContent?.[0] || "");
+  const decoded = decodeSourceMapMappings(parsed.mappings || "");
+  const out = [];
+
+  for (let lineIndex = 0; lineIndex < lineStarts.length; lineIndex += 1) {
+    const lineStart = lineStarts[lineIndex];
+    const lineEnd = lineStarts[lineIndex + 1] ?? generated.length;
+    const segments = decoded[lineIndex] || [];
+    let active = segments[0] || null;
+    let segmentIndex = 0;
+
+    for (let offset = lineStart; offset < lineEnd; offset += 1) {
+      const column = offset - lineStart;
+      while (segmentIndex + 1 < segments.length && segments[segmentIndex + 1].generatedColumn <= column) {
+        segmentIndex += 1;
+        active = segments[segmentIndex];
+      }
+
+      if (!active) {
+        out.push(clamp(offset, 0, sourceLength));
+        continue;
+      }
+
+      const delta = Math.max(0, column - active.generatedColumn);
+      const mappedBase = sourceLineStarts[active.sourceLine] ?? 0;
+      out.push(clamp(mappedBase + active.sourceColumn + delta, 0, sourceLength));
+    }
+  }
+
+  out.push(sourceLength);
+  return out;
+}
+
+function composeOffsetMaps(finalToIntermediate, intermediateToSource, sourceLength) {
+  return finalToIntermediate.map((offset) => mapGeneratedOffsetToSourceOffset(intermediateToSource, offset, sourceLength));
+}
 
 function encodeVlq(value) {
   let num = value < 0 ? ((-value) << 1) + 1 : value << 1;
@@ -796,9 +875,66 @@ function parseGeneratedJavaScript(generated, { file = "" } = {}) {
       onToken: parseTokens,
       onComment: parseComments,
     });
-    return { estree, parseTokens, parseComments, error: null };
+    return {
+      estree,
+      parseTokens,
+      parseComments,
+      error: null,
+      frontend: {
+        usedCompatibilityFrontend: false,
+        mapGeneratedToInput: null,
+        generatedCode: generated,
+      },
+    };
   } catch (error) {
-    return { estree: null, parseTokens, parseComments, error };
+    try {
+      const transformed = esbuild.transformSync(generated, {
+        loader: "tsx",
+        format: "esm",
+        target: "esnext",
+        sourcefile: file || "<memory>",
+        sourcemap: "external",
+        jsx: "transform",
+      });
+      const compatTokens = [];
+      const compatComments = [];
+      const estree = acornParse(transformed.code, {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        allowHashBang: true,
+        locations: true,
+        ranges: true,
+        onToken: compatTokens,
+        onComment: compatComments,
+      });
+      return {
+        estree,
+        parseTokens: compatTokens,
+        parseComments: compatComments,
+        error: null,
+        frontend: {
+          usedCompatibilityFrontend: true,
+          mapGeneratedToInput: buildGeneratedOffsetMapFromSourceMap({
+            generated: transformed.code,
+            mapText: transformed.map,
+            sourceLength: generated.length,
+          }),
+          generatedCode: transformed.code,
+        },
+      };
+    } catch {
+      return {
+        estree: null,
+        parseTokens,
+        parseComments,
+        error,
+        frontend: {
+          usedCompatibilityFrontend: false,
+          mapGeneratedToInput: null,
+          generatedCode: generated,
+        },
+      };
+    }
   }
 }
 
@@ -842,7 +978,21 @@ export function parseFastScript(source, { file = "", mode = "lenient", recover =
 
   const diagnostics = [];
 
-  if (tokenization.lexicalError) {
+  const rewrites = collectRewriteOperations(text, {
+    file,
+    lineStarts,
+    significant: tokenization.significant,
+  });
+  diagnostics.push(...rewrites.diagnostics);
+
+  const transformed = applyRewriteOperations(text, rewrites.ops);
+  const parsedGenerated = parseGeneratedJavaScript(transformed.code, { file });
+  const finalGeneratedCode = parsedGenerated.frontend?.generatedCode || transformed.code;
+  const finalMapGeneratedToSource = parsedGenerated.frontend?.mapGeneratedToInput
+    ? composeOffsetMaps(parsedGenerated.frontend.mapGeneratedToInput, transformed.mapGeneratedToSource, text.length)
+    : transformed.mapGeneratedToSource;
+
+  if (tokenization.lexicalError && !parsedGenerated.frontend?.usedCompatibilityFrontend) {
     const loc = tokenization.lexicalError.loc || { line: 1, column: 0 };
     const lineStart = lineStarts[clamp((loc.line || 1) - 1, 0, lineStarts.length - 1)] ?? 0;
     const offset = clamp(lineStart + (loc.column || 0), 0, text.length);
@@ -858,19 +1008,9 @@ export function parseFastScript(source, { file = "", mode = "lenient", recover =
     );
   }
 
-  const rewrites = collectRewriteOperations(text, {
-    file,
-    lineStarts,
-    significant: tokenization.significant,
-  });
-  diagnostics.push(...rewrites.diagnostics);
-
-  const transformed = applyRewriteOperations(text, rewrites.ops);
-  const parsedGenerated = parseGeneratedJavaScript(transformed.code, { file });
-
   if (parsedGenerated.error) {
-    const parseOffset = clamp(parsedGenerated.error.pos ?? 0, 0, transformed.code.length);
-    const sourceOffset = mapGeneratedOffsetToSourceOffset(transformed.mapGeneratedToSource, parseOffset, text.length);
+    const parseOffset = clamp(parsedGenerated.error.pos ?? 0, 0, finalGeneratedCode.length);
+    const sourceOffset = mapGeneratedOffsetToSourceOffset(finalMapGeneratedToSource, parseOffset, text.length);
     diagnostics.push(
       createDiagnostic({
         source: text,
@@ -884,13 +1024,13 @@ export function parseFastScript(source, { file = "", mode = "lenient", recover =
   }
 
   const estree = ensureProgramShape(parsedGenerated.estree);
-  remapAstNodeLocations(estree, text, lineStarts, transformed.mapGeneratedToSource);
+  remapAstNodeLocations(estree, text, lineStarts, finalMapGeneratedToSource);
 
   const cst = buildCst({ source: text, file, lineStarts, tokens, estree });
   const sourceMap = buildSourceMap({
     source: text,
-    generated: transformed.code,
-    mapGeneratedToSource: transformed.mapGeneratedToSource,
+    generated: finalGeneratedCode,
+    mapGeneratedToSource: finalMapGeneratedToSource,
     file,
   });
 
@@ -913,9 +1053,9 @@ export function parseFastScript(source, { file = "", mode = "lenient", recover =
     cst,
     tokens,
     diagnostics: normalizedDiagnostics,
-    transformedCode: transformed.code,
+    transformedCode: finalGeneratedCode,
     sourceMap,
-    mapGeneratedToSource: transformed.mapGeneratedToSource,
+    mapGeneratedToSource: finalMapGeneratedToSource,
     rewrites: transformed.rewrites,
     source: text,
   };