@danielblomma/cortex-mcp 1.3.1 → 1.4.0

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/tokenType.js

@@ -0,0 +1,118 @@
+// @ts-ignore
+import { TokenType, keywordTypes, tokTypes, TokContext } from 'acorn';
+const startsExpr = true;
+// Succinct definitions of keyword token types
+function kwLike(_name, options = {}) {
+    return new TokenType('name', options);
+}
+const acornTypeScriptMap = new WeakMap();
+export function generateAcornTypeScript(_acorn) {
+    const acorn = _acorn.Parser.acorn || _acorn;
+    let acornTypeScript = acornTypeScriptMap.get(acorn);
+    if (!acornTypeScript) {
+        const tsKwTokenType = generateTsKwTokenType();
+        const tsTokenType = generateTsTokenType();
+        const tsTokenContext = generateTsTokenContext();
+        const tsKeywordsRegExp = new RegExp(`^(?:${Object.keys(tsKwTokenType).join('|')})$`);
+        tsTokenType.jsxTagStart.updateContext = function () {
+            this.context.push(tsTokenContext.tc_expr); // treat as beginning of
+            // JSX expression
+            this.context.push(tsTokenContext.tc_oTag); // start opening tag context
+            this.exprAllowed = false;
+        };
+        tsTokenType.jsxTagEnd.updateContext = function (prevType) {
+            let out = this.context.pop();
+            if (out === tsTokenContext.tc_oTag && prevType === tokTypes.slash || out === tsTokenContext.tc_cTag) {
+                this.context.pop();
+                this.exprAllowed = this.curContext() === tsTokenContext.tc_expr;
+            }
+            else {
+                this.exprAllowed = true;
+            }
+        };
+        function tokenIsLiteralPropertyName(token) {
+            return [
+                ...[tokTypes.name, tokTypes.string, tokTypes.num],
+                ...Object.values(keywordTypes),
+                ...Object.values(tsKwTokenType)
+            ].includes(token);
+        }
+        function tokenIsKeywordOrIdentifier(token) {
+            return [
+                ...[tokTypes.name],
+                ...Object.values(keywordTypes),
+                ...Object.values(tsKwTokenType)
+            ].includes(token);
+        }
+        function tokenIsIdentifier(token) {
+            return [...Object.values(tsKwTokenType), tokTypes.name].includes(token);
+        }
+        function tokenIsTSDeclarationStart(token) {
+            return [
+                tsKwTokenType.abstract,
+                tsKwTokenType.declare,
+                tsKwTokenType.enum,
+                tsKwTokenType.module,
+                tsKwTokenType.namespace,
+                tsKwTokenType.interface,
+                tsKwTokenType.type
+            ].includes(token);
+        }
+        function tokenIsTSTypeOperator(token) {
+            return [
+                tsKwTokenType.keyof,
+                tsKwTokenType.readonly,
+                tsKwTokenType.unique
+            ].includes(token);
+        }
+        function tokenIsTemplate(token) {
+            return token === tokTypes.invalidTemplate;
+        }
+        acornTypeScript = {
+            tokTypes: Object.assign(Object.assign({}, tsKwTokenType), tsTokenType),
+            tokContexts: Object.assign({}, tsTokenContext),
+            keywordsRegExp: tsKeywordsRegExp,
+            tokenIsLiteralPropertyName,
+            tokenIsKeywordOrIdentifier,
+            tokenIsIdentifier,
+            tokenIsTSDeclarationStart,
+            tokenIsTSTypeOperator,
+            tokenIsTemplate
+        };
+    }
+    return acornTypeScript;
+}
+function generateTsTokenContext() {
+    return {
+        tc_oTag: new TokContext('<tag', false, false),
+        tc_cTag: new TokContext('</tag', false, false),
+        tc_expr: new TokContext('<tag>...</tag>', true, true)
+    };
+}
+function generateTsTokenType() {
+    return {
+        at: new TokenType('@'),
+        jsxName: new TokenType('jsxName'),
+        jsxText: new TokenType('jsxText', { beforeExpr: true }),
+        jsxTagStart: new TokenType('jsxTagStart', { startsExpr: true }),
+        jsxTagEnd: new TokenType('jsxTagEnd')
+    };
+}
+function generateTsKwTokenType() {
+    return {
+        assert: kwLike('assert', { startsExpr }),
+        asserts: kwLike('asserts', { startsExpr }),
+        global: kwLike('global', { startsExpr }),
+        keyof: kwLike('keyof', { startsExpr }),
+        readonly: kwLike('readonly', { startsExpr }),
+        unique: kwLike('unique', { startsExpr }),
+        abstract: kwLike('abstract', { startsExpr }),
+        declare: kwLike('declare', { startsExpr }),
+        enum: kwLike('enum', { startsExpr }),
+        module: kwLike('module', { startsExpr }),
+        namespace: kwLike('namespace', { startsExpr }),
+        interface: kwLike('interface', { startsExpr }),
+        type: kwLike('type', { startsExpr })
+    };
+}
+//# sourceMappingURL=tokenType.js.map

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/tokenType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenType.js","sourceRoot":"","sources":["../src/tokenType.ts"],"names":[],"mappings":"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"}

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/types.d.ts

@@ -0,0 +1,60 @@
+import type { Position, TokContext, TokenType } from 'acorn';
+export declare type Accessibility = 'public' | 'protected' | 'private';
+export declare type VarianceAnnotations = 'in' | 'out';
+export declare type ClassAccessor = 'accessor';
+export declare type TsModifier = 'readonly' | 'abstract' | 'declare' | 'static' | 'override' | Accessibility | VarianceAnnotations | ClassAccessor;
+export declare type LookaheadState = {
+    pos: number;
+    value: any;
+    type: TokenType;
+    start: number;
+    end: number;
+    context: TokContext[];
+    startLoc: any;
+    endLoc: any;
+    lastTokEndLoc: any;
+    lastTokStartLoc: any;
+    lastTokStart: any;
+    lastTokEnd: any;
+    curLine: number;
+    lineStart: number;
+    curPosition: () => Position;
+    containsEsc: boolean;
+};
+export declare type ParsingContext = 'EnumMembers' | 'HeritageClauseElement' | 'TupleElementTypes' | 'TypeMembers' | 'TypeParametersOrArguments';
+export declare type ModifierBase = {
+    accessibility?: Accessibility;
+} & {
+    [key in TsModifier]?: boolean | undefined | null;
+};
+export declare type TryParse<Node, Error, Thrown, Aborted, FailState> = {
+    node: Node;
+    error: Error;
+    thrown: Thrown;
+    aborted: Aborted;
+    failState: FailState;
+};
+export declare type AcornTypeScript = {
+    tokTypes: Record<string, TokenType>;
+    tokContexts: Record<string, TokenType>;
+    keywordsRegExp: RegExp;
+    tokenIsLiteralPropertyName(token: TokenType): boolean;
+    tokenIsKeywordOrIdentifier(token: TokenType): boolean;
+    tokenIsIdentifier(token: TokenType): boolean;
+    tokenIsTSDeclarationStart(token: TokenType): boolean;
+    tokenIsTSTypeOperator(token: TokenType): boolean;
+    tokenIsTemplate(token: TokenType): boolean;
+};
+export declare type AcornJsx = {
+    tokTypes: {
+        jsxName: TokenType;
+        jsxText: TokenType;
+        jsxTagEnd: TokenType;
+        jsxTagStart: TokenType;
+    };
+    tokContexts: {
+        tc_oTag: TokContext;
+        tc_cTag: TokContext;
+        tc_expr: TokContext;
+    };
+};

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/whitespace.d.ts

@@ -0,0 +1,2 @@
+export declare const skipWhiteSpaceInLine: RegExp;
+export declare const skipWhiteSpaceToLineBreak: RegExp;

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/whitespace.js

@@ -0,0 +1,19 @@
+export const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/y;
+// Skip whitespace and single-line comments, including /* no newline here */.
+// After this RegExp matches, its lastIndex points to a line terminator, or
+// the start of multi-line comment (which is effectively a line terminator),
+// or the end of string.
+export const skipWhiteSpaceToLineBreak = new RegExp(
+// Unfortunately JS doesn't support Perl's atomic /(?>pattern)/ or
+// possessive quantifiers, so we use a trick to prevent backtracking
+// when the look-ahead for line terminator fails.
+'(?=(' +
+    // Capture the whitespace and comments that should be skipped inside
+    // a look-ahead assertion, and then re-match the group as a unit.
+    skipWhiteSpaceInLine.source +
+    '))\\1' +
+    // Look-ahead for either line terminator, start of multi-line comment,
+    // or end of string.
+    /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, 'y' // sticky
+);
+//# sourceMappingURL=whitespace.js.map

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/whitespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace.js","sourceRoot":"","sources":["../src/whitespace.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAC/B,gDAAgD,CAAA;AAElD,6EAA6E;AAC7E,2EAA2E;AAC3E,4EAA4E;AAC5E,wBAAwB;AACxB,MAAM,CAAC,MAAM,yBAAyB,GAAG,IAAI,MAAM;AACjD,kEAAkE;AAClE,oEAAoE;AACpE,iDAAiD;AACjD,MAAM;IACN,oEAAoE;IACpE,iEAAiE;IACjE,oBAAoB,CAAC,MAAM;IAC3B,OAAO;IACP,sEAAsE;IACtE,oBAAoB;IACpB,0CAA0C,CAAC,MAAM,EACjD,GAAG,CAAC,SAAS;CACd,CAAA"}

package/scaffold/scripts/parsers/node_modules/acorn-typescript/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "acorn-typescript",
+  "version": "1.4.13",
+  "description": "Alternative, TypeScript parser",
+  "source": "src/index.ts",
+  "main": "lib/index.js",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "microbundle --define process.env.NODE_ENV=production --no-sourcemap --tsconfig ./tsconfig.json --format esm,cjs",
+    "test": "jest --collect-coverage --silent",
+    "test:test262": "ts-node -T __test__/run_test262.ts",
+    "release-major": "yarn build && yarn test && standard-version --release-as major",
+    "release-minor": "yarn build && yarn test && standard-version --release-as minor",
+    "release-patch": "yarn build && yarn test && standard-version --release-as patch"
+  },
+  "exports": {
+    ".": [
+      {
+        "import": "./lib/index.mjs",
+        "require": "./lib/index.js",
+        "default": "./lib/index.js"
+      },
+      "./lib/index.js"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TyrealHu/acorn-typescript.git"
+  },
+  "author": "tyrealhu",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/TyrealHu/acorn-typescript/issues"
+  },
+  "homepage": "https://github.com/TyrealHu/acorn-typescript#readme",
+  "devDependencies": {
+    "@types/jest": "^24.1.0",
+    "acorn": "^8.9.0",
+    "acorn-jsx": "^5.3.2",
+    "jest": "^24.1.0",
+    "microbundle": "^0.15.1",
+    "standard-version": "^9.5.0",
+    "ts-jest": "^26.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.4",
+    "test262": "git+https://github.com/tc39/test262.git#dac69563480b9f22709fd49d61a32b3a0513b6b1",
+    "test262-parser-runner": "^0.5.0"
+  },
+  "peerDependencies": {
+    "acorn": ">=8.9.0"
+  }
+}

package/scaffold/scripts/parsers/node_modules/acorn-typescript/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "target": "es6",
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node",
+    "outDir": "lib",
+    "experimentalDecorators": true,
+    "lib": ["es2017", "dom"],
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "preserveConstEnums": true,
+    "removeComments": false,
+    "sourceMap": true,
+    "strict": false
+  },
+  "include": ["./src/*", "./types/*"],
+  "exclude": ["node_modules", "lib"]
+}

package/scaffold/scripts/parsers/node_modules/acorn-walk/CHANGELOG.md

@@ -0,0 +1,209 @@
+## 8.3.5 (2026-02-19)
+
+### Bug fixes
+
+Emit a more informative error message when trying to walk a node type that has no walker function.
+
+Specify callbacks in types to receive `AnyNode` type, so that they can be narrowed more easily.
+
+Support import attributes.
+
+## 8.3.4 (2024-09-09)
+
+### Bug fixes
+
+Walk SwitchCase nodes as separate nodes.
+
+## 8.3.3 (2024-01-11)
+
+### Bug fixes
+
+Make acorn a dependency because acorn-walk uses the types from that package.
+
+## 8.3.2 (2024-01-11)
+
+### Bug fixes
+
+Add missing type for `findNodeBefore`.
+
+## 8.3.1 (2023-12-06)
+
+### Bug fixes
+
+Add `Function` and `Class` to the `AggregateType` type, so that they can be used in walkers without raising a type error.
+
+Visitor functions are now called in such a way that their `this` refers to the object they are part of.
+
+## 8.3.0 (2023-10-26)
+
+### New features
+
+Use a set of new, much more precise, TypeScript types.
+
+## 8.2.0 (2021-09-06)
+
+### New features
+
+Add support for walking ES2022 class static blocks.
+
+## 8.1.1 (2021-06-29)
+
+### Bug fixes
+
+Include `base` in the type declarations.
+
+## 8.1.0 (2021-04-24)
+
+### New features
+
+Support node types for class fields and private methods.
+
+## 8.0.2 (2021-01-25)
+
+### Bug fixes
+
+Adjust package.json to work with Node 12.16.0 and 13.0-13.6.
+
+## 8.0.0 (2021-01-05)
+
+### Bug fixes
+
+Fix a bug where `full` and `fullAncestor` would skip nodes with overridden types.
+
+## 8.0.0 (2020-08-12)
+
+### New features
+
+The package can now be loaded directly as an ECMAScript module in node 13+.
+
+## 7.2.0 (2020-06-17)
+
+### New features
+
+Support optional chaining and nullish coalescing.
+
+Support `import.meta`.
+
+Add support for `export * as ns from "source"`.
+
+## 7.1.1 (2020-02-13)
+
+### Bug fixes
+
+Clean up the type definitions to actually work well with the main parser.
+
+## 7.1.0 (2020-02-11)
+
+### New features
+
+Add a TypeScript definition file for the library.
+
+## 7.0.0 (2017-08-12)
+
+### New features
+
+Support walking `ImportExpression` nodes.
+
+## 6.2.0 (2017-07-04)
+
+### New features
+
+Add support for `Import` nodes.
+
+## 6.1.0 (2018-09-28)
+
+### New features
+
+The walker now walks `TemplateElement` nodes.
+
+## 6.0.1 (2018-09-14)
+
+### Bug fixes
+
+Fix bad "main" field in package.json.
+
+## 6.0.0 (2018-09-14)
+
+### Breaking changes
+
+This is now a separate package, `acorn-walk`, rather than part of the main `acorn` package.
+
+The `ScopeBody` and `ScopeExpression` meta-node-types are no longer supported.
+
+## 5.7.1 (2018-06-15)
+
+### Bug fixes
+
+Make sure the walker and bin files are rebuilt on release (the previous release didn't get the up-to-date versions).
+
+## 5.7.0 (2018-06-15)
+
+### Bug fixes
+
+Fix crash in walker when walking a binding-less catch node.
+
+## 5.6.2 (2018-06-05)
+
+### Bug fixes
+
+In the walker, go back to allowing the `baseVisitor` argument to be null to default to the default base everywhere.
+
+## 5.6.1 (2018-06-01)
+
+### Bug fixes
+
+Fix regression when passing `null` as fourth argument to `walk.recursive`.
+
+## 5.6.0 (2018-05-31)
+
+### Bug fixes
+
+Fix a bug in the walker that caused a crash when walking an object pattern spread.
+
+## 5.5.1 (2018-03-06)
+
+### Bug fixes
+
+Fix regression in walker causing property values in object patterns to be walked as expressions.
+
+## 5.5.0 (2018-02-27)
+
+### Bug fixes
+
+Support object spread in the AST walker.
+
+## 5.4.1 (2018-02-02)
+
+### Bug fixes
+
+5.4.0 somehow accidentally included an old version of walk.js.
+
+## 5.2.0 (2017-10-30)
+
+### Bug fixes
+
+The `full` and `fullAncestor` walkers no longer visit nodes multiple times.
+
+## 5.1.0 (2017-07-05)
+
+### New features
+
+New walker functions `full` and `fullAncestor`.
+
+## 3.2.0 (2016-06-07)
+
+### New features
+
+Make it possible to use `visit.ancestor` with a walk state.
+
+## 3.1.0 (2016-04-18)
+
+### New features
+
+The walker now allows defining handlers for `CatchClause` nodes.
+
+## 2.5.2 (2015-10-27)
+
+### Fixes
+
+Fix bug where the walker walked an exported `let` statement as an expression.

package/scaffold/scripts/parsers/node_modules/acorn-walk/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2012-2020 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/scaffold/scripts/parsers/node_modules/acorn-walk/README.md

@@ -0,0 +1,124 @@
+# Acorn AST walker
+
+An abstract syntax tree walker for the
+[ESTree](https://github.com/estree/estree) format.
+
+## Community
+
+Acorn is open source software released under an
+[MIT license](https://github.com/acornjs/acorn/blob/master/acorn-walk/LICENSE).
+
+You are welcome to
+[report bugs](https://github.com/acornjs/acorn/issues) or create pull
+requests on [github](https://github.com/acornjs/acorn).
+
+## Installation
+
+The easiest way to install acorn is from [`npm`](https://www.npmjs.com/):
+
+```sh
+npm install acorn-walk
+```
+
+Alternately, you can download the source and build acorn yourself:
+
+```sh
+git clone https://github.com/acornjs/acorn.git
+cd acorn
+npm install
+```
+
+## Interface
+
+An algorithm for recursing through a syntax tree is stored as an
+object, with a property for each tree node type holding a function
+that will recurse through such a node. There are several ways to run
+such a walker.
+
+**simple**`(node, visitors, base, state)` does a 'simple' walk over a
+tree. `node` should be the AST node to walk, and `visitors` an object
+with properties whose names correspond to node types in the [ESTree
+spec](https://github.com/estree/estree). The properties should contain
+functions that will be called with the node object and, if applicable
+the state at that point. The last two arguments are optional. `base`
+is a walker algorithm, and `state` is a start state. The default
+walker will simply visit all statements and expressions and not
+produce a meaningful state. (An example of a use of state is to track
+scope at each point in the tree.)
+
+```js
+import * as acorn from "acorn"
+import * as walk from "acorn-walk"
+
+walk.simple(acorn.parse("let x = 10"), {
+  Literal(node) {
+    console.log(`Found a literal: ${node.value}`)
+  }
+})
+```
+
+**ancestor**`(node, visitors, base, state)` does a 'simple' walk over
+a tree, building up an array of ancestor nodes (including the current node)
+and passing the array to the callbacks as a third parameter.
+
+```js
+import * as acorn from "acorn"
+import * as walk from "acorn-walk"
+
+walk.ancestor(acorn.parse("foo('hi')"), {
+  Literal(_node, _state, ancestors) {
+    console.log("This literal's ancestors are:", ancestors.map(n => n.type))
+  }
+})
+```
+
+**recursive**`(node, state, functions, base)` does a 'recursive'
+walk, where the walker functions are responsible for continuing the
+walk on the child nodes of their target node. `state` is the start
+state, and `functions` should contain an object that maps node types
+to walker functions. Such functions are called with `(node, state, c)`
+arguments, and can cause the walk to continue on a sub-node by calling
+the `c` argument on it with `(node, state)` arguments. The optional
+`base` argument provides the fallback walker functions for node types
+that aren't handled in the `functions` object. If not given, the
+default walkers will be used.
+
+**make**`(functions, base)` builds a new walker object by using the
+walker functions in `functions` and filling in the missing ones by
+taking defaults from `base`.
+
+**full**`(node, callback, base, state)` does a 'full' walk over a
+tree, calling the callback with the arguments (node, state, type) for
+each node
+
+**fullAncestor**`(node, callback, base, state)` does a 'full' walk
+over a tree, building up an array of ancestor nodes (including the
+current node) and passing the array to the callbacks as a third
+parameter.
+
+```js
+import * as acorn from "acorn"
+import * as walk from "acorn-walk"
+
+walk.full(acorn.parse("1 + 1"), node => {
+  console.log(`There's a ${node.type} node at ${node.ch}`)
+})
+```
+
+**findNodeAt**`(node, start, end, test, base, state)` tries to locate
+a node in a tree at the given start and/or end offsets, which
+satisfies the predicate `test`. `start` and `end` can be either `null`
+(as wildcard) or a number. `test` may be a string (indicating a node
+type) or a function that takes `(nodeType, node)` arguments and
+returns a boolean indicating whether this node is interesting. `base`
+and `state` are optional, and can be used to specify a custom walker.
+Nodes are tested from inner to outer, so if two nodes match the
+boundaries, the inner one will be preferred.
+
+**findNodeAround**`(node, pos, test, base, state)` is a lot like
+`findNodeAt`, but will match any node that exists 'around' (spanning)
+the given position.
+
+**findNodeAfter**`(node, pos, test, base, state)` is similar to
+`findNodeAround`, but will match all nodes *after* the given position
+(testing outer nodes before inner nodes).