TypeScript definitions for pug-tokens (#3196)

pugjs · May 1, 2020 · c99cb3c · c99cb3c
1 parent 7e0a8e4
commit c99cb3c
Showing 1 changed file with 338 additions and 0 deletions.
diff --git a/packages/pug-lexer/index.d.ts b/packages/pug-lexer/index.d.ts
@@ -0,0 +1,338 @@
+declare module 'pug-lexer' {
+	namespace lex {
+		export interface Loc {
+			start: { line: number; column: number };
+			end: { line: number; column: number };
+		}
+
+		export type LexTokenType =
+			| ':'
+			| '&attributes'
+			| 'attribute'
+			| 'block'
+			| 'blockcode'
+			| 'call'
+			| 'case'
+			| 'class'
+			| 'code'
+			| 'comment'
+			| 'default'
+			| 'doctype'
+			| 'dot'
+			| 'each'
+			| 'else-if'
+			| 'else'
+			| 'end-attributes'
+			| 'end-pipeless-text'
+			| 'end-pug-interpolation'
+			| 'eos'
+			| 'extends'
+			| 'filter'
+			| 'id'
+			| 'if'
+			| 'include'
+			| 'indent'
+			| 'interpolated-code'
+			| 'interpolation'
+			| 'mixin-block'
+			| 'mixin'
+			| 'newline'
+			| 'outdent'
+			| 'path'
+			| 'slash'
+			| 'start-attributes'
+			| 'start-pipeless-text'
+			| 'start-pug-interpolation'
+			| 'tag'
+			| 'text-html'
+			| 'text'
+			| 'when'
+			| 'while'
+			| 'yield';
+
+		export interface LexToken<Type extends LexTokenType> {
+			type: Type;
+			loc: Loc;
+		}
+
+		export interface TagToken extends LexToken<'tag'> {
+			val: string;
+		}
+
+		export type StartAttributesToken = LexToken<'start-attributes'>;
+
+		export interface AttributeToken extends LexToken<'attribute'> {
+			name: string;
+			val: string | boolean;
+			mustEscape: boolean;
+		}
+
+		export type EndAttributesToken = LexToken<'end-attributes'>;
+
+		export interface IndentToken extends LexToken<'indent'> {
+			val: number;
+		}
+
+		export interface ClassToken extends LexToken<'class'> {
+			val: string;
+		}
+
+		export type OutdentToken = LexToken<'outdent'>;
+
+		export type EosToken = LexToken<'eos'>;
+
+		export interface CommentToken extends LexToken<'comment'> {
+			val: string;
+			buffer: boolean;
+		}
+
+		export type NewlineToken = LexToken<'newline'>;
+
+		export interface TextToken extends LexToken<'text'> {
+			val: string;
+		}
+
+		export interface InterpolatedCodeToken extends LexToken<'interpolated-code'> {
+			mustEscape: boolean;
+			buffer: boolean;
+			val: string;
+		}
+
+		export interface CodeToken extends LexToken<'code'> {
+			val: string;
+			mustEscape: boolean;
+			buffer: boolean;
+		}
+
+		export interface IdToken extends LexToken<'id'> {
+			val: string;
+		}
+
+		export type StartPipelessTextToken = LexToken<'start-pipeless-text'>;
+
+		export type EndPipelessTextToken = LexToken<'end-pipeless-text'>;
+
+		export interface DoctypeToken extends LexToken<'doctype'> {
+			val: string;
+		}
+
+		export type DotToken = LexToken<'dot'>;
+
+		export interface BlockToken extends LexToken<'block'> {
+			val: string;
+			mode: 'replace' | 'prepend' | 'append';
+		}
+
+		export type ExtendsToken = LexToken<'extends'>;
+
+		export interface PathToken extends LexToken<'path'> {
+			val: string;
+		}
+
+		export type StartPugInterpolationToken = LexToken<'start-pug-interpolation'>;
+
+		export type EndPugInterpolationToken = LexToken<'end-pug-interpolation'>;
+
+		export interface InterpolationToken extends LexToken<'interpolation'> {
+			val: string;
+		}
+
+		export type IncludeToken = LexToken<'include'>;
+
+		export interface FilterToken extends LexToken<'filter'> {
+			val: string;
+		}
+
+		export interface CallToken extends LexToken<'call'> {
+			val: string;
+			args: string;
+		}
+
+		export interface MixinToken extends LexToken<'mixin'> {
+			val: string;
+			args: string | null;
+		}
+
+		export interface IfToken extends LexToken<'if'> {
+			val: string;
+		}
+
+		export type MixinBlockToken = LexToken<'mixin-block'>;
+
+		export interface ElseToken extends LexToken<'else'> {
+			val: string;
+		}
+
+		export interface AndAttributesToken extends LexToken<'&attributes'> {
+			val: string;
+		}
+
+		export interface TextHtmlToken extends LexToken<'text-html'> {
+			val: string;
+		}
+
+		export interface EachToken extends LexToken<'each'> {
+			val: string;
+			key: string | null;
+			code: string;
+		}
+
+		export interface WhileToken extends LexToken<'while'> {
+			val: string;
+		}
+
+		export interface CaseToken extends LexToken<'case'> {
+			val: string;
+		}
+
+		export interface WhenToken extends LexToken<'when'> {
+			val: string;
+		}
+
+		export type ColonToken = LexToken<':'>;
+
+		export type DefaultToken = LexToken<'default'>;
+
+		export interface ElseIfToken extends LexToken<'else-if'> {
+			val: string;
+		}
+
+		export type BlockcodeToken = LexToken<'blockcode'>;
+
+		export type YieldToken = LexToken<'yield'>;
+
+		export type SlashToken = LexToken<'slash'>;
+
+		export type Token =
+			| AndAttributesToken
+			| AttributeToken
+			| BlockcodeToken
+			| BlockToken
+			| CallToken
+			| CaseToken
+			| ClassToken
+			| CodeToken
+			| ColonToken
+			| CommentToken
+			| DefaultToken
+			| DoctypeToken
+			| DotToken
+			| EachToken
+			| ElseIfToken
+			| ElseToken
+			| EndAttributesToken
+			| EndPipelessTextToken
+			| EndPugInterpolationToken
+			| EosToken
+			| ExtendsToken
+			| FilterToken
+			| IdToken
+			| IfToken
+			| IncludeToken
+			| IndentToken
+			| InterpolatedCodeToken
+			| InterpolationToken
+			| MixinBlockToken
+			| MixinToken
+			| NewlineToken
+			| OutdentToken
+			| PathToken
+			| SlashToken
+			| StartAttributesToken
+			| StartPipelessTextToken
+			| StartPugInterpolationToken
+			| TagToken
+			| TextHtmlToken
+			| TextToken
+			| WhenToken
+			| WhileToken
+			| YieldToken;
+
+		export type LexerFunction = (type: string, exp?: any) => boolean;
+		export interface LexerOptions {
+			filename: string;
+			interpolated?: boolean;
+			startingLine?: number;
+			startingColumn?: number;
+			plugins?: LexerFunction[];
+		}
+		export class Lexer {
+			input: string;
+			originalInput: string;
+			filename?: string;
+			interpolated: boolean;
+			lineno: number;
+			colno: number;
+			plugins: LexerFunction[];
+			indentStack: number[];
+			indentRe: RegExp | null;
+			interpolationAllowed: boolean;
+			whitespaceRe: RegExp;
+			tokens: Token[];
+			ended: boolean;
+			constructor(str: string, options?: LexerOptions);
+			error(code: string, message: string): never;
+			assert(value: any, message: string): void;
+			isExpression(exp: string): boolean;
+			assertExpression(exp: string, noThrow?: boolean): boolean;
+			assertNestingCorrect(exp: string): void;
+			private tok<Type extends LexTokenType>(type: Type, val?: any): LexToken<Type>;
+			private tokEnd<Type extends LexTokenType>(tok: LexToken<Type>): LexToken<Type>;
+			private incrementLine(increment: number): void;
+			private incrementColumn(increment: number): void;
+			private consume(len: number): void;
+			private scan<Type extends LexTokenType>(regexp: RegExp, type: Type): LexToken<Type> | undefined;
+			private scanEndOfLine<Type extends LexTokenType>(regexp: RegExp, type: Type): LexToken<Type> | undefined;
+			private bracketExpression(skip?: number): number;
+			scanIndentation(): RegExpExecArray | null;
+			eos(): true | undefined;
+			blank(): true | undefined;
+			comment(): true | undefined;
+			interpolation(): true | undefined;
+			tag(): true | undefined;
+			filter(): true | undefined;
+			doctype(): true | undefined;
+			id(): true | undefined;
+			className(): true | undefined;
+			endInterpolation(): true | undefined;
+			addText(type: LexTokenType, value: string, prefix?: string, escaped?: number): void;
+			text(): true | undefined;
+			textHtml(): true | undefined;
+			dot(): true | undefined;
+			extends(): true | undefined;
+			prepend(): true | undefined;
+			append(): true | undefined;
+			block(): true | undefined;
+			mixinBlock(): true | undefined;
+			yield(): true | undefined;
+			include(): true | undefined;
+			path(): true | undefined;
+			case(): true | undefined;
+			when(): true | undefined;
+			default(): true | undefined;
+			call(): true | undefined;
+			mixin(): true | undefined;
+			conditional(): true | undefined;
+			while(): true | undefined;
+			each(): true | undefined;
+			eachOf(): true | undefined;
+			code(): true | undefined;
+			blockCode(): true | undefined;
+			attribute(): string;
+			attributeValue(str: string): { val?: string; mustEscape?: boolean; remainingSource: string };
+			attrs(): true | undefined;
+			attributesBlock(): true | undefined;
+			indent(): true | NewlineToken | undefined;
+			pipelessText(indents?: number): boolean | undefined;
+			slash(): true | undefined;
+			colon(): true | undefined;
+			fail(): never;
+			callLexerFunction(func: string): boolean;
+			private advance(): boolean;
+			getTokens(): Token[];
+		}
+	}
+	function lex(str: string, options?: lex.LexerOptions): lex.Token[];
+	export = lex;
+}
+