0sec-cli 0.18.0 → 0.22.0

package/node_modules/tree-sitter/tree-sitter.d.ts

@@ -0,0 +1,211 @@
+declare module "tree-sitter" {
+  class Parser {
+    parse(input: string | Parser.Input, oldTree?: Parser.Tree, options?: Parser.Options): Parser.Tree;
+    getIncludedRanges(): Parser.Range[];
+    getTimeoutMicros(): number;
+    setTimeoutMicros(timeout: number): void;
+    reset(): void;
+    getLanguage(): any;
+    setLanguage(language?: any): void;
+    getLogger(): Parser.Logger;
+    setLogger(logFunc?: Parser.Logger | false | null): void;
+    printDotGraphs(enabled?: boolean, fd?: number): void;
+  }
+
+  namespace Parser {
+    export type Options = {
+      bufferSize?: number, includedRanges?: Range[];
+    };
+
+    export type Point = {
+      row: number;
+      column: number;
+    };
+
+    export type Range = {
+      startIndex: number,
+      endIndex: number,
+      startPosition: Point,
+      endPosition: Point
+    };
+
+    export type Edit = {
+      startIndex: number;
+      oldEndIndex: number;
+      newEndIndex: number;
+      startPosition: Point;
+      oldEndPosition: Point;
+      newEndPosition: Point;
+    };
+
+    export type Logger = (
+      message: string,
+      params: { [param: string]: string },
+      type: "parse" | "lex"
+    ) => void;
+
+    export interface Input {
+      (index: number, position?: Point): string | null;
+    }
+
+    export interface SyntaxNode {
+      tree: Tree;
+      id: number;
+      typeId: number;
+      grammarId: number;
+      type: string;
+      grammarType: string;
+      isNamed: boolean;
+      isMissing: boolean;
+      isExtra: boolean;
+      hasChanges: boolean;
+      hasError: boolean;
+      isError: boolean;
+      text: string;
+      parseState: number;
+      nextParseState: number;
+      startPosition: Point;
+      endPosition: Point;
+      startIndex: number;
+      endIndex: number;
+      parent: SyntaxNode | null;
+      children: Array<SyntaxNode>;
+      namedChildren: Array<SyntaxNode>;
+      childCount: number;
+      namedChildCount: number;
+      firstChild: SyntaxNode | null;
+      firstNamedChild: SyntaxNode | null;
+      lastChild: SyntaxNode | null;
+      lastNamedChild: SyntaxNode | null;
+      nextSibling: SyntaxNode | null;
+      nextNamedSibling: SyntaxNode | null;
+      previousSibling: SyntaxNode | null;
+      previousNamedSibling: SyntaxNode | null;
+      descendantCount: number;
+
+      toString(): string;
+      child(index: number): SyntaxNode | null;
+      namedChild(index: number): SyntaxNode | null;
+      childForFieldName(fieldName: string): SyntaxNode | null;
+      childForFieldId(fieldId: number): SyntaxNode | null;
+      fieldNameForChild(childIndex: number): string | null;
+      childrenForFieldName(fieldName: string): Array<SyntaxNode>;
+      childrenForFieldId(fieldId: number): Array<SyntaxNode>;
+      firstChildForIndex(index: number): SyntaxNode | null;
+      firstNamedChildForIndex(index: number): SyntaxNode | null;
+
+      descendantForIndex(index: number): SyntaxNode;
+      descendantForIndex(startIndex: number, endIndex: number): SyntaxNode;
+      namedDescendantForIndex(index: number): SyntaxNode;
+      namedDescendantForIndex(startIndex: number, endIndex: number): SyntaxNode;
+      descendantForPosition(position: Point): SyntaxNode;
+      descendantForPosition(startPosition: Point, endPosition: Point): SyntaxNode;
+      namedDescendantForPosition(position: Point): SyntaxNode;
+      namedDescendantForPosition(startPosition: Point, endPosition: Point): SyntaxNode;
+      descendantsOfType(types: String | Array<String>, startPosition?: Point, endPosition?: Point): Array<SyntaxNode>;
+
+      closest(types: String | Array<String>): SyntaxNode | null;
+      walk(): TreeCursor;
+    }
+
+    export interface TreeCursor {
+      nodeType: string;
+      nodeTypeId: number;
+      nodeStateId: number;
+      nodeText: string;
+      nodeIsNamed: boolean;
+      nodeIsMissing: boolean;
+      startPosition: Point;
+      endPosition: Point;
+      startIndex: number;
+      endIndex: number;
+      readonly currentNode: SyntaxNode;
+      readonly currentFieldName: string;
+      readonly currentFieldId: number;
+      readonly currentDepth: number;
+      readonly currentDescendantIndex: number;
+
+      reset(node: SyntaxNode): void;
+      resetTo(cursor: TreeCursor): void;
+      gotoParent(): boolean;
+      gotoFirstChild(): boolean;
+      gotoLastChild(): boolean;
+      gotoFirstChildForIndex(goalIndex: number): boolean;
+      gotoFirstChildForPosition(goalPosition: Point): boolean;
+      gotoNextSibling(): boolean;
+      gotoPreviousSibling(): boolean;
+      gotoDescendant(goalDescendantIndex: number): void;
+    }
+
+    export interface Tree {
+      readonly rootNode: SyntaxNode;
+
+      rootNodeWithOffset(offsetBytes: number, offsetExtent: Point): SyntaxNode;
+      edit(edit: Edit): Tree;
+      walk(): TreeCursor;
+      getChangedRanges(other: Tree): Range[];
+      getIncludedRanges(): Range[];
+      getEditedRange(other: Tree): Range;
+      printDotGraph(fd?: number): void;
+    }
+
+    export interface QueryCapture {
+      name: string;
+      text?: string;
+      node: SyntaxNode;
+      setProperties?: { [prop: string]: string | null };
+      assertedProperties?: { [prop: string]: string | null };
+      refutedProperties?: { [prop: string]: string | null };
+    }
+
+    export interface QueryMatch {
+      pattern: number;
+      captures: QueryCapture[];
+    }
+
+    export type QueryOptions = {
+      startPosition?: Point;
+      endPosition?: Point;
+      startIndex?: number;
+      endIndex?: number;
+      matchLimit?: number;
+      maxStartDepth?: number;
+    };
+
+    export interface PredicateResult {
+      operator: string;
+      operands: { name: string; type: string }[];
+    }
+
+    export class Query {
+      readonly predicates: { [name: string]: Function }[];
+      readonly setProperties: any[];
+      readonly assertedProperties: any[];
+      readonly refutedProperties: any[];
+      readonly matchLimit: number;
+
+      constructor(language: any, source: string | Buffer);
+
+      captures(node: SyntaxNode, options?: QueryOptions): QueryCapture[];
+      matches(node: SyntaxNode, options?: QueryOptions): QueryMatch[];
+      disableCapture(captureName: string): void;
+      disablePattern(patternIndex: number): void;
+      isPatternGuaranteedAtStep(byteOffset: number): boolean;
+      isPatternRooted(patternIndex: number): boolean;
+      isPatternNonLocal(patternIndex: number): boolean;
+      startIndexForPattern(patternIndex: number): number;
+      didExceedMatchLimit(): boolean;
+    }
+
+    export class LookaheadIterable {
+      readonly currentTypeId: number;
+      readonly currentType: string;
+
+      reset(language: any, stateId: number): boolean;
+      resetState(stateId: number): boolean;
+      [Symbol.iterator](): Iterator<string>;
+    }
+  }
+
+  export = Parser
+}

package/node_modules/tree-sitter/vendor/tree-sitter/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-2024 Max Brunsfeld
+
+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/node_modules/tree-sitter/vendor/tree-sitter/README.md

@@ -0,0 +1,21 @@
+# tree-sitter
+
+[![DOI](https://zenodo.org/badge/14164618.svg)](https://zenodo.org/badge/latestdoi/14164618)
+[![discord][discord]](https://discord.gg/w7nTvsVJhm)
+[![matrix][matrix]](https://matrix.to/#/#tree-sitter-chat:matrix.org)
+
+Tree-sitter is a parser generator tool and an incremental parsing library. It can build a concrete syntax tree for a source file and efficiently update the syntax tree as the source file is edited. Tree-sitter aims to be:
+
+- **General** enough to parse any programming language
+- **Fast** enough to parse on every keystroke in a text editor
+- **Robust** enough to provide useful results even in the presence of syntax errors
+- **Dependency-free** so that the runtime library (which is written in pure C) can be embedded in any application
+
+## Links
+- [Documentation](https://tree-sitter.github.io)
+- [Rust binding](lib/binding_rust/README.md)
+- [WASM binding](lib/binding_web/README.md)
+- [Command-line interface](cli/README.md)
+
+[discord]: https://img.shields.io/discord/1063097320771698699?logo=discord&label=discord
+[matrix]: https://img.shields.io/matrix/tree-sitter-chat%3Amatrix.org?logo=matrix&label=matrix

package/node_modules/tree-sitter/vendor/tree-sitter/lib/README.md

@@ -0,0 +1,6 @@
+## Subdirectories
+
+* [`src`](./src) - C source code for the Tree-sitter library
+* [`include`](./include) - C headers for the Tree-sitter library
+* [`binding_rust`](./binding_rust) - Rust bindings to the Tree-sitter library
+* [`binding_web`](./binding_web) - JavaScript bindings to the Tree-sitter library, using WebAssembly