@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.42

package/dist/native-region-scanner-js.js

@@ -0,0 +1,310 @@
+import {
+  braceDelta,
+  jsControlKeyword,
+  nativeDeclaration,
+  nativeImportDeclaration,
+  sourceLines,
+  splitParameters
+} from './native-region-scanner-core.js';
+
+function scanJavaScriptLike(input) {
+  const declarations = [];
+  let currentClass;
+  let classDepth = 0;
+  let currentObject;
+  const lexicalState = { inBlockComment: false, inTemplateString: false };
+  for (const { line, number } of sourceLines(input.sourceText)) {
+    const scanLine = jsDeclarationScanLine(line, lexicalState);
+    const trimmed = scanLine.trim();
+    if (!trimmed || jsCommentOnlyLine(trimmed)) continue;
+    const declarationLine = trimmed.replace(/^(?:export\s+)?(?:declare\s+)?/, '');
+    let match;
+    if (currentObject) {
+      const routeRecord = jsRouteRecordDeclaration(input, number, trimmed, currentObject);
+      if (routeRecord) {
+        declarations.push(routeRecord);
+      } else {
+        const property = jsObjectPropertyDeclaration(input, number, trimmed, currentObject);
+        if (property) declarations.push(property);
+      }
+    }
+    if ((match = trimmed.match(/^import\s+(?:.+?\s+from\s+)?['"]([^'"]+)['"]/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDeclaration', 'module'));
+    } else if ((match = trimmed.match(/^import\s*\(\s*['"]([^'"]+)['"]\s*\)/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'DynamicImportExpression', 'module'));
+    } else if ((match = trimmed.match(/^export\s+(?:\*\s+from|\{[^}]*\}\s+from)\s+['"]([^'"]+)['"]/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ExportFromDeclaration', 'module'));
+    } else if ((match = declarationLine.match(/^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)\s*\(([^)]*)\)/))) {
+      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, declarationLine.includes('{')));
+    } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*\(([^)]*)\)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ExportDefaultFunctionDeclaration', 'function', match[1] ?? 'default', { parameters: splitParameters(match[2]), exportDefault: true }, trimmed.includes('{')));
+    } else if ((match = declarationLine.match(/^(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ClassDeclaration', 'class', match[1], {}, declarationLine.includes('{')));
+      if (declarationLine.includes('{') && !declarationLine.includes('}')) {
+        currentClass = match[1];
+        classDepth = 0;
+      }
+    } else if ((match = declarationLine.match(/^interface\s+([A-Za-z_$][\w$]*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'InterfaceDeclaration', 'interface', match[1], {}, declarationLine.includes('{')));
+    } else if ((match = declarationLine.match(/^(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'EnumDeclaration', 'type', match[1], {}, declarationLine.includes('{')));
+    } else if ((match = declarationLine.match(/^(?:namespace|module)\s+([A-Za-z_$][\w$.]*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ModuleDeclaration', 'module', match[1], {}, declarationLine.includes('{')));
+    } else if ((match = declarationLine.match(/^type\s+([A-Za-z_$][\w$]*)\s*=/))) {
+      declarations.push(nativeDeclaration(input, number, 'TypeAliasDeclaration', 'type', match[1], {}, false));
+    } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(?([^=;]*)\)?\s*=>/))) {
+      declarations.push(nativeDeclaration(input, number, 'VariableFunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+    } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\b/))) {
+      const initializerKind = jsInitializerKind(declarationLine);
+      const regionKind = jsRegionKindForDeclarationName(match[1], declarationLine);
+      declarations.push(nativeDeclaration(input, number, 'VariableDeclaration', jsVariableSymbolKind(regionKind, initializerKind), match[1], {
+        initializerKind
+      }, jsVariableHasBody(initializerKind, declarationLine), {
+        regionKind,
+        metadata: { initializerKind }
+      }));
+      currentObject = jsObjectRegionContext(match[1], declarationLine, number, regionKind);
+    } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function\*?\s*\(([^)]*)\)/))) {
+      declarations.push(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+    } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/))) {
+      const regionKind = jsRegionKindForDeclarationName(match[1], trimmed);
+      declarations.push(nativeDeclaration(input, number, 'CommonJsExport', 'variable', match[1], { export: 'commonjs' }, false, { regionKind }));
+    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
+      declarations.push(nativeDeclaration(input, number, 'MethodDefinition', 'method', `${currentClass}.${match[1]}`, {
+        methodName: match[1],
+        owner: currentClass,
+        parameters: splitParameters(match[2])
+      }, declarationLine.includes('{') || declarationLine.includes('=>')));
+    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*([A-Za-z_$][\w$]*)\s*(?::\s*([^=;{]+))?(?:[=;]|$)/))) {
+      declarations.push(nativeDeclaration(input, number, 'PropertyDefinition', 'property', `${currentClass}.${match[1]}`, {
+        propertyName: match[1],
+        owner: currentClass,
+        valueType: match[2]?.trim()
+      }, false));
+    }
+    if (currentClass) {
+      classDepth += braceDelta(trimmed);
+      if (classDepth <= 0) {
+        currentClass = undefined;
+        classDepth = 0;
+      }
+    }
+    if (currentObject) {
+      if (number !== currentObject.startLine) currentObject.depth += jsContainerDelta(trimmed);
+      if (currentObject.depth <= 0) currentObject = undefined;
+    }
+  }
+  return declarations;
+}
+
+function jsCommentOnlyLine(trimmed) {
+  return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
+}
+
+function jsDeclarationScanLine(line, state) {
+  let text = String(line ?? '');
+  if (state.inTemplateString) {
+    const close = findUnescapedBacktick(text, 0);
+    if (close < 0) return '';
+    text = text.slice(close + 1);
+    state.inTemplateString = false;
+  }
+  if (state.inBlockComment) {
+    const close = text.indexOf('*/');
+    if (close < 0) return '';
+    text = text.slice(close + 2);
+    state.inBlockComment = false;
+  }
+  let output = '';
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (quote) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (char === '/' && next === '/') break;
+    if (char === '/' && next === '*') {
+      const close = text.indexOf('*/', index + 2);
+      if (close < 0) {
+        state.inBlockComment = true;
+        break;
+      }
+      index = close + 1;
+      continue;
+    }
+    if (char === '\'' || char === '"') {
+      quote = char;
+      output += char;
+      continue;
+    }
+    if (char === '`') {
+      const close = findUnescapedBacktick(text, index + 1);
+      if (close < 0) {
+        state.inTemplateString = true;
+        output += '``';
+        break;
+      }
+      output += text.slice(index, close + 1);
+      index = close;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+function findUnescapedBacktick(text, startIndex) {
+  let escaped = false;
+  for (let index = startIndex; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) {
+      escaped = false;
+    } else if (char === '\\') {
+      escaped = true;
+    } else if (char === '`') {
+      return index;
+    }
+  }
+  return -1;
+}
+
+function jsObjectRegionContext(name, declarationLine, lineNumber, regionKind) {
+  const initializerKind = jsInitializerKind(declarationLine);
+  if (initializerKind !== 'object' && initializerKind !== 'array') return undefined;
+  const depth = jsContainerDelta(declarationLine);
+  if (depth <= 0) return undefined;
+  return {
+    name,
+    regionKind: regionKind ?? jsRegionKindForDeclarationName(name, declarationLine),
+    initializerKind,
+    depth,
+    startLine: lineNumber
+  };
+}
+
+function jsInitializerKind(line) {
+  const initializer = String(line ?? '').split('=').slice(1).join('=').trim();
+  if (!initializer) return 'unknown';
+  if (/^(?:async\s+)?function\b/.test(initializer) || /=>/.test(initializer)) return 'function';
+  if (initializer.startsWith('{')) return 'object';
+  if (initializer.startsWith('[')) return 'array';
+  if (/^new\s+/.test(initializer)) return 'instance';
+  if (/^['"`]/.test(initializer)) return 'string';
+  if (/^(?:true|false)\b/.test(initializer)) return 'boolean';
+  if (/^[0-9]/.test(initializer)) return 'number';
+  return 'expression';
+}
+
+function jsVariableHasBody(initializerKind, declarationLine) {
+  return initializerKind === 'function'
+    || initializerKind === 'object'
+    || initializerKind === 'array'
+    || /\{/.test(String(declarationLine ?? ''));
+}
+
+function jsVariableSymbolKind(regionKind, initializerKind) {
+  if (regionKind === 'route') return 'route';
+  if (initializerKind === 'function') return 'function';
+  return 'variable';
+}
+
+function jsRegionKindForDeclarationName(name, source = '') {
+  const raw = `${name ?? ''} ${source ?? ''}`;
+  const text = raw.replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase();
+  const compact = raw.toLowerCase();
+  if (/\b(routes?|router|screens?|pages?|navigation|navitems?|menuitems?)\b/.test(text) || /(route|router|screen|page|navigation|navitem|menuitem)/.test(compact)) return 'route';
+  if (/\b(config|settings|options|flags?|schema|manifest|registry|catalog)\b/.test(text) || /(config|settings|options|flags|schema|manifest|registry|catalog)/.test(compact)) return 'config';
+  if (/\b(content|copy|docs?|legal|messages?|strings?|i18n|locale|translations?)\b/.test(text) || /(content|copy|docs|legal|messages|strings|i18n|locale|translations)/.test(compact)) return 'content';
+  return undefined;
+}
+
+function jsObjectPropertyDeclaration(input, lineNumber, trimmed, context) {
+  if (/^[}\])]/.test(trimmed) || trimmed.startsWith('...')) return undefined;
+  const methodMatch = trimmed.match(/^(?:(?:async|get|set)\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\s*\(([^)]*)\)\s*(?:[:\w\s<>\[\]]*)?(?:\{|=>|,|$)/);
+  if (methodMatch && !jsControlKeyword(methodMatch[2])) {
+    const name = `${context.name}.${methodMatch[2]}`;
+    return nativeDeclaration(input, lineNumber, 'ObjectMethod', 'function', name, {
+      owner: context.name,
+      propertyName: methodMatch[2],
+      parameters: splitParameters(methodMatch[3])
+    }, true, {
+      regionKind: jsPropertyRegionKind(context, methodMatch[2], 'function'),
+      metadata: { owner: context.name, propertyName: methodMatch[2], initializerKind: 'function' }
+    });
+  }
+  const propertyMatch = trimmed.match(/^(?:(['"])([^'"]+)\1|([A-Za-z_$][\w$-]*))\s*:\s*(.+?)(?:,)?$/);
+  if (!propertyMatch) return undefined;
+  const propertyName = propertyMatch[2] ?? propertyMatch[3];
+  if (!propertyName || jsControlKeyword(propertyName)) return undefined;
+  const value = propertyMatch[4].trim();
+  const initializerKind = jsPropertyInitializerKind(value);
+  const functionLike = initializerKind === 'function';
+  const name = `${context.name}.${propertyName}`;
+  return nativeDeclaration(input, lineNumber, functionLike ? 'ObjectFunctionProperty' : 'ObjectProperty', functionLike ? 'function' : 'property', name, {
+    owner: context.name,
+    propertyName,
+    initializerKind
+  }, functionLike || initializerKind === 'object' || initializerKind === 'array', {
+    regionKind: jsPropertyRegionKind(context, propertyName, value),
+    metadata: {
+      owner: context.name,
+      propertyName,
+      initializerKind
+    }
+  });
+}
+
+function jsRouteRecordDeclaration(input, lineNumber, trimmed, context) {
+  if (context.regionKind !== 'route') return undefined;
+  const match = trimmed.match(/\b(?:path|route|href|url)\s*:\s*(['"`])([^'"`]+)\1/);
+  if (!match) return undefined;
+  const routePath = match[2];
+  return nativeDeclaration(input, lineNumber, 'RouteRecord', 'route', `${context.name}.${routePath}`, {
+    owner: context.name,
+    routePath
+  }, true, {
+    regionKind: 'route',
+    metadata: { owner: context.name, routePath, initializerKind: 'object' }
+  });
+}
+
+function jsPropertyInitializerKind(value) {
+  const text = String(value ?? '').trim();
+  if (/^(?:async\s*)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/.test(text)) return 'function';
+  if (text.startsWith('{')) return 'object';
+  if (text.startsWith('[')) return 'array';
+  if (/^['"`]/.test(text)) return 'string';
+  if (/^(?:true|false)\b/.test(text)) return 'boolean';
+  if (/^[0-9]/.test(text)) return 'number';
+  return 'expression';
+}
+
+function jsPropertyRegionKind(context, propertyName, value) {
+  const named = jsRegionKindForDeclarationName(propertyName, value);
+  if (named) return named;
+  if (context.regionKind === 'route') return 'route';
+  if (context.regionKind === 'content') return 'content';
+  if (context.regionKind === 'config') return 'config';
+  return 'property';
+}
+
+function jsContainerDelta(source) {
+  let delta = 0;
+  for (const char of String(source ?? '')) {
+    if (char === '{' || char === '[') delta += 1;
+    if (char === '}' || char === ']') delta -= 1;
+  }
+  return delta;
+}
+
+export { scanJavaScriptLike };

package/dist/native-region-scanner-main.js

@@ -0,0 +1,301 @@
+import { idFragment, uniqueStrings, upperFirst } from './native-import-utils.js';
+import {
+  nativeDeclaration,
+  nativeImportDeclaration,
+  nativeMacroLoss,
+  sourceLines,
+  splitParameters,
+  splitTypeParameters
+} from './native-region-scanner-core.js';
+
+function scanPython(input) {
+  const declarations = [];
+  for (const { line, number } of sourceLines(input.sourceText)) {
+    const trimmed = line.trim();
+    let match;
+    if ((match = trimmed.match(/^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*:/))) {
+      declarations.push(nativeDeclaration(input, number, 'FunctionDef', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+    } else if ((match = trimmed.match(/^class\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ClassDef', 'class', match[1], {}, true));
+    } else if ((match = trimmed.match(/^(?:from\s+([A-Za-z_][\w.]*)\s+import\s+.+|import\s+([A-Za-z_][\w.]*))/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1] ?? match[2], 'Import', 'module'));
+    }
+  }
+  return declarations;
+}
+
+function scanRust(input) {
+  const declarations = [];
+  for (const { line, number } of sourceLines(input.sourceText)) {
+    const trimmed = line.trim();
+    let match;
+    if ((match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ItemFn', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ItemStruct', 'type', match[1], {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ItemEnum', 'type', match[1], {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ItemTrait', 'trait', match[1], {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^impl(?:\s*<[^>]+>)?\s+(.+?)\s*\{/))) {
+      declarations.push(nativeDeclaration(input, number, 'ItemImpl', 'implementation', idFragment(match[1]), { target: match[1].trim() }, true));
+    } else if ((match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?mod\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'ItemMod', 'module', match[1], {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^use\s+(.+?);/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ItemUse', 'module'));
+    } else if (/^[A-Za-z_]\w*!\s*[({[]/.test(trimmed)) {
+      declarations.push(nativeMacroLoss(input, number, trimmed, 'macroExpansion'));
+    }
+  }
+  return declarations;
+}
+
+function scanCLike(input) {
+  const declarations = [];
+  for (const { line, number } of sourceLines(input.sourceText)) {
+    const trimmed = line.trim();
+    let match;
+    if ((match = trimmed.match(/^#\s*include\s+[<"]([^>"]+)[>"]/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'IncludeDirective', 'header'));
+    } else if ((match = trimmed.match(/^#\s*define\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeMacroLoss(input, number, trimmed, 'preprocessor', match[1]));
+    } else if ((match = trimmed.match(/^typedef\s+struct(?:\s+([A-Za-z_]\w*))?/))) {
+      declarations.push(nativeDeclaration(input, number, 'TypedefStructDeclaration', 'type', match[1] ?? `anonymous_struct_${number}`, {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:struct|enum)\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'TagDeclaration', 'type', match[1], {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:[A-Za-z_][\w\s*:&<>]+)\s+([A-Za-z_]\w*)\s*\(([^;{}]*)\)\s*(?:;|\{)?$/))) {
+      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.endsWith('{')));
+    }
+  }
+  return declarations;
+}
+
+function scanJava(input) {
+  const declarations = [];
+  for (const { line, number } of sourceLines(input.sourceText)) {
+    const trimmed = line.trim();
+    let match;
+    if ((match = trimmed.match(/^package\s+([A-Za-z_][\w.]*);/))) {
+      declarations.push(nativeDeclaration(input, number, 'PackageDeclaration', 'package', match[1], {}, false));
+    } else if ((match = trimmed.match(/^import\s+(?:static\s+)?([A-Za-z_][\w.*]*);/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDeclaration', 'package'));
+    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|abstract|final|static|sealed|non-sealed)\s+)*(class|interface|enum|record|@interface)\s+([A-Za-z_$][\w$]*)/))) {
+      const kind = match[1] === '@interface' ? 'AnnotationDeclaration' : `${upperFirst(match[1])}Declaration`;
+      declarations.push(nativeDeclaration(input, number, kind, javaSymbolKind(match[1]), match[2], {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|abstract|final|static|synchronized|native)\s+)*(?:<[^>]+>\s+)?[A-Za-z_$][\w$<>\[\].?,\s]*\s+([A-Za-z_$][\w$]*)\s*\(([^)]*)\)\s*(?:throws\s+[^{]+)?(?:\{|;)?$/))) {
+      declarations.push(nativeDeclaration(input, number, 'MethodDeclaration', 'method', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{')));
+    }
+  }
+  return declarations;
+}
+
+function scanGo(input) {
+  const declarations = [];
+  let inImportBlock = false;
+  for (const { line, number } of sourceLines(input.sourceText)) {
+    const trimmed = line.trim();
+    let match;
+    if (inImportBlock) {
+      if (trimmed === ')') {
+        inImportBlock = false;
+      } else if ((match = trimmed.match(/^(?:(?:[A-Za-z_]\w*|[_.])\s+)?["']([^"']+)["']/))) {
+        declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportSpec', 'package'));
+      }
+      continue;
+    }
+    if ((match = trimmed.match(/^package\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'PackageClause', 'package', match[1], {}, false));
+    } else if (/^import\s*\(/.test(trimmed)) {
+      inImportBlock = true;
+    } else if ((match = trimmed.match(/^import\s+(?:(?:[A-Za-z_]\w*|[_.])\s+)?["']([^"']+)["']/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportSpec', 'package'));
+    } else if ((match = trimmed.match(/^type\s+([A-Za-z_]\w*)\s*=\s*(.+)$/))) {
+      declarations.push(nativeDeclaration(input, number, 'TypeAlias', 'type', match[1], { target: match[2].trim() }, false));
+    } else if ((match = trimmed.match(/^type\s+([A-Za-z_]\w*)\s+(struct|interface)\b/))) {
+      declarations.push(nativeDeclaration(input, number, match[2] === 'struct' ? 'TypeSpecStruct' : 'TypeSpecInterface', 'type', match[1], {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^func\s+\(([^)]*)\)\s*([A-Za-z_]\w*)(?:\s*\[([^\]]+)\])?\s*\(([^)]*)\)/))) {
+      const receiver = parseGoReceiver(match[1]);
+      declarations.push(nativeDeclaration(input, number, 'MethodDecl', 'method', goReceiverMethodName(receiver, match[2]), {
+        methodName: match[2],
+        receiver,
+        typeParameters: splitTypeParameters(match[3]),
+        parameters: splitParameters(match[4])
+      }, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^func\s+([A-Za-z_]\w*)(?:\s*\[([^\]]+)\])?\s*\(([^)]*)\)/))) {
+      declarations.push(nativeDeclaration(input, number, 'FuncDecl', 'function', match[1], {
+        typeParameters: splitTypeParameters(match[2]),
+        parameters: splitParameters(match[3])
+      }, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^var\s+([A-Za-z_]\w*)\b/))) {
+      declarations.push(nativeDeclaration(input, number, 'VarDecl', 'variable', match[1], {}, false));
+    } else if ((match = trimmed.match(/^const\s+([A-Za-z_]\w*)\b/))) {
+      declarations.push(nativeDeclaration(input, number, 'ConstDecl', 'constant', match[1], {}, false));
+    }
+  }
+  return declarations;
+}
+
+function scanSwift(input) {
+  const declarations = [];
+  const protocols = new Set();
+  for (const { line, number } of sourceLines(input.sourceText)) {
+    const trimmed = line.trim();
+    const declarationLine = trimmed.replace(/^(?:@[A-Za-z_][\w.]+(?:\([^)]*\))?\s+)*/, '');
+    let match;
+    if ((match = declarationLine.match(/^import\s+(?:(?:struct|class|enum|protocol|func|var)\s+)?([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDecl', 'module'));
+    } else if ((match = declarationLine.match(/^(?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open|final|indirect)\s+)*(struct|class|enum|protocol|actor)\s+([A-Za-z_]\w*)/))) {
+      if (match[1] === 'protocol') protocols.add(match[2]);
+      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[1])}Decl`, swiftSymbolKind(match[1]), match[2], {}, declarationLine.includes('{')));
+    } else if ((match = declarationLine.match(/^(?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open)\s+)*extension\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)(.*)$/))) {
+      const extensionFields = parseSwiftExtensionTail(match[2]);
+      const isProtocolExtension = protocols.has(match[1]) || /Protocol$/.test(match[1]);
+      declarations.push(nativeDeclaration(input, number, isProtocolExtension ? 'ProtocolExtensionDecl' : 'ExtensionDecl', 'implementation', `${match[1]}.${isProtocolExtension ? 'protocolExtension' : 'extension'}`, {
+        extendedType: match[1],
+        ...extensionFields
+      }, declarationLine.includes('{')));
+    } else if ((match = declarationLine.match(/^(?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open|static|class|mutating|nonmutating|override|required|convenience|isolated|nonisolated)\s+)*func\s+([A-Za-z_]\w*|`[^`]+`)(?:\s*<([^>]+)>)?\s*\(([^)]*)\)/))) {
+      declarations.push(nativeDeclaration(input, number, 'FunctionDecl', 'function', unquoteSwiftIdentifier(match[1]), {
+        typeParameters: splitTypeParameters(match[2]),
+        parameters: splitParameters(match[3])
+      }, declarationLine.includes('{')));
+    } else if ((match = declarationLine.match(/^(?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open|static|class|final|lazy|weak|unowned|override|required|nonisolated)\s+)*(let|var)\s+([A-Za-z_]\w*)\b(?::\s*([^={]+))?/))) {
+      declarations.push(nativeDeclaration(input, number, 'PropertyDecl', 'property', match[2], {
+        binding: match[1],
+        valueType: match[3]?.trim()
+      }, declarationLine.includes('{') || declarationLine.includes('=>')));
+    } else if ((match = declarationLine.match(/^(?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open)\s+)*typealias\s+([A-Za-z_]\w*)\b(?:\s*=\s*(.+))?/))) {
+      declarations.push(nativeDeclaration(input, number, 'TypealiasDecl', 'type', match[1], { target: match[2]?.trim() }, false));
+    }
+  }
+  return declarations;
+}
+
+function scanCSharp(input) {
+  const declarations = [];
+  for (const { line, number } of sourceLines(input.sourceText)) {
+    const trimmed = line.trim();
+    let match;
+    if ((match = trimmed.match(/^using\s+([A-Za-z_]\w*)\s*=\s*(.+?)\s*;/))) {
+      declarations.push(nativeDeclaration(input, number, 'UsingAliasDirective', 'type', match[1], { target: match[2].trim() }, false));
+    } else if ((match = trimmed.match(/^using\s+(?:static\s+)?([A-Za-z_][\w.]*)\s*;/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'UsingDirective', 'namespace'));
+    } else if ((match = trimmed.match(/^namespace\s+([A-Za-z_][\w.]*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'NamespaceDeclaration', 'namespace', match[1], {}, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|static|unsafe|new)\s+)*delegate\s+(.+?)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*;/))) {
+      declarations.push(nativeDeclaration(input, number, 'DelegateDeclaration', 'type', match[2], {
+        returnType: match[1].trim(),
+        parameters: splitParameters(match[3])
+      }, false));
+    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|abstract|sealed|static|partial|readonly|ref|unsafe)\s+)*(class|interface|struct|enum|record(?:\s+(?:class|struct))?)\s+([A-Za-z_]\w*)/))) {
+      declarations.push(nativeDeclaration(input, number, csharpDeclarationKind(match[1]), csharpSymbolKind(match[1]), match[2], { csharpKind: match[1].replace(/\s+/g, ' ') }, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|static|virtual|override|async|partial|sealed|abstract|extern|new|unsafe|readonly)\s+)*(?:[A-Za-z_][\w<>\[\].?,\s]*\??|void)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:=>.*|\{|;)?$/))) {
+      const parameters = splitParameters(match[2]);
+      const extensionReceiver = csharpExtensionReceiver(parameters);
+      declarations.push(nativeDeclaration(input, number, extensionReceiver ? 'ExtensionMethodDeclaration' : 'MethodDeclaration', 'method', match[1], {
+        parameters,
+        ...(extensionReceiver ? { extensionReceiver } : {})
+      }, trimmed.includes('{') || trimmed.includes('=>')));
+    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|static|virtual|override|abstract|sealed|new|unsafe)\s+)*event\s+(.+?)\s+([A-Za-z_]\w*)\s*(?:[;{=]|=>)/))) {
+      declarations.push(nativeDeclaration(input, number, 'EventDeclaration', 'event', match[2], {
+        eventType: match[1].trim(),
+        accessors: csharpAccessors(trimmed)
+      }, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|static|virtual|override|abstract|sealed|new|required|readonly|unsafe)\s+)*([A-Za-z_][\w<>\[\].?,\s]*\??)\s+([A-Za-z_]\w*)\s*(?:\{|=>)/))) {
+      declarations.push(nativeDeclaration(input, number, 'PropertyDeclaration', 'property', match[2], {
+        propertyType: match[1].trim(),
+        accessors: csharpAccessors(trimmed)
+      }, trimmed.includes('{') || trimmed.includes('=>')));
+    }
+  }
+  return declarations;
+}
+
+function parseGoReceiver(raw) {
+  const value = String(raw ?? '').trim();
+  const match = value.match(/^(?:(\w+)\s+)?(.+)$/);
+  const rawType = String(match?.[2] ?? value).trim();
+  return {
+    raw: value,
+    ...(match?.[1] ? { name: match[1] } : {}),
+    rawType,
+    type: normalizeGoReceiverType(rawType)
+  };
+}
+
+function normalizeGoReceiverType(rawType) {
+  return String(rawType ?? '')
+    .trim()
+    .replace(/^[*&\s]+/, '')
+    .replace(/\[[^\]]+\]/g, '')
+    .replace(/\s+/g, ' ');
+}
+
+function goReceiverMethodName(receiver, methodName) {
+  return receiver?.type ? `${receiver.type}.${methodName}` : methodName;
+}
+
+function parseSwiftExtensionTail(rawTail) {
+  let tail = String(rawTail ?? '').split('{')[0].trim();
+  const fields = {};
+  const whereMatch = tail.match(/\bwhere\b(.+)$/);
+  if (whereMatch) {
+    fields.constraints = whereMatch[1].trim();
+    tail = tail.slice(0, whereMatch.index).trim();
+  }
+  if (tail.startsWith(':')) {
+    fields.conformances = tail.slice(1).split(',').map((part) => part.trim()).filter(Boolean);
+  }
+  return fields;
+}
+
+function unquoteSwiftIdentifier(identifier) {
+  return String(identifier).replace(/^`|`$/g, '');
+}
+
+function javaSymbolKind(kind) {
+  if (kind === 'interface' || kind === '@interface') return 'interface';
+  if (kind === 'enum' || kind === 'record') return 'type';
+  return 'class';
+}
+
+function swiftSymbolKind(kind) {
+  if (kind === 'protocol') return 'protocol';
+  if (kind === 'extension') return 'implementation';
+  if (kind === 'struct' || kind === 'enum' || kind === 'actor') return 'type';
+  return 'class';
+}
+
+function csharpSymbolKind(kind) {
+  const normalized = String(kind).replace(/\s+/g, ' ');
+  if (normalized === 'interface') return 'interface';
+  if (normalized === 'struct' || normalized === 'enum' || normalized.startsWith('record')) return 'type';
+  return 'class';
+}
+
+function csharpDeclarationKind(kind) {
+  const normalized = String(kind).replace(/\s+/g, ' ');
+  if (normalized === 'record struct') return 'RecordStructDeclaration';
+  if (normalized === 'record class') return 'RecordClassDeclaration';
+  if (normalized === 'record') return 'RecordDeclaration';
+  return `${upperFirst(normalized)}Declaration`;
+}
+
+function csharpExtensionReceiver(parameters) {
+  const match = String(parameters?.[0] ?? '').match(/^this\s+(.+?)\s+([A-Za-z_]\w*)$/);
+  return match ? { type: match[1].trim(), name: match[2] } : undefined;
+}
+
+function csharpAccessors(source) {
+  return uniqueStrings([...String(source ?? '').matchAll(/\b(get|set|init|add|remove)\b/g)].map((match) => match[1]));
+}
+
+export {
+  scanCLike,
+  scanCSharp,
+  scanGo,
+  scanJava,
+  scanPython,
+  scanRust,
+  scanSwift
+};

package/dist/native-region-scanner.js

@@ -0,0 +1,62 @@
+import { scanJavaScriptLike } from './native-region-scanner-js.js';
+import {
+  scanCLike,
+  scanCSharp,
+  scanGo,
+  scanJava,
+  scanPython,
+  scanRust,
+  scanSwift
+} from './native-region-scanner-main.js';
+import {
+  scanDart,
+  scanKotlin,
+  scanLua,
+  scanPhp,
+  scanRuby,
+  scanScala,
+  scanShell,
+  scanSql,
+  scanZig
+} from './native-region-scanner-dynamic.js';
+import {
+  scanElixir,
+  scanErlang,
+  scanGenericDeclarations,
+  scanHaskell,
+  scanR
+} from './native-region-scanner-functional.js';
+export { lightweightCoverageLosses } from './native-region-scanner-core.js';
+export {
+  detectNewlineStyle,
+  scanPreservedSourceDirectives,
+  scanPreservedSourceTokens
+} from './native-source-preservation-scanner.js';
+
+function scanNativeDeclarations(input) {
+  const language = String(input.language).toLowerCase();
+  if (language === 'javascript' || language === 'typescript') return scanJavaScriptLike(input);
+  if (language === 'python') return scanPython(input);
+  if (language === 'rust') return scanRust(input);
+  if (language === 'c' || language === 'cpp' || language === 'c++') return scanCLike(input);
+  if (language === 'java') return scanJava(input);
+  if (language === 'go') return scanGo(input);
+  if (language === 'swift') return scanSwift(input);
+  if (language === 'csharp' || language === 'c#') return scanCSharp(input);
+  if (language === 'php') return scanPhp(input);
+  if (language === 'ruby' || language === 'rb') return scanRuby(input);
+  if (language === 'kotlin' || language === 'kt') return scanKotlin(input);
+  if (language === 'scala' || language === 'sc') return scanScala(input);
+  if (language === 'dart') return scanDart(input);
+  if (language === 'lua') return scanLua(input);
+  if (language === 'shell' || language === 'sh' || language === 'bash' || language === 'zsh') return scanShell(input);
+  if (language === 'sql' || language === 'postgresql' || language === 'postgres' || language === 'mysql' || language === 'sqlite') return scanSql(input);
+  if (language === 'zig') return scanZig(input);
+  if (language === 'elixir' || language === 'ex' || language === 'exs') return scanElixir(input);
+  if (language === 'erlang' || language === 'erl' || language === 'hrl') return scanErlang(input);
+  if (language === 'haskell' || language === 'hs') return scanHaskell(input);
+  if (language === 'r') return scanR(input);
+  return scanGenericDeclarations(input);
+}
+
+export { scanNativeDeclarations };