@shapeshift-labs/frontier-lang-compiler 0.2.102 → 0.2.104

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

@@ -1,5 +1,5 @@
-import { nativeDeclaration } from './native-region-scanner-core.js';
-import { jsContainerDelta, jsRegionKindForDeclarationName } from './native-region-scanner-js-helpers.js';
+import { jsControlKeyword, nativeDeclaration, splitParameters } from './native-region-scanner-core.js';
+import { jsContainerDelta, jsContainerInitializerKind, jsRegionKindForDeclarationName } from './native-region-scanner-js-helpers.js';
 
 function jsCurrentObjectContext(stack) {
   return stack[stack.length - 1];
@@ -9,6 +9,21 @@ function jsContextAllowsPropertyScan(context) {
   return context?.initializerKind === 'object';
 }
 
+function jsArrayObjectContextFromLine(context, lineNumber, source) {
+  if (context?.initializerKind !== 'array' || context.arrayRecords !== true || !String(source ?? '').trim().startsWith('{')) return undefined;
+  const depth = jsContainerDelta(source);
+  if (depth <= 0) return undefined;
+  const index = (context.nextItemIndex ?? 0) + 1;
+  context.nextItemIndex = index;
+  return { name: `${context.name}.${index}`, ownerName: context.name, regionKind: context.regionKind, initializerKind: 'object', arrayItem: true, depth, startLine: lineNumber };
+}
+
+function updateJsArrayObjectContextName(context, source) {
+  if (!context?.arrayItem) return;
+  const match = String(source ?? '').trim().match(/^(?:name|id|key|slug|tool|command)\s*:\s*(['"`])([^'"`]+)\1/);
+  if (match) context.name = `${context.ownerName}.${match[2]}`;
+}
+
 function jsNestedObjectContextFromDeclaration(declaration, lineNumber, source) {
   const initializerKind = declaration?.fields?.initializerKind ?? declaration?.metadata?.initializerKind;
   if (initializerKind !== 'object' && initializerKind !== 'array') return undefined;
@@ -32,9 +47,9 @@ function jsInlineNestedObjectDeclarations(input, lineNumber, source, parentDecla
   for (const entry of splitTopLevelEntries(body)) {
     const parsed = parseObjectEntry(entry);
     if (!parsed) continue;
-    const initializerKind = nestedInitializerKind(parsed.value);
+    const initializerKind = parsed.method ? 'function' : nestedInitializerKind(parsed.value);
     const name = `${parentDeclaration.name}.${parsed.key}`;
-    const regionKind = nestedPropertyRegionKind(parentDeclaration, parsed.key, parsed.value);
+    const regionKind = initializerKind === 'function' ? 'body' : nestedPropertyRegionKind(parentDeclaration, parsed.key, parsed.value);
     const declaration = nativeDeclaration(input, lineNumber, initializerKind === 'function' ? 'NestedObjectFunctionProperty' : 'NestedObjectProperty', initializerKind === 'function' ? 'function' : 'property', name, {
       owner: parentDeclaration.name,
       propertyName: parsed.key,
@@ -57,6 +72,73 @@ function updateJsObjectContextStack(stack, lineNumber, source) {
   while (stack.length && stack[stack.length - 1].depth <= 0) stack.pop();
 }
 
+function jsObjectPropertyDeclaration(input, lineNumber, trimmed, context) {
+  if (/^[}\])]/.test(trimmed) || trimmed.startsWith('...')) return undefined;
+  const methodMatch = trimmed.match(/^(?:(?:async|get|set)\s+)?(?:\[\s*(['"`])([^'"`]+)\1\s*\]|(['"`]?)([A-Za-z_$][\w$-]*)\3)\s*\(([^)]*)\)\s*(?:[:\w\s<>\[\]]*)?(?:\{|=>|,|$)/);
+  const methodName = methodMatch?.[2] ?? methodMatch?.[4];
+  if (methodMatch && !jsControlKeyword(methodName)) {
+    const name = `${context.name}.${methodName}`;
+    return nativeDeclaration(input, lineNumber, 'ObjectMethod', 'function', name, {
+      owner: context.name,
+      propertyName: methodName,
+      parameters: splitParameters(methodMatch[5])
+    }, true, {
+      regionKind: 'body',
+      metadata: { owner: context.name, propertyName: methodName, initializerKind: 'function' }
+    });
+  }
+  const propertyMatch = trimmed.match(/^(?:\[\s*(['"`])([^'"`]+)\1\s*\]|(['"`])([^'"`]+)\3|([A-Za-z_$][\w$-]*))\s*:\s*(.+?)(?:,)?$/);
+  if (!propertyMatch) return undefined;
+  const propertyName = propertyMatch[2] ?? propertyMatch[4] ?? propertyMatch[5];
+  if (!propertyName || jsControlKeyword(propertyName)) return undefined;
+  const value = propertyMatch[6].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: functionLike ? 'body' : 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(/^(?:\{\s*)?(?: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';
+  const containerKind = jsContainerInitializerKind(text, undefined, text);
+  if (containerKind) return containerKind;
+  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 inlineObjectBody(source) {
   const text = String(source ?? '');
   const open = text.indexOf('{');
@@ -113,10 +195,12 @@ function splitTopLevelEntries(body) {
 }
 
 function parseObjectEntry(entry) {
-  if (!entry || entry.startsWith('...') || entry.startsWith('[')) return undefined;
-  const match = entry.match(/^(?:(['"])([^'"]+)\1|([A-Za-z_$][\w$-]*))\s*:\s*(.+)$/s);
-  if (!match) return undefined;
-  return { key: match[2] ?? match[3], value: match[4].trim() };
+  if (!entry || entry.startsWith('...')) return undefined;
+  const match = entry.match(/^(?:\[\s*(['"`])([^'"`]+)\1\s*\]|(['"`])([^'"`]+)\3|([A-Za-z_$][\w$-]*))\s*:\s*(.+)$/s);
+  if (match) return { key: match[2] ?? match[4] ?? match[5], value: match[6].trim() };
+  const methodMatch = entry.match(/^(?:(?:async|get|set)\s+)?(?:\[\s*(['"`])([^'"`]+)\1\s*\]|(['"`]?)([A-Za-z_$][\w$-]*)\3)\s*\(([^)]*)\)\s*(?:[:\w\s<>\[\]]*)?(?:\{|=>|$)/s);
+  if (!methodMatch) return undefined;
+  return { key: methodMatch[2] ?? methodMatch[4], value: entry.trim(), method: true };
 }
 
 function nestedInitializerKind(value) {
@@ -139,9 +223,13 @@ function nestedPropertyRegionKind(parentDeclaration, propertyName, value) {
 }
 
 export {
+  jsArrayObjectContextFromLine,
   jsContextAllowsPropertyScan,
   jsCurrentObjectContext,
   jsInlineNestedObjectDeclarations,
   jsNestedObjectContextFromDeclaration,
+  jsObjectPropertyDeclaration,
+  jsRouteRecordDeclaration,
+  updateJsArrayObjectContextName,
   updateJsObjectContextStack
 };

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

@@ -0,0 +1,27 @@
+function jsStructureDelta(source) {
+  let value = 0;
+  let opened = false;
+  let quote;
+  let escaped = false;
+  for (const char of String(source ?? '')) {
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') {
+      value += 1;
+      opened = true;
+    } else if (char === '}' || char === ']' || char === ')') {
+      value -= 1;
+    }
+  }
+  return { value, opened };
+}
+
+export { jsStructureDelta };

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

@@ -0,0 +1,99 @@
+import {
+  jsControlKeyword,
+  nativeDeclaration,
+  nativeSignatureDeclaration,
+  splitParameters
+} from './native-region-scanner-core.js';
+import { jsRegionKindForDeclarationName } from './native-region-scanner-js-helpers.js';
+import { jsStructureDelta } from './native-region-scanner-js-structure.js';
+
+function jsTypeRegionContext(name, declarationLine, lineNumber, regionKind, typeKind) {
+  const depth = jsStructureDelta(declarationLine).value;
+  if (depth <= 0) return undefined;
+  return {
+    name,
+    typeKind,
+    regionKind,
+    depth,
+    startLine: lineNumber,
+    memberStack: []
+  };
+}
+
+function jsCurrentTypeMemberContext(context) {
+  return context.memberStack.at(-1) ?? context;
+}
+
+function updateJsTypeRegionContext(context, lineNumber, source) {
+  const delta = jsStructureDelta(source).value;
+  context.depth += delta;
+  for (const memberContext of context.memberStack) {
+    if (memberContext.startLine !== lineNumber) memberContext.depth += delta;
+  }
+  while (context.memberStack.length && context.memberStack.at(-1).depth <= 0) context.memberStack.pop();
+}
+
+function jsTypeMemberDeclaration(input, lineNumber, declarationLine, context) {
+  const text = String(declarationLine ?? '').trim();
+  if (!text || /^[}\])]/.test(text) || text.startsWith('//')) return undefined;
+  let match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*([^;,]+))?[;,]?$/);
+  if (match && !jsControlKeyword(match[2])) {
+    return nativeSignatureDeclaration(input, lineNumber, 'TypeMethodSignature', 'method', `${context.name}.${match[2]}`, {
+      owner: context.name,
+      propertyName: match[2],
+      parameters: splitParameters(match[3]),
+      returnType: match[4]?.trim(),
+      typeKind: context.typeKind
+    }, false, {
+      regionKind: jsTypeMemberRegionKind(context, match[2], text),
+      metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
+    });
+  }
+  match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*:\s*(.+?)[;,]?$/);
+  if (!match || jsControlKeyword(match[2])) return undefined;
+  const valueType = match[3].trim();
+  const functionLike = /=>/.test(valueType) || /^\([^)]*\)\s*=>/.test(valueType);
+  const hasNestedTypeLiteralBody = jsTypeMemberValueStartsTypeLiteral(valueType) && jsStructureDelta(text).value > 0;
+  return (functionLike ? nativeSignatureDeclaration : nativeDeclaration)(input, lineNumber, functionLike ? 'TypeFunctionPropertySignature' : 'TypePropertySignature', functionLike ? 'function' : 'property', `${context.name}.${match[2]}`, {
+    owner: context.name,
+    propertyName: match[2],
+    valueType,
+    typeKind: context.typeKind
+  }, hasNestedTypeLiteralBody, {
+    regionKind: jsTypeMemberRegionKind(context, match[2], text),
+    metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
+  });
+}
+
+function jsNestedTypeMemberContextFromDeclaration(declaration, lineNumber, source, parentContext) {
+  if (!declaration) return undefined;
+  const depth = jsStructureDelta(source).value;
+  if (depth <= 0) return undefined;
+  const valueType = declaration.fields?.valueType ?? declaration.fields?.returnType;
+  const nestedTypeLiteral = jsTypeMemberValueStartsTypeLiteral(valueType);
+  return {
+    name: nestedTypeLiteral ? declaration.name : parentContext.name,
+    typeKind: parentContext.typeKind,
+    regionKind: nestedTypeLiteral ? (declaration.regionKind ?? 'property') : parentContext.regionKind,
+    depth,
+    startLine: lineNumber,
+    suppressMembers: !nestedTypeLiteral
+  };
+}
+
+function jsTypeMemberValueStartsTypeLiteral(valueType) {
+  const text = String(valueType ?? '').trim();
+  return text.startsWith('{') || /=>\s*\{\s*$/.test(text);
+}
+
+function jsTypeMemberRegionKind(context, propertyName) {
+  return jsRegionKindForDeclarationName(propertyName) ?? (context.regionKind === 'type' ? 'property' : context.regionKind) ?? 'property';
+}
+
+export {
+  jsCurrentTypeMemberContext,
+  jsNestedTypeMemberContextFromDeclaration,
+  jsTypeMemberDeclaration,
+  jsTypeRegionContext,
+  updateJsTypeRegionContext
+};

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

@@ -1,40 +1,49 @@
 import {
   braceDelta,
-  jsControlKeyword,
-  nativeDeclaration,
-  nativeImportDeclaration,
+  nativeDeclaration, nativeImportDeclaration, nativeSignatureDeclaration,
   sourceLines,
   splitParameters
 } from './native-region-scanner-core.js';
 import {
   jsCommentOnlyLine,
-  jsContainerDelta,
   jsDeclarationScanLine,
-  jsExportAliasDeclaration,
+  jsExportAliasDeclaration, jsExportDeclarations,
   jsExportedContainerDeclaration,
   jsExportedFunctionWrapperDeclaration,
   jsInitializerKind,
   jsImportDeclarations,
-  jsObjectPropertyDeclaration,
   jsObjectRegionContext,
   jsRegionKindForDeclarationName,
-  jsRouteRecordDeclaration,
   jsVariableHasBody,
   jsVariableSymbolKind
 } from './native-region-scanner-js-helpers.js';
+import { jsStructureDelta } from './native-region-scanner-js-structure.js';
 import {
-  jsContextAllowsPropertyScan,
-  jsCurrentObjectContext,
-  jsInlineNestedObjectDeclarations,
-  jsNestedObjectContextFromDeclaration,
-  updateJsObjectContextStack
+  jsCurrentTypeMemberContext,
+  jsNestedTypeMemberContextFromDeclaration,
+  jsTypeMemberDeclaration,
+  jsTypeRegionContext,
+  updateJsTypeRegionContext
+} from './native-region-scanner-js-types.js';
+import {
+  jsArrayObjectContextFromLine, jsContextAllowsPropertyScan, jsCurrentObjectContext,
+  jsInlineNestedObjectDeclarations, jsNestedObjectContextFromDeclaration,
+  jsObjectPropertyDeclaration, jsRouteRecordDeclaration,
+  updateJsArrayObjectContextName, updateJsObjectContextStack
 } from './native-region-scanner-js-nested.js';
+import {
+  jsClassMemberDeclaration,
+  jsInlineClassMemberDeclarations
+} from './native-region-scanner-js-class.js';
 
 function scanJavaScriptLike(input) {
   const declarations = [];
   const lines = sourceLines(input.sourceText);
   const pushDeclaration = (declaration) => {
-    if (declaration) declarations.push(jsDeclarationWithSourceSpan(input, declaration, lines));
+    if (!declaration) return undefined;
+    const declarationWithSpan = jsDeclarationWithSourceSpan(input, declaration, lines);
+    declarations.push(declarationWithSpan);
+    return declarationWithSpan;
   };
   const pushDeclarations = (items) => {
     for (const declaration of items ?? []) pushDeclaration(declaration);
@@ -51,14 +60,22 @@ function scanJavaScriptLike(input) {
     const declarationLine = trimmed.replace(/^(?:export\s+)?(?:declare\s+)?/, '');
     let match;
     if (currentType && number !== currentType.startLine) {
-      pushDeclaration(jsTypeMemberDeclaration(input, number, declarationLine, currentType));
+      const typeContext = jsCurrentTypeMemberContext(currentType);
+      if (!typeContext.suppressMembers) {
+        const typeMember = pushDeclaration(jsTypeMemberDeclaration(input, number, declarationLine, typeContext));
+        const nestedTypeContext = jsNestedTypeMemberContextFromDeclaration(typeMember, number, declarationLine, typeContext);
+        if (nestedTypeContext) currentType.memberStack.push(nestedTypeContext);
+      }
     }
     const currentObject = jsCurrentObjectContext(objectStack);
     if (currentObject) {
+      const arrayItemContext = jsArrayObjectContextFromLine(currentObject, number, trimmed);
+      if (arrayItemContext) objectStack.push(arrayItemContext);
       const routeRecord = jsRouteRecordDeclaration(input, number, trimmed, currentObject);
       if (routeRecord) {
         pushDeclaration(routeRecord);
       } else if (jsContextAllowsPropertyScan(currentObject)) {
+        updateJsArrayObjectContextName(currentObject, trimmed);
         const property = jsObjectPropertyDeclaration(input, number, trimmed, currentObject);
         if (property) {
           pushDeclaration(property);
@@ -74,9 +91,15 @@ function scanJavaScriptLike(input) {
     } else if ((match = trimmed.match(/^import\s*\(\s*['"]([^'"]+)['"]\s*\)/))) {
       pushDeclaration(nativeImportDeclaration(input, number, match[1], 'DynamicImportExpression', 'module'));
     } else if ((match = declarationLine.match(/^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?/))) {
-      pushDeclaration(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, declarationLine.includes('{')));
+      const hasBody = declarationLine.includes('{');
+      pushDeclaration((hasBody ? nativeDeclaration : nativeSignatureDeclaration)(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, hasBody));
     } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?/))) {
       pushDeclaration(nativeDeclaration(input, number, 'ExportDefaultFunctionDeclaration', 'function', match[1] ?? 'default', { parameters: splitParameters(match[2]), exportDefault: true }, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s*)?(?:<[^=]+>\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'ExportDefaultArrowFunctionDeclaration', 'function', 'default', {
+        parameters: splitParameters(match[1] ?? match[2]),
+        exportDefault: true
+      }, true));
     } else if ((match = declarationLine.match(/^(default\s+)?(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/)) && (match[1] || match[2])) {
       const className = match[2] ?? 'default';
       const exportDefault = Boolean(match[1]);
@@ -121,24 +144,43 @@ function scanJavaScriptLike(input) {
       if (match.context) objectStack.push(match.context);
     } else if ((match = jsExportAliasDeclaration(input, number, trimmed))) {
       pushDeclaration(match);
+    } else if ((match = trimmed.match(/^module\.exports\s*=\s*(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*(?:<[^({;]+>)?\s*\(([^)]*)\)/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsDefaultFunctionExport', 'function', match[1] ?? 'module.exports', {
+        export: 'commonjs',
+        parameters: splitParameters(match[2])
+      }, true));
+    } else if ((match = trimmed.match(/^module\.exports\s*=\s*(?:async\s*)?(?:<[^=]+>\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsDefaultArrowFunctionExport', 'function', 'module.exports', {
+        export: 'commonjs',
+        parameters: splitParameters(match[1] ?? match[2])
+      }, true));
+    } else if ((match = trimmed.match(/^module\.exports\s*=\s*(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/))) {
+      const className = match[1] ?? 'module.exports';
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsDefaultClassExport', 'class', className, { export: 'commonjs' }, trimmed.includes('{')));
+      pushDeclarations(jsInlineClassMemberDeclarations(input, number, trimmed, className));
+      if (jsStructureDelta(trimmed).value > 0) {
+        currentClass = className;
+        classDepth = 0;
+      }
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function\*?\s*\(([^)]*)\)/))) {
       pushDeclaration(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+    } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:<[^=]+>\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, true));
+    } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/))) {
+      const className = match[2] ?? match[1];
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsClassExport', 'class', className, { export: 'commonjs', exportName: match[1] }, trimmed.includes('{')));
+      pushDeclarations(jsInlineClassMemberDeclarations(input, number, trimmed, className));
+      if (jsStructureDelta(trimmed).value > 0) {
+        currentClass = className;
+        classDepth = 0;
+      }
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/))) {
       const regionKind = jsRegionKindForDeclarationName(match[1], trimmed);
       pushDeclaration(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*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
-      pushDeclaration(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*([^=;{]+))?(?:[=;]|$)/))) {
-      pushDeclaration(nativeDeclaration(input, number, 'PropertyDefinition', 'property', `${currentClass}.${match[1]}`, {
-        propertyName: match[1],
-        owner: currentClass,
-        valueType: match[2]?.trim()
-      }, false, { regionKind: 'property' }));
+    } else if (currentClass) {
+      pushDeclaration(jsClassMemberDeclaration(input, number, declarationLine, currentClass));
     }
+    pushDeclarations(jsExportDeclarations(input, number, trimmed));
     if (currentClass) {
       classDepth += braceDelta(trimmed);
       if (classDepth <= 0) {
@@ -147,7 +189,7 @@ function scanJavaScriptLike(input) {
       }
     }
     if (currentType) {
-      if (number !== currentType.startLine) currentType.depth += jsStructureDelta(trimmed).value;
+      if (number !== currentType.startLine) updateJsTypeRegionContext(currentType, number, trimmed);
       if (currentType.depth <= 0) currentType = undefined;
     }
     updateJsObjectContextStack(objectStack, number, trimmed);
@@ -192,94 +234,4 @@ function jsBalancedDeclarationEndLine(input, lines, startLine) {
   return startLine;
 }
 
-function jsStructureDelta(source) {
-  let value = 0;
-  let opened = false;
-  let quote;
-  let escaped = false;
-  for (const char of String(source ?? '')) {
-    if (quote) {
-      if (escaped) escaped = false;
-      else if (char === '\\') escaped = true;
-      else if (char === quote) quote = undefined;
-      continue;
-    }
-    if (char === '\'' || char === '"' || char === '`') {
-      quote = char;
-      continue;
-    }
-    if (char === '{' || char === '[' || char === '(') {
-      value += 1;
-      opened = true;
-    } else if (char === '}' || char === ']' || char === ')') {
-      value -= 1;
-    }
-  }
-  return { value, opened };
-}
-
-function jsTypeRegionContext(name, declarationLine, lineNumber, regionKind, typeKind) {
-  const depth = jsStructureDelta(declarationLine).value;
-  if (depth <= 0) return undefined;
-  return {
-    name,
-    typeKind,
-    regionKind,
-    depth,
-    startLine: lineNumber
-  };
-}
-
-function jsTypeMemberDeclaration(input, lineNumber, declarationLine, context) {
-  const text = String(declarationLine ?? '').trim();
-  if (!text || /^[}\])]/.test(text) || text.startsWith('//')) return undefined;
-  let match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*([^;,]+))?[;,]?$/);
-  if (match && !jsControlKeyword(match[2])) {
-    return nativeDeclaration(input, lineNumber, 'TypeMethodSignature', 'method', `${context.name}.${match[2]}`, {
-      owner: context.name,
-      propertyName: match[2],
-      parameters: splitParameters(match[3]),
-      returnType: match[4]?.trim(),
-      typeKind: context.typeKind
-    }, false, {
-      regionKind: jsTypeMemberRegionKind(context, match[2], text),
-      metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
-    });
-  }
-  match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*:\s*(.+?)[;,]?$/);
-  if (!match || jsControlKeyword(match[2])) return undefined;
-  const valueType = match[3].trim();
-  const functionLike = /=>/.test(valueType) || /^\([^)]*\)\s*=>/.test(valueType);
-  return nativeDeclaration(input, lineNumber, functionLike ? 'TypeFunctionPropertySignature' : 'TypePropertySignature', functionLike ? 'function' : 'property', `${context.name}.${match[2]}`, {
-    owner: context.name,
-    propertyName: match[2],
-    valueType,
-    typeKind: context.typeKind
-  }, false, {
-    regionKind: jsTypeMemberRegionKind(context, match[2], text),
-    metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
-  });
-}
-
-function jsTypeMemberRegionKind(context, propertyName, source) {
-  return jsRegionKindForDeclarationName(propertyName, source) ?? (context.regionKind === 'type' ? 'property' : context.regionKind) ?? 'property';
-}
-
-function jsInlineClassMemberDeclarations(input, lineNumber, declarationLine, className) {
-  const open = declarationLine.indexOf('{');
-  const close = declarationLine.lastIndexOf('}');
-  if (open < 0 || close <= open) return [];
-  const body = declarationLine.slice(open + 1, close);
-  const declarations = [];
-  for (const match of body.matchAll(/(?:(?: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*(?::\s*[^={;]+)?\s*(?:\{|=>)/g)) {
-    if (jsControlKeyword(match[1])) continue;
-    declarations.push(nativeDeclaration(input, lineNumber, 'MethodDefinition', 'method', `${className}.${match[1]}`, {
-      methodName: match[1],
-      owner: className,
-      parameters: splitParameters(match[2])
-    }, true));
-  }
-  return declarations;
-}
-
 export { scanJavaScriptLike };

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

@@ -0,0 +1,94 @@
+import { upperFirst } from './native-import-utils.js';
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters } from './native-region-scanner-core.js';
+import { braceBlockSpan } from './native-region-scanner-spans.js';
+
+function scanKotlin(input) {
+  const declarations = [];
+  const lines = sourceLines(input.sourceText);
+  const blockStack = [];
+  let braceDepth = 0;
+  for (const [index, { line, number }] of lines.entries()) {
+    const trimmed = line.trim();
+    const lineStartDepth = depthAfterLeadingClosers(trimmed, braceDepth);
+    while (blockStack.length && blockStack[blockStack.length - 1].bodyDepth > lineStartDepth) blockStack.pop();
+    let match;
+    if ((match = trimmed.match(/^package\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'PackageHeader', 'package', match[1], {}, false));
+    } else if ((match = trimmed.match(/^import\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\.\*)?)(?:\s+as\s+[A-Za-z_]\w*)?$/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDirective', 'package'));
+    } else if ((match = trimmed.match(/^(?:(?:public|private|protected|internal|expect|actual|open|final|abstract|sealed|data|value)\s+)*(?:(enum|annotation)\s+)?(class|interface|object)\s+([A-Za-z_]\w*)/))) {
+      const owner = nearestContainer(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, kotlinDeclarationKind(match[2], match[1]), kotlinSymbolKind(match[2], match[1]), name, owner ? { owner: owner.name } : {}, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: match[2], name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^(?:(?:public|private|protected|internal|expect|actual|open|final|abstract|inline|tailrec|operator|infix|external|suspend|override)\s+)*fun\s+(?:<[^>]+>\s*)?(?:([A-Za-z_][\w.<>?]*)\.)?([A-Za-z_]\w*)\s*\(([^)]*)\)/))) {
+      const owner = nearestContainer(blockStack);
+      const receiverType = match[1];
+      const target = kotlinFunctionTarget(owner, receiverType, match[2]);
+      const hasBody = trimmed.includes('{') || trimmed.includes('=');
+      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', target.owner ? 'method' : 'function', target.name, {
+        parameters: splitParameters(match[3]),
+        methodName: match[2],
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {}),
+        ...(receiverType ? { receiverType } : {})
+      }, hasBody, {
+        ...spanOptions(input, lines, index, trimmed.includes('{')),
+        metadata: {
+          methodName: match[2],
+          ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {}),
+          ...(receiverType ? { receiverType } : {})
+        }
+      }));
+      if (trimmed.includes('{')) blockStack.push({ kind: 'function', name: target.name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^(?:(?:public|private|protected|internal|expect|actual)\s+)*typealias\s+([A-Za-z_]\w*)\s*=/))) {
+      declarations.push(nativeDeclaration(input, number, 'TypeAliasDeclaration', 'type', match[1], {}, false));
+    } else if ((match = trimmed.match(/^(?:(?:public|private|protected|internal|expect|actual|open|final|abstract|override|const|lateinit)\s+)*(?:val|var)\s+([A-Za-z_]\w*)\b/))) {
+      declarations.push(nativeDeclaration(input, number, 'PropertyDeclaration', 'variable', match[1], {}, false));
+    }
+    braceDepth = Math.max(0, braceDepth + braceDelta(line));
+  }
+  return declarations;
+}
+
+function spanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
+}
+
+function depthAfterLeadingClosers(trimmed, depth) {
+  const closers = String(trimmed).match(/^}+/)?.[0].length ?? 0;
+  return Math.max(0, depth - closers);
+}
+
+function nearestContainer(blockStack) {
+  for (let index = blockStack.length - 1; index >= 0; index -= 1) {
+    if (blockStack[index].kind === 'function') return undefined;
+    if (blockStack[index].kind === 'class' || blockStack[index].kind === 'interface' || blockStack[index].kind === 'object') return blockStack[index];
+  }
+  return undefined;
+}
+
+function kotlinFunctionTarget(owner, receiverType, methodName) {
+  if (receiverType) return { name: `${receiverType}.extension.${methodName}`, owner: receiverType, receiverKind: 'extension' };
+  if (owner) return { name: `${owner.name}.${methodName}`, owner: owner.name, receiverKind: 'member' };
+  return { name: methodName };
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+function kotlinDeclarationKind(kind, prefix) {
+  if (prefix === 'enum') return 'EnumClassDeclaration';
+  if (prefix === 'annotation') return 'AnnotationClassDeclaration';
+  return `${upperFirst(kind)}Declaration`;
+}
+
+function kotlinSymbolKind(kind, prefix) {
+  if (kind === 'interface') return 'interface';
+  if (kind === 'object') return 'module';
+  if (prefix === 'enum' || prefix === 'annotation') return 'type';
+  return 'class';
+}
+
+export { scanKotlin };