@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/node_modules/@mrclrchtr/supi-tree-sitter/scripts/generate-sql-wasm.mjs

@@ -8,10 +8,10 @@
  *
  * Trust considerations:
  * - The @derekstride/tree-sitter-sql install script uses "npx --yes", which
- *   some package managers flag as a supply-chain risk. pnpm ignores build
- *   scripts by default, so this script never runs during install.
+ *   some package managers flag as a supply-chain risk. This workspace disables
+ *   that package's build script explicitly via pnpm `allowBuilds`.
  * - The WASM is built locally from the installed package source (not downloaded
- *   from npm). The build uses tree-sitter-cli 0.22.6 with Emscripten/Docker.
+ *   from npm). The build uses tree-sitter-cli with Emscripten/Docker.
  * - Alternatives considered: tree-sitter-sql (m-novikov, stale since 2021),
  *   tree-sitter-sql-bigquery (dialect-specific), and dialect-specific grammars.
  *   derekstride/tree-sitter-sql is the most mature general-purpose SQL grammar.
@@ -55,6 +55,7 @@ function readMetadata() {
 
 function assertSqlWasmCurrent() {
   const sqlPackage = readPackage("@derekstride/tree-sitter-sql");
+  const cliPackage = readPackage("tree-sitter-cli");
   const metadata = readMetadata();
   const actualSha = sha256(wasmPath);
   const errors = [];
@@ -67,6 +68,11 @@ function assertSqlWasmCurrent() {
       `metadata pins @derekstride/tree-sitter-sql ${metadata.source?.version}, but installed package is ${sqlPackage.json.version}`,
     );
   }
+  if (metadata.generatedWith?.treeSitterCli !== cliPackage.json.version) {
+    errors.push(
+      `metadata pins tree-sitter-cli ${metadata.generatedWith?.treeSitterCli}, but installed CLI is ${cliPackage.json.version}`,
+    );
+  }
   if (metadata.sha256 !== actualSha) {
     errors.push(`metadata sha256 ${metadata.sha256} does not match vendored file ${actualSha}`);
   }
@@ -92,7 +98,7 @@ function generateSqlWasm() {
   try {
     fs.cpSync(sqlPackage.dir, grammarDir, { recursive: true });
 
-    // tree-sitter-cli 0.22.6 requires a "tree-sitter" section in package.json
+    // tree-sitter-cli requires a "tree-sitter" section in package.json
     const grammarPackageJsonPath = path.join(grammarDir, "package.json");
     const grammarPackageJson = JSON.parse(fs.readFileSync(grammarPackageJsonPath, "utf-8"));
     grammarPackageJson["tree-sitter"] = [{ scope: "source.sql" }];
@@ -128,6 +134,14 @@ function generateSqlWasm() {
         treeSitterCli: cliPackage.json.version,
       },
       sha256: checksum,
+      trust: {
+        note: "The @derekstride/tree-sitter-sql npm package is a devDependency only. It is never resolved at runtime; the vendored WASM above is the sole runtime artifact. This workspace explicitly disables the package's npx-based install script via pnpm allowBuilds. The WASM was built locally from the installed package source. See scripts/generate-sql-wasm.mjs for the rebuild procedure.",
+        alternativesConsidered: [
+          "tree-sitter-sql (m-novikov, 2021, stale)",
+          "tree-sitter-sql-bigquery (BigQuery-specific)",
+          "dialect-specific grammars (too narrow)",
+        ],
+      },
     };
     fs.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`);
     process.stdout.write(`Generated ${wasmPath}\n`);

package/node_modules/@mrclrchtr/supi-tree-sitter/scripts/vendor-wasm.mjs

@@ -108,8 +108,14 @@ function checkGrammar(grammarId, source) {
 
   try {
     const pkg = readPackage(source.npmPackage);
+    const sourceWasmPath = path.join(pkg.dir, source.wasmFile);
+    if (!fs.existsSync(sourceWasmPath)) {
+      errors.push(`${grammarId}: installed package is missing ${source.wasmFile}`);
+      return errors;
+    }
     const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
     const actualSha = sha256(wasmPath);
+    const sourceSha = sha256(sourceWasmPath);
 
     if (metadata.source?.npmPackage !== source.npmPackage) {
       errors.push(`${grammarId}: metadata source npmPackage mismatch`);
@@ -119,8 +125,18 @@ function checkGrammar(grammarId, source) {
         `${grammarId}: metadata version ${metadata.source?.version} !== installed ${pkg.json.version}`,
       );
     }
+    if (actualSha !== sourceSha) {
+      errors.push(
+        `${grammarId}: vendored sha256 ${actualSha} !== installed package source ${sourceSha}`,
+      );
+    }
     if (metadata.sha256 !== actualSha) {
-      errors.push(`${grammarId}: metadata sha256 ${metadata.sha256} !== actual ${actualSha}`);
+      errors.push(`${grammarId}: metadata sha256 ${metadata.sha256} !== vendored ${actualSha}`);
+    }
+    if (metadata.sha256 !== sourceSha) {
+      errors.push(
+        `${grammarId}: metadata sha256 ${metadata.sha256} !== installed package source ${sourceSha}`,
+      );
     }
   } catch (err) {
     errors.push(`${grammarId}: ${err.message}`);

package/node_modules/@mrclrchtr/supi-tree-sitter/src/api.ts

@@ -12,6 +12,8 @@ export {
   isJsTsGrammar,
   isSupportedFile,
 } from "./language.ts";
+export type { StructuralSearchOperation } from "./operation-support.ts";
+export { getStructuralSearchSupportedExtensions } from "./operation-support.ts";
 export { TreeSitterRuntime } from "./session/runtime.ts";
 export type {
   TsControllerState,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/coordinates.ts

@@ -1,10 +1,16 @@
 // Coordinate conversion between public 1-based UTF-16 positions
-// and Tree-sitter runtime byte/row/column positions.
+// and Tree-sitter runtime positions.
+//
+// web-tree-sitter's Parser.parse(string) uses JavaScript string columns
+// (UTF-16 code unit offsets) for startPosition/endPosition. We convert
+// 1-based user-facing positions to 0-based row/column and back without
+// any byte-level encoding.
+//
+// This matches the column convention used by LSP and Monaco, so ranges
+// are directly shareable between tree-sitter and LSP workflows.
 
 import type { SourceRange } from "./types.ts";
 
-const encoder = new TextEncoder();
-
 /** Point in source: 1-based line and UTF-16 character. */
 export interface PublicPoint {
   line: number;
@@ -16,7 +22,8 @@ export interface PublicPoint {
  * for Tree-sitter lookup.
  *
  * `character` is a UTF-16 code-unit column (editor/LSP convention).
- * We convert it to a byte offset within the line by counting UTF-8 bytes.
+ * The column maps directly to JavaScript string code units — no byte
+ * conversion is needed for web-tree-sitter's string-parsing mode.
  */
 export function publicToTreeSitter(
   line: number,
@@ -25,32 +32,27 @@ export function publicToTreeSitter(
 ): { row: number; column: number } {
   const row = line - 1;
   const lines = splitSourceLines(source);
-  const lineText = row < lines.length ? lines[row] : "";
-  // character is 1-based; clamp to line length
-  const charIndex = Math.max(0, Math.min(character - 1, lineText.length));
-  // Convert UTF-16 code unit index to byte offset
-  const textBefore = lineText.substring(0, charIndex);
-  const byteOffset = encoder.encode(textBefore).length;
-  return { row, column: byteOffset };
+  const lineText = row < lines.length ? (lines[row] ?? "") : "";
+  // Clamp column to the line length.
+  const column = Math.max(0, Math.min(character - 1, lineText.length));
+  return { row, column };
 }
 
 /**
  * Convert a Tree-sitter (row, column) pair to a 1-based (line, character) pair.
  *
- * `column` is a byte offset within the line; we convert it to a UTF-16
- * code-unit index.
+ * `column` is a zero-based JavaScript string code unit offset within the line.
  */
 export function treeSitterToPublic(row: number, column: number, source: string): PublicPoint {
+  // Clamp to EOL for positions right after the last character.
   const lines = splitSourceLines(source);
-  const lineText = row < lines.length ? lines[row] : "";
-  // Convert byte offset to UTF-16 code unit index
-  const charIndex = byteToUtf16Index(lineText, column);
-  return { line: row + 1, character: charIndex + 1 };
+  const lineText = row < lines.length ? (lines[row] ?? "") : "";
+  const safeColumn = Math.max(0, Math.min(column, lineText.length));
+  return { line: row + 1, character: safeColumn + 1 };
 }
 
 /**
  * Convert a Tree-sitter point {row, column} to a SourceRange-compatible point.
- * Uses the source text for byte-to-UTF16 conversion.
  */
 export function tsPointToPublic(
   point: { row: number; column: number },
@@ -83,26 +85,3 @@ export function nodeToRange(
 export function splitSourceLines(source: string): string[] {
   return source.replace(/\r\n?/g, "\n").split("\n");
 }
-
-/**
- * Convert a byte offset within a line to a UTF-16 code unit index.
- */
-function byteToUtf16Index(line: string, byteOffset: number): number {
-  let byteCount = 0;
-  for (let i = 0; i < line.length; i++) {
-    if (byteCount >= byteOffset) return i;
-    const char = line.charCodeAt(i);
-    // surrogate pair — 4 bytes in UTF-8, but 2 UTF-16 code units
-    if (char >= 0xd800 && char <= 0xdbff) {
-      byteCount += 4;
-      i++; // skip low surrogate
-    } else if (char > 0x7f) {
-      // Non-ASCII: 2-3 bytes in UTF-8
-      if (char <= 0x7ff) byteCount += 2;
-      else byteCount += 3;
-    } else {
-      byteCount += 1;
-    }
-  }
-  return line.length;
-}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/index.ts

@@ -11,6 +11,8 @@ export {
   isJsTsGrammar,
   isSupportedFile,
 } from "./language.ts";
+export type { StructuralSearchOperation } from "./operation-support.ts";
+export { getStructuralSearchSupportedExtensions } from "./operation-support.ts";
 // Provider implementation
 export { createTreeSitterProvider } from "./provider/tree-sitter-provider.ts";
 export { TreeSitterRuntime } from "./session/runtime.ts";

package/node_modules/@mrclrchtr/supi-tree-sitter/src/language.ts

@@ -61,6 +61,13 @@ export function getSupportedExtensions(): string[] {
   return [...SUPPORTED_EXTENSIONS];
 }
 
+/** Internal registry snapshot used to derive operation-specific language support. */
+export function getSupportedExtensionGrammarEntries(): Array<
+  readonly [SupportedExtension, GrammarId]
+> {
+  return Object.entries(EXTENSION_GRAMMAR) as Array<readonly [SupportedExtension, GrammarId]>;
+}
+
 /** Get the file extension if it's supported, otherwise undefined. */
 export function getSupportedExtension(filePath: string): SupportedExtension | undefined {
   const ext = path.extname(filePath).toLowerCase();

package/node_modules/@mrclrchtr/supi-tree-sitter/src/operation-support.ts

@@ -0,0 +1,40 @@
+import { getSupportedExtensionGrammarEntries, isJsTsGrammar } from "./language.ts";
+import { supportsCallSitesGrammar } from "./tool/call-sites.ts";
+import type { GrammarId, SupportedExtension } from "./types.ts";
+
+/** Structural collection operations whose language support defines an AST Scan universe. */
+const STRUCTURAL_SEARCH_OPERATIONS = ["outline", "imports", "exports", "call-sites"] as const;
+
+/** One Tree-sitter structural collection operation used by code-aware search. */
+export type StructuralSearchOperation = (typeof STRUCTURAL_SEARCH_OPERATIONS)[number];
+
+/**
+ * Return the file extensions that the concrete extractor supports for an operation.
+ *
+ * This is operation support, not general parser support. The result is derived from
+ * the same grammar predicates and query registry used by the extractors themselves.
+ */
+export function getStructuralSearchSupportedExtensions(
+  operation: StructuralSearchOperation,
+): SupportedExtension[] {
+  return getSupportedExtensionGrammarEntries()
+    .filter(([, grammar]) => supportsGrammarOperation(grammar, operation))
+    .map(([extension]) => extension);
+}
+
+/** Return whether one grammar is supported by the requested structural operation. */
+export function supportsGrammarOperation(
+  grammar: GrammarId,
+  operation: StructuralSearchOperation,
+): boolean {
+  switch (operation) {
+    case "call-sites":
+      return supportsCallSitesGrammar(grammar);
+    case "outline":
+    case "imports":
+    case "exports":
+      return isJsTsGrammar(grammar);
+    default:
+      throw new TypeError(`Unsupported structural search operation: ${String(operation)}`);
+  }
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/session/session.ts

@@ -1,6 +1,7 @@
 // Session factory — creates runtime-backed Tree-sitter services and owned sessions.
 
-import { detectGrammar, isJsTsGrammar } from "../language.ts";
+import { detectGrammar } from "../language.ts";
+import { supportsGrammarOperation } from "../operation-support.ts";
 import {
   extractCallSites,
   extractExports,
@@ -45,15 +46,16 @@ export function createTreeSitterService(runtime: TreeSitterRuntime): TreeSitterS
     },
 
     async outline(file: string): Promise<TreeSitterResult<OutlineItem[]>> {
-      const parseResult = await runtime.parseFile(file);
-      if (parseResult.kind !== "success") return parseResult;
-      if (!isJsTsGrammar(parseResult.data.grammarId)) {
+      const grammarId = detectGrammar(file);
+      if (grammarId && !supportsGrammarOperation(grammarId, "outline")) {
         return {
           kind: "unsupported-language",
           file,
-          message: `outline is not supported for ${parseResult.data.grammarId} files`,
+          message: `outline is not supported for ${grammarId} files`,
         };
       }
+      const parseResult = await runtime.parseFile(file);
+      if (parseResult.kind !== "success") return parseResult;
       const { tree, source } = parseResult.data;
       try {
         const items = extractOutline(tree.rootNode, source);
@@ -65,7 +67,7 @@ export function createTreeSitterService(runtime: TreeSitterRuntime): TreeSitterS
 
     async imports(file: string): Promise<TreeSitterResult<ImportRecord[]>> {
       const grammarId = detectGrammar(file);
-      if (grammarId && !isJsTsGrammar(grammarId)) {
+      if (grammarId && !supportsGrammarOperation(grammarId, "imports")) {
         return {
           kind: "unsupported-language",
           file,
@@ -77,7 +79,7 @@ export function createTreeSitterService(runtime: TreeSitterRuntime): TreeSitterS
 
     async exports(file: string): Promise<TreeSitterResult<ExportRecord[]>> {
       const grammarId = detectGrammar(file);
-      if (grammarId && !isJsTsGrammar(grammarId)) {
+      if (grammarId && !supportsGrammarOperation(grammarId, "exports")) {
         return {
           kind: "unsupported-language",
           file,

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/call-sites.ts

@@ -30,10 +30,15 @@ const CALL_SITE_QUERIES: Partial<Record<GrammarId, string>> = {
   kotlin:
     "(call_expression . (simple_identifier) @call) (call_expression . (navigation_expression . (simple_identifier) @call))",
   ruby: "(call method: (identifier) @call)",
-  bash: "(command name: (word) @call)",
+  bash: "(command name: (command_name) @call)",
   r: "(call function: (identifier) @call)",
 };
 
+/** Return whether the call-site extractor has a query for one grammar. */
+export function supportsCallSitesGrammar(grammarId: GrammarId): boolean {
+  return CALL_SITE_QUERIES[grammarId] !== undefined;
+}
+
 /**
  * Extract all call-site callee expressions from a file.
  *

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/callees.ts

@@ -188,7 +188,7 @@ export async function lookupCalleesAt(
 
   try {
     const scopes = ENCLOSING_SCOPE_TYPES[grammarId];
-    const tsPoint = tsPosition(line, character);
+    const tsPoint = { row: line - 1, column: character - 1 };
     const node = tree.rootNode.descendantForPosition(tsPoint);
 
     if (!node) {
@@ -222,13 +222,7 @@ export async function lookupCalleesAt(
       };
     }
 
-    const callees = filterCalleeCaptures(
-      queryResult.data,
-      enclosingNode,
-      scopes,
-      tsPoint.row,
-      depth,
-    );
+    const callees = filterCalleeCaptures(queryResult.data, enclosingNode, scopes, tsPoint, depth);
 
     const enclosingRange = nodeToSourceRange(enclosingNode);
     const scopeName = extractScopeName(enclosingNode.type, enclosingNode.text);
@@ -250,47 +244,74 @@ export async function lookupCalleesAt(
 }
 
 /**
- * Recursively collect line ranges of inner function/method/callback scopes that
- * do not contain the anchor row. Captures from these ranges are excluded so
+ * Recursively collect inner function/method/callback scopes that do NOT
+ * contain the anchor point. Captures from these ranges are excluded so
  * nested calls are not attributed to the parent scope.
+ *
+ * Containment compares both row and column to handle same-line nested
+ * functions correctly.
  */
 function collectInnerScopes(
   node: {
     type: string;
     children: unknown[];
-    startPosition: { row: number };
-    endPosition: { row: number };
+    startPosition: { row: number; column: number };
+    endPosition: { row: number; column: number };
   } | null,
   scopeTypes: ReadonlySet<string>,
-  anchorRow: number,
-  ranges: Array<{ startRow: number; endRow: number }>,
+  anchor: { row: number; column: number },
+  ranges: Array<{
+    startRow: number;
+    startColumn: number;
+    endRow: number;
+    endColumn: number;
+  }>,
 ): void {
   if (!node) return;
   // biome-ignore lint/complexity/noForEach: safe iteration over node children
   (node.children ?? []).forEach((child) => {
     const childNode = child as {
       type: string;
-      startPosition: { row: number };
-      endPosition: { row: number };
+      startPosition: { row: number; column: number };
+      endPosition: { row: number; column: number };
       children: unknown[];
     };
     if (scopeTypes.has(childNode.type)) {
-      // Exclude this inner scope if it does NOT contain the anchor
-      if (!(childNode.startPosition.row <= anchorRow && childNode.endPosition.row >= anchorRow)) {
+      // Exclude this inner scope if it does NOT contain the anchor point.
+      const contains = containsPoint(childNode, anchor);
+      if (!contains) {
         ranges.push({
-          startRow: childNode.startPosition.row + 1,
-          endRow: childNode.endPosition.row + 1,
+          startRow: childNode.startPosition.row,
+          startColumn: childNode.startPosition.column,
+          endRow: childNode.endPosition.row,
+          endColumn: childNode.endPosition.column,
         });
       }
       // Still recurse into it for deeper nesting
-      collectInnerScopes(childNode, scopeTypes, anchorRow, ranges);
+      collectInnerScopes(childNode, scopeTypes, anchor, ranges);
     } else {
       // Recurse into non-scope children to find deeper scopes
-      collectInnerScopes(childNode, scopeTypes, anchorRow, ranges);
+      collectInnerScopes(childNode, scopeTypes, anchor, ranges);
     }
   });
 }
 
+function containsPoint(
+  node: {
+    startPosition: { row: number; column: number };
+    endPosition: { row: number; column: number };
+  },
+  point: { row: number; column: number },
+): boolean {
+  const afterStart =
+    point.row > node.startPosition.row ||
+    (point.row === node.startPosition.row && point.column >= node.startPosition.column);
+  const beforeEnd =
+    point.row < node.endPosition.row ||
+    (point.row === node.endPosition.row && point.column <= node.endPosition.column);
+  return afterStart && beforeEnd;
+}
+
 /**
  * Filter query captures to only those within the enclosing scope.
  * In `direct` depth, excludes captures that fall within inner nested
@@ -298,35 +319,57 @@ function collectInnerScopes(
  * enclosing scope are included regardless of nesting.
  */
 // biome-ignore lint/complexity/useMaxParams: filtering needs captures + node context + depth
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: filtering combines scope containment, column-aware inner-scope exclusion, and dedup in one cohesive pass
 function filterCalleeCaptures(
   captures: Array<{ range: SourceRange; text: string }>,
   // biome-ignore lint/suspicious/noExplicitAny: tree-sitter SyntaxNode is complex
   enclosingNode: any,
   scopeTypes: ReadonlySet<string>,
-  anchorRow: number,
+  anchor: { row: number; column: number },
   depth: "direct" | "deep" = "direct",
 ): Array<{ name: string; range: SourceRange }> {
-  const excludeRanges: Array<{ startRow: number; endRow: number }> = [];
+  const excludeRanges: Array<{
+    startRow: number;
+    startColumn: number;
+    endRow: number;
+    endColumn: number;
+  }> = [];
   if (depth === "direct") {
-    collectInnerScopes(enclosingNode, scopeTypes, anchorRow, excludeRanges);
+    collectInnerScopes(enclosingNode, scopeTypes, anchor, excludeRanges);
   }
 
   const seen = new Set<string>();
   const callees: Array<{ name: string; range: SourceRange }> = [];
 
-  const enclosingStartRow = enclosingNode.startPosition.row + 1;
-  const enclosingEndRow = enclosingNode.endPosition.row + 1;
+  const enclosingStartRow = enclosingNode.startPosition.row;
+  const enclosingEndRow = enclosingNode.endPosition.row;
+  const enclosingStartColumn = enclosingNode.startPosition.column;
+  const enclosingEndColumn = enclosingNode.endPosition.column;
 
   for (const capture of captures) {
-    // Only include captures within the enclosing scope
-    if (capture.range.startLine < enclosingStartRow || capture.range.endLine > enclosingEndRow) {
+    // Only include captures within the enclosing scope, using columns
+    // for same-line containment.
+    const capStartLine = capture.range.startLine - 1;
+    const capEndLine = capture.range.endLine - 1;
+    const capStartChar = capture.range.startCharacter - 1;
+    const capEndChar = capture.range.endCharacter - 1;
+    if (capStartLine < enclosingStartRow || capEndLine > enclosingEndRow) {
+      continue;
+    }
+    if (capStartLine === enclosingStartRow && capStartChar < enclosingStartColumn) {
+      continue;
+    }
+    if (capEndLine === enclosingEndRow && capEndChar > enclosingEndColumn) {
       continue;
     }
 
-    // In direct depth, exclude captures that fall within inner nested function scopes
+    // In direct depth, exclude captures within inner nested function scopes
     if (depth === "direct") {
       const isInInner = excludeRanges.some(
-        (exc) => capture.range.startLine >= exc.startRow && capture.range.endLine <= exc.endRow,
+        (exc) =>
+          (capStartLine > exc.startRow ||
+            (capStartLine === exc.startRow && capStartChar >= exc.startColumn)) &&
+          (capEndLine < exc.endRow || (capEndLine === exc.endRow && capEndChar <= exc.endColumn)),
       );
       if (isInInner) continue;
     }
@@ -343,7 +386,8 @@ function filterCalleeCaptures(
 
 // ── Internal helpers ──────────────────────────────────────────────────
 
-/** Convert a tree-sitter node to a SourceRange. */
+/** Convert a tree-sitter node to a SourceRange using the source text for
+ * UTF-16 column conversion. */
 function nodeToSourceRange(node: {
   startPosition: { row: number; column: number };
   endPosition: { row: number; column: number };
@@ -355,8 +399,3 @@ function nodeToSourceRange(node: {
     endCharacter: node.endPosition.column + 1,
   };
 }
-
-/** Convert 1-based position to tree-sitter 0-based point. */
-function tsPosition(line: number, character: number): { row: number; column: number } {
-  return { row: line - 1, column: character - 1 };
-}

package/node_modules/yaml/LICENSE

@@ -0,0 +1,13 @@
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.