@rohal12/spindle-lsp 0.15.3 → 0.15.4

package/dist/bin.js

@@ -55,7 +55,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = false ? pkg.version : "0.15.3";
+    VERSION = false ? pkg.version : "0.15.4";
   }
 });
 
@@ -31694,7 +31694,7 @@ var init_variable_tracker = __esm({
             const member = u.fullName.split(".")[1];
             if (member === void 0) continue;
             if (declared.get(u.baseName)?.type !== "array") continue;
-            if (ARRAY_MEMBERS.has(member)) continue;
+            if (ARRAY_MEMBERS.has(member) || /^(0|[1-9]\d*)$/.test(member) && Number(member) < 4294967295) continue;
             results.push({ sigil, name: u.baseName, member, range: u.range });
           }
         }
@@ -33043,17 +33043,10 @@ function lexFormat(formatString) {
         throw new Error(`Lex: Invalid character after '|': '${next}'`);
       }
     } else if (quoteRe.test(ch)) {
-      const openQuote = ch;
-      const start = pos;
-      pos++;
-      while (pos < formatString.length && formatString[pos] !== openQuote) {
-        if (++iter > LEX_LIMIT) throw new Error("Format lex string iteration limit exceeded");
-        pos++;
-      }
-      if (pos >= formatString.length) throw new Error("Lex: Unterminated string literal");
-      const value = formatString.slice(start + 1, pos);
-      pos++;
-      lexed.push({ kind: 1 /* Literal */, value });
+      const quoted = readQuoted(formatString, pos);
+      if (!quoted) throw new Error("Lex: Unterminated string literal");
+      pos = quoted.end;
+      lexed.push({ kind: 1 /* Literal */, value: quoted.value });
     } else if (ch === "(" || ch === ")") {
       pos++;
       lexed.push({ kind: 2 /* Group */, open: ch === "(" });
@@ -33201,114 +33194,111 @@ function isFail(s) {
   return s === 1 /* Failure */ || s === 0 /* NotFound */;
 }
 function crawlValidate(format, args2, startIndex, state) {
-  let iter = 0;
+  const memo2 = /* @__PURE__ */ new Map();
+  function append(left, right) {
+    return { ...right, rank: left.rank + right.rank, warnings: left.warnings.concat(right.warnings) };
+  }
+  function follow(left, right) {
+    return left.flatMap((matched) => isFail(matched.status) ? [matched] : crawl(right, matched.argIndex).map((result2) => append(matched, result2)));
+  }
   function crawl(fmt, argIdx) {
-    if (++iter > VALIDATE_LIMIT) {
+    let positions = memo2.get(fmt);
+    if (!positions) memo2.set(fmt, positions = /* @__PURE__ */ new Map());
+    const cached2 = positions.get(argIdx);
+    if (cached2) return cached2;
+    if (positions.size >= VALIDATE_LIMIT) {
       throw new Error(`Validation iteration limit exceeded at argument ${argIdx}`);
     }
+    const unique = /* @__PURE__ */ new Map();
+    for (const result2 of match2(fmt, argIdx)) {
+      const key = isFail(result2.status) ? "failure" : result2.argIndex;
+      const previous2 = unique.get(key);
+      if (!previous2 || key === "failure" && result2.rank > previous2.rank) unique.set(key, result2);
+    }
+    const results2 = [...unique.values()];
+    positions.set(argIdx, results2);
+    return results2;
+  }
+  function match2(fmt, argIdx) {
     switch (fmt.kind) {
       case 4 /* MaybeNext */: {
-        let rank = 0;
-        let warnings = [];
-        let idx = argIdx;
-        if (fmt.left) {
-          const left = crawl(fmt.left, idx);
-          if (isFail(left.status)) return left;
-          rank += left.rank;
-          idx = left.argIndex;
-          warnings = left.warnings;
-        }
-        const right = crawl(fmt.right, idx);
-        if (right.status === 0 /* NotFound */) {
-          return makeSuccess(idx, rank, warnings);
-        }
-        if (isFail(right.status)) {
-          right.status = 1 /* Failure */;
-          return right;
-        }
-        return makeSuccess(right.argIndex, rank + right.rank, warnings.concat(right.warnings));
+        const left = fmt.left ? crawl(fmt.left, argIdx) : [makeSuccess(argIdx, 0)];
+        return [...follow(left, fmt.right), ...left];
       }
       case 3 /* AndNext */: {
-        const left = crawl(fmt.left, argIdx);
-        if (isFail(left.status)) return left;
-        const right = crawl(fmt.right, left.argIndex);
-        if (isFail(right.status)) return right;
-        return makeSuccess(
-          right.argIndex,
-          left.rank + right.rank,
-          left.warnings.concat(right.warnings)
-        );
+        return follow(crawl(fmt.left, argIdx), fmt.right);
       }
       case 5 /* Or */: {
-        const left = crawl(fmt.left, argIdx);
-        if (!isFail(left.status)) return left;
-        const right = crawl(fmt.right, argIdx);
-        if (!isFail(right.status)) return right;
-        return left;
+        return [...crawl(fmt.left, argIdx), ...crawl(fmt.right, argIdx)];
       }
       case 6 /* Repeat */: {
-        let rank = 0;
-        let warnings = [];
-        let idx = argIdx;
-        for (; ; ) {
-          const r = crawl(fmt.right, idx);
-          if (isFail(r.status)) break;
-          idx = r.argIndex;
-          rank += r.rank;
-          warnings = warnings.concat(r.warnings);
-        }
-        return makeSuccess(idx, rank, warnings);
+        const matches = [];
+        const pending = [makeSuccess(argIdx, 0)];
+        const reached = /* @__PURE__ */ new Set();
+        while (pending.length > 0) {
+          const matched = pending.pop();
+          if (reached.has(matched.argIndex)) continue;
+          reached.add(matched.argIndex);
+          matches.push(matched);
+          const items = crawl(fmt.right, matched.argIndex);
+          for (let i2 = items.length - 1; i2 >= 0; i2--) {
+            const item = items[i2];
+            if (!isFail(item.status) && !reached.has(item.argIndex)) pending.push(append(matched, item));
+          }
+        }
+        return matches.sort((left, right) => right.argIndex - left.argIndex);
       }
       case 1 /* Literal */: {
         const arg = args2[argIdx];
         if (arg === void 0) {
-          return makeError(0 /* NotFound */, `Expected literal '${fmt.value}' but no argument found`, argIdx);
+          return [makeError(0 /* NotFound */, `Expected literal '${fmt.value}' but no argument found`, argIdx)];
         }
         if (isAlwaysArg(arg)) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK);
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
         }
-        const argText = arg.type === 0 /* String */ ? arg.text.slice(1, -1) : arg.text;
+        const argText = arg.type === 0 /* String */ ? readQuoted(arg.text, 0)?.value : arg.text;
         if (argText === fmt.value) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK);
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
         }
         if (fmt.value === "null" && arg.type === 3 /* Null */ || fmt.value === "undefined" && arg.type === 10 /* Undefined */ || fmt.value === "true" && arg.type === 2 /* Boolean */ && arg.text === "true" || fmt.value === "false" && arg.type === 2 /* Boolean */ && arg.text === "false" || fmt.value === "NaN" && arg.type === 9 /* NaN */) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK);
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
         }
-        return makeError(1 /* Failure */, `Expected literal '${fmt.value}'`, argIdx, CORRECT_TYPE_RANK);
+        return [makeError(1 /* Failure */, `Expected literal '${fmt.value}'`, argIdx, CORRECT_TYPE_RANK)];
       }
       case 0 /* Type */: {
         const arg = args2[argIdx];
         const typeDef = fmt.type;
         if (arg === void 0) {
-          return makeError(
+          return [makeError(
             0 /* NotFound */,
             `Expected type '${typeDef.name[0]}' but no argument found`,
             argIdx
-          );
+          )];
         }
         if (isAlwaysArg(arg)) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK);
+          return [makeSuccess(argIdx + 1, CORRECT_RANK)];
         }
         const result2 = typeDef.validate(arg, args2, argIdx, state);
         if (result2 instanceof TypeError2) {
-          return {
+          return [{
             status: 1 /* Failure */,
             rank: 0,
             argIndex: argIdx,
             errors: [{ message: result2.message, argIndex: argIdx }],
             warnings: []
-          };
+          }];
         }
         if (result2 instanceof TypeWarning) {
-          return makeSuccess(argIdx + 1, CORRECT_RANK, [
+          return [makeSuccess(argIdx + 1, CORRECT_RANK, [
             { message: result2.message, argIndex: argIdx }
-          ]);
+          ])];
         }
-        return makeSuccess(argIdx + 1, CORRECT_RANK);
+        return [makeSuccess(argIdx + 1, CORRECT_RANK)];
       }
     }
   }
-  return crawl(format, startIndex);
+  const results = crawl(format, startIndex);
+  return results.find((result2) => !isFail(result2.status) && result2.argIndex === args2.length) ?? results.reduce((best, result2) => result2.rank > best.rank ? result2 : best);
 }
 var TypeError2, TypeWarning, parameterTypes, LEX_LIMIT, wsRe, identStartRe, identStopRe, quoteRe, digitRe, PARSE_LIMIT, DESCRIBE_ALTERNATIVE_LIMIT, VALIDATE_LIMIT, CORRECT_TYPE_RANK, CORRECT_RANK, Parameters;
 var init_parameter_validator = __esm({
@@ -33820,7 +33810,7 @@ function computeDiagnostics(uri, workspace, options) {
 }
 function storyReport(workspace) {
   const documents = [];
-  for (const uri of workspace.documents.getUris()) {
+  for (const uri of workspace.passages.getDocumentUris()) {
     if (isMacroSource(uri)) continue;
     const doc = workspace.markup.get(uri);
     if (doc) documents.push(doc);
@@ -81366,7 +81356,7 @@ function startServer(args2) {
   connection.onInitialize((params) => {
     console.error("[spindle-lsp] onInitialize called");
     const initOptions = params.initializationOptions ?? {};
-    workspaceRoot = initOptions.workspaceRoot ?? (params.workspaceFolders?.[0]?.uri ? uriToFsPath(params.workspaceFolders[0].uri) : void 0) ?? (params.rootUri ? uriToFsPath(params.rootUri) : void 0);
+    workspaceRoot = (initOptions.workspaceRoot !== void 0 ? uriToFsPath(initOptions.workspaceRoot) : void 0) ?? (params.workspaceFolders?.[0]?.uri ? uriToFsPath(params.workspaceFolders[0].uri) : void 0) ?? (params.rootUri ? uriToFsPath(params.rootUri) : void 0);
     let projectConfig = { macros: {} };
     try {
       if (workspaceRoot) projectConfig = loadConfigFromDisk(workspaceRoot);