svg-eslint-parser 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,418 @@
+import * as eslint from 'eslint';
+import { SourceCode as SourceCode$1 } from 'eslint';
+
+declare const meta: {
+    name: string;
+    version: string;
+};
+
+/**
+ * parse error
+ */
+declare class ParseError extends SyntaxError {
+    index: number;
+    lineNumber: number;
+    column: number;
+    constructor(message: string, offset: number, line: number, column: number);
+}
+
+declare enum NodeTypes {
+    Program = "Program",
+    Document = "Document",
+    Text = "Text",
+    Doctype = "Doctype",
+    DoctypeOpen = "DoctypeOpen",
+    DoctypeClose = "DoctypeClose",
+    DoctypeAttribute = "DoctypeAttribute",
+    DoctypeAttributeKey = "DoctypeAttributeKey",
+    DoctypeAttributeValue = "DoctypeAttributeValue",
+    DoctypeAttributeWrapperEnd = "DoctypeAttributeWrapperEnd",
+    DoctypeAttributeWrapperStart = "DoctypeAttributeWrapperStart",
+    Tag = "Tag",
+    OpenTagStart = "OpenTagStart",
+    OpenTagEnd = "OpenTagEnd",
+    CloseTag = "CloseTag",
+    Comment = "Comment",
+    CommentOpen = "CommentOpen",
+    CommentClose = "CommentClose",
+    CommentContent = "CommentContent",
+    Attribute = "Attribute",
+    AttributeKey = "AttributeKey",
+    AttributeValue = "AttributeValue",
+    AttributeValueWrapperStart = "AttributeValueWrapperStart",
+    AttributeValueWrapperEnd = "AttributeValueWrapperEnd"
+}
+
+declare enum TokenTypes {
+    Program = "Program",
+    Document = "Document",
+    Text = "Text",
+    Doctype = "Doctype",
+    DoctypeOpen = "DoctypeOpen",
+    DoctypeClose = "DoctypeClose",
+    DoctypeAttributeValue = "DoctypeAttributeValue",
+    DoctypeAttributeWrapperStart = "DoctypeAttributeWrapperStart",
+    DoctypeAttributeWrapperEnd = "DoctypeAttributeWrapperEnd",
+    Tag = "Tag",
+    OpenTagStart = "OpenTagStart",
+    OpenTagEnd = "OpenTagEnd",
+    CloseTag = "CloseTag",
+    Comment = "Comment",
+    CommentOpen = "CommentOpen",
+    CommentClose = "CommentClose",
+    CommentContent = "CommentContent",
+    Attribute = "Attribute",
+    AttributeKey = "AttributeKey",
+    AttributeValue = "AttributeValue",
+    AttributeAssignment = "AttributeAssignment",
+    AttributeValueWrapperStart = "AttributeValueWrapperStart",
+    AttributeValueWrapperEnd = "AttributeValueWrapperEnd"
+}
+
+declare enum TokenizerContextTypes {
+    Data = "Data",
+    OpenTagStart = "OpenTagStart",
+    OpenTagEnd = "OpenTagEnd",
+    CloseTag = "CloseTag",
+    Attributes = "Attributes",
+    AttributeKey = "AttributeKey",
+    AttributeValue = "AttributeValue",
+    AttributeValueBare = "AttributeValueBare",
+    AttributeValueWrapped = "AttributeValueWrapped",
+    CommentContent = "CommentContent",
+    CommentOpen = "CommentOpen",
+    CommentClose = "CommentClose",
+    DoctypeOpen = "DoctypeOpen",
+    DoctypeClose = "DoctypeClose",
+    DoctypeAttributes = "DoctypeAttributes",
+    DoctypeAttributeBare = "DoctypeAttributeBare",
+    DoctypeAttributeWrapped = "DoctypeAttributeWrapped"
+}
+
+declare enum ConstructTreeContextTypes {
+    Tag = "Tag",
+    TagName = "TagName",
+    TagContent = "TagContent",
+    Attribute = "Attribute",
+    Attributes = "Attributes",
+    AttributeValue = "AttributeValue",
+    Doctype = "Doctype",
+    DoctypeAttribute = "DoctypeAttribute",
+    DoctypeAttributes = "DoctypeAttributes",
+    Comment = "Comment"
+}
+
+interface Locations {
+    loc: SourceLocation;
+    range: Range;
+}
+interface Position {
+    /**
+     * 0 based index (>= 0)
+     */
+    column: number;
+    /**
+     * 1 based index (>= 1)
+     */
+    line: number;
+}
+type Range = [number, number];
+interface SourceLocation {
+    /**
+     * end position of source
+     */
+    end: Position;
+    /**
+     * start position of source
+     */
+    start: Position;
+}
+
+/**
+ * token
+ */
+interface Token<T extends TokenTypes> extends Locations {
+    /**
+     * node type
+     */
+    type: T;
+    /**
+     * token value
+     */
+    value: string;
+}
+/**
+ * any token
+ */
+type AnyToken = Token<TokenTypes.Attribute> | Token<TokenTypes.AttributeAssignment> | Token<TokenTypes.AttributeKey> | Token<TokenTypes.AttributeValue> | Token<TokenTypes.AttributeValueWrapperEnd> | Token<TokenTypes.AttributeValueWrapperStart> | Token<TokenTypes.CloseTag> | Token<TokenTypes.Comment> | Token<TokenTypes.CommentClose> | Token<TokenTypes.CommentContent> | Token<TokenTypes.CommentOpen> | Token<TokenTypes.Doctype> | Token<TokenTypes.DoctypeAttributeValue> | Token<TokenTypes.DoctypeAttributeWrapperEnd> | Token<TokenTypes.DoctypeAttributeWrapperStart> | Token<TokenTypes.DoctypeClose> | Token<TokenTypes.DoctypeOpen> | Token<TokenTypes.Document> | Token<TokenTypes.OpenTagEnd> | Token<TokenTypes.OpenTagStart> | Token<TokenTypes.Program> | Token<TokenTypes.Tag> | Token<TokenTypes.Text>;
+
+interface BaseNode extends Locations {
+    type: NodeTypes;
+}
+interface SimpleNode<T extends NodeTypes> extends BaseNode {
+    type: T;
+    value: string;
+}
+/**
+ * attribute
+ */
+type AttributeKeyNode = SimpleNode<NodeTypes.AttributeKey>;
+interface AttributeNode extends BaseNode {
+    key: AttributeKeyNode;
+    type: NodeTypes.Attribute;
+    endWrapper?: AttributeValueWrapperEndNode;
+    startWrapper?: AttributeValueWrapperStartNode;
+    value?: AttributeValueNode;
+}
+type AttributeValueNode = SimpleNode<NodeTypes.AttributeValue>;
+type AttributeValueWrapperEndNode = SimpleNode<NodeTypes.AttributeValueWrapperEnd>;
+type AttributeValueWrapperStartNode = SimpleNode<NodeTypes.AttributeValueWrapperStart>;
+/**
+ * comment
+ */
+type CommentCloseNode = SimpleNode<NodeTypes.CommentClose>;
+type CommentContentNode = SimpleNode<NodeTypes.CommentContent>;
+interface CommentNode extends BaseNode {
+    close: CommentCloseNode;
+    open: CommentOpenNode;
+    type: NodeTypes.Comment;
+    value: CommentContentNode;
+}
+type CommentOpenNode = SimpleNode<NodeTypes.CommentOpen>;
+/**
+ * doctype
+ */
+type DoctypeAttributeKeyNode = SimpleNode<NodeTypes.DoctypeAttributeKey>;
+interface DoctypeAttributeNode extends BaseNode {
+    key: DoctypeAttributeKeyNode;
+    type: NodeTypes.DoctypeAttribute;
+    endWrapper?: DoctypeAttributeWrapperEndNode;
+    startWrapper?: DoctypeAttributeWrapperStartNode;
+    value?: DoctypeAttributeValueNode;
+}
+type DoctypeAttributeValueNode = SimpleNode<NodeTypes.DoctypeAttributeValue>;
+type DoctypeAttributeWrapperEndNode = SimpleNode<NodeTypes.DoctypeAttributeWrapperEnd>;
+type DoctypeAttributeWrapperStartNode = SimpleNode<NodeTypes.DoctypeAttributeWrapperStart>;
+type DoctypeCloseNode = SimpleNode<NodeTypes.DoctypeClose>;
+interface DoctypeNode extends BaseNode {
+    attributes: DoctypeAttributeNode[];
+    close: DoctypeCloseNode;
+    open: DoctypeOpenNode;
+    type: NodeTypes.Doctype;
+}
+type DoctypeOpenNode = SimpleNode<NodeTypes.DoctypeOpen>;
+interface DocumentNode extends BaseNode {
+    children: NestableNode[];
+    type: NodeTypes.Document;
+}
+type TextNode = SimpleNode<NodeTypes.Text>;
+/**
+ * tag
+ */
+type CloseTagNode = SimpleNode<NodeTypes.CloseTag>;
+type OpenTagEndNode = SimpleNode<NodeTypes.OpenTagEnd>;
+type OpenTagStartNode = SimpleNode<NodeTypes.OpenTagStart>;
+interface TagNode extends BaseNode {
+    attributes: AttributeNode[];
+    children: NestableNode[];
+    name: string;
+    openEnd: OpenTagEndNode;
+    openStart: OpenTagStartNode;
+    selfClosing: boolean;
+    type: NodeTypes.Tag;
+    close?: CloseTagNode;
+}
+/**
+ * program
+ */
+interface Program extends BaseNode {
+    body: DocumentNode[];
+    comments: CommentContentNode[];
+    tokens: AnyToken[];
+    type: NodeTypes.Program;
+}
+/**
+ * nestable node
+ */
+type NestableNode = CommentNode | TagNode | TextNode;
+/**
+ * any node
+ */
+type AnyNode = AttributeKeyNode | AttributeNode | AttributeValueNode | AttributeValueWrapperEndNode | AttributeValueWrapperStartNode | CloseTagNode | CommentCloseNode | CommentContentNode | CommentNode | CommentOpenNode | DoctypeAttributeKeyNode | DoctypeAttributeNode | DoctypeAttributeValueNode | DoctypeAttributeWrapperEndNode | DoctypeAttributeWrapperStartNode | DoctypeCloseNode | DoctypeNode | DoctypeOpenNode | DocumentNode | OpenTagEndNode | OpenTagStartNode | Program | TagNode | TextNode;
+
+interface Options {
+}
+interface ParseForESLintResult {
+    ast: Program;
+    services: {
+        isSVG: boolean;
+    };
+    visitorKeys: SourceCode$1.VisitorKeys;
+}
+interface ParseResult {
+    ast: DocumentNode;
+    tokens: AnyToken[];
+}
+
+type AnyContextualNode = ContextualAttributeNode | ContextualCommentNode | ContextualDoctypeAttributeNode | ContextualDoctypeNode | ContextualDocumentNode | ContextualTagNode;
+type ContextualAttributeNode = ContextualNode<AttributeNode, 'key' | 'value'>;
+type ContextualCommentNode = ContextualNode<CommentNode, 'close' | 'open' | 'value'>;
+type ContextualDoctypeAttributeNode = ContextualNode<DoctypeAttributeNode, 'key' | 'value'>;
+type ContextualDoctypeNode = ContextualNode<DoctypeNode, 'close' | 'open'> & {
+    attributes: ContextualDoctypeAttributeNode[];
+};
+type ContextualDocumentNode = Omit<ContextualNode<DocumentNode, never>, 'children'> & {
+    children: Array<DocumentNode['children'][number] | Exclude<AnyContextualNode, ContextualDoctypeNode>>;
+};
+type ContextualNode<T extends AnyNode, K extends keyof T> = PartialBy<T, K> & {
+    parentRef?: any;
+};
+type ContextualTagNode = ContextualNode<TagNode, 'close' | 'name' | 'openEnd' | 'openStart' | 'selfClosing'> & {
+    attributes: ContextualAttributeNode[];
+    children: Array<ContextualCommentNode | ContextualDoctypeNode | ContextualTagNode | TagNode['children'][number]>;
+};
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+declare class Chars {
+    value: string;
+    range: Range;
+    constructor(value: string, range: Range);
+    concat(chars: Chars): void;
+    equals(chars: string): boolean;
+    length(): number;
+}
+
+declare class CharsBuffer {
+    charsBuffer: Chars[];
+    concat(chars: Chars): void;
+    concatBuffer(buffer: CharsBuffer): void;
+    length(): number;
+    clear(): void;
+    value(): string;
+    last(): Chars;
+    first(): Chars;
+    removeLast(): void;
+    removeFirst(): void;
+    replace(other: CharsBuffer): void;
+}
+
+declare class SourceCode {
+    readonly source: string;
+    private charsList;
+    private charsIndex;
+    constructor(source: string);
+    getLocationOf(range: Range): SourceLocation;
+    current(): Chars;
+    next(): void;
+    prev(): void;
+    isEof(): boolean;
+    index(): number;
+    private createCharsList;
+}
+
+type TokenizerState = {
+    accumulatedContent: CharsBuffer;
+    contextParams: ContextParams;
+    currentContext: TokenizerContextTypes;
+    decisionBuffer: CharsBuffer;
+    sourceCode: SourceCode;
+    tokens: {
+        push(token: AnyToken): void;
+    };
+};
+type ContextParams = {
+    [TokenizerContextTypes.Attributes]?: {
+        tagName: string;
+    };
+    [TokenizerContextTypes.AttributeValueWrapped]?: {
+        wrapper: string;
+    };
+    [TokenizerContextTypes.DoctypeAttributeWrapped]?: {
+        wrapper: string;
+    };
+    [TokenizerContextTypes.OpenTagEnd]?: {
+        tagName: string;
+    };
+};
+
+type ConstructTreeState<N extends AnyContextualNode> = {
+    caretPosition: number;
+    currentNode: N;
+    rootNode: DocumentNode;
+    currentContext: {
+        type: ConstructTreeContextTypes;
+        content?: any[];
+        parentRef?: any;
+    };
+};
+
+interface ConstructTreeHandler {
+    construct: (token: AnyToken, state: ConstructTreeState<any>) => ConstructTreeState<any>;
+}
+
+interface TokenizeHandler {
+    parse: (chars: CharsBuffer, state: TokenizerState) => void;
+    handleContentEnd?: (state: TokenizerState) => void;
+}
+
+type index_AnyContextualNode = AnyContextualNode;
+type index_AnyNode = AnyNode;
+type index_AnyToken = AnyToken;
+type index_AttributeKeyNode = AttributeKeyNode;
+type index_AttributeNode = AttributeNode;
+type index_AttributeValueNode = AttributeValueNode;
+type index_AttributeValueWrapperEndNode = AttributeValueWrapperEndNode;
+type index_AttributeValueWrapperStartNode = AttributeValueWrapperStartNode;
+type index_BaseNode = BaseNode;
+type index_CloseTagNode = CloseTagNode;
+type index_CommentCloseNode = CommentCloseNode;
+type index_CommentContentNode = CommentContentNode;
+type index_CommentNode = CommentNode;
+type index_CommentOpenNode = CommentOpenNode;
+type index_ConstructTreeHandler = ConstructTreeHandler;
+type index_ConstructTreeState<N extends AnyContextualNode> = ConstructTreeState<N>;
+type index_ContextualAttributeNode = ContextualAttributeNode;
+type index_ContextualCommentNode = ContextualCommentNode;
+type index_ContextualDoctypeAttributeNode = ContextualDoctypeAttributeNode;
+type index_ContextualDoctypeNode = ContextualDoctypeNode;
+type index_ContextualDocumentNode = ContextualDocumentNode;
+type index_ContextualNode<T extends AnyNode, K extends keyof T> = ContextualNode<T, K>;
+type index_ContextualTagNode = ContextualTagNode;
+type index_DoctypeAttributeKeyNode = DoctypeAttributeKeyNode;
+type index_DoctypeAttributeNode = DoctypeAttributeNode;
+type index_DoctypeAttributeValueNode = DoctypeAttributeValueNode;
+type index_DoctypeAttributeWrapperEndNode = DoctypeAttributeWrapperEndNode;
+type index_DoctypeAttributeWrapperStartNode = DoctypeAttributeWrapperStartNode;
+type index_DoctypeCloseNode = DoctypeCloseNode;
+type index_DoctypeNode = DoctypeNode;
+type index_DoctypeOpenNode = DoctypeOpenNode;
+type index_DocumentNode = DocumentNode;
+type index_Locations = Locations;
+type index_NestableNode = NestableNode;
+type index_OpenTagEndNode = OpenTagEndNode;
+type index_OpenTagStartNode = OpenTagStartNode;
+type index_Options = Options;
+type index_ParseForESLintResult = ParseForESLintResult;
+type index_ParseResult = ParseResult;
+type index_PartialBy<T, K extends keyof T> = PartialBy<T, K>;
+type index_Position = Position;
+type index_Program = Program;
+type index_Range = Range;
+type index_SimpleNode<T extends NodeTypes> = SimpleNode<T>;
+type index_SourceLocation = SourceLocation;
+type index_TagNode = TagNode;
+type index_TextNode = TextNode;
+type index_Token<T extends TokenTypes> = Token<T>;
+type index_TokenizeHandler = TokenizeHandler;
+type index_TokenizerState = TokenizerState;
+declare namespace index {
+  export type { index_AnyContextualNode as AnyContextualNode, index_AnyNode as AnyNode, index_AnyToken as AnyToken, index_AttributeKeyNode as AttributeKeyNode, index_AttributeNode as AttributeNode, index_AttributeValueNode as AttributeValueNode, index_AttributeValueWrapperEndNode as AttributeValueWrapperEndNode, index_AttributeValueWrapperStartNode as AttributeValueWrapperStartNode, index_BaseNode as BaseNode, index_CloseTagNode as CloseTagNode, index_CommentCloseNode as CommentCloseNode, index_CommentContentNode as CommentContentNode, index_CommentNode as CommentNode, index_CommentOpenNode as CommentOpenNode, index_ConstructTreeHandler as ConstructTreeHandler, index_ConstructTreeState as ConstructTreeState, index_ContextualAttributeNode as ContextualAttributeNode, index_ContextualCommentNode as ContextualCommentNode, index_ContextualDoctypeAttributeNode as ContextualDoctypeAttributeNode, index_ContextualDoctypeNode as ContextualDoctypeNode, index_ContextualDocumentNode as ContextualDocumentNode, index_ContextualNode as ContextualNode, index_ContextualTagNode as ContextualTagNode, index_DoctypeAttributeKeyNode as DoctypeAttributeKeyNode, index_DoctypeAttributeNode as DoctypeAttributeNode, index_DoctypeAttributeValueNode as DoctypeAttributeValueNode, index_DoctypeAttributeWrapperEndNode as DoctypeAttributeWrapperEndNode, index_DoctypeAttributeWrapperStartNode as DoctypeAttributeWrapperStartNode, index_DoctypeCloseNode as DoctypeCloseNode, index_DoctypeNode as DoctypeNode, index_DoctypeOpenNode as DoctypeOpenNode, index_DocumentNode as DocumentNode, index_Locations as Locations, index_NestableNode as NestableNode, index_OpenTagEndNode as OpenTagEndNode, index_OpenTagStartNode as OpenTagStartNode, index_Options as Options, index_ParseForESLintResult as ParseForESLintResult, index_ParseResult as ParseResult, index_PartialBy as PartialBy, index_Position as Position, index_Program as Program, index_Range as Range, index_SimpleNode as SimpleNode, index_SourceLocation as SourceLocation, index_TagNode as TagNode, index_TextNode as TextNode, index_Token as Token, index_TokenizeHandler as TokenizeHandler, index_TokenizerState as TokenizerState };
+}
+
+declare function parseForESLint(source: string, options?: Options): ParseForESLintResult;
+
+declare function parseSVG(code: string, options?: Options): Program;
+declare const name: string;
+declare const VisitorKeys: eslint.SourceCode.VisitorKeys;
+
+export { index as AST, ParseError, VisitorKeys, meta, name, parseForESLint, parseSVG };