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

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

@@ -0,0 +1,80 @@
+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 scanPhp(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().replace(/^<\?php\s*/, '');
+    const lineStartDepth = depthAfterLeadingClosers(trimmed, braceDepth);
+    while (blockStack.length && blockStack[blockStack.length - 1].bodyDepth > lineStartDepth) blockStack.pop();
+
+    let match;
+    if ((match = trimmed.match(/^namespace\s+([A-Za-z_][\w\\]*)\s*;/))) {
+      declarations.push(nativeDeclaration(input, number, 'NamespaceDefinition', 'namespace', match[1], {}, false));
+    } else if ((match = trimmed.match(/^use\s+([A-Za-z_][\w\\]*)(?:\s+as\s+([A-Za-z_]\w*))?\s*;/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'UseDeclaration', 'namespace'));
+    } else if ((match = trimmed.match(/^(?:(?:abstract|final|readonly)\s+)*(class|interface|trait|enum)\s+([A-Za-z_]\w*)/))) {
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[1])}Declaration`, phpSymbolKind(match[1]), match[2], {}, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: match[1], name: match[2], bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^((?:(?:public|protected|private|static|final|abstract)\s+)*)function\s+&?\s*([A-Za-z_]\w*)\s*\(([^)]*)\)/))) {
+      const owner = nearestContainer(blockStack);
+      const target = phpFunctionTarget(owner, match[1], match[2]);
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', target.owner ? 'method' : 'function', target.name, {
+        parameters: splitParameters(match[3]),
+        ...(target.owner ? { owner: target.owner, methodName: match[2], receiverKind: target.receiverKind } : {}),
+        ...(match[1].trim() ? { modifiers: splitParameters(match[1].trim().replace(/\s+/g, ',')) } : {})
+      }, hasBody, {
+        ...spanOptions(input, lines, index, hasBody),
+        metadata: {
+          ...(target.owner ? { owner: target.owner, methodName: match[2], receiverKind: target.receiverKind } : {}),
+          ...(match[1].trim() ? { modifiers: splitParameters(match[1].trim().replace(/\s+/g, ',')) } : {})
+        }
+      }));
+      if (hasBody) blockStack.push({ kind: 'function', name: target.name, bodyDepth: braceDepth + 1 });
+    }
+    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 (['class', 'interface', 'trait', 'enum'].includes(blockStack[index].kind)) return blockStack[index];
+  }
+  return undefined;
+}
+
+function phpFunctionTarget(owner, modifiers, methodName) {
+  if (!owner) return { name: methodName };
+  const receiverKind = /\bstatic\b/.test(modifiers) ? 'static' : 'instance';
+  return { name: receiverKind === 'static' ? `${owner.name}.static.${methodName}` : `${owner.name}.${methodName}`, owner: owner.name, receiverKind };
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+function phpSymbolKind(kind) {
+  if (kind === 'interface') return 'interface';
+  if (kind === 'trait') return 'trait';
+  if (kind === 'enum') return 'type';
+  return 'class';
+}
+
+export { scanPhp };

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

@@ -0,0 +1,62 @@
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters } from './native-region-scanner-core.js';
+import { pythonBlockSpan } from './native-region-scanner-spans.js';
+
+function scanPython(input) {
+  const declarations = [];
+  const lines = sourceLines(input.sourceText);
+  const blockStack = [];
+  let decorators = [];
+  for (const [index, { line, number }] of lines.entries()) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      decorators = [];
+      continue;
+    }
+    const indent = indentationLength(line);
+    while (blockStack.length && indent <= blockStack[blockStack.length - 1].indent) blockStack.pop();
+
+    let match;
+    if ((match = trimmed.match(/^@([A-Za-z_][\w.]*(?:\([^)]*\))?)/))) {
+      decorators.push(match[1]);
+      continue;
+    }
+    if ((match = trimmed.match(/^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*:/))) {
+      const owner = blockStack[blockStack.length - 1]?.kind === 'class' ? blockStack[blockStack.length - 1].name : undefined;
+      const name = owner ? `${owner}.${match[1]}` : match[1];
+      declarations.push(nativeDeclaration(input, number, 'FunctionDef', owner ? 'method' : 'function', name, {
+        parameters: splitParameters(match[2]),
+        ...(owner ? { owner, methodName: match[1] } : {}),
+        ...(decorators.length ? { decorators } : {})
+      }, true, {
+        span: pythonBlockSpan(input, lines, index),
+        metadata: {
+          ...(owner ? { owner, methodName: match[1] } : {}),
+          ...(decorators.length ? { decorators } : {})
+        }
+      }));
+      blockStack.push({ kind: 'def', name, indent });
+    } else if ((match = trimmed.match(/^class\s+([A-Za-z_]\w*)/))) {
+      const owner = blockStack[blockStack.length - 1]?.kind === 'class' ? blockStack[blockStack.length - 1].name : undefined;
+      const name = owner ? `${owner}.${match[1]}` : match[1];
+      declarations.push(nativeDeclaration(input, number, 'ClassDef', 'class', name, {
+        ...(owner ? { owner } : {}),
+        ...(decorators.length ? { decorators } : {})
+      }, true, {
+        span: pythonBlockSpan(input, lines, index),
+        metadata: {
+          ...(owner ? { owner } : {}),
+          ...(decorators.length ? { decorators } : {})
+        }
+      }));
+      blockStack.push({ kind: 'class', name, indent });
+    } 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'));
+    }
+    decorators = [];
+  }
+  return declarations;
+}
+
+function indentationLength(line) { return String(line ?? '').match(/^\s*/)?.[0].length ?? 0; }
+
+export { scanPython };

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

@@ -0,0 +1,72 @@
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters } from './native-region-scanner-core.js';
+import { endKeywordBlockSpan } from './native-region-scanner-spans.js';
+
+function scanRuby(input) {
+  const declarations = [];
+  const lines = sourceLines(input.sourceText);
+  const blockStack = [];
+  for (const [index, { line, number }] of lines.entries()) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^end\b/.test(trimmed)) {
+      blockStack.pop();
+      continue;
+    }
+
+    let match;
+    if ((match = trimmed.match(/^(?:require|load)\s+['"]([^'"]+)['"]/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'Require', 'module'));
+    } else if ((match = trimmed.match(/^module\s+([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)/))) {
+      const name = qualifiedContainerName(blockStack, match[1]);
+      declarations.push(nativeDeclaration(input, number, 'Module', 'module', name, {}, true, endSpanOptions(input, lines, index)));
+      blockStack.push({ kind: 'module', name });
+    } else if ((match = trimmed.match(/^class\s+([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)/))) {
+      const name = qualifiedContainerName(blockStack, match[1]);
+      declarations.push(nativeDeclaration(input, number, 'Class', 'class', name, {}, true, endSpanOptions(input, lines, index)));
+      blockStack.push({ kind: 'class', name });
+    } else if ((match = trimmed.match(/^def\s+(?:(self|[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)\.)?([A-Za-z_]\w*[!?=]?)\s*(?:\(([^)]*)\)|([^#=]*))?/))) {
+      const owner = nearestContainer(blockStack);
+      const target = rubyMethodTarget(owner, match[1], match[2]);
+      declarations.push(nativeDeclaration(input, number, 'Def', target.owner ? 'method' : 'function', target.name, {
+        parameters: splitParameters(match[3] ?? match[4]),
+        methodName: match[2],
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {})
+      }, true, {
+        ...endSpanOptions(input, lines, index),
+        metadata: {
+          methodName: match[2],
+          ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {})
+        }
+      }));
+      blockStack.push({ kind: 'def', name: target.name });
+    }
+  }
+  return declarations;
+}
+
+function endSpanOptions(input, lines, index) {
+  return { span: endKeywordBlockSpan(input, lines, index) };
+}
+
+function qualifiedContainerName(blockStack, name) {
+  if (name.includes('::')) return name;
+  const owner = nearestContainer(blockStack);
+  return owner?.kind === 'module' ? `${owner.name}::${name}` : name;
+}
+
+function nearestContainer(blockStack) {
+  for (let index = blockStack.length - 1; index >= 0; index -= 1) {
+    if (blockStack[index].kind === 'class' || blockStack[index].kind === 'module') return blockStack[index];
+    if (blockStack[index].kind === 'def') return undefined;
+  }
+  return undefined;
+}
+
+function rubyMethodTarget(owner, receiver, methodName) {
+  if (receiver && receiver !== 'self') return { name: `${receiver}.singleton.${methodName}`, owner: receiver, receiverKind: 'singleton' };
+  if (receiver === 'self' && owner) return { name: `${owner.name}.singleton.${methodName}`, owner: owner.name, receiverKind: 'singleton' };
+  if (owner) return { name: `${owner.name}.instance.${methodName}`, owner: owner.name, receiverKind: 'instance' };
+  return { name: methodName };
+}
+
+export { scanRuby };

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

@@ -0,0 +1,91 @@
+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 scanScala(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, 'PackageClause', 'package', match[1], {}, false));
+    } else if ((match = trimmed.match(/^import\s+(.+?);?$/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1].trim(), 'Import', 'package'));
+    } else if ((match = trimmed.match(/^(?:(?:private|protected|final|sealed|abstract|case|implicit|lazy|override|inline|transparent|open)\s+)*(class|trait|object|enum)\s+([A-Za-z_]\w*)/))) {
+      const owner = nearestContainer(blockStack);
+      const name = scalaContainerName(owner, match[1], match[2]);
+      const hasBody = trimmed.includes('{') || trimmed.includes(':');
+      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[1])}Def`, scalaSymbolKind(match[1]), name, owner ? { owner: owner.name } : {}, hasBody, spanOptions(input, lines, index, trimmed.includes('{'))));
+      if (trimmed.includes('{')) blockStack.push({ kind: match[1], name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^(?:(?:private|protected|final|implicit|override|inline)\s+)*def\s+([A-Za-z_]\w*)\s*(?:\[[^\]]+\])?\s*\(([^)]*)\)/))) {
+      const owner = nearestContainer(blockStack);
+      const target = scalaMethodTarget(owner, match[1]);
+      const hasBody = trimmed.includes('{') || trimmed.includes('=');
+      declarations.push(nativeDeclaration(input, number, 'DefDef', target.owner ? 'method' : 'function', target.name, {
+        parameters: splitParameters(match[2]),
+        methodName: match[1],
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {})
+      }, hasBody, {
+        ...spanOptions(input, lines, index, trimmed.includes('{')),
+        metadata: {
+          methodName: match[1],
+          ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {})
+        }
+      }));
+      if (trimmed.includes('{')) blockStack.push({ kind: 'function', name: target.name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^(?:(?:private|protected|final|implicit|opaque)\s+)*type\s+([A-Za-z_]\w*)\b/))) {
+      declarations.push(nativeDeclaration(input, number, 'TypeDef', 'type', match[1], {}, false));
+    } else if ((match = trimmed.match(/^(?:(?:private|protected|final|implicit|lazy|override|inline)\s+)*(?:val|var)\s+([A-Za-z_]\w*)\b/))) {
+      declarations.push(nativeDeclaration(input, number, 'ValDef', '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 (['class', 'trait', 'object', 'enum'].includes(blockStack[index].kind)) return blockStack[index];
+  }
+  return undefined;
+}
+
+function scalaContainerName(owner, kind, name) {
+  const base = kind === 'object' ? `${name}.object` : name;
+  return owner ? `${owner.name}.${base}` : base;
+}
+
+function scalaMethodTarget(owner, methodName) {
+  if (!owner) return { name: methodName };
+  const receiverKind = owner.kind === 'object' ? 'object' : 'member';
+  return { name: `${owner.name}.${methodName}`, owner: owner.name, receiverKind };
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+function scalaSymbolKind(kind) {
+  if (kind === 'trait') return 'trait';
+  if (kind === 'object') return 'module';
+  if (kind === 'enum') return 'type';
+  return 'class';
+}
+
+export { scanScala };

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

@@ -0,0 +1,74 @@
+function pythonBlockSpan(input, lines, index) {
+  const baseIndent = indentationLength(lines[index]?.line);
+  let end = index;
+  for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+    const line = lines[cursor].line;
+    if (line.trim() && indentationLength(line) <= baseIndent) break;
+    end = cursor;
+  }
+  return lineSpan(input, lines[index], lines[end] ?? lines[index]);
+}
+
+function braceBlockSpan(input, lines, index) {
+  let depth = 0;
+  let seenOpen = false;
+  let end = index;
+  for (let cursor = index; cursor < lines.length; cursor += 1) {
+    for (const char of lines[cursor].line) {
+      if (char === '{') {
+        seenOpen = true;
+        depth += 1;
+      } else if (char === '}') depth -= 1;
+    }
+    end = cursor;
+    if (seenOpen && depth <= 0) break;
+  }
+  return lineSpan(input, lines[index], lines[end] ?? lines[index]);
+}
+
+function endKeywordBlockSpan(input, lines, index) {
+  let depth = 0;
+  let end = index;
+  for (let cursor = index; cursor < lines.length; cursor += 1) {
+    const trimmed = lines[cursor].line.trim();
+    if (endBlockStart(trimmed)) depth += 1;
+    if (/^end\b/.test(trimmed)) depth -= 1;
+    end = cursor;
+    if (depth <= 0 && cursor > index) break;
+  }
+  return lineSpan(input, lines[index], lines[end] ?? lines[index]);
+}
+
+function terminatedBlockSpan(input, lines, index, terminator) {
+  let end = index;
+  for (let cursor = index; cursor < lines.length; cursor += 1) {
+    end = cursor;
+    if (terminator.test(lines[cursor].line.trim())) break;
+  }
+  return lineSpan(input, lines[index], lines[end] ?? lines[index]);
+}
+
+function sqlStatementSpan(input, lines, index) {
+  let end = index;
+  let inDollarQuote = false;
+  for (let cursor = index; cursor < lines.length; cursor += 1) {
+    const line = lines[cursor].line;
+    const markerCount = (line.match(/\$\$/g) ?? []).length;
+    if (markerCount % 2 === 1) inDollarQuote = !inDollarQuote;
+    end = cursor;
+    if (!inDollarQuote && /;\s*$/.test(line.trim())) break;
+  }
+  return lineSpan(input, lines[index], lines[end] ?? lines[index]);
+}
+
+function lineSpan(input, startLine, endLine) {
+  return { sourceId: input.sourceHash, path: input.sourcePath, startLine: startLine.number, endLine: endLine.number, startColumn: 1, endColumn: endLine.line.length + 1 };
+}
+
+function indentationLength(line) { return String(line ?? '').match(/^\s*/)?.[0].length ?? 0; }
+
+function endBlockStart(line) {
+  return /^(?:class|module|def|defp?|defmodule|function|if|unless|case|while|for|begin|try|receive)\b/.test(line);
+}
+
+export { braceBlockSpan, endKeywordBlockSpan, pythonBlockSpan, sqlStatementSpan, terminatedBlockSpan };

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

@@ -0,0 +1,155 @@
+import { upperFirst } from './native-import-utils.js';
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters, splitTypeParameters } from './native-region-scanner-core.js';
+import { braceBlockSpan } from './native-region-scanner-spans.js';
+
+function scanSwift(input) {
+  const declarations = [];
+  const protocols = new Set();
+  const blockStack = [];
+  const lines = sourceLines(input.sourceText);
+  let braceDepth = 0;
+  for (const [index, { line, number }] of lines.entries()) {
+    const trimmed = line.trim();
+    const declarationLine = trimmed.replace(/^(?:@[A-Za-z_][\w.]+(?:\([^)]*\))?\s+)*/, '');
+    const lineStartDepth = depthAfterLeadingClosers(declarationLine, braceDepth);
+    while (blockStack.length && blockStack[blockStack.length - 1].bodyDepth > lineStartDepth) blockStack.pop();
+
+    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*)/))) {
+      const owner = nearestSwiftOwner(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      if (match[2] === 'protocol') protocols.add(name);
+      const hasBody = declarationLine.includes('{');
+      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[2])}Decl`, swiftSymbolKind(match[2]), name, {
+        modifiers: swiftModifiers(match[1]),
+        ...(owner ? { owner: owner.name } : {})
+      }, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: swiftTypeStackKind(match[2]), name, bodyDepth: braceDepth + 1 });
+    } 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[3]);
+      const isProtocolExtension = protocols.has(match[2]) || /Protocol$/.test(match[2]);
+      const receiverKind = isProtocolExtension ? 'protocolExtension' : 'extension';
+      const name = `${match[2]}.${receiverKind}`;
+      const hasBody = declarationLine.includes('{');
+      declarations.push(nativeDeclaration(input, number, isProtocolExtension ? 'ProtocolExtensionDecl' : 'ExtensionDecl', 'implementation', name, {
+        modifiers: swiftModifiers(match[1]),
+        extendedType: match[2],
+        receiverKind,
+        ...extensionFields
+      }, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: 'extension', name, receiverKind, receiverType: match[2], bodyDepth: braceDepth + 1 });
+    } 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*\(([^)]*)\)/))) {
+      const owner = nearestSwiftOwner(blockStack);
+      const target = swiftMemberTarget(owner, match[1], unquoteSwiftIdentifier(match[2]));
+      const hasBody = declarationLine.includes('{');
+      declarations.push(nativeDeclaration(input, number, 'FunctionDecl', target.owner ? 'method' : 'function', target.name, {
+        methodName: unquoteSwiftIdentifier(match[2]),
+        modifiers: swiftModifiers(match[1]),
+        typeParameters: splitTypeParameters(match[3]),
+        parameters: splitParameters(match[4]),
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind, receiverType: target.receiverType } : {})
+      }, hasBody, memberSpanOptions(input, lines, index, hasBody, target, unquoteSwiftIdentifier(match[2]), match[1])));
+      if (hasBody) blockStack.push({ kind: 'method', name: target.name, bodyDepth: braceDepth + 1 });
+    } 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*([^={]+))?/))) {
+      const owner = nearestSwiftOwner(blockStack);
+      const target = swiftMemberTarget(owner, match[1], match[3]);
+      const hasBody = declarationLine.includes('{') || declarationLine.includes('=>');
+      declarations.push(nativeDeclaration(input, number, 'PropertyDecl', 'property', target.name, {
+        binding: match[2],
+        modifiers: swiftModifiers(match[1]),
+        valueType: match[4]?.trim(),
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind, receiverType: target.receiverType } : {})
+      }, hasBody, memberSpanOptions(input, lines, index, hasBody, target, match[3], match[1])));
+    } else if ((match = declarationLine.match(/^(?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open)\s+)*typealias\s+([A-Za-z_]\w*)\b(?:\s*=\s*(.+))?/))) {
+      const owner = nearestSwiftOwner(blockStack);
+      const name = owner ? `${owner.name}.${match[1]}` : match[1];
+      declarations.push(nativeDeclaration(input, number, 'TypealiasDecl', 'type', name, {
+        target: match[2]?.trim(),
+        ...(owner ? { owner: owner.name } : {})
+      }, false));
+    }
+    braceDepth = Math.max(0, braceDepth + braceDelta(line));
+  }
+  return declarations;
+}
+
+function spanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
+}
+
+function memberSpanOptions(input, lines, index, hasBody, target, methodName, modifiers) {
+  return {
+    ...spanOptions(input, lines, index, hasBody),
+    metadata: {
+      methodName,
+      modifiers: swiftModifiers(modifiers),
+      ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind, receiverType: target.receiverType } : {})
+    }
+  };
+}
+
+function depthAfterLeadingClosers(trimmed, depth) {
+  const closers = String(trimmed).match(/^}+/)?.[0].length ?? 0;
+  return Math.max(0, depth - closers);
+}
+
+function nearestSwiftOwner(blockStack) {
+  for (let index = blockStack.length - 1; index >= 0; index -= 1) {
+    if (blockStack[index].kind === 'method') return undefined;
+    if (['actor', 'class', 'enum', 'extension', 'protocol', 'struct'].includes(blockStack[index].kind)) return blockStack[index];
+  }
+  return undefined;
+}
+
+function swiftMemberTarget(owner, modifiers, memberName) {
+  if (!owner) return { name: memberName };
+  if (owner.kind === 'extension') {
+    if (/\b(?:static|class)\b/.test(modifiers)) {
+      return { name: `${owner.name}.static.${memberName}`, owner: owner.name, receiverKind: 'static', receiverType: owner.receiverType };
+    }
+    return { name: `${owner.name}.${memberName}`, owner: owner.name, receiverKind: owner.receiverKind, receiverType: owner.receiverType };
+  }
+  const receiverKind = /\b(?:static|class)\b/.test(modifiers) ? 'static' : 'member';
+  return { name: receiverKind === 'static' ? `${owner.name}.static.${memberName}` : `${owner.name}.${memberName}`, owner: owner.name, receiverKind };
+}
+
+function swiftModifiers(raw) {
+  return splitParameters(String(raw ?? '').trim().replace(/\s+/g, ','));
+}
+
+function swiftTypeStackKind(kind) {
+  return String(kind).replace(/\s+/g, ' ');
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+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 swiftSymbolKind(kind) {
+  if (kind === 'protocol') return 'protocol';
+  if (kind === 'extension') return 'implementation';
+  if (kind === 'struct' || kind === 'enum' || kind === 'actor') return 'type';
+  return 'class';
+}
+
+export { scanSwift };

package/dist/native-region-scanner.js

@@ -1,24 +1,24 @@
 import { scanJavaScriptLike } from './native-region-scanner-js.js';
 import {
   scanCLike,
-  scanCSharp,
   scanGo,
-  scanJava,
-  scanPython,
-  scanRust,
-  scanSwift
+  scanRust
 } from './native-region-scanner-main.js';
+import { scanJava } from './native-region-scanner-java.js';
+import { scanSwift } from './native-region-scanner-swift.js';
+import { scanCSharp } from './native-region-scanner-csharp.js';
+import { scanPython } from './native-region-scanner-python.js';
+import { scanPhp } from './native-region-scanner-php.js';
+import { scanKotlin } from './native-region-scanner-kotlin.js';
+import { scanScala } from './native-region-scanner-scala.js';
+import { scanDart } from './native-region-scanner-dart.js';
 import {
-  scanDart,
-  scanKotlin,
   scanLua,
-  scanPhp,
-  scanRuby,
-  scanScala,
   scanShell,
   scanSql,
   scanZig
 } from './native-region-scanner-dynamic.js';
+import { scanRuby } from './native-region-scanner-ruby.js';
 import {
   scanElixir,
   scanErlang,
@@ -33,6 +33,10 @@ export {
   scanPreservedSourceDirectives,
   scanPreservedSourceTokens
 } from './native-source-preservation-scanner.js';
+export {
+  isJavaScriptTypeScriptSource,
+  scanJavaScriptTypeScriptSourceLedger
+} from './native-source-ledger.js';
 
 function scanNativeDeclarations(input) {
   const language = normalizeNativeLanguageId(input.language) || String(input.language).toLowerCase();