poe-code 4.0.56 → 4.0.58

package/dist/index.js

@@ -121259,13 +121259,13 @@ var init_parser3 = __esm({
         };
       }
       parseExpression(options = {}) {
-        const first = this.parseNonSequenceExpression();
+        const first = this.parseAssignmentExpression();
         if (options.allowSequence !== true || this.consumePunctuator(",") === void 0) {
           return first;
         }
         const expressions = [first.node];
         do {
-          expressions.push(this.parseNonSequenceExpression().node);
+          expressions.push(this.parseAssignmentExpression().node);
         } while (this.consumePunctuator(",") !== void 0);
         return {
           node: {
@@ -121276,7 +121276,7 @@ var init_parser3 = __esm({
           parenthesized: false
         };
       }
-      parseNonSequenceExpression() {
+      parseAssignmentExpression() {
         const arrowFunction = this.tryParseArrowFunctionExpression();
         if (arrowFunction !== void 0) {
           return {
@@ -121284,9 +121284,6 @@ var init_parser3 = __esm({
             parenthesized: false
           };
         }
-        return this.parseAssignmentExpression();
-      }
-      parseAssignmentExpression() {
         const patternAssignment = this.tryParsePatternAssignmentExpression();
         if (patternAssignment !== void 0) {
           return {
@@ -121362,7 +121359,7 @@ var init_parser3 = __esm({
           }
           const consequent = this.parseExpression();
           this.expectPunctuator(":");
-          const alternate = this.parseConditionalExpression();
+          const alternate = this.parseAssignmentExpression();
           return {
             node: {
               type: "ConditionalExpression",
@@ -124435,534 +124432,6 @@ var init_AS001 = __esm({
   }
 });
 
-// packages/safejs/src/lint/rules/AS002.ts
-function AS002(source, options = {}) {
-  return new AS002Scanner(options.filename ?? "<input>").scan(source);
-}
-var AS002Scanner;
-var init_AS002 = __esm({
-  "packages/safejs/src/lint/rules/AS002.ts"() {
-    "use strict";
-    init_parser3();
-    AS002Scanner = class {
-      constructor(filename) {
-        this.filename = filename;
-      }
-      filename;
-      diagnostics = [];
-      scopes = [];
-      lambdaStack = [];
-      reportedCaptures = /* @__PURE__ */ new Set();
-      scan(source) {
-        const module = parseModule(source, this.filename);
-        this.visitModule(module);
-        return this.diagnostics;
-      }
-      visitModule(node) {
-        this.withScope(this.collectModuleBindings(node.body), () => {
-          for (const statement of node.body) {
-            this.visitStatement(statement);
-          }
-        });
-      }
-      visitStatement(node) {
-        switch (node.type) {
-          case "BlockStatement":
-            this.visitBlock(node);
-            return;
-          case "ExpressionStatement":
-            this.visitExpressionStatement(node);
-            return;
-          case "IfStatement":
-            this.visitIfStatement(node);
-            return;
-          case "ForStatement":
-            this.visitForStatement(node);
-            return;
-          case "ForInStatement":
-          case "ForOfStatement":
-            this.visitForOfStatement(node);
-            return;
-          case "WhileStatement":
-          case "DoWhileStatement":
-            this.visitWhileStatement(node);
-            return;
-          case "TryStatement":
-            this.visitTryStatement(node);
-            return;
-          case "VariableDeclaration":
-            this.visitVariableDeclaration(node);
-            return;
-          case "ReturnStatement":
-            if (node.argument !== void 0) {
-              this.visitExpression(node.argument);
-            }
-            return;
-          case "ThrowStatement":
-            this.visitThrowStatement(node);
-            return;
-          case "ExportNamedDeclaration":
-            this.visitVariableDeclaration(node.declaration);
-            return;
-          case "ExportDefaultDeclaration":
-            this.visitExpression(node.declaration);
-            return;
-          case "ImportDeclaration":
-          case "BreakStatement":
-          case "ContinueStatement":
-            return;
-        }
-      }
-      visitBlock(node) {
-        this.withScope(this.collectBlockBindings(node.body), () => {
-          for (const statement of node.body) {
-            this.visitStatement(statement);
-          }
-        });
-      }
-      visitExpressionStatement(node) {
-        this.visitExpression(node.expression);
-      }
-      visitIfStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.consequent);
-        if (node.alternate !== void 0) {
-          this.visitStatement(node.alternate);
-        }
-      }
-      visitForStatement(node) {
-        const bindings = node.init?.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.init) : [];
-        this.withScope(bindings, () => {
-          if (node.init !== void 0) {
-            if (node.init.type === "VariableDeclaration") {
-              this.visitVariableDeclaration(node.init);
-            } else {
-              this.visitExpression(node.init);
-            }
-          }
-          if (node.test !== void 0) {
-            this.visitExpression(node.test);
-          }
-          if (node.update !== void 0) {
-            this.visitExpression(node.update);
-          }
-          this.visitStatement(node.body);
-        });
-      }
-      visitForOfStatement(node) {
-        const bindings = node.left.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.left) : [];
-        this.withScope(bindings, () => {
-          if (node.left.type === "VariableDeclaration") {
-            this.visitVariableDeclaration(node.left);
-          } else {
-            this.visitAssignmentTarget(node.left);
-          }
-          this.visitExpression(node.right);
-          this.visitStatement(node.body);
-        });
-      }
-      visitWhileStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.body);
-      }
-      visitTryStatement(node) {
-        this.visitBlock(node.block);
-        if (node.handler !== void 0) {
-          this.visitCatchClause(node.handler);
-        }
-        if (node.finalizer !== void 0) {
-          this.visitBlock(node.finalizer);
-        }
-      }
-      visitCatchClause(node) {
-        this.withScope(this.collectCatchBindings(node), () => {
-          if (node.param !== void 0) {
-            this.visitBindingPattern(node.param);
-          }
-          this.visitBlock(node.body);
-        });
-      }
-      visitThrowStatement(node) {
-        this.visitExpression(node.argument);
-      }
-      visitVariableDeclaration(node) {
-        for (const declarator of node.declarations) {
-          this.visitVariableDeclarator(declarator);
-        }
-      }
-      visitVariableDeclarator(node) {
-        this.visitBindingPattern(node.id);
-        if (node.init !== void 0) {
-          this.visitExpression(node.init);
-        }
-      }
-      visitExpression(node) {
-        switch (node.type) {
-          case "Identifier":
-            this.visitIdentifier(node);
-            return;
-          case "ArrowFunctionExpression":
-            this.visitArrowFunction(node);
-            return;
-          case "AwaitExpression":
-            this.visitAwaitExpression(node);
-            return;
-          case "ArrayExpression":
-            this.visitArrayExpression(node);
-            return;
-          case "ObjectExpression":
-            this.visitObjectExpression(node);
-            return;
-          case "UnaryExpression":
-            this.visitUnaryExpression(node);
-            return;
-          case "BinaryExpression":
-            this.visitBinaryExpression(node);
-            return;
-          case "LogicalExpression":
-            this.visitLogicalExpression(node);
-            return;
-          case "ConditionalExpression":
-            this.visitConditionalExpression(node);
-            return;
-          case "MemberExpression":
-            this.visitMemberExpression(node);
-            return;
-          case "AssignmentExpression":
-            this.visitAssignmentExpression(node);
-            return;
-          case "CallExpression":
-            this.visitCallExpression(node);
-            return;
-          case "TemplateLiteral":
-            this.visitTemplateLiteral(node);
-            return;
-          case "BooleanLiteral":
-          case "NullLiteral":
-          case "NumericLiteral":
-          case "StringLiteral":
-          case "UndefinedLiteral":
-            return;
-        }
-      }
-      visitArrowFunction(node) {
-        const lambdaContext = {
-          depth: this.lambdaStack.length + 1,
-          nodeId: node.nodeId ?? -1
-        };
-        this.lambdaStack.push(lambdaContext);
-        this.withScope(this.collectParameterBindings(node), () => {
-          for (const parameter of node.params) {
-            this.visitBindingElement(parameter);
-          }
-          if (node.body.type === "BlockStatement") {
-            this.visitBlock(node.body);
-          } else {
-            this.visitExpression(node.body);
-          }
-        });
-        this.lambdaStack.pop();
-      }
-      visitAwaitExpression(node) {
-        this.visitExpression(node.argument);
-      }
-      visitArrayExpression(node) {
-        for (const element of node.elements) {
-          if (element?.type === "SpreadElement") {
-            this.visitSpreadElement(element);
-            continue;
-          }
-          if (element !== void 0) {
-            this.visitExpression(element);
-          }
-        }
-      }
-      visitObjectExpression(node) {
-        for (const property of node.properties) {
-          if (property.type === "SpreadElement") {
-            this.visitSpreadElement(property);
-            continue;
-          }
-          this.visitProperty(property);
-        }
-      }
-      visitUnaryExpression(node) {
-        this.visitExpression(node.argument);
-      }
-      visitBinaryExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-      }
-      visitLogicalExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-      }
-      visitConditionalExpression(node) {
-        this.visitExpression(node.test);
-        this.visitExpression(node.consequent);
-        this.visitExpression(node.alternate);
-      }
-      visitMemberExpression(node) {
-        this.visitExpression(node.object);
-        if (node.computed) {
-          this.visitExpression(node.property);
-        }
-      }
-      visitAssignmentExpression(node) {
-        this.visitAssignmentTarget(node.left);
-        this.visitExpression(node.right);
-      }
-      visitCallExpression(node) {
-        this.visitExpression(node.callee);
-        for (const argument of node.arguments) {
-          if (argument.type === "SpreadElement") {
-            this.visitSpreadElement(argument);
-            continue;
-          }
-          this.visitExpression(argument);
-        }
-      }
-      visitTemplateLiteral(node) {
-        for (const expression of node.expressions) {
-          this.visitExpression(expression);
-        }
-      }
-      visitProperty(node) {
-        if (node.computed) {
-          this.visitExpression(node.key);
-        }
-        this.visitExpression(node.value);
-      }
-      visitSpreadElement(node) {
-        this.visitExpression(node.argument);
-      }
-      visitBindingElement(node) {
-        switch (node.type) {
-          case "AssignmentPattern":
-            this.visitBindingPattern(node.left);
-            this.visitExpression(node.right);
-            return;
-          case "RestElement":
-            this.visitBindingPattern(node.argument);
-            return;
-          default:
-            this.visitBindingPattern(node);
-            return;
-        }
-      }
-      visitBindingPattern(node) {
-        switch (node.type) {
-          case "Identifier":
-            return;
-          case "MemberExpression":
-            this.visitMemberExpression(node);
-            return;
-          case "ArrayPattern":
-            for (const element of node.elements) {
-              if (element !== null) {
-                this.visitBindingElement(element);
-              }
-            }
-            return;
-          case "ObjectPattern":
-            for (const property of node.properties) {
-              if (property.type === "RestElement") {
-                this.visitBindingPattern(property.argument);
-                continue;
-              }
-              this.visitAssignmentProperty(property);
-            }
-            return;
-        }
-      }
-      visitAssignmentProperty(node) {
-        if (node.computed) {
-          this.visitExpression(node.key);
-        }
-        this.visitBindingElement(node.value);
-      }
-      visitAssignmentTarget(node) {
-        switch (node.type) {
-          case "AssignmentPattern":
-            this.visitAssignmentTarget(node.left);
-            this.visitExpression(node.right);
-            return;
-          case "RestElement":
-            this.visitAssignmentTarget(node.argument);
-            return;
-          case "Identifier":
-            this.visitIdentifier(node);
-            return;
-          case "MemberExpression":
-            this.visitMemberExpression(node);
-            return;
-          case "ArrayPattern":
-            for (const element of node.elements) {
-              if (element === null) {
-                continue;
-              }
-              this.visitAssignmentTarget(element);
-            }
-            return;
-          case "ObjectPattern":
-            for (const property of node.properties) {
-              if (property.type === "RestElement") {
-                this.visitAssignmentTarget(property);
-                continue;
-              }
-              if (property.computed) {
-                this.visitExpression(property.key);
-              }
-              this.visitAssignmentTarget(property.value);
-            }
-            return;
-        }
-      }
-      visitIdentifier(node) {
-        const currentLambda = this.lambdaStack[this.lambdaStack.length - 1];
-        if (currentLambda === void 0) {
-          return;
-        }
-        const binding = this.resolveBinding(node.name);
-        if (binding === void 0 || binding.kind !== "let" || binding.ownerLambdaDepth >= currentLambda.depth) {
-          return;
-        }
-        const captureKey = `${currentLambda.nodeId}:${binding.name}`;
-        if (this.reportedCaptures.has(captureKey)) {
-          return;
-        }
-        this.reportedCaptures.add(captureKey);
-        this.diagnostics.push({
-          code: "AS002",
-          severity: "error",
-          message: `Lambda closes over let-bound '${binding.name}' from an outer scope. Change it to const or pass it as a parameter.`,
-          filename: this.filename,
-          line: node.span.start.line,
-          column: node.span.start.column,
-          span: node.span
-        });
-      }
-      withScope(bindings, visit) {
-        const scope = /* @__PURE__ */ new Map();
-        for (const binding of bindings) {
-          scope.set(binding.name, binding);
-        }
-        this.scopes.push(scope);
-        visit();
-        this.scopes.pop();
-      }
-      resolveBinding(name) {
-        for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
-          const binding = this.scopes[index]?.get(name);
-          if (binding !== void 0) {
-            return binding;
-          }
-        }
-        return void 0;
-      }
-      collectModuleBindings(body) {
-        const bindings = [];
-        for (const statement of body) {
-          if (statement.type === "ImportDeclaration") {
-            bindings.push(...this.collectImportBindings(statement));
-            continue;
-          }
-          if (statement.type === "VariableDeclaration") {
-            bindings.push(...this.collectDeclarationBindings(statement));
-            continue;
-          }
-          if (statement.type === "ExportNamedDeclaration") {
-            bindings.push(...this.collectDeclarationBindings(statement.declaration));
-          }
-        }
-        return bindings;
-      }
-      collectBlockBindings(body) {
-        const bindings = [];
-        for (const statement of body) {
-          if (statement.type === "VariableDeclaration") {
-            bindings.push(...this.collectDeclarationBindings(statement));
-          }
-        }
-        return bindings;
-      }
-      collectParameterBindings(node) {
-        const bindings = [];
-        for (const parameter of node.params) {
-          this.collectBindingNamesFromElement(parameter, "param", bindings);
-        }
-        return bindings;
-      }
-      collectDeclarationBindings(node) {
-        const bindings = [];
-        for (const declarator of node.declarations) {
-          this.collectBindingNamesFromPattern(declarator.id, node.kind, bindings);
-        }
-        return bindings;
-      }
-      collectCatchBindings(node) {
-        const bindings = [];
-        if (node.param !== void 0) {
-          this.collectBindingNamesFromPattern(node.param, "let", bindings);
-        }
-        return bindings;
-      }
-      collectImportBindings(node) {
-        const bindings = [];
-        for (const specifier of node.specifiers) {
-          bindings.push(this.createBinding(specifier.local.name, "import"));
-        }
-        return bindings;
-      }
-      collectBindingNamesFromElement(node, kind, bindings) {
-        switch (node.type) {
-          case "AssignmentPattern":
-            this.collectBindingNamesFromPattern(node.left, kind, bindings);
-            return;
-          case "RestElement":
-            this.collectBindingNamesFromPattern(node.argument, kind, bindings);
-            return;
-          default:
-            this.collectBindingNamesFromPattern(node, kind, bindings);
-            return;
-        }
-      }
-      collectBindingNamesFromPattern(node, kind, bindings) {
-        switch (node.type) {
-          case "Identifier":
-            bindings.push(this.createBinding(node.name, kind));
-            return;
-          case "MemberExpression":
-            return;
-          case "ArrayPattern":
-            for (const element of node.elements) {
-              if (element !== null) {
-                this.collectBindingNamesFromElement(element, kind, bindings);
-              }
-            }
-            return;
-          case "ObjectPattern":
-            for (const property of node.properties) {
-              if (property.type === "RestElement") {
-                this.collectBindingNamesFromPattern(property.argument, kind, bindings);
-                continue;
-              }
-              this.collectBindingNamesFromElement(property.value, kind, bindings);
-            }
-            return;
-        }
-      }
-      createBinding(name, kind) {
-        return {
-          kind,
-          name,
-          ownerLambdaDepth: this.lambdaStack.length
-        };
-      }
-    };
-  }
-});
-
 // packages/safejs/src/lint/rules/known-globals.ts
 var KNOWN_RUNTIME_GLOBALS;
 var init_known_globals = __esm({
@@ -136295,7 +135764,6 @@ var init_lint3 = __esm({
   "packages/safejs/src/lint/index.ts"() {
     "use strict";
     init_AS001();
-    init_AS002();
     init_AS003();
     init_AS004();
     init_AS005();
@@ -136326,7 +135794,6 @@ var init_lint3 = __esm({
     init_tokenizer2();
     init_parser3();
     RULES = [
-      AS002,
       AS003,
       AS004,
       AS005,
@@ -152713,7 +152180,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "4.0.56",
+      version: "4.0.58",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",