@colrealpro/react-luau-doctor 0.18.1 → 0.18.3

package/dist/scan-worker.js

@@ -1109,6 +1109,71 @@ function applyMasks(source, ranges) {
   }
   return output;
 }
+function genericFunctionParameterRanges(source, mask) {
+  const ranges = [];
+  const functionPattern = /\bfunction\b/g;
+  for (const match of source.matchAll(functionPattern)) {
+    const start = match.index;
+    if (!isCode(mask, start, start + match[0].length))
+      continue;
+    let cursor = start + match[0].length;
+    while (cursor < source.length) {
+      const char = source[cursor];
+      if (/\s/.test(char)) {
+        cursor += 1;
+        continue;
+      }
+      if (char === "(")
+        break;
+      if (char === "<") {
+        let depth = 0;
+        const rangeStart = cursor;
+        while (cursor < source.length) {
+          if (isCode(mask, cursor)) {
+            if (source[cursor] === "<")
+              depth += 1;
+            else if (source[cursor] === ">") {
+              depth -= 1;
+              if (depth === 0) {
+                cursor += 1;
+                ranges.push({ start: rangeStart, end: cursor });
+                break;
+              }
+            }
+          }
+          cursor += 1;
+        }
+        break;
+      }
+      if (/[A-Za-z0-9_.:]/.test(char)) {
+        cursor += 1;
+        continue;
+      }
+      break;
+    }
+  }
+  return ranges;
+}
+function normalizeGenericTypePackUses(source, mask) {
+  const declarationRanges = genericFunctionParameterRanges(source, mask);
+  const replacements = [];
+  const packPattern = /\b[A-Za-z_][A-Za-z0-9_]*\.\.\./g;
+  for (const match of source.matchAll(packPattern)) {
+    const start = match.index;
+    const end = start + match[0].length;
+    if (!isCode(mask, start, end))
+      continue;
+    if (declarationRanges.some((range) => start >= range.start && end <= range.end))
+      continue;
+    const name = match[0].slice(0, -3);
+    replacements.push({ start, end, value: `...${name}` });
+  }
+  let output = source;
+  for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
+    output = `${output.slice(0, replacement.start)}${replacement.value}${output.slice(replacement.end)}`;
+  }
+  return output;
+}
 function normalizeIntegerLiteralSuffixes(source, mask) {
   const suffixes = [];
   const integerPattern = /\b(?:0[xX][0-9A-Fa-f_]+|0[bB][01_]+|[0-9][0-9_]*)i\b/g;
@@ -1148,13 +1213,14 @@ function parserCompatibleSource(source) {
   const mask = codeMask(source);
   const keywordCompatible = replaceContextualKeywords(source, mask);
   const literalCompatible = normalizeIntegerLiteralSuffixes(keywordCompatible, mask);
+  const packCompatible = normalizeGenericTypePackUses(literalCompatible, mask);
   const ranges = [
     ...maskTypeAliases(source, mask),
     ...maskTypeLevelBlocks(source, mask),
     ...attributeRanges(source, mask),
     ...explicitTypeArgumentRanges(source, mask)
   ];
-  const masked = applyMasks(literalCompatible, ranges);
+  const masked = applyMasks(packCompatible, ranges);
   return masked.replace(/^(\s*)type(?=\s*(?:\+=|-=|\*=|\/=|%=|\^=|\.\.=|=(?!=)))/gm, "$1_typ");
 }
 
@@ -7389,5 +7455,5 @@ parentPort.on("message", async (request) => {
   }
 });
 
-//# debugId=D3DA65AABFE680C664756E2164756E21
+//# debugId=CD648BE1625A701464756E2164756E21
 //# sourceMappingURL=scan-worker.js.map