hyperscript.org
Version:
a small scripting language for the web
1,291 lines (1,290 loc) • 2.21 MB
TypeScript
export = _hyperscript;
declare const _hyperscript: {
config: {
attributes: string;
defaultTransition: string;
disableSelector: string;
conversions: any;
};
internals: {
lexer: {
/**
* @param {string} string
* @param {boolean} [template]
* @returns {Tokens}
*/
tokenize(string: string, template?: boolean): {
tokens: any;
consumed: any;
source: any;
readonly list: any;
/** @type Token | null */
_lastConsumed: {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
consumeWhitespace(): void;
/**
* @param {Tokens} tokens
* @param {*} error
* @returns {never}
*/
raiseError(tokens: any, error: any): never;
/**
* @param {string} value
* @returns {Token}
*/
requireOpToken(value: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} op1
* @param {string} [op2]
* @param {string} [op3]
* @returns {Token | void}
*/
matchAnyOpToken(op1: string, op2?: string, op3?: string, ...args: any[]): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} op1
* @param {string} [op2]
* @param {string} [op3]
* @returns {Token | void}
*/
matchAnyToken(op1: string, op2?: string, op3?: string, ...args: any[]): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} value
* @returns {Token | void}
*/
matchOpToken(value: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} type1
* @param {string} [type2]
* @param {string} [type3]
* @param {string} [type4]
* @returns {Token}
*/
requireTokenType(type1: string, type2?: string, type3?: string, type4?: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} type1
* @param {string} [type2]
* @param {string} [type3]
* @param {string} [type4]
* @returns {Token | void}
*/
matchTokenType(type1: string, type2?: string, type3?: string, type4?: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} value
* @param {string} [type]
* @returns {Token}
*/
requireToken(value: string, type?: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
peekToken(value: any, peek: any, type: any): any;
/**
* @param {string} value
* @param {string} [type]
* @returns {Token | void}
*/
matchToken(value: string, type?: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token}
*/
consumeToken(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string | null} value
* @param {string | null} [type]
* @returns {Token[]}
*/
consumeUntil(value: string | null, type?: string | null): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
}[];
/**
* @returns {string}
*/
lastWhitespace(): string;
consumeUntilWhitespace(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
}[];
/**
* @returns {boolean}
*/
hasMore(): boolean;
/**
* @param {number} n
* @param {boolean} [dontIgnoreWhitespace]
* @returns {Token}
*/
token(n: number, dontIgnoreWhitespace?: boolean): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token}
*/
currentToken(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token | null}
*/
lastMatch(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
follows: any[];
pushFollow(str: any): void;
popFollow(): void;
clearFollows(): any[];
restoreFollows(f: any): void;
};
};
Lexer: {
new (): {
/**
* @param {string} string
* @param {boolean} [template]
* @returns {Tokens}
*/
tokenize(string: string, template?: boolean): {
tokens: any;
consumed: any;
source: any;
readonly list: any;
/** @type Token | null */
_lastConsumed: {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
consumeWhitespace(): void;
/**
* @param {Tokens} tokens
* @param {*} error
* @returns {never}
*/
raiseError(tokens: any, error: any): never;
/**
* @param {string} value
* @returns {Token}
*/
requireOpToken(value: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} op1
* @param {string} [op2]
* @param {string} [op3]
* @returns {Token | void}
*/
matchAnyOpToken(op1: string, op2?: string, op3?: string, ...args: any[]): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} op1
* @param {string} [op2]
* @param {string} [op3]
* @returns {Token | void}
*/
matchAnyToken(op1: string, op2?: string, op3?: string, ...args: any[]): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} value
* @returns {Token | void}
*/
matchOpToken(value: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} type1
* @param {string} [type2]
* @param {string} [type3]
* @param {string} [type4]
* @returns {Token}
*/
requireTokenType(type1: string, type2?: string, type3?: string, type4?: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} type1
* @param {string} [type2]
* @param {string} [type3]
* @param {string} [type4]
* @returns {Token | void}
*/
matchTokenType(type1: string, type2?: string, type3?: string, type4?: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} value
* @param {string} [type]
* @returns {Token}
*/
requireToken(value: string, type?: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
peekToken(value: any, peek: any, type: any): any;
/**
* @param {string} value
* @param {string} [type]
* @returns {Token | void}
*/
matchToken(value: string, type?: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token}
*/
consumeToken(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string | null} value
* @param {string | null} [type]
* @returns {Token[]}
*/
consumeUntil(value: string | null, type?: string | null): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
}[];
/**
* @returns {string}
*/
lastWhitespace(): string;
consumeUntilWhitespace(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
}[];
/**
* @returns {boolean}
*/
hasMore(): boolean;
/**
* @param {number} n
* @param {boolean} [dontIgnoreWhitespace]
* @returns {Token}
*/
token(n: number, dontIgnoreWhitespace?: boolean): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token}
*/
currentToken(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token | null}
*/
lastMatch(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
follows: any[];
pushFollow(str: any): void;
popFollow(): void;
clearFollows(): any[];
restoreFollows(f: any): void;
};
};
OP_TABLE: {
"+": string;
"-": string;
"*": string;
"/": string;
".": string;
"..": string;
"\\": string;
":": string;
"%": string;
"|": string;
"!": string;
"?": string;
"#": string;
"&": string;
$: string;
";": string;
",": string;
"(": string;
")": string;
"<": string;
">": string;
"<=": string;
">=": string;
"==": string;
"===": string;
"!=": string;
"!==": string;
"{": string;
"}": string;
"[": string;
"]": string;
"=": string;
};
/**
* isValidCSSClassChar returns `true` if the provided character is valid in a CSS class.
* @param {string} c
* @returns boolean
*/
isValidCSSClassChar(c: string): boolean;
/**
* isValidCSSIDChar returns `true` if the provided character is valid in a CSS ID
* @param {string} c
* @returns boolean
*/
isValidCSSIDChar(c: string): boolean;
/**
* isWhitespace returns `true` if the provided character is whitespace.
* @param {string} c
* @returns boolean
*/
isWhitespace(c: string): boolean;
/**
* positionString returns a string representation of a Token's line and column details.
* @param {Token} token
* @returns string
*/
positionString(token: {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
}): string;
/**
* isNewline returns `true` if the provided character is a carriage return or newline
* @param {string} c
* @returns boolean
*/
isNewline(c: string): boolean;
/**
* isNumeric returns `true` if the provided character is a number (0-9)
* @param {string} c
* @returns boolean
*/
isNumeric(c: string): boolean;
/**
* isAlpha returns `true` if the provided character is a letter in the alphabet
* @param {string} c
* @returns boolean
*/
isAlpha(c: string): boolean;
/**
* @param {string} c
* @param {boolean} [dollarIsOp]
* @returns boolean
*/
isIdentifierChar(c: string, dollarIsOp?: boolean): boolean;
/**
* @param {string} c
* @returns boolean
*/
isReservedChar(c: string): boolean;
/**
* @param {Token[]} tokens
* @returns {boolean}
*/
isValidSingleQuoteStringStart(tokens: {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
}[]): boolean;
/**
* @param {string} string
* @param {boolean} [template]
* @returns {Tokens}
*/
tokenize(string: string, template?: boolean): {
tokens: any;
consumed: any;
source: any;
readonly list: any;
/** @type Token | null */
_lastConsumed: {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
consumeWhitespace(): void;
/**
* @param {Tokens} tokens
* @param {*} error
* @returns {never}
*/
raiseError(tokens: any, error: any): never;
/**
* @param {string} value
* @returns {Token}
*/
requireOpToken(value: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} op1
* @param {string} [op2]
* @param {string} [op3]
* @returns {Token | void}
*/
matchAnyOpToken(op1: string, op2?: string, op3?: string, ...args: any[]): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} op1
* @param {string} [op2]
* @param {string} [op3]
* @returns {Token | void}
*/
matchAnyToken(op1: string, op2?: string, op3?: string, ...args: any[]): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} value
* @returns {Token | void}
*/
matchOpToken(value: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} type1
* @param {string} [type2]
* @param {string} [type3]
* @param {string} [type4]
* @returns {Token}
*/
requireTokenType(type1: string, type2?: string, type3?: string, type4?: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} type1
* @param {string} [type2]
* @param {string} [type3]
* @param {string} [type4]
* @returns {Token | void}
*/
matchTokenType(type1: string, type2?: string, type3?: string, type4?: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} value
* @param {string} [type]
* @returns {Token}
*/
requireToken(value: string, type?: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
peekToken(value: any, peek: any, type: any): any;
/**
* @param {string} value
* @param {string} [type]
* @returns {Token | void}
*/
matchToken(value: string, type?: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token}
*/
consumeToken(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string | null} value
* @param {string | null} [type]
* @returns {Token[]}
*/
consumeUntil(value: string | null, type?: string | null): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
}[];
/**
* @returns {string}
*/
lastWhitespace(): string;
consumeUntilWhitespace(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
}[];
/**
* @returns {boolean}
*/
hasMore(): boolean;
/**
* @param {number} n
* @param {boolean} [dontIgnoreWhitespace]
* @returns {Token}
*/
token(n: number, dontIgnoreWhitespace?: boolean): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token}
*/
currentToken(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @returns {Token | null}
*/
lastMatch(): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
follows: any[];
pushFollow(str: any): void;
popFollow(): void;
clearFollows(): any[];
restoreFollows(f: any): void;
};
};
parser: {
runtime: {
lexer: {
/**
* @param {string} string
* @param {boolean} [template]
* @returns {Tokens}
*/
tokenize(string: string, template?: boolean): {
tokens: any;
consumed: any;
source: any;
readonly list: any;
/** @type Token | null */
_lastConsumed: {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
consumeWhitespace(): void;
/**
* @param {Tokens} tokens
* @param {*} error
* @returns {never}
*/
raiseError(tokens: any, error: any): never;
/**
* @param {string} value
* @returns {Token}
*/
requireOpToken(value: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} op1
* @param {string} [op2]
* @param {string} [op3]
* @returns {Token | void}
*/
matchAnyOpToken(op1: string, op2?: string, op3?: string, ...args: any[]): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} op1
* @param {string} [op2]
* @param {string} [op3]
* @returns {Token | void}
*/
matchAnyToken(op1: string, op2?: string, op3?: string, ...args: any[]): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} value
* @returns {Token | void}
*/
matchOpToken(value: string): void | {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**
* @param {string} type1
* @param {string} [type2]
* @param {string} [type3]
* @param {string} [type4]
* @returns {Token}
*/
requireTokenType(type1: string, type2?: string, type3?: string, type4?: string): {
type?: string;
value: string;
start?: number;
end?: number;
column?: number;
line?: number;
/**
* `true` if this token represents an operator
*/
op?: boolean;
/**
* `true` if this token is a template, for class refs, id refs, strings
*/
template?: boolean;
};
/**