Socket
Socket
Sign inDemoInstall

angular-html-parser

Package Overview
Dependencies
1
Maintainers
3
Versions
20
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 1.8.0 to 2.0.0

lib/compiler/src/ml_parser/entities.d.ts
lib/compiler/src/ml_parser/entities.js
lib/compiler/src/ml_parser/tokens.d.ts
lib/compiler/src/ml_parser/tokens.js

5

lib/angular-html-parser/src/index.d.ts

@@ -1,2 +0,3 @@

import { TagContentType } from '../../compiler/src/ml_parser/tags';
import { TagContentType } from '../../compiler/src/ml_parser/tags.js';
import { ParseTreeResult } from "../../compiler/src/ml_parser/parser.js";
export { TagContentType };

@@ -33,2 +34,2 @@ export interface ParseOptions {

}
export declare function parse(input: string, options?: ParseOptions): import("../../compiler/src/ml_parser/parser").ParseTreeResult;
export declare function parse(input: string, options?: ParseOptions): ParseTreeResult;

13

lib/angular-html-parser/src/index.js

@@ -1,14 +0,12 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const html_parser_1 = require("../../compiler/src/ml_parser/html_parser");
const tags_1 = require("../../compiler/src/ml_parser/tags");
exports.TagContentType = tags_1.TagContentType;
import { HtmlParser } from "../../compiler/src/ml_parser/html_parser.js";
import { TagContentType } from '../../compiler/src/ml_parser/tags.js';
let parser = null;
const getParser = () => {
if (!parser) {
parser = new html_parser_1.HtmlParser();
parser = new HtmlParser();
}
return parser;
};
function parse(input, options = {}) {
export { TagContentType };
export function parse(input, options = {}) {
const { canSelfClose = false, allowHtmComponentClosingTags = false, isTagNameCaseSensitive = false, getTagContentType, } = options;

@@ -22,2 +20,1 @@ return getParser().parse(input, "angular-html-parser", {

}
exports.parse = parse;

3

lib/compiler/src/assertions.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -8,3 +8,2 @@ * Use of this source code is governed by an MIT-style license that can be

*/
export declare function assertArrayOfStrings(identifier: string, value: any): void;
export declare function assertInterpolationSymbols(identifier: string, value: any): void;

23

lib/compiler/src/assertions.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,17 +8,2 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
function assertArrayOfStrings(identifier, value) {
if (value == null) {
return;
}
if (!Array.isArray(value)) {
throw new Error(`Expected '${identifier}' to be an array of strings.`);
}
for (let i = 0; i < value.length; i += 1) {
if (typeof value[i] !== 'string') {
throw new Error(`Expected '${identifier}' to be an array of strings.`);
}
}
}
exports.assertArrayOfStrings = assertArrayOfStrings;
const UNUSABLE_INTERPOLATION_REGEXPS = [

@@ -30,5 +14,5 @@ /^\s*$/,

/&(#|[a-z])/i,
/^\/\//,
/^\/\//, // comment
];
function assertInterpolationSymbols(identifier, value) {
export function assertInterpolationSymbols(identifier, value) {
if (value != null && !(Array.isArray(value) && value.length == 2)) {

@@ -48,2 +32,1 @@ throw new Error(`Expected '${identifier}' to be an array, [start, end].`);

}
exports.assertInterpolationSymbols = assertInterpolationSymbols;

3

lib/compiler/src/chars.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -75,1 +75,2 @@ * Use of this source code is governed by an MIT-style license that can be

export declare function isOctalDigit(code: number): boolean;
export declare function isQuote(code: number): boolean;

159

lib/compiler/src/chars.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,87 +8,83 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.$EOF = 0;
exports.$BSPACE = 8;
exports.$TAB = 9;
exports.$LF = 10;
exports.$VTAB = 11;
exports.$FF = 12;
exports.$CR = 13;
exports.$SPACE = 32;
exports.$BANG = 33;
exports.$DQ = 34;
exports.$HASH = 35;
exports.$$ = 36;
exports.$PERCENT = 37;
exports.$AMPERSAND = 38;
exports.$SQ = 39;
exports.$LPAREN = 40;
exports.$RPAREN = 41;
exports.$STAR = 42;
exports.$PLUS = 43;
exports.$COMMA = 44;
exports.$MINUS = 45;
exports.$PERIOD = 46;
exports.$SLASH = 47;
exports.$COLON = 58;
exports.$SEMICOLON = 59;
exports.$LT = 60;
exports.$EQ = 61;
exports.$GT = 62;
exports.$QUESTION = 63;
exports.$0 = 48;
exports.$7 = 55;
exports.$9 = 57;
exports.$A = 65;
exports.$E = 69;
exports.$F = 70;
exports.$X = 88;
exports.$Z = 90;
exports.$LBRACKET = 91;
exports.$BACKSLASH = 92;
exports.$RBRACKET = 93;
exports.$CARET = 94;
exports.$_ = 95;
exports.$a = 97;
exports.$b = 98;
exports.$e = 101;
exports.$f = 102;
exports.$n = 110;
exports.$r = 114;
exports.$t = 116;
exports.$u = 117;
exports.$v = 118;
exports.$x = 120;
exports.$z = 122;
exports.$LBRACE = 123;
exports.$BAR = 124;
exports.$RBRACE = 125;
exports.$NBSP = 160;
exports.$PIPE = 124;
exports.$TILDA = 126;
exports.$AT = 64;
exports.$BT = 96;
function isWhitespace(code) {
return (code >= exports.$TAB && code <= exports.$SPACE) || (code == exports.$NBSP);
export const $EOF = 0;
export const $BSPACE = 8;
export const $TAB = 9;
export const $LF = 10;
export const $VTAB = 11;
export const $FF = 12;
export const $CR = 13;
export const $SPACE = 32;
export const $BANG = 33;
export const $DQ = 34;
export const $HASH = 35;
export const $$ = 36;
export const $PERCENT = 37;
export const $AMPERSAND = 38;
export const $SQ = 39;
export const $LPAREN = 40;
export const $RPAREN = 41;
export const $STAR = 42;
export const $PLUS = 43;
export const $COMMA = 44;
export const $MINUS = 45;
export const $PERIOD = 46;
export const $SLASH = 47;
export const $COLON = 58;
export const $SEMICOLON = 59;
export const $LT = 60;
export const $EQ = 61;
export const $GT = 62;
export const $QUESTION = 63;
export const $0 = 48;
export const $7 = 55;
export const $9 = 57;
export const $A = 65;
export const $E = 69;
export const $F = 70;
export const $X = 88;
export const $Z = 90;
export const $LBRACKET = 91;
export const $BACKSLASH = 92;
export const $RBRACKET = 93;
export const $CARET = 94;
export const $_ = 95;
export const $a = 97;
export const $b = 98;
export const $e = 101;
export const $f = 102;
export const $n = 110;
export const $r = 114;
export const $t = 116;
export const $u = 117;
export const $v = 118;
export const $x = 120;
export const $z = 122;
export const $LBRACE = 123;
export const $BAR = 124;
export const $RBRACE = 125;
export const $NBSP = 160;
export const $PIPE = 124;
export const $TILDA = 126;
export const $AT = 64;
export const $BT = 96;
export function isWhitespace(code) {
return (code >= $TAB && code <= $SPACE) || (code == $NBSP);
}
exports.isWhitespace = isWhitespace;
function isDigit(code) {
return exports.$0 <= code && code <= exports.$9;
export function isDigit(code) {
return $0 <= code && code <= $9;
}
exports.isDigit = isDigit;
function isAsciiLetter(code) {
return code >= exports.$a && code <= exports.$z || code >= exports.$A && code <= exports.$Z;
export function isAsciiLetter(code) {
return code >= $a && code <= $z || code >= $A && code <= $Z;
}
exports.isAsciiLetter = isAsciiLetter;
function isAsciiHexDigit(code) {
return code >= exports.$a && code <= exports.$f || code >= exports.$A && code <= exports.$F || isDigit(code);
export function isAsciiHexDigit(code) {
return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);
}
exports.isAsciiHexDigit = isAsciiHexDigit;
function isNewLine(code) {
return code === exports.$LF || code === exports.$CR;
export function isNewLine(code) {
return code === $LF || code === $CR;
}
exports.isNewLine = isNewLine;
function isOctalDigit(code) {
return exports.$0 <= code && code <= exports.$7;
export function isOctalDigit(code) {
return $0 <= code && code <= $7;
}
exports.isOctalDigit = isOctalDigit;
export function isQuote(code) {
return code === $SQ || code === $DQ || code === $BT;
}

44

lib/compiler/src/i18n/i18n_ast.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -8,7 +8,17 @@ * Use of this source code is governed by an MIT-style license that can be

*/
import { ParseSourceSpan } from '../parse_util';
import { ParseSourceSpan } from "../parse_util.js";
/**
* Describes the text contents of a placeholder as it appears in an ICU expression, including its
* source span information.
*/
export interface MessagePlaceholder {
/** The text contents of the placeholder */
text: string;
/** The source span of the placeholder */
sourceSpan: ParseSourceSpan;
}
export declare class Message {
nodes: Node[];
placeholders: {
[phName: string]: string;
[phName: string]: MessagePlaceholder;
};

@@ -20,17 +30,21 @@ placeholderToMessage: {

description: string;
customId: string;
sources: MessageSpan[];
id: string;
sources: MessageSpan[];
/** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
legacyIds: string[];
messageString: string;
/**
* @param nodes message AST
* @param placeholders maps placeholder names to static content
* @param placeholders maps placeholder names to static content and their source spans
* @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
* @param meaning
* @param description
* @param id
* @param customId
*/
constructor(nodes: Node[], placeholders: {
[phName: string]: string;
[phName: string]: MessagePlaceholder;
}, placeholderToMessage: {
[phName: string]: Message;
}, meaning: string, description: string, id: string);
}, meaning: string, description: string, customId: string);
}

@@ -83,5 +97,7 @@ export interface MessageSpan {

sourceSpan: ParseSourceSpan;
startSourceSpan: ParseSourceSpan | null;
endSourceSpan: ParseSourceSpan | null;
constructor(tag: string, attrs: {
[k: string]: string;
}, startName: string, closeName: string, children: Node[], isVoid: boolean, sourceSpan: ParseSourceSpan);
}, startName: string, closeName: string, children: Node[], isVoid: boolean, sourceSpan: ParseSourceSpan, startSourceSpan: ParseSourceSpan | null, endSourceSpan: ParseSourceSpan | null);
visit(visitor: Visitor, context?: any): any;

@@ -100,6 +116,14 @@ }

sourceSpan: ParseSourceSpan;
/** Used to capture a message computed from a previous processing pass (see `setI18nRefs()`). */
previousMessage?: Message;
constructor(value: Icu, name: string, sourceSpan: ParseSourceSpan);
visit(visitor: Visitor, context?: any): any;
}
export declare type AST = Message | Node;
/**
* Each HTML node that is affect by an i18n tag will also have an `i18n` property that is of type
* `I18nMeta`.
* This information is either a `Message`, which indicates it is the root of an i18n message, or a
* `Node`, which indicates is it part of a containing `Message`.
*/
export declare type I18nMeta = Message | Node;
export interface Visitor {

@@ -106,0 +130,0 @@ visitText(text: Text, context?: any): any;

113

lib/compiler/src/i18n/i18n_ast.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,13 +8,12 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
class Message {
export class Message {
/**
* @param nodes message AST
* @param placeholders maps placeholder names to static content
* @param placeholders maps placeholder names to static content and their source spans
* @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
* @param meaning
* @param description
* @param id
* @param customId
*/
constructor(nodes, placeholders, placeholderToMessage, meaning, description, id) {
constructor(nodes, placeholders, placeholderToMessage, meaning, description, customId) {
this.nodes = nodes;

@@ -26,3 +24,7 @@ this.placeholders = placeholders;

this.description = description;
this.id = id;
this.customId = customId;
this.id = this.customId;
/** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
this.legacyIds = [];
this.messageString = serializeMessage(this.nodes);
if (nodes.length) {

@@ -42,4 +44,3 @@ this.sources = [{

}
exports.Message = Message;
class Text {
export class Text {
constructor(value, sourceSpan) {

@@ -49,7 +50,8 @@ this.value = value;

}
visit(visitor, context) { return visitor.visitText(this, context); }
visit(visitor, context) {
return visitor.visitText(this, context);
}
}
exports.Text = Text;
// TODO(vicb): do we really need this node (vs an array) ?
class Container {
export class Container {
constructor(children, sourceSpan) {

@@ -59,6 +61,7 @@ this.children = children;

}
visit(visitor, context) { return visitor.visitContainer(this, context); }
visit(visitor, context) {
return visitor.visitContainer(this, context);
}
}
exports.Container = Container;
class Icu {
export class Icu {
constructor(expression, type, cases, sourceSpan) {

@@ -70,7 +73,10 @@ this.expression = expression;

}
visit(visitor, context) { return visitor.visitIcu(this, context); }
visit(visitor, context) {
return visitor.visitIcu(this, context);
}
}
exports.Icu = Icu;
class TagPlaceholder {
constructor(tag, attrs, startName, closeName, children, isVoid, sourceSpan) {
export class TagPlaceholder {
constructor(tag, attrs, startName, closeName, children, isVoid,
// TODO sourceSpan should cover all (we need a startSourceSpan and endSourceSpan)
sourceSpan, startSourceSpan, endSourceSpan) {
this.tag = tag;

@@ -83,7 +89,10 @@ this.attrs = attrs;

this.sourceSpan = sourceSpan;
this.startSourceSpan = startSourceSpan;
this.endSourceSpan = endSourceSpan;
}
visit(visitor, context) { return visitor.visitTagPlaceholder(this, context); }
visit(visitor, context) {
return visitor.visitTagPlaceholder(this, context);
}
}
exports.TagPlaceholder = TagPlaceholder;
class Placeholder {
export class Placeholder {
constructor(value, name, sourceSpan) {

@@ -94,6 +103,7 @@ this.value = value;

}
visit(visitor, context) { return visitor.visitPlaceholder(this, context); }
visit(visitor, context) {
return visitor.visitPlaceholder(this, context);
}
}
exports.Placeholder = Placeholder;
class IcuPlaceholder {
export class IcuPlaceholder {
constructor(value, name, sourceSpan) {

@@ -104,8 +114,11 @@ this.value = value;

}
visit(visitor, context) { return visitor.visitIcuPlaceholder(this, context); }
visit(visitor, context) {
return visitor.visitIcuPlaceholder(this, context);
}
}
exports.IcuPlaceholder = IcuPlaceholder;
// Clone the AST
class CloneVisitor {
visitText(text, context) { return new Text(text.value, text.sourceSpan); }
export class CloneVisitor {
visitText(text, context) {
return new Text(text.value, text.sourceSpan);
}
visitContainer(container, context) {

@@ -124,3 +137,3 @@ const children = container.children.map(n => n.visit(this, context));

const children = ph.children.map(n => n.visit(this, context));
return new TagPlaceholder(ph.tag, ph.attrs, ph.startName, ph.closeName, children, ph.isVoid, ph.sourceSpan);
return new TagPlaceholder(ph.tag, ph.attrs, ph.startName, ph.closeName, children, ph.isVoid, ph.sourceSpan, ph.startSourceSpan, ph.endSourceSpan);
}

@@ -134,5 +147,4 @@ visitPlaceholder(ph, context) {

}
exports.CloneVisitor = CloneVisitor;
// Visit all the nodes recursively
class RecurseVisitor {
export class RecurseVisitor {
visitText(text, context) { }

@@ -143,3 +155,5 @@ visitContainer(container, context) {

visitIcu(icu, context) {
Object.keys(icu.cases).forEach(k => { icu.cases[k].visit(this); });
Object.keys(icu.cases).forEach(k => {
icu.cases[k].visit(this);
});
}

@@ -152,2 +166,31 @@ visitTagPlaceholder(ph, context) {

}
exports.RecurseVisitor = RecurseVisitor;
/**
* Serialize the message to the Localize backtick string format that would appear in compiled code.
*/
function serializeMessage(messageNodes) {
const visitor = new LocalizeMessageStringVisitor();
const str = messageNodes.map(n => n.visit(visitor)).join('');
return str;
}
class LocalizeMessageStringVisitor {
visitText(text) {
return text.value;
}
visitContainer(container) {
return container.children.map(child => child.visit(this)).join('');
}
visitIcu(icu) {
const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
return `{${icu.expressionPlaceholder}, ${icu.type}, ${strCases.join(' ')}}`;
}
visitTagPlaceholder(ph) {
const children = ph.children.map(child => child.visit(this)).join('');
return `{$${ph.startName}}${children}{$${ph.closeName}}`;
}
visitPlaceholder(ph) {
return `{$${ph.name}}`;
}
visitIcuPlaceholder(ph) {
return `{$${ph.name}}`;
}
}

55

lib/compiler/src/ml_parser/ast.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -8,5 +8,5 @@ * Use of this source code is governed by an MIT-style license that can be

*/
import { AstPath } from '../ast_path';
import { AST as I18nAST } from '../i18n/i18n_ast';
import { ParseSourceSpan } from '../parse_util';
import { I18nMeta } from "../i18n/i18n_ast.js";
import { ParseSourceSpan } from "../parse_util.js";
import { InterpolatedAttributeToken, InterpolatedTextToken } from "./tokens.js";
interface BaseNode {

@@ -17,25 +17,28 @@ sourceSpan: ParseSourceSpan;

export declare type Node = Attribute | CDATA | Comment | DocType | Element | Text;
export declare class Text implements BaseNode {
export declare abstract class NodeWithI18n implements BaseNode {
sourceSpan: ParseSourceSpan;
i18n?: I18nMeta;
constructor(sourceSpan: ParseSourceSpan, i18n?: I18nMeta);
abstract visit(visitor: Visitor, context: any): any;
}
export declare class Text extends NodeWithI18n {
value: string;
sourceSpan: ParseSourceSpan;
i18n?: I18nAST;
constructor(value: string, sourceSpan: ParseSourceSpan, i18n?: I18nAST);
tokens: InterpolatedTextToken[];
constructor(value: string, sourceSpan: ParseSourceSpan, tokens: InterpolatedTextToken[], i18n?: I18nMeta);
visit(visitor: Visitor, context: any): any;
readonly type = "text";
}
export declare class CDATA implements BaseNode {
export declare class CDATA extends NodeWithI18n {
value: string;
sourceSpan: ParseSourceSpan;
constructor(value: string, sourceSpan: ParseSourceSpan);
tokens: InterpolatedTextToken[];
constructor(value: string, sourceSpan: ParseSourceSpan, tokens: InterpolatedTextToken[], i18n?: I18nMeta);
visit(visitor: Visitor, context: any): any;
readonly type = "cdata";
}
export declare class Expansion implements BaseNode {
export declare class Expansion extends NodeWithI18n {
switchValue: string;
type: string;
cases: ExpansionCase[];
sourceSpan: ParseSourceSpan;
switchValueSourceSpan: ParseSourceSpan;
i18n?: I18nAST;
constructor(switchValue: string, type: string, cases: ExpansionCase[], sourceSpan: ParseSourceSpan, switchValueSourceSpan: ParseSourceSpan, i18n?: I18nAST);
constructor(switchValue: string, type: string, cases: ExpansionCase[], sourceSpan: ParseSourceSpan, switchValueSourceSpan: ParseSourceSpan, i18n?: I18nMeta);
visit(visitor: Visitor, context: any): any;

@@ -52,23 +55,21 @@ }

}
export declare class Attribute implements BaseNode {
export declare class Attribute extends NodeWithI18n {
name: string;
value: string;
sourceSpan: ParseSourceSpan;
valueSpan: ParseSourceSpan | null;
nameSpan: ParseSourceSpan | null;
i18n: I18nAST | null;
constructor(name: string, value: string, sourceSpan: ParseSourceSpan, valueSpan?: ParseSourceSpan | null, nameSpan?: ParseSourceSpan | null, i18n?: I18nAST | null);
readonly keySpan: ParseSourceSpan | undefined;
valueSpan: ParseSourceSpan | undefined;
valueTokens: InterpolatedAttributeToken[] | undefined;
constructor(name: string, value: string, sourceSpan: ParseSourceSpan, keySpan: ParseSourceSpan | undefined, valueSpan: ParseSourceSpan | undefined, valueTokens: InterpolatedAttributeToken[] | undefined, i18n: I18nMeta | undefined);
visit(visitor: Visitor, context: any): any;
readonly type = "attribute";
get nameSpan(): ParseSourceSpan;
}
export declare class Element implements BaseNode {
export declare class Element extends NodeWithI18n {
name: string;
attrs: Attribute[];
children: Node[];
sourceSpan: ParseSourceSpan;
startSourceSpan: ParseSourceSpan | null;
startSourceSpan: ParseSourceSpan;
endSourceSpan: ParseSourceSpan | null;
nameSpan: ParseSourceSpan | null;
i18n: I18nAST | null;
constructor(name: string, attrs: Attribute[], children: Node[], sourceSpan: ParseSourceSpan, startSourceSpan?: ParseSourceSpan | null, endSourceSpan?: ParseSourceSpan | null, nameSpan?: ParseSourceSpan | null, i18n?: I18nAST | null);
constructor(name: string, attrs: Attribute[], children: Node[], sourceSpan: ParseSourceSpan, startSourceSpan: ParseSourceSpan, endSourceSpan?: ParseSourceSpan | null, nameSpan?: ParseSourceSpan | null, i18n?: I18nMeta);
visit(visitor: Visitor, context: any): any;

@@ -115,4 +116,2 @@ readonly type = "element";

}
export declare type HtmlAstPath = AstPath<Node>;
export declare function findNode(nodes: Node[], position: number): HtmlAstPath;
export {};

141

lib/compiler/src/ml_parser/ast.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,37 +8,44 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
const ast_path_1 = require("../ast_path");
// Expansion|ExpansionCase -- not used
class Text {
constructor(value, sourceSpan, i18n) {
this.value = value;
// Expansion|ExpansionCase -- not used by angular-html-parser, should be removed on publish
export class NodeWithI18n {
constructor(sourceSpan, i18n) {
this.sourceSpan = sourceSpan;
this.i18n = i18n;
}
}
export class Text extends NodeWithI18n {
constructor(value, sourceSpan, tokens, i18n) {
super(sourceSpan, i18n);
this.value = value;
this.tokens = tokens;
this.type = 'text';
}
visit(visitor, context) { return visitor.visitText(this, context); }
visit(visitor, context) {
return visitor.visitText(this, context);
}
}
exports.Text = Text;
class CDATA {
constructor(value, sourceSpan) {
export class CDATA extends NodeWithI18n {
constructor(value, sourceSpan, tokens, i18n) {
super(sourceSpan, i18n);
this.value = value;
this.sourceSpan = sourceSpan;
this.tokens = tokens;
this.type = 'cdata';
}
visit(visitor, context) { return visitor.visitCdata(this, context); }
visit(visitor, context) {
return visitor.visitCdata(this, context);
}
}
exports.CDATA = CDATA;
class Expansion {
export class Expansion extends NodeWithI18n {
constructor(switchValue, type, cases, sourceSpan, switchValueSourceSpan, i18n) {
super(sourceSpan, i18n);
this.switchValue = switchValue;
this.type = type;
this.cases = cases;
this.sourceSpan = sourceSpan;
this.switchValueSourceSpan = switchValueSourceSpan;
this.i18n = i18n;
}
visit(visitor, context) { return visitor.visitExpansion(this, context); }
visit(visitor, context) {
return visitor.visitExpansion(this, context);
}
}
exports.Expansion = Expansion;
class ExpansionCase {
export class ExpansionCase {
constructor(value, expression, sourceSpan, valueSourceSpan, expSourceSpan) {

@@ -52,34 +58,40 @@ this.value = value;

}
visit(visitor, context) { return visitor.visitExpansionCase(this, context); }
visit(visitor, context) {
return visitor.visitExpansionCase(this, context);
}
}
exports.ExpansionCase = ExpansionCase;
class Attribute {
constructor(name, value, sourceSpan, valueSpan = null, nameSpan = null, i18n = null) {
export class Attribute extends NodeWithI18n {
constructor(name, value, sourceSpan, keySpan, valueSpan, valueTokens, i18n) {
super(sourceSpan, i18n);
this.name = name;
this.value = value;
this.sourceSpan = sourceSpan;
this.keySpan = keySpan;
this.valueSpan = valueSpan;
this.nameSpan = nameSpan;
this.i18n = i18n;
this.valueTokens = valueTokens;
this.type = 'attribute';
}
visit(visitor, context) { return visitor.visitAttribute(this, context); }
visit(visitor, context) {
return visitor.visitAttribute(this, context);
}
// angular-html-parser: backwards compatibility for Prettier
get nameSpan() {
return this.keySpan;
}
}
exports.Attribute = Attribute;
class Element {
constructor(name, attrs, children, sourceSpan, startSourceSpan = null, endSourceSpan = null, nameSpan = null, i18n = null) {
export class Element extends NodeWithI18n {
constructor(name, attrs, children, sourceSpan, startSourceSpan, endSourceSpan = null, nameSpan = null, i18n) {
super(sourceSpan, i18n);
this.name = name;
this.attrs = attrs;
this.children = children;
this.sourceSpan = sourceSpan;
this.startSourceSpan = startSourceSpan;
this.endSourceSpan = endSourceSpan;
this.nameSpan = nameSpan;
this.i18n = i18n;
this.type = 'element';
}
visit(visitor, context) { return visitor.visitElement(this, context); }
visit(visitor, context) {
return visitor.visitElement(this, context);
}
}
exports.Element = Element;
class Comment {
export class Comment {
constructor(value, sourceSpan) {

@@ -90,6 +102,7 @@ this.value = value;

}
visit(visitor, context) { return visitor.visitComment(this, context); }
visit(visitor, context) {
return visitor.visitComment(this, context);
}
}
exports.Comment = Comment;
class DocType {
export class DocType {
constructor(value, sourceSpan) {

@@ -100,6 +113,7 @@ this.value = value;

}
visit(visitor, context) { return visitor.visitDocType(this, context); }
visit(visitor, context) {
return visitor.visitDocType(this, context);
}
}
exports.DocType = DocType;
function visitAll(visitor, nodes, context = null) {
export function visitAll(visitor, nodes, context = null) {
const result = [];

@@ -117,4 +131,3 @@ const visit = visitor.visit ?

}
exports.visitAll = visitAll;
class RecursiveVisitor {
export class RecursiveVisitor {
constructor() { }

@@ -133,5 +146,5 @@ visitElement(ast, context) {

visitExpansion(ast, context) {
// `ExpansionCase` is excluded from `Node` in angular-html-parser.
// @ts-ignore -- Using ts-ignore here to minimize efforts on merging upstream changes.
return this.visitChildren(context, visit => { visit(ast.cases); });
return this.visitChildren(context, visit => {
visit(ast.cases);
});
}

@@ -150,33 +163,1 @@ visitExpansionCase(ast, context) { }

}
exports.RecursiveVisitor = RecursiveVisitor;
function spanOf(ast) {
const start = ast.sourceSpan.start.offset;
let end = ast.sourceSpan.end.offset;
if (ast instanceof Element) {
if (ast.endSourceSpan) {
end = ast.endSourceSpan.end.offset;
}
else if (ast.children && ast.children.length) {
end = spanOf(ast.children[ast.children.length - 1]).end;
}
}
return { start, end };
}
function findNode(nodes, position) {
const path = [];
const visitor = new class extends RecursiveVisitor {
visit(ast, context) {
const span = spanOf(ast);
if (span.start <= position && position < span.end) {
path.push(ast);
}
else {
// Returning a value here will result in the children being skipped.
return true;
}
}
};
visitAll(visitor, nodes);
return new ast_path_1.AstPath(path, position);
}
exports.findNode = findNode;

9

lib/compiler/src/ml_parser/html_parser.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -8,6 +8,5 @@ * Use of this source code is governed by an MIT-style license that can be

*/
import { TokenizeOptions } from './lexer';
import { ParseTreeResult, Parser } from './parser';
import { TagContentType } from './tags';
export { ParseTreeResult, TreeError } from './parser';
import { TokenizeOptions } from "./lexer.js";
import { Parser, ParseTreeResult } from "./parser.js";
import { TagContentType } from "./tags.js";
export declare class HtmlParser extends Parser {

@@ -14,0 +13,0 @@ constructor();

18

lib/compiler/src/ml_parser/html_parser.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,10 +8,8 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
const html_tags_1 = require("./html_tags");
const parser_1 = require("./parser");
var parser_2 = require("./parser");
exports.ParseTreeResult = parser_2.ParseTreeResult;
exports.TreeError = parser_2.TreeError;
class HtmlParser extends parser_1.Parser {
constructor() { super(html_tags_1.getHtmlTagDefinition); }
import { getHtmlTagDefinition } from "./html_tags.js";
import { Parser } from "./parser.js";
export class HtmlParser extends Parser {
constructor() {
super(getHtmlTagDefinition);
}
parse(source, url, options, isTagNameCaseSensitive = false, getTagContentType) {

@@ -22,2 +19,1 @@ return super.parse(source, url, options, isTagNameCaseSensitive, getTagContentType);

}
exports.HtmlParser = HtmlParser;

16

lib/compiler/src/ml_parser/html_tags.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -8,21 +8,27 @@ * Use of this source code is governed by an MIT-style license that can be

*/
import { TagContentType, TagDefinition } from './tags';
import { TagContentType, TagDefinition } from "./tags.js";
export declare class HtmlTagDefinition implements TagDefinition {
private closedByChildren;
private contentType;
closedByParent: boolean;
implicitNamespacePrefix: string | null;
contentType: TagContentType;
isVoid: boolean;
ignoreFirstLf: boolean;
canSelfClose: boolean;
constructor({ closedByChildren, implicitNamespacePrefix, contentType, closedByParent, isVoid, ignoreFirstLf }?: {
preventNamespaceInheritance: boolean;
constructor({ closedByChildren, implicitNamespacePrefix, contentType, closedByParent, isVoid, ignoreFirstLf, preventNamespaceInheritance }?: {
closedByChildren?: string[];
closedByParent?: boolean;
implicitNamespacePrefix?: string;
contentType?: TagContentType;
contentType?: TagContentType | {
default: TagContentType;
[namespace: string]: TagContentType;
};
isVoid?: boolean;
ignoreFirstLf?: boolean;
preventNamespaceInheritance?: boolean;
});
isClosedByChild(name: string): boolean;
getContentType(prefix?: string): TagContentType;
}
export declare function getHtmlTagDefinition(tagName: string): HtmlTagDefinition;

52

lib/compiler/src/ml_parser/html_tags.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,6 +8,5 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
const tags_1 = require("./tags");
class HtmlTagDefinition {
constructor({ closedByChildren, implicitNamespacePrefix, contentType = tags_1.TagContentType.PARSABLE_DATA, closedByParent = false, isVoid = false, ignoreFirstLf = false } = {}) {
import { TagContentType } from "./tags.js";
export class HtmlTagDefinition {
constructor({ closedByChildren, implicitNamespacePrefix, contentType = TagContentType.PARSABLE_DATA, closedByParent = false, isVoid = false, ignoreFirstLf = false, preventNamespaceInheritance = false } = {}) {
this.closedByChildren = {};

@@ -25,2 +23,3 @@ this.closedByParent = false;

this.ignoreFirstLf = ignoreFirstLf;
this.preventNamespaceInheritance = preventNamespaceInheritance;
}

@@ -30,9 +29,15 @@ isClosedByChild(name) {

}
getContentType(prefix) {
if (typeof this.contentType === 'object') {
const overrideType = prefix === undefined ? undefined : this.contentType[prefix];
return overrideType ?? this.contentType.default;
}
return this.contentType;
}
}
exports.HtmlTagDefinition = HtmlTagDefinition;
let _DEFAULT_TAG_DEFINITION;
// see http://www.w3.org/TR/html51/syntax.html#optional-tags
// see https://www.w3.org/TR/html51/syntax.html#optional-tags
// This implementation does not fully conform to the HTML5 spec.
let TAG_DEFINITIONS;
function getHtmlTagDefinition(tagName) {
export function getHtmlTagDefinition(tagName) {
if (!TAG_DEFINITIONS) {

@@ -71,2 +76,13 @@ _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();

'svg': new HtmlTagDefinition({ implicitNamespacePrefix: 'svg' }),
'foreignObject': new HtmlTagDefinition({
// Usually the implicit namespace here would be redundant since it will be inherited from
// the parent `svg`, but we have to do it for `foreignObject`, because the way the parser
// works is that the parent node of an end tag is its own start tag which means that
// the `preventNamespaceInheritance` on `foreignObject` would have it default to the
// implicit namespace which is `html`, unless specified otherwise.
implicitNamespacePrefix: 'svg',
// We want to prevent children of foreignObject from inheriting its namespace, because
// the point of the element is to allow nodes from other namespaces to be inserted.
preventNamespaceInheritance: true,
}),
'math': new HtmlTagDefinition({ implicitNamespacePrefix: 'math' }),

@@ -84,10 +100,16 @@ 'li': new HtmlTagDefinition({ closedByChildren: ['li'], closedByParent: true }),

'listing': new HtmlTagDefinition({ ignoreFirstLf: true }),
'style': new HtmlTagDefinition({ contentType: tags_1.TagContentType.RAW_TEXT }),
'script': new HtmlTagDefinition({ contentType: tags_1.TagContentType.RAW_TEXT }),
'title': new HtmlTagDefinition({ contentType: tags_1.TagContentType.ESCAPABLE_RAW_TEXT }),
'textarea': new HtmlTagDefinition({ contentType: tags_1.TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),
'style': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),
'script': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),
'title': new HtmlTagDefinition({
// The browser supports two separate `title` tags which have to use
// a different content type: `HTMLTitleElement` and `SVGTitleElement`
contentType: { default: TagContentType.ESCAPABLE_RAW_TEXT, svg: TagContentType.PARSABLE_DATA }
}),
'textarea': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),
};
}
return TAG_DEFINITIONS[tagName] || _DEFAULT_TAG_DEFINITION;
// We have to make both a case-sensitive and a case-insensitive lookup, because
// HTML tag names are case insensitive, whereas some SVG tags are case sensitive.
return TAG_DEFINITIONS[tagName] ?? // TAG_DEFINITIONS[tagName.toLowerCase()] ?? -- angular-html-parser modification
_DEFAULT_TAG_DEFINITION;
}
exports.getHtmlTagDefinition = getHtmlTagDefinition;

2

lib/compiler/src/ml_parser/interpolation_config.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -5,0 +5,0 @@ * Use of this source code is governed by an MIT-style license that can be

15

lib/compiler/src/ml_parser/interpolation_config.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,5 +8,4 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
const assertions_1 = require("../assertions");
class InterpolationConfig {
import { assertInterpolationSymbols } from "../assertions.js";
export class InterpolationConfig {
constructor(start, end) {

@@ -19,9 +17,8 @@ this.start = start;

if (!markers) {
return exports.DEFAULT_INTERPOLATION_CONFIG;
return DEFAULT_INTERPOLATION_CONFIG;
}
assertions_1.assertInterpolationSymbols('interpolation', markers);
assertInterpolationSymbols('interpolation', markers);
return new InterpolationConfig(markers[0], markers[1]);
}
}
exports.InterpolationConfig = InterpolationConfig;
exports.DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');
export const DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');

55

lib/compiler/src/ml_parser/lexer.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -8,35 +8,6 @@ * Use of this source code is governed by an MIT-style license that can be

*/
import { ParseError, ParseSourceSpan } from '../parse_util';
import { InterpolationConfig } from './interpolation_config';
import { TagContentType } from './tags';
export declare enum TokenType {
TAG_OPEN_START = 0,
TAG_OPEN_END = 1,
TAG_OPEN_END_VOID = 2,
TAG_CLOSE = 3,
TEXT = 4,
ESCAPABLE_RAW_TEXT = 5,
RAW_TEXT = 6,
COMMENT_START = 7,
COMMENT_END = 8,
CDATA_START = 9,
CDATA_END = 10,
ATTR_NAME = 11,
ATTR_QUOTE = 12,
ATTR_VALUE = 13,
DOC_TYPE_START = 14,
DOC_TYPE_END = 15,
EXPANSION_FORM_START = 16,
EXPANSION_CASE_VALUE = 17,
EXPANSION_CASE_EXP_START = 18,
EXPANSION_CASE_EXP_END = 19,
EXPANSION_FORM_END = 20,
EOF = 21
}
export declare class Token {
type: TokenType | null;
parts: string[];
sourceSpan: ParseSourceSpan;
constructor(type: TokenType | null, parts: string[], sourceSpan: ParseSourceSpan);
}
import { ParseError, ParseSourceSpan } from "../parse_util.js";
import { InterpolationConfig } from "./interpolation_config.js";
import { TagContentType } from "./tags.js";
import { Token, TokenType } from "./tokens.js";
export declare class TokenError extends ParseError {

@@ -49,3 +20,4 @@ tokenType: TokenType | null;

errors: TokenError[];
constructor(tokens: Token[], errors: TokenError[]);
nonNormalizedIcuExpressions: Token[];
constructor(tokens: Token[], errors: TokenError[], nonNormalizedIcuExpressions: Token[]);
}

@@ -96,2 +68,11 @@ export interface LexerRange {

/**
* If this text is stored in an external template (e.g. via `templateUrl`) then we need to decide
* whether or not to normalize the line-endings (from `\r\n` to `\n`) when processing ICU
* expressions.
*
* If `true` then we will normalize ICU expression line endings.
* The default is `false`, but this will be switched in a future major release.
*/
i18nNormalizeLineEndingsInICUs?: boolean;
/**
* An array of characters that should be considered as leading trivia.

@@ -102,2 +83,6 @@ * Leading trivia are characters that are not important to the developer, and so should not be

leadingTriviaChars?: string[];
/**
* If true, do not convert CRLF to LF.
*/
preserveLineEndings?: boolean;
canSelfClose?: boolean;

@@ -104,0 +89,0 @@ allowHtmComponentClosingTags?: boolean;

505

lib/compiler/src/ml_parser/lexer.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,41 +8,8 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
const chars = require("../chars");
const parse_util_1 = require("../parse_util");
const interpolation_config_1 = require("./interpolation_config");
const tags_1 = require("./tags");
var TokenType;
(function (TokenType) {
TokenType[TokenType["TAG_OPEN_START"] = 0] = "TAG_OPEN_START";
TokenType[TokenType["TAG_OPEN_END"] = 1] = "TAG_OPEN_END";
TokenType[TokenType["TAG_OPEN_END_VOID"] = 2] = "TAG_OPEN_END_VOID";
TokenType[TokenType["TAG_CLOSE"] = 3] = "TAG_CLOSE";
TokenType[TokenType["TEXT"] = 4] = "TEXT";
TokenType[TokenType["ESCAPABLE_RAW_TEXT"] = 5] = "ESCAPABLE_RAW_TEXT";
TokenType[TokenType["RAW_TEXT"] = 6] = "RAW_TEXT";
TokenType[TokenType["COMMENT_START"] = 7] = "COMMENT_START";
TokenType[TokenType["COMMENT_END"] = 8] = "COMMENT_END";
TokenType[TokenType["CDATA_START"] = 9] = "CDATA_START";
TokenType[TokenType["CDATA_END"] = 10] = "CDATA_END";
TokenType[TokenType["ATTR_NAME"] = 11] = "ATTR_NAME";
TokenType[TokenType["ATTR_QUOTE"] = 12] = "ATTR_QUOTE";
TokenType[TokenType["ATTR_VALUE"] = 13] = "ATTR_VALUE";
TokenType[TokenType["DOC_TYPE_START"] = 14] = "DOC_TYPE_START";
TokenType[TokenType["DOC_TYPE_END"] = 15] = "DOC_TYPE_END";
TokenType[TokenType["EXPANSION_FORM_START"] = 16] = "EXPANSION_FORM_START";
TokenType[TokenType["EXPANSION_CASE_VALUE"] = 17] = "EXPANSION_CASE_VALUE";
TokenType[TokenType["EXPANSION_CASE_EXP_START"] = 18] = "EXPANSION_CASE_EXP_START";
TokenType[TokenType["EXPANSION_CASE_EXP_END"] = 19] = "EXPANSION_CASE_EXP_END";
TokenType[TokenType["EXPANSION_FORM_END"] = 20] = "EXPANSION_FORM_END";
TokenType[TokenType["EOF"] = 21] = "EOF";
})(TokenType = exports.TokenType || (exports.TokenType = {}));
class Token {
constructor(type, parts, sourceSpan) {
this.type = type;
this.parts = parts;
this.sourceSpan = sourceSpan;
}
}
exports.Token = Token;
class TokenError extends parse_util_1.ParseError {
import * as chars from "../chars.js";
import { ParseError, ParseLocation, ParseSourceFile, ParseSourceSpan } from "../parse_util.js";
import { NAMED_ENTITIES } from "./entities.js";
import { DEFAULT_INTERPOLATION_CONFIG } from "./interpolation_config.js";
import { TagContentType, mergeNsAndName } from "./tags.js";
export class TokenError extends ParseError {
constructor(errorMsg, tokenType, span) {

@@ -54,14 +20,14 @@ super(span, errorMsg);

}
exports.TokenError = TokenError;
class TokenizeResult {
constructor(tokens, errors) {
export class TokenizeResult {
constructor(tokens, errors, nonNormalizedIcuExpressions) {
this.tokens = tokens;
this.errors = errors;
this.nonNormalizedIcuExpressions = nonNormalizedIcuExpressions;
}
}
exports.TokenizeResult = TokenizeResult;
function tokenize(source, url, getTagContentType, options = {}) {
return new _Tokenizer(new parse_util_1.ParseSourceFile(source, url), getTagContentType, options).tokenize();
export function tokenize(source, url, getTagContentType, options = {}) {
const tokenizer = new _Tokenizer(new ParseSourceFile(source, url), getTagContentType, options);
tokenizer.tokenize();
return new TokenizeResult(mergeTextTokens(tokenizer.tokens), tokenizer.errors, tokenizer.nonNormalizedIcuExpressions);
}
exports.tokenize = tokenize;
const _CR_OR_CRLF_REGEXP = /\r\n?/g;

@@ -75,2 +41,10 @@ function _unexpectedCharacterErrorMsg(charCode) {

}
function _unparsableEntityErrorMsg(type, entityStr) {
return `Unable to parse entity "${entityStr}" - ${type} character reference entities must end with ";"`;
}
var CharacterReferenceType;
(function (CharacterReferenceType) {
CharacterReferenceType["HEX"] = "hexadecimal";
CharacterReferenceType["DEC"] = "decimal";
})(CharacterReferenceType || (CharacterReferenceType = {}));
class _ControlFlowError {

@@ -81,3 +55,3 @@ constructor(error) {

}
// See http://www.w3.org/TR/html51/syntax.html#writing
// See https://www.w3.org/TR/html51/syntax.html#writing-html-documents
class _Tokenizer {

@@ -98,4 +72,5 @@ /**

this.errors = [];
this.nonNormalizedIcuExpressions = [];
this._tokenizeIcu = options.tokenizeExpansionForms || false;
this._interpolationConfig = options.interpolationConfig || interpolation_config_1.DEFAULT_INTERPOLATION_CONFIG;
this._interpolationConfig = options.interpolationConfig || DEFAULT_INTERPOLATION_CONFIG;
this._leadingTriviaCodePoints =

@@ -108,2 +83,5 @@ options.leadingTriviaChars && options.leadingTriviaChars.map(c => c.codePointAt(0) || 0);

new PlainCharacterCursor(_file, range);
this._preserveLineEndings = options.preserveLineEndings || false;
this._escapedString = options.escapedString || false;
this._i18nNormalizeLineEndingsInICUs = options.i18nNormalizeLineEndingsInICUs || false;
try {

@@ -117,3 +95,6 @@ this._cursor.init();

_processCarriageReturns(content) {
// http://www.w3.org/TR/html5/syntax.html#preprocessing-the-input-stream
if (this._preserveLineEndings) {
return content;
}
// https://www.w3.org/TR/html51/syntax.html#preprocessing-the-input-stream
// In order to keep the original position in the source, we can not

@@ -158,3 +139,5 @@ // pre-process it.

else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
this._consumeText();
// In (possibly interpolated) text the end of the text is given by `isTextEnd()`, while
// the premature end of an interpolation is given by the start of a new HTML element.
this._consumeWithInterpolation(5 /* TokenType.TEXT */, 8 /* TokenType.INTERPOLATION */, () => this._isTextEnd(), () => this._isTagStart());
}

@@ -166,5 +149,4 @@ }

}
this._beginToken(TokenType.EOF);
this._beginToken(25 /* TokenType.EOF */);
this._endToken([]);
return new TokenizeResult(mergeTextTokens(this.tokens), this.errors);
}

@@ -200,3 +182,3 @@ /**

}
_endToken(parts, end = this._cursor.clone()) {
_endToken(parts, end) {
if (this._currentTokenStart === null) {

@@ -208,3 +190,7 @@ throw new TokenError('Programming error - attempted to end a token when there was no start to the token', this._currentTokenType, this._cursor.getSpan(end));

}
const token = new Token(this._currentTokenType, parts, this._cursor.getSpan(this._currentTokenStart, this._leadingTriviaCodePoints));
const token = {
type: this._currentTokenType,
parts,
sourceSpan: (end ?? this._cursor).getSpan(this._currentTokenStart, this._leadingTriviaCodePoints),
};
this.tokens.push(token);

@@ -299,4 +285,3 @@ this._currentTokenStart = null;

this._attemptCharCodeUntilFn(predicate);
const end = this._cursor.clone();
if (end.diff(start) < len) {
if (this._cursor.diff(start) < len) {
throw this._createError(_unexpectedCharacterErrorMsg(this._cursor.peek()), this._cursor.getSpan(start));

@@ -310,15 +295,11 @@ }

}
_readChar(decodeEntities) {
if (decodeEntities && this._cursor.peek() === chars.$AMPERSAND) {
return this._decodeEntity();
}
else {
// Don't rely upon reading directly from `_input` as the actual char value
// may have been generated from an escape sequence.
const char = String.fromCodePoint(this._cursor.peek());
this._cursor.advance();
return char;
}
_readChar() {
// Don't rely upon reading directly from `_input` as the actual char value
// may have been generated from an escape sequence.
const char = String.fromCodePoint(this._cursor.peek());
this._cursor.advance();
return char;
}
_decodeEntity() {
_consumeEntity(textTokenType) {
this._beginToken(9 /* TokenType.ENCODED_ENTITY */);
const start = this._cursor.clone();

@@ -331,3 +312,7 @@ this._cursor.advance();

if (this._cursor.peek() != chars.$SEMICOLON) {
throw this._createError(_unexpectedCharacterErrorMsg(this._cursor.peek()), this._cursor.getSpan());
// Advance cursor to include the peeked character in the string provided to the error
// message.
this._cursor.advance();
const entityType = isHex ? CharacterReferenceType.HEX : CharacterReferenceType.DEC;
throw this._createError(_unparsableEntityErrorMsg(entityType, this._cursor.getChars(start)), this._cursor.getSpan());
}

@@ -338,5 +323,5 @@ const strNum = this._cursor.getChars(codeStart);

const charCode = parseInt(strNum, isHex ? 16 : 10);
return String.fromCharCode(charCode);
this._endToken([String.fromCharCode(charCode), this._cursor.getChars(start)]);
}
catch (_a) {
catch {
throw this._createError(_unknownEntityErrorMsg(this._cursor.getChars(start)), this._cursor.getSpan());

@@ -349,16 +334,21 @@ }

if (this._cursor.peek() != chars.$SEMICOLON) {
// No semicolon was found so abort the encoded entity token that was in progress, and treat
// this as a text token
this._beginToken(textTokenType, start);
this._cursor = nameStart;
return '&';
this._endToken(['&']);
}
const name = this._cursor.getChars(nameStart);
this._cursor.advance();
const char = tags_1.NAMED_ENTITIES[name];
if (!char) {
throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
else {
const name = this._cursor.getChars(nameStart);
this._cursor.advance();
const char = NAMED_ENTITIES[name];
if (!char) {
throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
}
this._endToken([char, `&${name};`]);
}
return char;
}
}
_consumeRawText(decodeEntities, endMarkerPredicate) {
this._beginToken(decodeEntities ? TokenType.ESCAPABLE_RAW_TEXT : TokenType.RAW_TEXT);
_consumeRawText(consumeEntities, endMarkerPredicate) {
this._beginToken(consumeEntities ? 6 /* TokenType.ESCAPABLE_RAW_TEXT */ : 7 /* TokenType.RAW_TEXT */);
const parts = [];

@@ -372,11 +362,19 @@ while (true) {

}
parts.push(this._readChar(decodeEntities));
if (consumeEntities && this._cursor.peek() === chars.$AMPERSAND) {
this._endToken([this._processCarriageReturns(parts.join(''))]);
parts.length = 0;
this._consumeEntity(6 /* TokenType.ESCAPABLE_RAW_TEXT */);
this._beginToken(6 /* TokenType.ESCAPABLE_RAW_TEXT */);
}
else {
parts.push(this._readChar());
}
}
return this._endToken([this._processCarriageReturns(parts.join(''))]);
this._endToken([this._processCarriageReturns(parts.join(''))]);
}
_consumeComment(start) {
this._beginToken(TokenType.COMMENT_START, start);
this._beginToken(10 /* TokenType.COMMENT_START */, start);
this._endToken([]);
this._consumeRawText(false, () => this._attemptStr('-->'));
this._beginToken(TokenType.COMMENT_END);
this._beginToken(11 /* TokenType.COMMENT_END */);
this._requireStr('-->');

@@ -387,6 +385,6 @@ this._endToken([]);

_consumeBogusComment(start) {
this._beginToken(TokenType.COMMENT_START, start);
this._beginToken(10 /* TokenType.COMMENT_START */, start);
this._endToken([]);
this._consumeRawText(false, () => this._cursor.peek() === chars.$GT);
this._beginToken(TokenType.COMMENT_END);
this._beginToken(11 /* TokenType.COMMENT_END */);
this._cursor.advance();

@@ -396,6 +394,6 @@ this._endToken([]);

_consumeCdata(start) {
this._beginToken(TokenType.CDATA_START, start);
this._beginToken(12 /* TokenType.CDATA_START */, start);
this._endToken([]);
this._consumeRawText(false, () => this._attemptStr(']]>'));
this._beginToken(TokenType.CDATA_END);
this._beginToken(13 /* TokenType.CDATA_END */);
this._requireStr(']]>');

@@ -405,6 +403,6 @@ this._endToken([]);

_consumeDocType(start) {
this._beginToken(TokenType.DOC_TYPE_START, start);
this._beginToken(18 /* TokenType.DOC_TYPE_START */, start);
this._endToken([]);
this._consumeRawText(false, () => this._cursor.peek() === chars.$GT);
this._beginToken(TokenType.DOC_TYPE_END);
this._beginToken(19 /* TokenType.DOC_TYPE_END */);
this._cursor.advance();

@@ -436,4 +434,2 @@ this._endToken([]);

let openTagToken;
let tokensBeforeTagOpen = this.tokens.length;
const innerStart = this._cursor.clone();
const attrs = [];

@@ -448,3 +444,4 @@ try {

this._attemptCharCodeUntilFn(isNotWhitespace);
while (this._cursor.peek() !== chars.$SLASH && this._cursor.peek() !== chars.$GT) {
while (this._cursor.peek() !== chars.$SLASH && this._cursor.peek() !== chars.$GT &&
this._cursor.peek() !== chars.$LT && this._cursor.peek() !== chars.$EOF) {
const [prefix, name] = this._consumeAttributeName();

@@ -466,10 +463,12 @@ this._attemptCharCodeUntilFn(isNotWhitespace);

if (e instanceof _ControlFlowError) {
// When the start tag is invalid (including invalid "attributes"), assume we want a "<"
this._cursor = innerStart;
if (openTagToken) {
this.tokens.length = tokensBeforeTagOpen;
// We errored before we could close the opening tag, so it is incomplete.
openTagToken.type = 4 /* TokenType.INCOMPLETE_TAG_OPEN */;
}
// Back to back text tokens are merged at the end
this._beginToken(TokenType.TEXT, start);
this._endToken(['<']);
else {
// When the start tag is invalid, assume we want a "<" as text.
// Back to back text tokens are merged at the end.
this._beginToken(5 /* TokenType.TEXT */, start);
this._endToken(['<']);
}
return;

@@ -479,3 +478,3 @@ }

}
if (this._canSelfClose && this.tokens[this.tokens.length - 1].type === TokenType.TAG_OPEN_END_VOID) {
if (this._canSelfClose && this.tokens[this.tokens.length - 1].type === 2 /* TokenType.TAG_OPEN_END_VOID */) {
return;

@@ -485,11 +484,11 @@ }

this._handleFullNameStackForTagOpen(prefix, tagName);
if (contentTokenType === tags_1.TagContentType.RAW_TEXT) {
if (contentTokenType === TagContentType.RAW_TEXT) {
this._consumeRawTextWithTagClose(prefix, tagName, false);
}
else if (contentTokenType === tags_1.TagContentType.ESCAPABLE_RAW_TEXT) {
else if (contentTokenType === TagContentType.ESCAPABLE_RAW_TEXT) {
this._consumeRawTextWithTagClose(prefix, tagName, true);
}
}
_consumeRawTextWithTagClose(prefix, tagName, decodeEntities) {
const textToken = this._consumeRawText(decodeEntities, () => {
_consumeRawTextWithTagClose(prefix, tagName, consumeEntities) {
this._consumeRawText(consumeEntities, () => {
if (!this._attemptCharCode(chars.$LT))

@@ -505,3 +504,3 @@ return false;

});
this._beginToken(TokenType.TAG_CLOSE);
this._beginToken(3 /* TokenType.TAG_CLOSE */);
this._requireCharCodeUntilFn(code => code === chars.$GT, 3);

@@ -513,3 +512,3 @@ this._cursor.advance(); // Consume the `>`

_consumeTagOpenStart(start) {
this._beginToken(TokenType.TAG_OPEN_START, start);
this._beginToken(0 /* TokenType.TAG_OPEN_START */, start);
const parts = this._consumePrefixAndName();

@@ -523,3 +522,3 @@ return this._endToken(parts);

}
this._beginToken(TokenType.ATTR_NAME);
this._beginToken(14 /* TokenType.ATTR_NAME */);
const prefixAndName = this._consumePrefixAndName();

@@ -532,28 +531,23 @@ this._endToken(prefixAndName);

if (this._cursor.peek() === chars.$SQ || this._cursor.peek() === chars.$DQ) {
this._beginToken(TokenType.ATTR_QUOTE);
const quoteChar = this._cursor.peek();
this._cursor.advance();
this._endToken([String.fromCodePoint(quoteChar)]);
this._beginToken(TokenType.ATTR_VALUE);
const parts = [];
while (this._cursor.peek() !== quoteChar) {
parts.push(this._readChar(true));
}
value = this._processCarriageReturns(parts.join(''));
this._endToken([value]);
this._beginToken(TokenType.ATTR_QUOTE);
this._cursor.advance();
this._endToken([String.fromCodePoint(quoteChar)]);
this._consumeQuote(quoteChar);
// In an attribute then end of the attribute value and the premature end to an interpolation
// are both triggered by the `quoteChar`.
const endPredicate = () => this._cursor.peek() === quoteChar;
value = this._consumeWithInterpolation(16 /* TokenType.ATTR_VALUE_TEXT */, 17 /* TokenType.ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
this._consumeQuote(quoteChar);
}
else {
this._beginToken(TokenType.ATTR_VALUE);
const valueStart = this._cursor.clone();
this._requireCharCodeUntilFn(isNameEnd, 1);
value = this._processCarriageReturns(this._cursor.getChars(valueStart));
this._endToken([value]);
const endPredicate = () => isNameEnd(this._cursor.peek());
value = this._consumeWithInterpolation(16 /* TokenType.ATTR_VALUE_TEXT */, 17 /* TokenType.ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
}
return value;
}
_consumeQuote(quoteChar) {
this._beginToken(15 /* TokenType.ATTR_QUOTE */);
this._requireCharCode(quoteChar);
this._endToken([String.fromCodePoint(quoteChar)]);
}
_consumeTagOpenEnd() {
const tokenType = this._attemptCharCode(chars.$SLASH) ? TokenType.TAG_OPEN_END_VOID : TokenType.TAG_OPEN_END;
const tokenType = this._attemptCharCode(chars.$SLASH) ? 2 /* TokenType.TAG_OPEN_END_VOID */ : 1 /* TokenType.TAG_OPEN_END */;
this._beginToken(tokenType);

@@ -564,3 +558,3 @@ this._requireCharCode(chars.$GT);

_consumeTagClose(start) {
this._beginToken(TokenType.TAG_CLOSE, start);
this._beginToken(3 /* TokenType.TAG_CLOSE */, start);
this._attemptCharCodeUntilFn(isNotWhitespace);

@@ -582,12 +576,23 @@ // https://github.com/developit/htm

_consumeExpansionFormStart() {
this._beginToken(TokenType.EXPANSION_FORM_START);
this._beginToken(20 /* TokenType.EXPANSION_FORM_START */);
this._requireCharCode(chars.$LBRACE);
this._endToken([]);
this._expansionCaseStack.push(TokenType.EXPANSION_FORM_START);
this._beginToken(TokenType.RAW_TEXT);
this._expansionCaseStack.push(20 /* TokenType.EXPANSION_FORM_START */);
this._beginToken(7 /* TokenType.RAW_TEXT */);
const condition = this._readUntil(chars.$COMMA);
this._endToken([condition]);
const normalizedCondition = this._processCarriageReturns(condition);
if (this._i18nNormalizeLineEndingsInICUs) {
// We explicitly want to normalize line endings for this text.
this._endToken([normalizedCondition]);
}
else {
// We are not normalizing line endings.
const conditionToken = this._endToken([condition]);
if (normalizedCondition !== condition) {
this.nonNormalizedIcuExpressions.push(conditionToken);
}
}
this._requireCharCode(chars.$COMMA);
this._attemptCharCodeUntilFn(isNotWhitespace);
this._beginToken(TokenType.RAW_TEXT);
this._beginToken(7 /* TokenType.RAW_TEXT */);
const type = this._readUntil(chars.$COMMA);

@@ -599,14 +604,14 @@ this._endToken([type]);

_consumeExpansionCaseStart() {
this._beginToken(TokenType.EXPANSION_CASE_VALUE);
this._beginToken(21 /* TokenType.EXPANSION_CASE_VALUE */);
const value = this._readUntil(chars.$LBRACE).trim();
this._endToken([value]);
this._attemptCharCodeUntilFn(isNotWhitespace);
this._beginToken(TokenType.EXPANSION_CASE_EXP_START);
this._beginToken(22 /* TokenType.EXPANSION_CASE_EXP_START */);
this._requireCharCode(chars.$LBRACE);
this._endToken([]);
this._attemptCharCodeUntilFn(isNotWhitespace);
this._expansionCaseStack.push(TokenType.EXPANSION_CASE_EXP_START);
this._expansionCaseStack.push(22 /* TokenType.EXPANSION_CASE_EXP_START */);
}
_consumeExpansionCaseEnd() {
this._beginToken(TokenType.EXPANSION_CASE_EXP_END);
this._beginToken(23 /* TokenType.EXPANSION_CASE_EXP_END */);
this._requireCharCode(chars.$RBRACE);

@@ -618,3 +623,3 @@ this._endToken([]);

_consumeExpansionFormEnd() {
this._beginToken(TokenType.EXPANSION_FORM_END);
this._beginToken(24 /* TokenType.EXPANSION_FORM_END */);
this._requireCharCode(chars.$RBRACE);

@@ -624,24 +629,109 @@ this._endToken([]);

}
_consumeText() {
const start = this._cursor.clone();
this._beginToken(TokenType.TEXT, start);
/**
* Consume a string that may contain interpolation expressions.
*
* The first token consumed will be of `tokenType` and then there will be alternating
* `interpolationTokenType` and `tokenType` tokens until the `endPredicate()` returns true.
*
* If an interpolation token ends prematurely it will have no end marker in its `parts` array.
*
* @param textTokenType the kind of tokens to interleave around interpolation tokens.
* @param interpolationTokenType the kind of tokens that contain interpolation.
* @param endPredicate a function that should return true when we should stop consuming.
* @param endInterpolation a function that should return true if there is a premature end to an
* interpolation expression - i.e. before we get to the normal interpolation closing marker.
*/
_consumeWithInterpolation(textTokenType, interpolationTokenType, endPredicate, endInterpolation) {
this._beginToken(textTokenType);
const parts = [];
do {
while (!endPredicate()) {
const current = this._cursor.clone();
if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) {
parts.push(this._interpolationConfig.start);
this._inInterpolation = true;
this._endToken([this._processCarriageReturns(parts.join(''))], current);
parts.length = 0;
this._consumeInterpolation(interpolationTokenType, current, endInterpolation);
this._beginToken(textTokenType);
}
else if (this._interpolationConfig && this._inInterpolation &&
this._attemptStr(this._interpolationConfig.end)) {
parts.push(this._interpolationConfig.end);
this._inInterpolation = false;
else if (this._cursor.peek() === chars.$AMPERSAND) {
this._endToken([this._processCarriageReturns(parts.join(''))]);
parts.length = 0;
this._consumeEntity(textTokenType);
this._beginToken(textTokenType);
}
else {
parts.push(this._readChar(true));
parts.push(this._readChar());
}
} while (!this._isTextEnd());
this._endToken([this._processCarriageReturns(parts.join(''))]);
}
// It is possible that an interpolation was started but not ended inside this text token.
// Make sure that we reset the state of the lexer correctly.
this._inInterpolation = false;
const value = this._processCarriageReturns(parts.join(''));
this._endToken([value]);
return value;
}
/**
* Consume a block of text that has been interpreted as an Angular interpolation.
*
* @param interpolationTokenType the type of the interpolation token to generate.
* @param interpolationStart a cursor that points to the start of this interpolation.
* @param prematureEndPredicate a function that should return true if the next characters indicate
* an end to the interpolation before its normal closing marker.
*/
_consumeInterpolation(interpolationTokenType, interpolationStart, prematureEndPredicate) {
const parts = [];
this._beginToken(interpolationTokenType, interpolationStart);
parts.push(this._interpolationConfig.start);
// Find the end of the interpolation, ignoring content inside quotes.
const expressionStart = this._cursor.clone();
let inQuote = null;
let inComment = false;
while (this._cursor.peek() !== chars.$EOF &&
(prematureEndPredicate === null || !prematureEndPredicate())) {
const current = this._cursor.clone();
if (this._isTagStart()) {
// We are starting what looks like an HTML element in the middle of this interpolation.
// Reset the cursor to before the `<` character and end the interpolation token.
// (This is actually wrong but here for backward compatibility).
this._cursor = current;
parts.push(this._getProcessedChars(expressionStart, current));
this._endToken(parts);
return;
}
if (inQuote === null) {
if (this._attemptStr(this._interpolationConfig.end)) {
// We are not in a string, and we hit the end interpolation marker
parts.push(this._getProcessedChars(expressionStart, current));
parts.push(this._interpolationConfig.end);
this._endToken(parts);
return;
}
else if (this._attemptStr('//')) {
// Once we are in a comment we ignore any quotes
inComment = true;
}
}
const char = this._cursor.peek();
this._cursor.advance();
if (char === chars.$BACKSLASH) {
// Skip the next character because it was escaped.
this._cursor.advance();
}
else if (char === inQuote) {
// Exiting the current quoted string
inQuote = null;
}
else if (!inComment && inQuote === null && chars.isQuote(char)) {
// Entering a new quoted string
inQuote = char;
}
}
// We hit EOF without finding a closing interpolation marker
parts.push(this._getProcessedChars(expressionStart, this._cursor));
this._endToken(parts);
}
_getProcessedChars(start, end) {
return this._processCarriageReturns(end.getChars(start));
}
_isTextEnd() {
if (this._cursor.peek() === chars.$LT || this._cursor.peek() === chars.$EOF) {
if (this._isTagStart() || this._cursor.peek() === chars.$EOF) {
return true;

@@ -661,2 +751,20 @@ }

}
/**
* Returns true if the current cursor is pointing to the start of a tag
* (opening/closing/comments/cdata/etc).
*/
_isTagStart() {
if (this._cursor.peek() === chars.$LT) {
// We assume that `<` followed by whitespace is not the start of an HTML element.
const tmp = this._cursor.clone();
tmp.advance();
// If the next character is alphabetic, ! nor / then it is a tag start
const code = tmp.peek();
if ((chars.$a <= code && code <= chars.$z) || (chars.$A <= code && code <= chars.$Z) ||
code === chars.$SLASH || code === chars.$BANG) {
return true;
}
}
return false;
}
_readUntil(char) {

@@ -670,3 +778,3 @@ const start = this._cursor.clone();

this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
TokenType.EXPANSION_CASE_EXP_START;
22 /* TokenType.EXPANSION_CASE_EXP_START */;
}

@@ -676,3 +784,3 @@ _isInExpansionForm() {

this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
TokenType.EXPANSION_FORM_START;
20 /* TokenType.EXPANSION_FORM_START */;
}

@@ -692,3 +800,3 @@ isExpansionFormStart() {

_handleFullNameStackForTagOpen(prefix, tagName) {
const fullName = tags_1.mergeNsAndName(prefix, tagName);
const fullName = mergeNsAndName(prefix, tagName);
if (this._fullNameStack.length === 0 || this._fullNameStack[this._fullNameStack.length - 1] === fullName) {

@@ -699,3 +807,3 @@ this._fullNameStack.push(fullName);

_handleFullNameStackForTagClose(prefix, tagName) {
const fullName = tags_1.mergeNsAndName(prefix, tagName);
const fullName = mergeNsAndName(prefix, tagName);
if (this._fullNameStack.length !== 0 && this._fullNameStack[this._fullNameStack.length - 1] === fullName) {

@@ -710,4 +818,5 @@ this._fullNameStack.pop();

function isNameEnd(code) {
return chars.isWhitespace(code) || code === chars.$GT || code === chars.$SLASH ||
code === chars.$SQ || code === chars.$DQ || code === chars.$EQ;
return chars.isWhitespace(code) || code === chars.$GT || code === chars.$LT ||
code === chars.$SLASH || code === chars.$SQ || code === chars.$DQ || code === chars.$EQ ||
code === chars.$EOF;
}

@@ -719,12 +828,12 @@ function isPrefixEnd(code) {

function isDigitEntityEnd(code) {
return code == chars.$SEMICOLON || code == chars.$EOF || !chars.isAsciiHexDigit(code);
return code === chars.$SEMICOLON || code === chars.$EOF || !chars.isAsciiHexDigit(code);
}
function isNamedEntityEnd(code) {
return code == chars.$SEMICOLON || code == chars.$EOF || !chars.isAsciiLetter(code);
return code === chars.$SEMICOLON || code === chars.$EOF || !chars.isAsciiLetter(code);
}
function isExpansionCaseStart(peek) {
return peek === chars.$EQ || chars.isAsciiLetter(peek) || chars.isDigit(peek);
return peek !== chars.$RBRACE;
}
function compareCharCodeCaseInsensitive(code1, code2) {
return toUpperCaseCharCode(code1) == toUpperCaseCharCode(code2);
return toUpperCaseCharCode(code1) === toUpperCaseCharCode(code2);
}

@@ -739,3 +848,5 @@ function toUpperCaseCharCode(code) {

const token = srcTokens[i];
if (lastDstToken && lastDstToken.type == TokenType.TEXT && token.type == TokenType.TEXT) {
if ((lastDstToken && lastDstToken.type === 5 /* TokenType.TEXT */ && token.type === 5 /* TokenType.TEXT */) ||
(lastDstToken && lastDstToken.type === 16 /* TokenType.ATTR_VALUE_TEXT */ &&
token.type === 16 /* TokenType.ATTR_VALUE_TEXT */)) {
lastDstToken.parts[0] += token.parts[0];

@@ -757,3 +868,13 @@ lastDstToken.sourceSpan.end = token.sourceSpan.end;

this.end = fileOrCursor.end;
this.state = Object.assign({}, fileOrCursor.state);
const state = fileOrCursor.state;
// Note: avoid using `{...fileOrCursor.state}` here as that has a severe performance penalty.
// In ES5 bundles the object spread operator is translated into the `__assign` helper, which
// is not optimized by VMs as efficiently as a raw object literal. Since this constructor is
// called in tight loops, this difference matters.
this.state = {
peek: state.peek,
offset: state.offset,
line: state.line,
column: state.column,
};
}

@@ -775,17 +896,35 @@ else {

}
clone() { return new PlainCharacterCursor(this); }
peek() { return this.state.peek; }
charsLeft() { return this.end - this.state.offset; }
diff(other) { return this.state.offset - other.state.offset; }
advance() { this.advanceState(this.state); }
init() { this.updatePeek(this.state); }
clone() {
return new PlainCharacterCursor(this);
}
peek() {
return this.state.peek;
}
charsLeft() {
return this.end - this.state.offset;
}
diff(other) {
return this.state.offset - other.state.offset;
}
advance() {
this.advanceState(this.state);
}
init() {
this.updatePeek(this.state);
}
getSpan(start, leadingTriviaCodePoints) {
start = start || this;
let fullStart = start;
if (leadingTriviaCodePoints) {
start = start.clone();
while (this.diff(start) > 0 && leadingTriviaCodePoints.indexOf(start.peek()) !== -1) {
if (fullStart === start) {
start = start.clone();
}
start.advance();
}
}
return new parse_util_1.ParseSourceSpan(new parse_util_1.ParseLocation(start.file, start.state.offset, start.state.line, start.state.column), new parse_util_1.ParseLocation(this.file, this.state.offset, this.state.line, this.state.column));
const startLocation = this.locationFromCursor(start);
const endLocation = this.locationFromCursor(this);
const fullStartLocation = fullStart !== start ? this.locationFromCursor(fullStart) : startLocation;
return new ParseSourceSpan(startLocation, endLocation, fullStartLocation);
}

@@ -795,3 +934,5 @@ getChars(start) {

}
charAt(pos) { return this.input.charCodeAt(pos); }
charAt(pos) {
return this.input.charCodeAt(pos);
}
advanceState(state) {

@@ -816,2 +957,5 @@ if (state.offset >= this.end) {

}
locationFromCursor(cursor) {
return new ParseLocation(cursor.file, cursor.state.offset, cursor.state.line, cursor.state.column);
}
}

@@ -822,3 +966,3 @@ class EscapedCharacterCursor extends PlainCharacterCursor {

super(fileOrCursor);
this.internalState = Object.assign({}, fileOrCursor.internalState);
this.internalState = { ...fileOrCursor.internalState };
}

@@ -839,3 +983,5 @@ else {

}
clone() { return new EscapedCharacterCursor(this); }
clone() {
return new EscapedCharacterCursor(this);
}
getChars(start) {

@@ -860,3 +1006,3 @@ const cursor = start.clone();

// of the external state.
this.internalState = Object.assign({}, this.state);
this.internalState = { ...this.state };
// Move past the backslash

@@ -943,3 +1089,3 @@ this.advanceState(this.internalState);

decodeHexDigits(start, length) {
const hex = this.input.substr(start.internalState.offset, length);
const hex = this.input.slice(start.internalState.offset, start.internalState.offset + length);
const charCode = parseInt(hex, 16);

@@ -955,3 +1101,3 @@ if (!isNaN(charCode)) {

}
class CursorError {
export class CursorError {
constructor(msg, cursor) {

@@ -962,2 +1108,1 @@ this.msg = msg;

}
exports.CursorError = CursorError;

12

lib/compiler/src/ml_parser/parser.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -8,6 +8,6 @@ * Use of this source code is governed by an MIT-style license that can be

*/
import { ParseError, ParseSourceSpan } from '../parse_util';
import * as html from './ast';
import * as lex from './lexer';
import { TagContentType, TagDefinition } from './tags';
import { ParseError, ParseSourceSpan } from "../parse_util.js";
import * as html from "./ast.js";
import { TokenizeOptions } from "./lexer.js";
import { TagContentType, TagDefinition } from "./tags.js";
export declare class TreeError extends ParseError {

@@ -26,3 +26,3 @@ elementName: string | null;

constructor(getTagDefinition: (tagName: string) => TagDefinition);
parse(source: string, url: string, options?: lex.TokenizeOptions, isTagNameCaseSensitive?: boolean, getTagContentType?: (tagName: string, prefix: string, hasParent: boolean, attrs: Array<{
parse(source: string, url: string, options?: TokenizeOptions, isTagNameCaseSensitive?: boolean, getTagContentType?: (tagName: string, prefix: string, hasParent: boolean, attrs: Array<{
prefix: string;

@@ -29,0 +29,0 @@ name: string;

353

lib/compiler/src/ml_parser/parser.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,8 +8,8 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
const parse_util_1 = require("../parse_util");
const html = require("./ast");
const lex = require("./lexer");
const tags_1 = require("./tags");
class TreeError extends parse_util_1.ParseError {
import { ParseError, ParseSourceSpan } from "../parse_util.js";
import * as html from "./ast.js";
import { NAMED_ENTITIES } from "./entities.js";
import { tokenize } from "./lexer.js";
import { getNsPrefix, mergeNsAndName, splitNsName } from "./tags.js";
export class TreeError extends ParseError {
constructor(elementName, span, msg) {

@@ -24,4 +23,3 @@ super(span, msg);

}
exports.TreeError = TreeError;
class ParseTreeResult {
export class ParseTreeResult {
constructor(rootNodes, errors) {

@@ -32,4 +30,3 @@ this.rootNodes = rootNodes;

}
exports.ParseTreeResult = ParseTreeResult;
class Parser {
export class Parser {
constructor(getTagDefinition) {

@@ -41,3 +38,3 @@ this.getTagDefinition = getTagDefinition;

const getTagDefinition = isTagNameCaseSensitive ? this.getTagDefinition : lowercasify(this.getTagDefinition);
const getDefaultTagContentType = (tagName) => getTagDefinition(tagName).contentType;
const getDefaultTagContentType = (tagName) => getTagDefinition(tagName).getContentType();
const getTagContentTypeWithProcessedTagName = isTagNameCaseSensitive ? getTagContentType : lowercasify(getTagContentType);

@@ -50,10 +47,10 @@ const _getTagContentType = getTagContentType

: getDefaultTagContentType;
const tokensAndErrors = lex.tokenize(source, url, _getTagContentType, options);
const tokenizeResult = tokenize(source, url, _getTagContentType, options);
const canSelfClose = (options && options.canSelfClose) || false;
const allowHtmComponentClosingTags = (options && options.allowHtmComponentClosingTags) || false;
const treeAndErrors = new _TreeBuilder(tokensAndErrors.tokens, getTagDefinition, canSelfClose, allowHtmComponentClosingTags, isTagNameCaseSensitive).build();
return new ParseTreeResult(treeAndErrors.rootNodes, tokensAndErrors.errors.concat(treeAndErrors.errors));
const parser = new _TreeBuilder(tokenizeResult.tokens, getTagDefinition, canSelfClose, allowHtmComponentClosingTags, isTagNameCaseSensitive);
parser.build();
return new ParseTreeResult(parser.rootNodes, tokenizeResult.errors.concat(parser.errors));
}
}
exports.Parser = Parser;
class _TreeBuilder {

@@ -67,33 +64,34 @@ constructor(tokens, getTagDefinition, canSelfClose, allowHtmComponentClosingTags, isTagNameCaseSensitive) {

this._index = -1;
this._rootNodes = [];
this._errors = [];
this._elementStack = [];
this.rootNodes = [];
this.errors = [];
this._advance();
}
build() {
while (this._peek.type !== lex.TokenType.EOF) {
if (this._peek.type === lex.TokenType.TAG_OPEN_START) {
while (this._peek.type !== 25 /* TokenType.EOF */) {
if (this._peek.type === 0 /* TokenType.TAG_OPEN_START */ ||
this._peek.type === 4 /* TokenType.INCOMPLETE_TAG_OPEN */) {
this._consumeStartTag(this._advance());
}
else if (this._peek.type === lex.TokenType.TAG_CLOSE) {
else if (this._peek.type === 3 /* TokenType.TAG_CLOSE */) {
this._closeVoidElement();
this._consumeEndTag(this._advance());
}
else if (this._peek.type === lex.TokenType.CDATA_START) {
else if (this._peek.type === 12 /* TokenType.CDATA_START */) {
this._closeVoidElement();
this._consumeCdata(this._advance());
}
else if (this._peek.type === lex.TokenType.COMMENT_START) {
else if (this._peek.type === 10 /* TokenType.COMMENT_START */) {
this._closeVoidElement();
this._consumeComment(this._advance());
}
else if (this._peek.type === lex.TokenType.TEXT || this._peek.type === lex.TokenType.RAW_TEXT ||
this._peek.type === lex.TokenType.ESCAPABLE_RAW_TEXT) {
else if (this._peek.type === 5 /* TokenType.TEXT */ || this._peek.type === 7 /* TokenType.RAW_TEXT */ ||
this._peek.type === 6 /* TokenType.ESCAPABLE_RAW_TEXT */) {
this._closeVoidElement();
this._consumeText(this._advance());
}
else if (this._peek.type === lex.TokenType.EXPANSION_FORM_START) {
else if (this._peek.type === 20 /* TokenType.EXPANSION_FORM_START */) {
this._consumeExpansion(this._advance());
}
else if (this._peek.type === lex.TokenType.DOC_TYPE_START) {
else if (this._peek.type === 18 /* TokenType.DOC_TYPE_START */) {
this._consumeDocType(this._advance());

@@ -106,3 +104,2 @@ }

}
return new ParseTreeResult(this._rootNodes, this._errors);
}

@@ -127,17 +124,17 @@ _advance() {

const value = this._getText(text);
const endToken = this._advanceIf(lex.TokenType.CDATA_END);
this._addToParent(new html.CDATA(value, new parse_util_1.ParseSourceSpan(startToken.sourceSpan.start, (endToken || text).sourceSpan.end)));
const endToken = this._advanceIf(13 /* TokenType.CDATA_END */);
this._addToParent(new html.CDATA(value, new ParseSourceSpan(startToken.sourceSpan.start, (endToken || text).sourceSpan.end), [text]));
}
_consumeComment(startToken) {
const text = this._advanceIf(lex.TokenType.RAW_TEXT);
const endToken = this._advanceIf(lex.TokenType.COMMENT_END);
const text = this._advanceIf(7 /* TokenType.RAW_TEXT */);
const endToken = this._advanceIf(11 /* TokenType.COMMENT_END */);
const value = text != null ? text.parts[0].trim() : null;
const sourceSpan = new parse_util_1.ParseSourceSpan(startToken.sourceSpan.start, (endToken || text || startToken).sourceSpan.end);
const sourceSpan = new ParseSourceSpan(startToken.sourceSpan.start, (endToken || text || startToken).sourceSpan.end);
this._addToParent(new html.Comment(value, sourceSpan));
}
_consumeDocType(startToken) {
const text = this._advanceIf(lex.TokenType.RAW_TEXT);
const endToken = this._advanceIf(lex.TokenType.DOC_TYPE_END);
const text = this._advanceIf(7 /* TokenType.RAW_TEXT */);
const endToken = this._advanceIf(19 /* TokenType.DOC_TYPE_END */);
const value = text != null ? text.parts[0].trim() : null;
const sourceSpan = new parse_util_1.ParseSourceSpan(startToken.sourceSpan.start, (endToken || text || startToken).sourceSpan.end);
const sourceSpan = new ParseSourceSpan(startToken.sourceSpan.start, (endToken || text || startToken).sourceSpan.end);
this._addToParent(new html.DocType(value, sourceSpan));

@@ -150,3 +147,3 @@ }

// read =
while (this._peek.type === lex.TokenType.EXPANSION_CASE_VALUE) {
while (this._peek.type === 21 /* TokenType.EXPANSION_CASE_VALUE */) {
const expCase = this._parseExpansionCase();

@@ -158,9 +155,7 @@ if (!expCase)

// read the final }
if (this._peek.type !== lex.TokenType.EXPANSION_FORM_END) {
this._errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '}'.`));
if (this._peek.type !== 24 /* TokenType.EXPANSION_FORM_END */) {
this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '}'.`));
return;
}
const sourceSpan = new parse_util_1.ParseSourceSpan(token.sourceSpan.start, this._peek.sourceSpan.end);
// `Expansion` is excluded from `Node` in angular-html-parser as it doesn't generate such nodes.
// @ts-ignore -- Using ts-ignore here to minimize efforts on merging upstream changes.
const sourceSpan = new ParseSourceSpan(token.sourceSpan.start, this._peek.sourceSpan.end, token.sourceSpan.fullStart);
this._addToParent(new html.Expansion(switchValue.parts[0], type.parts[0], cases, sourceSpan, switchValue.sourceSpan));

@@ -172,4 +167,4 @@ this._advance();

// read {
if (this._peek.type !== lex.TokenType.EXPANSION_CASE_EXP_START) {
this._errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '{'.`));
if (this._peek.type !== 22 /* TokenType.EXPANSION_CASE_EXP_START */) {
this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '{'.`));
return null;

@@ -183,43 +178,44 @@ }

const end = this._advance();
exp.push(new lex.Token(lex.TokenType.EOF, [], end.sourceSpan));
exp.push({ type: 25 /* TokenType.EOF */, parts: [], sourceSpan: end.sourceSpan });
// parse everything in between { and }
const parsedExp = new _TreeBuilder(exp, this.getTagDefinition, this.canSelfClose, this.allowHtmComponentClosingTags, this.isTagNameCaseSensitive).build();
if (parsedExp.errors.length > 0) {
this._errors = this._errors.concat(parsedExp.errors);
const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition, this.canSelfClose, this.allowHtmComponentClosingTags, this.isTagNameCaseSensitive);
expansionCaseParser.build();
if (expansionCaseParser.errors.length > 0) {
this.errors = this.errors.concat(expansionCaseParser.errors);
return null;
}
const sourceSpan = new parse_util_1.ParseSourceSpan(value.sourceSpan.start, end.sourceSpan.end);
const expSourceSpan = new parse_util_1.ParseSourceSpan(start.sourceSpan.start, end.sourceSpan.end);
return new html.ExpansionCase(value.parts[0], parsedExp.rootNodes, sourceSpan, value.sourceSpan, expSourceSpan);
const sourceSpan = new ParseSourceSpan(value.sourceSpan.start, end.sourceSpan.end, value.sourceSpan.fullStart);
const expSourceSpan = new ParseSourceSpan(start.sourceSpan.start, end.sourceSpan.end, start.sourceSpan.fullStart);
return new html.ExpansionCase(value.parts[0], expansionCaseParser.rootNodes, sourceSpan, value.sourceSpan, expSourceSpan);
}
_collectExpansionExpTokens(start) {
const exp = [];
const expansionFormStack = [lex.TokenType.EXPANSION_CASE_EXP_START];
const expansionFormStack = [22 /* TokenType.EXPANSION_CASE_EXP_START */];
while (true) {
if (this._peek.type === lex.TokenType.EXPANSION_FORM_START ||
this._peek.type === lex.TokenType.EXPANSION_CASE_EXP_START) {
if (this._peek.type === 20 /* TokenType.EXPANSION_FORM_START */ ||
this._peek.type === 22 /* TokenType.EXPANSION_CASE_EXP_START */) {
expansionFormStack.push(this._peek.type);
}
if (this._peek.type === lex.TokenType.EXPANSION_CASE_EXP_END) {
if (lastOnStack(expansionFormStack, lex.TokenType.EXPANSION_CASE_EXP_START)) {
if (this._peek.type === 23 /* TokenType.EXPANSION_CASE_EXP_END */) {
if (lastOnStack(expansionFormStack, 22 /* TokenType.EXPANSION_CASE_EXP_START */)) {
expansionFormStack.pop();
if (expansionFormStack.length == 0)
if (expansionFormStack.length === 0)
return exp;
}
else {
this._errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
return null;
}
}
if (this._peek.type === lex.TokenType.EXPANSION_FORM_END) {
if (lastOnStack(expansionFormStack, lex.TokenType.EXPANSION_FORM_START)) {
if (this._peek.type === 24 /* TokenType.EXPANSION_FORM_END */) {
if (lastOnStack(expansionFormStack, 20 /* TokenType.EXPANSION_FORM_START */)) {
expansionFormStack.pop();
}
else {
this._errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
return null;
}
}
if (this._peek.type === lex.TokenType.EOF) {
this._errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
if (this._peek.type === 25 /* TokenType.EOF */) {
this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
return null;

@@ -242,5 +238,34 @@ }

_consumeText(token) {
const text = this._getText(token);
const tokens = [token];
const startSpan = token.sourceSpan;
let text = token.parts[0];
if (text.length > 0 && text[0] === '\n') {
const parent = this._getParentElement();
if (parent != null && parent.children.length === 0 &&
this.getTagDefinition(parent.name).ignoreFirstLf) {
text = text.substring(1);
tokens[0] = { type: token.type, sourceSpan: token.sourceSpan, parts: [text] };
}
}
while (this._peek.type === 8 /* TokenType.INTERPOLATION */ || this._peek.type === 5 /* TokenType.TEXT */ ||
this._peek.type === 9 /* TokenType.ENCODED_ENTITY */) {
token = this._advance();
tokens.push(token);
if (token.type === 8 /* TokenType.INTERPOLATION */) {
// For backward compatibility we decode HTML entities that appear in interpolation
// expressions. This is arguably a bug, but it could be a considerable breaking change to
// fix it. It should be addressed in a larger project to refactor the entire parser/lexer
// chain after View Engine has been removed.
text += token.parts.join('').replace(/&([^;]+);/g, decodeEntity);
}
else if (token.type === 9 /* TokenType.ENCODED_ENTITY */) {
text += token.parts[0];
}
else {
text += token.parts.join('');
}
}
if (text.length > 0) {
this._addToParent(new html.Text(text, token.sourceSpan));
const endSpan = token.sourceSpan;
this._addToParent(new html.Text(text, new ParseSourceSpan(startSpan.start, endSpan.end, startSpan.fullStart, startSpan.details), tokens));
}

@@ -255,6 +280,5 @@ }

_consumeStartTag(startTagToken) {
const prefix = startTagToken.parts[0];
const name = startTagToken.parts[1];
const [prefix, name] = startTagToken.parts;
const attrs = [];
while (this._peek.type === lex.TokenType.ATTR_NAME) {
while (this._peek.type === 14 /* TokenType.ATTR_NAME */) {
attrs.push(this._consumeAttr(this._advance()));

@@ -266,23 +290,32 @@ }

// so that we don't get a token for the end tag...
if (this._peek.type === lex.TokenType.TAG_OPEN_END_VOID) {
if (this._peek.type === 2 /* TokenType.TAG_OPEN_END_VOID */) {
this._advance();
selfClosing = true;
const tagDef = this.getTagDefinition(fullName);
if (!(this.canSelfClose || tagDef.canSelfClose || tags_1.getNsPrefix(fullName) !== null || tagDef.isVoid)) {
this._errors.push(TreeError.create(fullName, startTagToken.sourceSpan, `Only void and foreign elements can be self closed "${startTagToken.parts[1]}"`));
if (!(this.canSelfClose || tagDef.canSelfClose || getNsPrefix(fullName) !== null || tagDef.isVoid)) {
this.errors.push(TreeError.create(fullName, startTagToken.sourceSpan, `Only void and foreign elements can be self closed "${startTagToken.parts[1]}"`));
}
}
else if (this._peek.type === lex.TokenType.TAG_OPEN_END) {
else if (this._peek.type === 1 /* TokenType.TAG_OPEN_END */) {
this._advance();
selfClosing = false;
}
const end = this._peek.sourceSpan.start;
const span = new parse_util_1.ParseSourceSpan(startTagToken.sourceSpan.start, end);
const nameSpan = new parse_util_1.ParseSourceSpan(startTagToken.sourceSpan.start.moveBy(1), startTagToken.sourceSpan.end);
const el = new html.Element(fullName, attrs, [], span, span, undefined, nameSpan);
const end = this._peek.sourceSpan.fullStart;
const span = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
// Create a separate `startSpan` because `span` will be modified when there is an `end` span.
const startSpan = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
const nameSpan = new ParseSourceSpan(startTagToken.sourceSpan.start.moveBy(1), startTagToken.sourceSpan.end);
const el = new html.Element(fullName, attrs, [], span, startSpan, undefined, nameSpan);
this._pushElement(el);
if (selfClosing) {
this._popElement(fullName);
el.endSourceSpan = span;
// Elements that are self-closed have their `endSourceSpan` set to the full span, as the
// element start tag also represents the end tag.
this._popElement(fullName, span);
}
else if (startTagToken.type === 4 /* TokenType.INCOMPLETE_TAG_OPEN */) {
// We already know the opening tag is not complete, so it is unlikely it has a corresponding
// close tag. Let's optimistically parse it as a full element and emit an error.
this._popElement(fullName, null);
this.errors.push(TreeError.create(fullName, span, `Opening tag "${fullName}" not terminated.`));
}
}

@@ -298,28 +331,41 @@ _pushElement(el) {

_consumeEndTag(endTagToken) {
// @ts-expect-error -- in angular-html-parser endTagToken.parts.length can be 0 (HTM component end-tags)
const fullName = this.allowHtmComponentClosingTags && endTagToken.parts.length === 0
? null
: this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());
if (this._getParentElement()) {
this._getParentElement().endSourceSpan = endTagToken.sourceSpan;
}
if (fullName && this.getTagDefinition(fullName).isVoid) {
this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, `Void elements do not have end tags "${endTagToken.parts[1]}"`));
this.errors.push(TreeError.create(fullName, endTagToken.sourceSpan, `Void elements do not have end tags "${endTagToken.parts[1]}"`));
}
else if (!this._popElement(fullName)) {
else if (!this._popElement(fullName, endTagToken.sourceSpan)) {
const errMsg = `Unexpected closing tag "${fullName}". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags`;
this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, errMsg));
this.errors.push(TreeError.create(fullName, endTagToken.sourceSpan, errMsg));
}
}
_popElement(fullName) {
/**
* Closes the nearest element with the tag name `fullName` in the parse tree.
* `endSourceSpan` is the span of the closing tag, or null if the element does
* not have a closing tag (for example, this happens when an incomplete
* opening tag is recovered).
*/
_popElement(fullName, endSourceSpan) {
let unexpectedCloseTagDetected = false;
for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
const el = this._elementStack[stackIndex];
if (!fullName ||
( /* isForeignElement */tags_1.getNsPrefix(el.name)
( /* isForeignElement */getNsPrefix(el.name)
? el.name == fullName
: el.name.toLowerCase() == fullName.toLowerCase())) {
// Record the parse span with the element that is being closed. Any elements that are
// removed from the element stack at this point are closed implicitly, so they won't get
// an end source span (as there is no explicit closing element).
el.endSourceSpan = endSourceSpan;
el.sourceSpan.end = endSourceSpan !== null ? endSourceSpan.end : el.sourceSpan.end;
this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
return true;
return !unexpectedCloseTagDetected;
}
if (!this.getTagDefinition(el.name).closedByParent) {
return false;
// Note that we encountered an unexpected close tag but continue processing the element
// stack so we can assign an `endSourceSpan` if there is a corresponding start tag for this
// end tag in the stack.
unexpectedCloseTagDetected = true;
}

@@ -330,23 +376,51 @@ }

_consumeAttr(attrName) {
const fullName = tags_1.mergeNsAndName(attrName.parts[0], attrName.parts[1]);
let end = attrName.sourceSpan.end;
const fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]);
let attrEnd = attrName.sourceSpan.end;
let startQuoteToken;
// Consume any quote
if (this._peek.type === 15 /* TokenType.ATTR_QUOTE */) {
startQuoteToken = this._advance();
}
// Consume the attribute value
let value = '';
let valueSpan = undefined;
let quoteStart = undefined;
if (this._peek.type === lex.TokenType.ATTR_QUOTE) {
const quoteToken = this._advance();
quoteStart = quoteToken.sourceSpan.start;
const valueTokens = [];
let valueStartSpan = undefined;
let valueEnd = undefined;
// NOTE: We need to use a new variable `nextTokenType` here to hide the actual type of
// `_peek.type` from TS. Otherwise TS will narrow the type of `_peek.type` preventing it from
// being able to consider `ATTR_VALUE_INTERPOLATION` as an option. This is because TS is not
// able to see that `_advance()` will actually mutate `_peek`.
const nextTokenType = this._peek.type;
if (nextTokenType === 16 /* TokenType.ATTR_VALUE_TEXT */) {
valueStartSpan = this._peek.sourceSpan;
valueEnd = this._peek.sourceSpan.end;
while (this._peek.type === 16 /* TokenType.ATTR_VALUE_TEXT */ ||
this._peek.type === 17 /* TokenType.ATTR_VALUE_INTERPOLATION */ ||
this._peek.type === 9 /* TokenType.ENCODED_ENTITY */) {
const valueToken = this._advance();
valueTokens.push(valueToken);
if (valueToken.type === 17 /* TokenType.ATTR_VALUE_INTERPOLATION */) {
// For backward compatibility we decode HTML entities that appear in interpolation
// expressions. This is arguably a bug, but it could be a considerable breaking change to
// fix it. It should be addressed in a larger project to refactor the entire parser/lexer
// chain after View Engine has been removed.
value += valueToken.parts.join('').replace(/&([^;]+);/g, decodeEntity);
}
else if (valueToken.type === 9 /* TokenType.ENCODED_ENTITY */) {
value += valueToken.parts[0];
}
else {
value += valueToken.parts.join('');
}
valueEnd = attrEnd = valueToken.sourceSpan.end;
}
}
if (this._peek.type === lex.TokenType.ATTR_VALUE) {
const valueToken = this._advance();
value = valueToken.parts[0];
end = valueToken.sourceSpan.end;
valueSpan = valueToken.sourceSpan;
}
if (this._peek.type === lex.TokenType.ATTR_QUOTE) {
// Consume any quote
if (this._peek.type === 15 /* TokenType.ATTR_QUOTE */) {
const quoteToken = this._advance();
end = quoteToken.sourceSpan.end;
valueSpan = new parse_util_1.ParseSourceSpan(quoteStart, end);
valueEnd = attrEnd = quoteToken.sourceSpan.end;
}
return new html.Attribute(fullName, value, new parse_util_1.ParseSourceSpan(attrName.sourceSpan.start, end), valueSpan, attrName.sourceSpan);
const valueSpan = valueStartSpan && valueEnd &&
new ParseSourceSpan(startQuoteToken?.sourceSpan.start ?? valueStartSpan.start, valueEnd, startQuoteToken?.sourceSpan.fullStart ?? valueStartSpan.fullStart);
return new html.Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, attrEnd, attrName.sourceSpan.fullStart), attrName.sourceSpan, valueSpan, valueTokens.length > 0 ? valueTokens : undefined, undefined);
}

@@ -356,17 +430,2 @@ _getParentElement() {

}
/**
* Returns the parent in the DOM and the container.
*
* `<ng-container>` elements are skipped as they are not rendered as DOM element.
*/
_getParentElementSkippingContainers() {
let container = null;
for (let i = this._elementStack.length - 1; i >= 0; i--) {
if (!tags_1.isNgContainer(this._elementStack[i].name)) {
return { parent: this._elementStack[i], container };
}
container = this._elementStack[i];
}
return { parent: null, container };
}
_addToParent(node) {

@@ -378,30 +437,5 @@ const parent = this._getParentElement();

else {
this._rootNodes.push(node);
this.rootNodes.push(node);
}
}
/**
* Insert a node between the parent and the container.
* When no container is given, the node is appended as a child of the parent.
* Also updates the element stack accordingly.
*
* @internal
*/
_insertBeforeContainer(parent, container, node) {
if (!container) {
this._addToParent(node);
this._elementStack.push(node);
}
else {
if (parent) {
// replace the container with the new node in the children
const index = parent.children.indexOf(container);
parent.children[index] = node;
}
else {
this._rootNodes.push(node);
}
node.children.push(container);
this._elementStack.splice(this._elementStack.indexOf(container), 0, node);
}
}
_getElementFullName(prefix, localName, parentElement) {

@@ -411,6 +445,10 @@ if (prefix === '') {

if (prefix === '' && parentElement != null) {
prefix = tags_1.getNsPrefix(parentElement.name);
const parentTagName = splitNsName(parentElement.name)[1];
const parentTagDefinition = this.getTagDefinition(parentTagName);
if (!parentTagDefinition.preventNamespaceInheritance) {
prefix = getNsPrefix(parentElement.name);
}
}
}
return tags_1.mergeNsAndName(prefix, localName);
return mergeNsAndName(prefix, localName);
}

@@ -421,1 +459,18 @@ }

}
/**
* Decode the `entity` string, which we believe is the contents of an HTML entity.
*
* If the string is not actually a valid/known entity then just return the original `match` string.
*/
function decodeEntity(match, entity) {
if (NAMED_ENTITIES[entity] !== undefined) {
return NAMED_ENTITIES[entity] || match;
}
if (/^#x[a-f0-9]+$/i.test(entity)) {
return String.fromCodePoint(parseInt(entity.slice(2), 16));
}
if (/^#\d+$/.test(entity)) {
return String.fromCodePoint(parseInt(entity.slice(1), 10));
}
return match;
}

9

lib/compiler/src/ml_parser/tags.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -16,7 +16,8 @@ * Use of this source code is governed by an MIT-style license that can be

implicitNamespacePrefix: string | null;
contentType: TagContentType;
isVoid: boolean;
ignoreFirstLf: boolean;
canSelfClose: boolean;
preventNamespaceInheritance: boolean;
isClosedByChild(name: string): boolean;
getContentType(prefix?: string): TagContentType;
}

@@ -30,5 +31,1 @@ export declare function splitNsName(elementName: string): [string | null, string];

export declare function mergeNsAndName(prefix: string, localName: string): string;
export declare const NAMED_ENTITIES: {
[k: string]: string;
};
export declare const NGSP_UNICODE = "\uE500";

2178

lib/compiler/src/ml_parser/tags.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,4 +8,3 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
var TagContentType;
export var TagContentType;
(function (TagContentType) {

@@ -16,4 +14,4 @@ TagContentType[TagContentType["RAW_TEXT"] = 0] = "RAW_TEXT";

TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
})(TagContentType = exports.TagContentType || (exports.TagContentType = {}));
function splitNsName(elementName) {
})(TagContentType || (TagContentType = {}));
export function splitNsName(elementName) {
if (elementName[0] != ':') {

@@ -23,3 +21,3 @@ return [null, elementName];

const colonIndex = elementName.indexOf(':', 1);
if (colonIndex == -1) {
if (colonIndex === -1) {
throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);

@@ -29,2175 +27,19 @@ }

}
exports.splitNsName = splitNsName;
// `<ng-container>` tags work the same regardless the namespace
function isNgContainer(tagName) {
export function isNgContainer(tagName) {
return splitNsName(tagName)[1] === 'ng-container';
}
exports.isNgContainer = isNgContainer;
// `<ng-content>` tags work the same regardless the namespace
function isNgContent(tagName) {
export function isNgContent(tagName) {
return splitNsName(tagName)[1] === 'ng-content';
}
exports.isNgContent = isNgContent;
// `<ng-template>` tags work the same regardless the namespace
function isNgTemplate(tagName) {
export function isNgTemplate(tagName) {
return splitNsName(tagName)[1] === 'ng-template';
}
exports.isNgTemplate = isNgTemplate;
function getNsPrefix(fullName) {
export function getNsPrefix(fullName) {
return fullName === null ? null : splitNsName(fullName)[0];
}
exports.getNsPrefix = getNsPrefix;
function mergeNsAndName(prefix, localName) {
export function mergeNsAndName(prefix, localName) {
return prefix ? `:${prefix}:${localName}` : localName;
}
exports.mergeNsAndName = mergeNsAndName;
// see http://www.w3.org/TR/html51/syntax.html#named-character-references
// see https://html.spec.whatwg.org/multipage/entities.json
/* script to generate full named entities:
function codepointToEscapedString(c) {
return c < 0x10000
? `\\u${c.toString(16).toUpperCase().padStart(4, '0')}`
: codepointToEscapedString(Math.floor((c - 0x10000) / 0x400) + 0xd800) +
codepointToEscapedString((c - 0x10000) % 0x400 + 0xdc00);
}
function generateNamedEntities(entitiesJson) {
return Object.fromEntries(
Object.entries(entitiesJson)
.filter(([k, v]) => k.startsWith('&') && k.endsWith(';'))
.map(([k, v]) => [k.slice(1, -1), v.codepoints.map(codepointToEscapedString).join('')])
.sort(([k1, v1], [k2, v2]) => k1.toUpperCase().localeCompare(k2.toUpperCase()))
);
}
console.log(JSON.stringify(generateNamedEntities(entitiesJson), null, 2).replace(/\\\\/g, '\\'));
*/
exports.NAMED_ENTITIES = {
'Aacute': '\u00C1',
'aacute': '\u00E1',
'Abreve': '\u0102',
'abreve': '\u0103',
'ac': '\u223E',
'acd': '\u223F',
'acE': '\u223E\u0333',
'Acirc': '\u00C2',
'acirc': '\u00E2',
'acute': '\u00B4',
'Acy': '\u0410',
'acy': '\u0430',
'AElig': '\u00C6',
'aelig': '\u00E6',
'af': '\u2061',
'Afr': '\uD835\uDD04',
'afr': '\uD835\uDD1E',
'Agrave': '\u00C0',
'agrave': '\u00E0',
'alefsym': '\u2135',
'aleph': '\u2135',
'Alpha': '\u0391',
'alpha': '\u03B1',
'Amacr': '\u0100',
'amacr': '\u0101',
'amalg': '\u2A3F',
'AMP': '\u0026',
'amp': '\u0026',
'And': '\u2A53',
'and': '\u2227',
'andand': '\u2A55',
'andd': '\u2A5C',
'andslope': '\u2A58',
'andv': '\u2A5A',
'ang': '\u2220',
'ange': '\u29A4',
'angle': '\u2220',
'angmsd': '\u2221',
'angmsdaa': '\u29A8',
'angmsdab': '\u29A9',
'angmsdac': '\u29AA',
'angmsdad': '\u29AB',
'angmsdae': '\u29AC',
'angmsdaf': '\u29AD',
'angmsdag': '\u29AE',
'angmsdah': '\u29AF',
'angrt': '\u221F',
'angrtvb': '\u22BE',
'angrtvbd': '\u299D',
'angsph': '\u2222',
'angst': '\u00C5',
'angzarr': '\u237C',
'Aogon': '\u0104',
'aogon': '\u0105',
'Aopf': '\uD835\uDD38',
'aopf': '\uD835\uDD52',
'ap': '\u2248',
'apacir': '\u2A6F',
'apE': '\u2A70',
'ape': '\u224A',
'apid': '\u224B',
'apos': '\u0027',
'ApplyFunction': '\u2061',
'approx': '\u2248',
'approxeq': '\u224A',
'Aring': '\u00C5',
'aring': '\u00E5',
'Ascr': '\uD835\uDC9C',
'ascr': '\uD835\uDCB6',
'Assign': '\u2254',
'ast': '\u002A',
'asymp': '\u2248',
'asympeq': '\u224D',
'Atilde': '\u00C3',
'atilde': '\u00E3',
'Auml': '\u00C4',
'auml': '\u00E4',
'awconint': '\u2233',
'awint': '\u2A11',
'backcong': '\u224C',
'backepsilon': '\u03F6',
'backprime': '\u2035',
'backsim': '\u223D',
'backsimeq': '\u22CD',
'Backslash': '\u2216',
'Barv': '\u2AE7',
'barvee': '\u22BD',
'Barwed': '\u2306',
'barwed': '\u2305',
'barwedge': '\u2305',
'bbrk': '\u23B5',
'bbrktbrk': '\u23B6',
'bcong': '\u224C',
'Bcy': '\u0411',
'bcy': '\u0431',
'bdquo': '\u201E',
'becaus': '\u2235',
'Because': '\u2235',
'because': '\u2235',
'bemptyv': '\u29B0',
'bepsi': '\u03F6',
'bernou': '\u212C',
'Bernoullis': '\u212C',
'Beta': '\u0392',
'beta': '\u03B2',
'beth': '\u2136',
'between': '\u226C',
'Bfr': '\uD835\uDD05',
'bfr': '\uD835\uDD1F',
'bigcap': '\u22C2',
'bigcirc': '\u25EF',
'bigcup': '\u22C3',
'bigodot': '\u2A00',
'bigoplus': '\u2A01',
'bigotimes': '\u2A02',
'bigsqcup': '\u2A06',
'bigstar': '\u2605',
'bigtriangledown': '\u25BD',
'bigtriangleup': '\u25B3',
'biguplus': '\u2A04',
'bigvee': '\u22C1',
'bigwedge': '\u22C0',
'bkarow': '\u290D',
'blacklozenge': '\u29EB',
'blacksquare': '\u25AA',
'blacktriangle': '\u25B4',
'blacktriangledown': '\u25BE',
'blacktriangleleft': '\u25C2',
'blacktriangleright': '\u25B8',
'blank': '\u2423',
'blk12': '\u2592',
'blk14': '\u2591',
'blk34': '\u2593',
'block': '\u2588',
'bne': '\u003D\u20E5',
'bnequiv': '\u2261\u20E5',
'bNot': '\u2AED',
'bnot': '\u2310',
'Bopf': '\uD835\uDD39',
'bopf': '\uD835\uDD53',
'bot': '\u22A5',
'bottom': '\u22A5',
'bowtie': '\u22C8',
'boxbox': '\u29C9',
'boxDL': '\u2557',
'boxDl': '\u2556',
'boxdL': '\u2555',
'boxdl': '\u2510',
'boxDR': '\u2554',
'boxDr': '\u2553',
'boxdR': '\u2552',
'boxdr': '\u250C',
'boxH': '\u2550',
'boxh': '\u2500',
'boxHD': '\u2566',
'boxHd': '\u2564',
'boxhD': '\u2565',
'boxhd': '\u252C',
'boxHU': '\u2569',
'boxHu': '\u2567',
'boxhU': '\u2568',
'boxhu': '\u2534',
'boxminus': '\u229F',
'boxplus': '\u229E',
'boxtimes': '\u22A0',
'boxUL': '\u255D',
'boxUl': '\u255C',
'boxuL': '\u255B',
'boxul': '\u2518',
'boxUR': '\u255A',
'boxUr': '\u2559',
'boxuR': '\u2558',
'boxur': '\u2514',
'boxV': '\u2551',
'boxv': '\u2502',
'boxVH': '\u256C',
'boxVh': '\u256B',
'boxvH': '\u256A',
'boxvh': '\u253C',
'boxVL': '\u2563',
'boxVl': '\u2562',
'boxvL': '\u2561',
'boxvl': '\u2524',
'boxVR': '\u2560',
'boxVr': '\u255F',
'boxvR': '\u255E',
'boxvr': '\u251C',
'bprime': '\u2035',
'Breve': '\u02D8',
'breve': '\u02D8',
'brvbar': '\u00A6',
'Bscr': '\u212C',
'bscr': '\uD835\uDCB7',
'bsemi': '\u204F',
'bsim': '\u223D',
'bsime': '\u22CD',
'bsol': '\u005C',
'bsolb': '\u29C5',
'bsolhsub': '\u27C8',
'bull': '\u2022',
'bullet': '\u2022',
'bump': '\u224E',
'bumpE': '\u2AAE',
'bumpe': '\u224F',
'Bumpeq': '\u224E',
'bumpeq': '\u224F',
'Cacute': '\u0106',
'cacute': '\u0107',
'Cap': '\u22D2',
'cap': '\u2229',
'capand': '\u2A44',
'capbrcup': '\u2A49',
'capcap': '\u2A4B',
'capcup': '\u2A47',
'capdot': '\u2A40',
'CapitalDifferentialD': '\u2145',
'caps': '\u2229\uFE00',
'caret': '\u2041',
'caron': '\u02C7',
'Cayleys': '\u212D',
'ccaps': '\u2A4D',
'Ccaron': '\u010C',
'ccaron': '\u010D',
'Ccedil': '\u00C7',
'ccedil': '\u00E7',
'Ccirc': '\u0108',
'ccirc': '\u0109',
'Cconint': '\u2230',
'ccups': '\u2A4C',
'ccupssm': '\u2A50',
'Cdot': '\u010A',
'cdot': '\u010B',
'cedil': '\u00B8',
'Cedilla': '\u00B8',
'cemptyv': '\u29B2',
'cent': '\u00A2',
'CenterDot': '\u00B7',
'centerdot': '\u00B7',
'Cfr': '\u212D',
'cfr': '\uD835\uDD20',
'CHcy': '\u0427',
'chcy': '\u0447',
'check': '\u2713',
'checkmark': '\u2713',
'Chi': '\u03A7',
'chi': '\u03C7',
'cir': '\u25CB',
'circ': '\u02C6',
'circeq': '\u2257',
'circlearrowleft': '\u21BA',
'circlearrowright': '\u21BB',
'circledast': '\u229B',
'circledcirc': '\u229A',
'circleddash': '\u229D',
'CircleDot': '\u2299',
'circledR': '\u00AE',
'circledS': '\u24C8',
'CircleMinus': '\u2296',
'CirclePlus': '\u2295',
'CircleTimes': '\u2297',
'cirE': '\u29C3',
'cire': '\u2257',
'cirfnint': '\u2A10',
'cirmid': '\u2AEF',
'cirscir': '\u29C2',
'ClockwiseContourIntegral': '\u2232',
'CloseCurlyDoubleQuote': '\u201D',
'CloseCurlyQuote': '\u2019',
'clubs': '\u2663',
'clubsuit': '\u2663',
'Colon': '\u2237',
'colon': '\u003A',
'Colone': '\u2A74',
'colone': '\u2254',
'coloneq': '\u2254',
'comma': '\u002C',
'commat': '\u0040',
'comp': '\u2201',
'compfn': '\u2218',
'complement': '\u2201',
'complexes': '\u2102',
'cong': '\u2245',
'congdot': '\u2A6D',
'Congruent': '\u2261',
'Conint': '\u222F',
'conint': '\u222E',
'ContourIntegral': '\u222E',
'Copf': '\u2102',
'copf': '\uD835\uDD54',
'coprod': '\u2210',
'Coproduct': '\u2210',
'COPY': '\u00A9',
'copy': '\u00A9',
'copysr': '\u2117',
'CounterClockwiseContourIntegral': '\u2233',
'crarr': '\u21B5',
'Cross': '\u2A2F',
'cross': '\u2717',
'Cscr': '\uD835\uDC9E',
'cscr': '\uD835\uDCB8',
'csub': '\u2ACF',
'csube': '\u2AD1',
'csup': '\u2AD0',
'csupe': '\u2AD2',
'ctdot': '\u22EF',
'cudarrl': '\u2938',
'cudarrr': '\u2935',
'cuepr': '\u22DE',
'cuesc': '\u22DF',
'cularr': '\u21B6',
'cularrp': '\u293D',
'Cup': '\u22D3',
'cup': '\u222A',
'cupbrcap': '\u2A48',
'CupCap': '\u224D',
'cupcap': '\u2A46',
'cupcup': '\u2A4A',
'cupdot': '\u228D',
'cupor': '\u2A45',
'cups': '\u222A\uFE00',
'curarr': '\u21B7',
'curarrm': '\u293C',
'curlyeqprec': '\u22DE',
'curlyeqsucc': '\u22DF',
'curlyvee': '\u22CE',
'curlywedge': '\u22CF',
'curren': '\u00A4',
'curvearrowleft': '\u21B6',
'curvearrowright': '\u21B7',
'cuvee': '\u22CE',
'cuwed': '\u22CF',
'cwconint': '\u2232',
'cwint': '\u2231',
'cylcty': '\u232D',
'Dagger': '\u2021',
'dagger': '\u2020',
'daleth': '\u2138',
'Darr': '\u21A1',
'dArr': '\u21D3',
'darr': '\u2193',
'dash': '\u2010',
'Dashv': '\u2AE4',
'dashv': '\u22A3',
'dbkarow': '\u290F',
'dblac': '\u02DD',
'Dcaron': '\u010E',
'dcaron': '\u010F',
'Dcy': '\u0414',
'dcy': '\u0434',
'DD': '\u2145',
'dd': '\u2146',
'ddagger': '\u2021',
'ddarr': '\u21CA',
'DDotrahd': '\u2911',
'ddotseq': '\u2A77',
'deg': '\u00B0',
'Del': '\u2207',
'Delta': '\u0394',
'delta': '\u03B4',
'demptyv': '\u29B1',
'dfisht': '\u297F',
'Dfr': '\uD835\uDD07',
'dfr': '\uD835\uDD21',
'dHar': '\u2965',
'dharl': '\u21C3',
'dharr': '\u21C2',
'DiacriticalAcute': '\u00B4',
'DiacriticalDot': '\u02D9',
'DiacriticalDoubleAcute': '\u02DD',
'DiacriticalGrave': '\u0060',
'DiacriticalTilde': '\u02DC',
'diam': '\u22C4',
'Diamond': '\u22C4',
'diamond': '\u22C4',
'diamondsuit': '\u2666',
'diams': '\u2666',
'die': '\u00A8',
'DifferentialD': '\u2146',
'digamma': '\u03DD',
'disin': '\u22F2',
'div': '\u00F7',
'divide': '\u00F7',
'divideontimes': '\u22C7',
'divonx': '\u22C7',
'DJcy': '\u0402',
'djcy': '\u0452',
'dlcorn': '\u231E',
'dlcrop': '\u230D',
'dollar': '\u0024',
'Dopf': '\uD835\uDD3B',
'dopf': '\uD835\uDD55',
'Dot': '\u00A8',
'dot': '\u02D9',
'DotDot': '\u20DC',
'doteq': '\u2250',
'doteqdot': '\u2251',
'DotEqual': '\u2250',
'dotminus': '\u2238',
'dotplus': '\u2214',
'dotsquare': '\u22A1',
'doublebarwedge': '\u2306',
'DoubleContourIntegral': '\u222F',
'DoubleDot': '\u00A8',
'DoubleDownArrow': '\u21D3',
'DoubleLeftArrow': '\u21D0',
'DoubleLeftRightArrow': '\u21D4',
'DoubleLeftTee': '\u2AE4',
'DoubleLongLeftArrow': '\u27F8',
'DoubleLongLeftRightArrow': '\u27FA',
'DoubleLongRightArrow': '\u27F9',
'DoubleRightArrow': '\u21D2',
'DoubleRightTee': '\u22A8',
'DoubleUpArrow': '\u21D1',
'DoubleUpDownArrow': '\u21D5',
'DoubleVerticalBar': '\u2225',
'DownArrow': '\u2193',
'Downarrow': '\u21D3',
'downarrow': '\u2193',
'DownArrowBar': '\u2913',
'DownArrowUpArrow': '\u21F5',
'DownBreve': '\u0311',
'downdownarrows': '\u21CA',
'downharpoonleft': '\u21C3',
'downharpoonright': '\u21C2',
'DownLeftRightVector': '\u2950',
'DownLeftTeeVector': '\u295E',
'DownLeftVector': '\u21BD',
'DownLeftVectorBar': '\u2956',
'DownRightTeeVector': '\u295F',
'DownRightVector': '\u21C1',
'DownRightVectorBar': '\u2957',
'DownTee': '\u22A4',
'DownTeeArrow': '\u21A7',
'drbkarow': '\u2910',
'drcorn': '\u231F',
'drcrop': '\u230C',
'Dscr': '\uD835\uDC9F',
'dscr': '\uD835\uDCB9',
'DScy': '\u0405',
'dscy': '\u0455',
'dsol': '\u29F6',
'Dstrok': '\u0110',
'dstrok': '\u0111',
'dtdot': '\u22F1',
'dtri': '\u25BF',
'dtrif': '\u25BE',
'duarr': '\u21F5',
'duhar': '\u296F',
'dwangle': '\u29A6',
'DZcy': '\u040F',
'dzcy': '\u045F',
'dzigrarr': '\u27FF',
'Eacute': '\u00C9',
'eacute': '\u00E9',
'easter': '\u2A6E',
'Ecaron': '\u011A',
'ecaron': '\u011B',
'ecir': '\u2256',
'Ecirc': '\u00CA',
'ecirc': '\u00EA',
'ecolon': '\u2255',
'Ecy': '\u042D',
'ecy': '\u044D',
'eDDot': '\u2A77',
'Edot': '\u0116',
'eDot': '\u2251',
'edot': '\u0117',
'ee': '\u2147',
'efDot': '\u2252',
'Efr': '\uD835\uDD08',
'efr': '\uD835\uDD22',
'eg': '\u2A9A',
'Egrave': '\u00C8',
'egrave': '\u00E8',
'egs': '\u2A96',
'egsdot': '\u2A98',
'el': '\u2A99',
'Element': '\u2208',
'elinters': '\u23E7',
'ell': '\u2113',
'els': '\u2A95',
'elsdot': '\u2A97',
'Emacr': '\u0112',
'emacr': '\u0113',
'empty': '\u2205',
'emptyset': '\u2205',
'EmptySmallSquare': '\u25FB',
'emptyv': '\u2205',
'EmptyVerySmallSquare': '\u25AB',
'emsp': '\u2003',
'emsp13': '\u2004',
'emsp14': '\u2005',
'ENG': '\u014A',
'eng': '\u014B',
'ensp': '\u2002',
'Eogon': '\u0118',
'eogon': '\u0119',
'Eopf': '\uD835\uDD3C',
'eopf': '\uD835\uDD56',
'epar': '\u22D5',
'eparsl': '\u29E3',
'eplus': '\u2A71',
'epsi': '\u03B5',
'Epsilon': '\u0395',
'epsilon': '\u03B5',
'epsiv': '\u03F5',
'eqcirc': '\u2256',
'eqcolon': '\u2255',
'eqsim': '\u2242',
'eqslantgtr': '\u2A96',
'eqslantless': '\u2A95',
'Equal': '\u2A75',
'equals': '\u003D',
'EqualTilde': '\u2242',
'equest': '\u225F',
'Equilibrium': '\u21CC',
'equiv': '\u2261',
'equivDD': '\u2A78',
'eqvparsl': '\u29E5',
'erarr': '\u2971',
'erDot': '\u2253',
'Escr': '\u2130',
'escr': '\u212F',
'esdot': '\u2250',
'Esim': '\u2A73',
'esim': '\u2242',
'Eta': '\u0397',
'eta': '\u03B7',
'ETH': '\u00D0',
'eth': '\u00F0',
'Euml': '\u00CB',
'euml': '\u00EB',
'euro': '\u20AC',
'excl': '\u0021',
'exist': '\u2203',
'Exists': '\u2203',
'expectation': '\u2130',
'ExponentialE': '\u2147',
'exponentiale': '\u2147',
'fallingdotseq': '\u2252',
'Fcy': '\u0424',
'fcy': '\u0444',
'female': '\u2640',
'ffilig': '\uFB03',
'fflig': '\uFB00',
'ffllig': '\uFB04',
'Ffr': '\uD835\uDD09',
'ffr': '\uD835\uDD23',
'filig': '\uFB01',
'FilledSmallSquare': '\u25FC',
'FilledVerySmallSquare': '\u25AA',
'fjlig': '\u0066\u006A',
'flat': '\u266D',
'fllig': '\uFB02',
'fltns': '\u25B1',
'fnof': '\u0192',
'Fopf': '\uD835\uDD3D',
'fopf': '\uD835\uDD57',
'ForAll': '\u2200',
'forall': '\u2200',
'fork': '\u22D4',
'forkv': '\u2AD9',
'Fouriertrf': '\u2131',
'fpartint': '\u2A0D',
'frac12': '\u00BD',
'frac13': '\u2153',
'frac14': '\u00BC',
'frac15': '\u2155',
'frac16': '\u2159',
'frac18': '\u215B',
'frac23': '\u2154',
'frac25': '\u2156',
'frac34': '\u00BE',
'frac35': '\u2157',
'frac38': '\u215C',
'frac45': '\u2158',
'frac56': '\u215A',
'frac58': '\u215D',
'frac78': '\u215E',
'frasl': '\u2044',
'frown': '\u2322',
'Fscr': '\u2131',
'fscr': '\uD835\uDCBB',
'gacute': '\u01F5',
'Gamma': '\u0393',
'gamma': '\u03B3',
'Gammad': '\u03DC',
'gammad': '\u03DD',
'gap': '\u2A86',
'Gbreve': '\u011E',
'gbreve': '\u011F',
'Gcedil': '\u0122',
'Gcirc': '\u011C',
'gcirc': '\u011D',
'Gcy': '\u0413',
'gcy': '\u0433',
'Gdot': '\u0120',
'gdot': '\u0121',
'gE': '\u2267',
'ge': '\u2265',
'gEl': '\u2A8C',
'gel': '\u22DB',
'geq': '\u2265',
'geqq': '\u2267',
'geqslant': '\u2A7E',
'ges': '\u2A7E',
'gescc': '\u2AA9',
'gesdot': '\u2A80',
'gesdoto': '\u2A82',
'gesdotol': '\u2A84',
'gesl': '\u22DB\uFE00',
'gesles': '\u2A94',
'Gfr': '\uD835\uDD0A',
'gfr': '\uD835\uDD24',
'Gg': '\u22D9',
'gg': '\u226B',
'ggg': '\u22D9',
'gimel': '\u2137',
'GJcy': '\u0403',
'gjcy': '\u0453',
'gl': '\u2277',
'gla': '\u2AA5',
'glE': '\u2A92',
'glj': '\u2AA4',
'gnap': '\u2A8A',
'gnapprox': '\u2A8A',
'gnE': '\u2269',
'gne': '\u2A88',
'gneq': '\u2A88',
'gneqq': '\u2269',
'gnsim': '\u22E7',
'Gopf': '\uD835\uDD3E',
'gopf': '\uD835\uDD58',
'grave': '\u0060',
'GreaterEqual': '\u2265',
'GreaterEqualLess': '\u22DB',
'GreaterFullEqual': '\u2267',
'GreaterGreater': '\u2AA2',
'GreaterLess': '\u2277',
'GreaterSlantEqual': '\u2A7E',
'GreaterTilde': '\u2273',
'Gscr': '\uD835\uDCA2',
'gscr': '\u210A',
'gsim': '\u2273',
'gsime': '\u2A8E',
'gsiml': '\u2A90',
'GT': '\u003E',
'Gt': '\u226B',
'gt': '\u003E',
'gtcc': '\u2AA7',
'gtcir': '\u2A7A',
'gtdot': '\u22D7',
'gtlPar': '\u2995',
'gtquest': '\u2A7C',
'gtrapprox': '\u2A86',
'gtrarr': '\u2978',
'gtrdot': '\u22D7',
'gtreqless': '\u22DB',
'gtreqqless': '\u2A8C',
'gtrless': '\u2277',
'gtrsim': '\u2273',
'gvertneqq': '\u2269\uFE00',
'gvnE': '\u2269\uFE00',
'Hacek': '\u02C7',
'hairsp': '\u200A',
'half': '\u00BD',
'hamilt': '\u210B',
'HARDcy': '\u042A',
'hardcy': '\u044A',
'hArr': '\u21D4',
'harr': '\u2194',
'harrcir': '\u2948',
'harrw': '\u21AD',
'Hat': '\u005E',
'hbar': '\u210F',
'Hcirc': '\u0124',
'hcirc': '\u0125',
'hearts': '\u2665',
'heartsuit': '\u2665',
'hellip': '\u2026',
'hercon': '\u22B9',
'Hfr': '\u210C',
'hfr': '\uD835\uDD25',
'HilbertSpace': '\u210B',
'hksearow': '\u2925',
'hkswarow': '\u2926',
'hoarr': '\u21FF',
'homtht': '\u223B',
'hookleftarrow': '\u21A9',
'hookrightarrow': '\u21AA',
'Hopf': '\u210D',
'hopf': '\uD835\uDD59',
'horbar': '\u2015',
'HorizontalLine': '\u2500',
'Hscr': '\u210B',
'hscr': '\uD835\uDCBD',
'hslash': '\u210F',
'Hstrok': '\u0126',
'hstrok': '\u0127',
'HumpDownHump': '\u224E',
'HumpEqual': '\u224F',
'hybull': '\u2043',
'hyphen': '\u2010',
'Iacute': '\u00CD',
'iacute': '\u00ED',
'ic': '\u2063',
'Icirc': '\u00CE',
'icirc': '\u00EE',
'Icy': '\u0418',
'icy': '\u0438',
'Idot': '\u0130',
'IEcy': '\u0415',
'iecy': '\u0435',
'iexcl': '\u00A1',
'iff': '\u21D4',
'Ifr': '\u2111',
'ifr': '\uD835\uDD26',
'Igrave': '\u00CC',
'igrave': '\u00EC',
'ii': '\u2148',
'iiiint': '\u2A0C',
'iiint': '\u222D',
'iinfin': '\u29DC',
'iiota': '\u2129',
'IJlig': '\u0132',
'ijlig': '\u0133',
'Im': '\u2111',
'Imacr': '\u012A',
'imacr': '\u012B',
'image': '\u2111',
'ImaginaryI': '\u2148',
'imagline': '\u2110',
'imagpart': '\u2111',
'imath': '\u0131',
'imof': '\u22B7',
'imped': '\u01B5',
'Implies': '\u21D2',
'in': '\u2208',
'incare': '\u2105',
'infin': '\u221E',
'infintie': '\u29DD',
'inodot': '\u0131',
'Int': '\u222C',
'int': '\u222B',
'intcal': '\u22BA',
'integers': '\u2124',
'Integral': '\u222B',
'intercal': '\u22BA',
'Intersection': '\u22C2',
'intlarhk': '\u2A17',
'intprod': '\u2A3C',
'InvisibleComma': '\u2063',
'InvisibleTimes': '\u2062',
'IOcy': '\u0401',
'iocy': '\u0451',
'Iogon': '\u012E',
'iogon': '\u012F',
'Iopf': '\uD835\uDD40',
'iopf': '\uD835\uDD5A',
'Iota': '\u0399',
'iota': '\u03B9',
'iprod': '\u2A3C',
'iquest': '\u00BF',
'Iscr': '\u2110',
'iscr': '\uD835\uDCBE',
'isin': '\u2208',
'isindot': '\u22F5',
'isinE': '\u22F9',
'isins': '\u22F4',
'isinsv': '\u22F3',
'isinv': '\u2208',
'it': '\u2062',
'Itilde': '\u0128',
'itilde': '\u0129',
'Iukcy': '\u0406',
'iukcy': '\u0456',
'Iuml': '\u00CF',
'iuml': '\u00EF',
'Jcirc': '\u0134',
'jcirc': '\u0135',
'Jcy': '\u0419',
'jcy': '\u0439',
'Jfr': '\uD835\uDD0D',
'jfr': '\uD835\uDD27',
'jmath': '\u0237',
'Jopf': '\uD835\uDD41',
'jopf': '\uD835\uDD5B',
'Jscr': '\uD835\uDCA5',
'jscr': '\uD835\uDCBF',
'Jsercy': '\u0408',
'jsercy': '\u0458',
'Jukcy': '\u0404',
'jukcy': '\u0454',
'Kappa': '\u039A',
'kappa': '\u03BA',
'kappav': '\u03F0',
'Kcedil': '\u0136',
'kcedil': '\u0137',
'Kcy': '\u041A',
'kcy': '\u043A',
'Kfr': '\uD835\uDD0E',
'kfr': '\uD835\uDD28',
'kgreen': '\u0138',
'KHcy': '\u0425',
'khcy': '\u0445',
'KJcy': '\u040C',
'kjcy': '\u045C',
'Kopf': '\uD835\uDD42',
'kopf': '\uD835\uDD5C',
'Kscr': '\uD835\uDCA6',
'kscr': '\uD835\uDCC0',
'lAarr': '\u21DA',
'Lacute': '\u0139',
'lacute': '\u013A',
'laemptyv': '\u29B4',
'lagran': '\u2112',
'Lambda': '\u039B',
'lambda': '\u03BB',
'Lang': '\u27EA',
'lang': '\u27E8',
'langd': '\u2991',
'langle': '\u27E8',
'lap': '\u2A85',
'Laplacetrf': '\u2112',
'laquo': '\u00AB',
'Larr': '\u219E',
'lArr': '\u21D0',
'larr': '\u2190',
'larrb': '\u21E4',
'larrbfs': '\u291F',
'larrfs': '\u291D',
'larrhk': '\u21A9',
'larrlp': '\u21AB',
'larrpl': '\u2939',
'larrsim': '\u2973',
'larrtl': '\u21A2',
'lat': '\u2AAB',
'lAtail': '\u291B',
'latail': '\u2919',
'late': '\u2AAD',
'lates': '\u2AAD\uFE00',
'lBarr': '\u290E',
'lbarr': '\u290C',
'lbbrk': '\u2772',
'lbrace': '\u007B',
'lbrack': '\u005B',
'lbrke': '\u298B',
'lbrksld': '\u298F',
'lbrkslu': '\u298D',
'Lcaron': '\u013D',
'lcaron': '\u013E',
'Lcedil': '\u013B',
'lcedil': '\u013C',
'lceil': '\u2308',
'lcub': '\u007B',
'Lcy': '\u041B',
'lcy': '\u043B',
'ldca': '\u2936',
'ldquo': '\u201C',
'ldquor': '\u201E',
'ldrdhar': '\u2967',
'ldrushar': '\u294B',
'ldsh': '\u21B2',
'lE': '\u2266',
'le': '\u2264',
'LeftAngleBracket': '\u27E8',
'LeftArrow': '\u2190',
'Leftarrow': '\u21D0',
'leftarrow': '\u2190',
'LeftArrowBar': '\u21E4',
'LeftArrowRightArrow': '\u21C6',
'leftarrowtail': '\u21A2',
'LeftCeiling': '\u2308',
'LeftDoubleBracket': '\u27E6',
'LeftDownTeeVector': '\u2961',
'LeftDownVector': '\u21C3',
'LeftDownVectorBar': '\u2959',
'LeftFloor': '\u230A',
'leftharpoondown': '\u21BD',
'leftharpoonup': '\u21BC',
'leftleftarrows': '\u21C7',
'LeftRightArrow': '\u2194',
'Leftrightarrow': '\u21D4',
'leftrightarrow': '\u2194',
'leftrightarrows': '\u21C6',
'leftrightharpoons': '\u21CB',
'leftrightsquigarrow': '\u21AD',
'LeftRightVector': '\u294E',
'LeftTee': '\u22A3',
'LeftTeeArrow': '\u21A4',
'LeftTeeVector': '\u295A',
'leftthreetimes': '\u22CB',
'LeftTriangle': '\u22B2',
'LeftTriangleBar': '\u29CF',
'LeftTriangleEqual': '\u22B4',
'LeftUpDownVector': '\u2951',
'LeftUpTeeVector': '\u2960',
'LeftUpVector': '\u21BF',
'LeftUpVectorBar': '\u2958',
'LeftVector': '\u21BC',
'LeftVectorBar': '\u2952',
'lEg': '\u2A8B',
'leg': '\u22DA',
'leq': '\u2264',
'leqq': '\u2266',
'leqslant': '\u2A7D',
'les': '\u2A7D',
'lescc': '\u2AA8',
'lesdot': '\u2A7F',
'lesdoto': '\u2A81',
'lesdotor': '\u2A83',
'lesg': '\u22DA\uFE00',
'lesges': '\u2A93',
'lessapprox': '\u2A85',
'lessdot': '\u22D6',
'lesseqgtr': '\u22DA',
'lesseqqgtr': '\u2A8B',
'LessEqualGreater': '\u22DA',
'LessFullEqual': '\u2266',
'LessGreater': '\u2276',
'lessgtr': '\u2276',
'LessLess': '\u2AA1',
'lesssim': '\u2272',
'LessSlantEqual': '\u2A7D',
'LessTilde': '\u2272',
'lfisht': '\u297C',
'lfloor': '\u230A',
'Lfr': '\uD835\uDD0F',
'lfr': '\uD835\uDD29',
'lg': '\u2276',
'lgE': '\u2A91',
'lHar': '\u2962',
'lhard': '\u21BD',
'lharu': '\u21BC',
'lharul': '\u296A',
'lhblk': '\u2584',
'LJcy': '\u0409',
'ljcy': '\u0459',
'Ll': '\u22D8',
'll': '\u226A',
'llarr': '\u21C7',
'llcorner': '\u231E',
'Lleftarrow': '\u21DA',
'llhard': '\u296B',
'lltri': '\u25FA',
'Lmidot': '\u013F',
'lmidot': '\u0140',
'lmoust': '\u23B0',
'lmoustache': '\u23B0',
'lnap': '\u2A89',
'lnapprox': '\u2A89',
'lnE': '\u2268',
'lne': '\u2A87',
'lneq': '\u2A87',
'lneqq': '\u2268',
'lnsim': '\u22E6',
'loang': '\u27EC',
'loarr': '\u21FD',
'lobrk': '\u27E6',
'LongLeftArrow': '\u27F5',
'Longleftarrow': '\u27F8',
'longleftarrow': '\u27F5',
'LongLeftRightArrow': '\u27F7',
'Longleftrightarrow': '\u27FA',
'longleftrightarrow': '\u27F7',
'longmapsto': '\u27FC',
'LongRightArrow': '\u27F6',
'Longrightarrow': '\u27F9',
'longrightarrow': '\u27F6',
'looparrowleft': '\u21AB',
'looparrowright': '\u21AC',
'lopar': '\u2985',
'Lopf': '\uD835\uDD43',
'lopf': '\uD835\uDD5D',
'loplus': '\u2A2D',
'lotimes': '\u2A34',
'lowast': '\u2217',
'lowbar': '\u005F',
'LowerLeftArrow': '\u2199',
'LowerRightArrow': '\u2198',
'loz': '\u25CA',
'lozenge': '\u25CA',
'lozf': '\u29EB',
'lpar': '\u0028',
'lparlt': '\u2993',
'lrarr': '\u21C6',
'lrcorner': '\u231F',
'lrhar': '\u21CB',
'lrhard': '\u296D',
'lrm': '\u200E',
'lrtri': '\u22BF',
'lsaquo': '\u2039',
'Lscr': '\u2112',
'lscr': '\uD835\uDCC1',
'Lsh': '\u21B0',
'lsh': '\u21B0',
'lsim': '\u2272',
'lsime': '\u2A8D',
'lsimg': '\u2A8F',
'lsqb': '\u005B',
'lsquo': '\u2018',
'lsquor': '\u201A',
'Lstrok': '\u0141',
'lstrok': '\u0142',
'LT': '\u003C',
'Lt': '\u226A',
'lt': '\u003C',
'ltcc': '\u2AA6',
'ltcir': '\u2A79',
'ltdot': '\u22D6',
'lthree': '\u22CB',
'ltimes': '\u22C9',
'ltlarr': '\u2976',
'ltquest': '\u2A7B',
'ltri': '\u25C3',
'ltrie': '\u22B4',
'ltrif': '\u25C2',
'ltrPar': '\u2996',
'lurdshar': '\u294A',
'luruhar': '\u2966',
'lvertneqq': '\u2268\uFE00',
'lvnE': '\u2268\uFE00',
'macr': '\u00AF',
'male': '\u2642',
'malt': '\u2720',
'maltese': '\u2720',
'Map': '\u2905',
'map': '\u21A6',
'mapsto': '\u21A6',
'mapstodown': '\u21A7',
'mapstoleft': '\u21A4',
'mapstoup': '\u21A5',
'marker': '\u25AE',
'mcomma': '\u2A29',
'Mcy': '\u041C',
'mcy': '\u043C',
'mdash': '\u2014',
'mDDot': '\u223A',
'measuredangle': '\u2221',
'MediumSpace': '\u205F',
'Mellintrf': '\u2133',
'Mfr': '\uD835\uDD10',
'mfr': '\uD835\uDD2A',
'mho': '\u2127',
'micro': '\u00B5',
'mid': '\u2223',
'midast': '\u002A',
'midcir': '\u2AF0',
'middot': '\u00B7',
'minus': '\u2212',
'minusb': '\u229F',
'minusd': '\u2238',
'minusdu': '\u2A2A',
'MinusPlus': '\u2213',
'mlcp': '\u2ADB',
'mldr': '\u2026',
'mnplus': '\u2213',
'models': '\u22A7',
'Mopf': '\uD835\uDD44',
'mopf': '\uD835\uDD5E',
'mp': '\u2213',
'Mscr': '\u2133',
'mscr': '\uD835\uDCC2',
'mstpos': '\u223E',
'Mu': '\u039C',
'mu': '\u03BC',
'multimap': '\u22B8',
'mumap': '\u22B8',
'nabla': '\u2207',
'Nacute': '\u0143',
'nacute': '\u0144',
'nang': '\u2220\u20D2',
'nap': '\u2249',
'napE': '\u2A70\u0338',
'napid': '\u224B\u0338',
'napos': '\u0149',
'napprox': '\u2249',
'natur': '\u266E',
'natural': '\u266E',
'naturals': '\u2115',
'nbsp': '\u00A0',
'nbump': '\u224E\u0338',
'nbumpe': '\u224F\u0338',
'ncap': '\u2A43',
'Ncaron': '\u0147',
'ncaron': '\u0148',
'Ncedil': '\u0145',
'ncedil': '\u0146',
'ncong': '\u2247',
'ncongdot': '\u2A6D\u0338',
'ncup': '\u2A42',
'Ncy': '\u041D',
'ncy': '\u043D',
'ndash': '\u2013',
'ne': '\u2260',
'nearhk': '\u2924',
'neArr': '\u21D7',
'nearr': '\u2197',
'nearrow': '\u2197',
'nedot': '\u2250\u0338',
'NegativeMediumSpace': '\u200B',
'NegativeThickSpace': '\u200B',
'NegativeThinSpace': '\u200B',
'NegativeVeryThinSpace': '\u200B',
'nequiv': '\u2262',
'nesear': '\u2928',
'nesim': '\u2242\u0338',
'NestedGreaterGreater': '\u226B',
'NestedLessLess': '\u226A',
'NewLine': '\u000A',
'nexist': '\u2204',
'nexists': '\u2204',
'Nfr': '\uD835\uDD11',
'nfr': '\uD835\uDD2B',
'ngE': '\u2267\u0338',
'nge': '\u2271',
'ngeq': '\u2271',
'ngeqq': '\u2267\u0338',
'ngeqslant': '\u2A7E\u0338',
'nges': '\u2A7E\u0338',
'nGg': '\u22D9\u0338',
'ngsim': '\u2275',
'nGt': '\u226B\u20D2',
'ngt': '\u226F',
'ngtr': '\u226F',
'nGtv': '\u226B\u0338',
'nhArr': '\u21CE',
'nharr': '\u21AE',
'nhpar': '\u2AF2',
'ni': '\u220B',
'nis': '\u22FC',
'nisd': '\u22FA',
'niv': '\u220B',
'NJcy': '\u040A',
'njcy': '\u045A',
'nlArr': '\u21CD',
'nlarr': '\u219A',
'nldr': '\u2025',
'nlE': '\u2266\u0338',
'nle': '\u2270',
'nLeftarrow': '\u21CD',
'nleftarrow': '\u219A',
'nLeftrightarrow': '\u21CE',
'nleftrightarrow': '\u21AE',
'nleq': '\u2270',
'nleqq': '\u2266\u0338',
'nleqslant': '\u2A7D\u0338',
'nles': '\u2A7D\u0338',
'nless': '\u226E',
'nLl': '\u22D8\u0338',
'nlsim': '\u2274',
'nLt': '\u226A\u20D2',
'nlt': '\u226E',
'nltri': '\u22EA',
'nltrie': '\u22EC',
'nLtv': '\u226A\u0338',
'nmid': '\u2224',
'NoBreak': '\u2060',
'NonBreakingSpace': '\u00A0',
'Nopf': '\u2115',
'nopf': '\uD835\uDD5F',
'Not': '\u2AEC',
'not': '\u00AC',
'NotCongruent': '\u2262',
'NotCupCap': '\u226D',
'NotDoubleVerticalBar': '\u2226',
'NotElement': '\u2209',
'NotEqual': '\u2260',
'NotEqualTilde': '\u2242\u0338',
'NotExists': '\u2204',
'NotGreater': '\u226F',
'NotGreaterEqual': '\u2271',
'NotGreaterFullEqual': '\u2267\u0338',
'NotGreaterGreater': '\u226B\u0338',
'NotGreaterLess': '\u2279',
'NotGreaterSlantEqual': '\u2A7E\u0338',
'NotGreaterTilde': '\u2275',
'NotHumpDownHump': '\u224E\u0338',
'NotHumpEqual': '\u224F\u0338',
'notin': '\u2209',
'notindot': '\u22F5\u0338',
'notinE': '\u22F9\u0338',
'notinva': '\u2209',
'notinvb': '\u22F7',
'notinvc': '\u22F6',
'NotLeftTriangle': '\u22EA',
'NotLeftTriangleBar': '\u29CF\u0338',
'NotLeftTriangleEqual': '\u22EC',
'NotLess': '\u226E',
'NotLessEqual': '\u2270',
'NotLessGreater': '\u2278',
'NotLessLess': '\u226A\u0338',
'NotLessSlantEqual': '\u2A7D\u0338',
'NotLessTilde': '\u2274',
'NotNestedGreaterGreater': '\u2AA2\u0338',
'NotNestedLessLess': '\u2AA1\u0338',
'notni': '\u220C',
'notniva': '\u220C',
'notnivb': '\u22FE',
'notnivc': '\u22FD',
'NotPrecedes': '\u2280',
'NotPrecedesEqual': '\u2AAF\u0338',
'NotPrecedesSlantEqual': '\u22E0',
'NotReverseElement': '\u220C',
'NotRightTriangle': '\u22EB',
'NotRightTriangleBar': '\u29D0\u0338',
'NotRightTriangleEqual': '\u22ED',
'NotSquareSubset': '\u228F\u0338',
'NotSquareSubsetEqual': '\u22E2',
'NotSquareSuperset': '\u2290\u0338',
'NotSquareSupersetEqual': '\u22E3',
'NotSubset': '\u2282\u20D2',
'NotSubsetEqual': '\u2288',
'NotSucceeds': '\u2281',
'NotSucceedsEqual': '\u2AB0\u0338',
'NotSucceedsSlantEqual': '\u22E1',
'NotSucceedsTilde': '\u227F\u0338',
'NotSuperset': '\u2283\u20D2',
'NotSupersetEqual': '\u2289',
'NotTilde': '\u2241',
'NotTildeEqual': '\u2244',
'NotTildeFullEqual': '\u2247',
'NotTildeTilde': '\u2249',
'NotVerticalBar': '\u2224',
'npar': '\u2226',
'nparallel': '\u2226',
'nparsl': '\u2AFD\u20E5',
'npart': '\u2202\u0338',
'npolint': '\u2A14',
'npr': '\u2280',
'nprcue': '\u22E0',
'npre': '\u2AAF\u0338',
'nprec': '\u2280',
'npreceq': '\u2AAF\u0338',
'nrArr': '\u21CF',
'nrarr': '\u219B',
'nrarrc': '\u2933\u0338',
'nrarrw': '\u219D\u0338',
'nRightarrow': '\u21CF',
'nrightarrow': '\u219B',
'nrtri': '\u22EB',
'nrtrie': '\u22ED',
'nsc': '\u2281',
'nsccue': '\u22E1',
'nsce': '\u2AB0\u0338',
'Nscr': '\uD835\uDCA9',
'nscr': '\uD835\uDCC3',
'nshortmid': '\u2224',
'nshortparallel': '\u2226',
'nsim': '\u2241',
'nsime': '\u2244',
'nsimeq': '\u2244',
'nsmid': '\u2224',
'nspar': '\u2226',
'nsqsube': '\u22E2',
'nsqsupe': '\u22E3',
'nsub': '\u2284',
'nsubE': '\u2AC5\u0338',
'nsube': '\u2288',
'nsubset': '\u2282\u20D2',
'nsubseteq': '\u2288',
'nsubseteqq': '\u2AC5\u0338',
'nsucc': '\u2281',
'nsucceq': '\u2AB0\u0338',
'nsup': '\u2285',
'nsupE': '\u2AC6\u0338',
'nsupe': '\u2289',
'nsupset': '\u2283\u20D2',
'nsupseteq': '\u2289',
'nsupseteqq': '\u2AC6\u0338',
'ntgl': '\u2279',
'Ntilde': '\u00D1',
'ntilde': '\u00F1',
'ntlg': '\u2278',
'ntriangleleft': '\u22EA',
'ntrianglelefteq': '\u22EC',
'ntriangleright': '\u22EB',
'ntrianglerighteq': '\u22ED',
'Nu': '\u039D',
'nu': '\u03BD',
'num': '\u0023',
'numero': '\u2116',
'numsp': '\u2007',
'nvap': '\u224D\u20D2',
'nVDash': '\u22AF',
'nVdash': '\u22AE',
'nvDash': '\u22AD',
'nvdash': '\u22AC',
'nvge': '\u2265\u20D2',
'nvgt': '\u003E\u20D2',
'nvHarr': '\u2904',
'nvinfin': '\u29DE',
'nvlArr': '\u2902',
'nvle': '\u2264\u20D2',
'nvlt': '\u003C\u20D2',
'nvltrie': '\u22B4\u20D2',
'nvrArr': '\u2903',
'nvrtrie': '\u22B5\u20D2',
'nvsim': '\u223C\u20D2',
'nwarhk': '\u2923',
'nwArr': '\u21D6',
'nwarr': '\u2196',
'nwarrow': '\u2196',
'nwnear': '\u2927',
'Oacute': '\u00D3',
'oacute': '\u00F3',
'oast': '\u229B',
'ocir': '\u229A',
'Ocirc': '\u00D4',
'ocirc': '\u00F4',
'Ocy': '\u041E',
'ocy': '\u043E',
'odash': '\u229D',
'Odblac': '\u0150',
'odblac': '\u0151',
'odiv': '\u2A38',
'odot': '\u2299',
'odsold': '\u29BC',
'OElig': '\u0152',
'oelig': '\u0153',
'ofcir': '\u29BF',
'Ofr': '\uD835\uDD12',
'ofr': '\uD835\uDD2C',
'ogon': '\u02DB',
'Ograve': '\u00D2',
'ograve': '\u00F2',
'ogt': '\u29C1',
'ohbar': '\u29B5',
'ohm': '\u03A9',
'oint': '\u222E',
'olarr': '\u21BA',
'olcir': '\u29BE',
'olcross': '\u29BB',
'oline': '\u203E',
'olt': '\u29C0',
'Omacr': '\u014C',
'omacr': '\u014D',
'Omega': '\u03A9',
'omega': '\u03C9',
'Omicron': '\u039F',
'omicron': '\u03BF',
'omid': '\u29B6',
'ominus': '\u2296',
'Oopf': '\uD835\uDD46',
'oopf': '\uD835\uDD60',
'opar': '\u29B7',
'OpenCurlyDoubleQuote': '\u201C',
'OpenCurlyQuote': '\u2018',
'operp': '\u29B9',
'oplus': '\u2295',
'Or': '\u2A54',
'or': '\u2228',
'orarr': '\u21BB',
'ord': '\u2A5D',
'order': '\u2134',
'orderof': '\u2134',
'ordf': '\u00AA',
'ordm': '\u00BA',
'origof': '\u22B6',
'oror': '\u2A56',
'orslope': '\u2A57',
'orv': '\u2A5B',
'oS': '\u24C8',
'Oscr': '\uD835\uDCAA',
'oscr': '\u2134',
'Oslash': '\u00D8',
'oslash': '\u00F8',
'osol': '\u2298',
'Otilde': '\u00D5',
'otilde': '\u00F5',
'Otimes': '\u2A37',
'otimes': '\u2297',
'otimesas': '\u2A36',
'Ouml': '\u00D6',
'ouml': '\u00F6',
'ovbar': '\u233D',
'OverBar': '\u203E',
'OverBrace': '\u23DE',
'OverBracket': '\u23B4',
'OverParenthesis': '\u23DC',
'par': '\u2225',
'para': '\u00B6',
'parallel': '\u2225',
'parsim': '\u2AF3',
'parsl': '\u2AFD',
'part': '\u2202',
'PartialD': '\u2202',
'Pcy': '\u041F',
'pcy': '\u043F',
'percnt': '\u0025',
'period': '\u002E',
'permil': '\u2030',
'perp': '\u22A5',
'pertenk': '\u2031',
'Pfr': '\uD835\uDD13',
'pfr': '\uD835\uDD2D',
'Phi': '\u03A6',
'phi': '\u03C6',
'phiv': '\u03D5',
'phmmat': '\u2133',
'phone': '\u260E',
'Pi': '\u03A0',
'pi': '\u03C0',
'pitchfork': '\u22D4',
'piv': '\u03D6',
'planck': '\u210F',
'planckh': '\u210E',
'plankv': '\u210F',
'plus': '\u002B',
'plusacir': '\u2A23',
'plusb': '\u229E',
'pluscir': '\u2A22',
'plusdo': '\u2214',
'plusdu': '\u2A25',
'pluse': '\u2A72',
'PlusMinus': '\u00B1',
'plusmn': '\u00B1',
'plussim': '\u2A26',
'plustwo': '\u2A27',
'pm': '\u00B1',
'Poincareplane': '\u210C',
'pointint': '\u2A15',
'Popf': '\u2119',
'popf': '\uD835\uDD61',
'pound': '\u00A3',
'Pr': '\u2ABB',
'pr': '\u227A',
'prap': '\u2AB7',
'prcue': '\u227C',
'prE': '\u2AB3',
'pre': '\u2AAF',
'prec': '\u227A',
'precapprox': '\u2AB7',
'preccurlyeq': '\u227C',
'Precedes': '\u227A',
'PrecedesEqual': '\u2AAF',
'PrecedesSlantEqual': '\u227C',
'PrecedesTilde': '\u227E',
'preceq': '\u2AAF',
'precnapprox': '\u2AB9',
'precneqq': '\u2AB5',
'precnsim': '\u22E8',
'precsim': '\u227E',
'Prime': '\u2033',
'prime': '\u2032',
'primes': '\u2119',
'prnap': '\u2AB9',
'prnE': '\u2AB5',
'prnsim': '\u22E8',
'prod': '\u220F',
'Product': '\u220F',
'profalar': '\u232E',
'profline': '\u2312',
'profsurf': '\u2313',
'prop': '\u221D',
'Proportion': '\u2237',
'Proportional': '\u221D',
'propto': '\u221D',
'prsim': '\u227E',
'prurel': '\u22B0',
'Pscr': '\uD835\uDCAB',
'pscr': '\uD835\uDCC5',
'Psi': '\u03A8',
'psi': '\u03C8',
'puncsp': '\u2008',
'Qfr': '\uD835\uDD14',
'qfr': '\uD835\uDD2E',
'qint': '\u2A0C',
'Qopf': '\u211A',
'qopf': '\uD835\uDD62',
'qprime': '\u2057',
'Qscr': '\uD835\uDCAC',
'qscr': '\uD835\uDCC6',
'quaternions': '\u210D',
'quatint': '\u2A16',
'quest': '\u003F',
'questeq': '\u225F',
'QUOT': '\u0022',
'quot': '\u0022',
'rAarr': '\u21DB',
'race': '\u223D\u0331',
'Racute': '\u0154',
'racute': '\u0155',
'radic': '\u221A',
'raemptyv': '\u29B3',
'Rang': '\u27EB',
'rang': '\u27E9',
'rangd': '\u2992',
'range': '\u29A5',
'rangle': '\u27E9',
'raquo': '\u00BB',
'Rarr': '\u21A0',
'rArr': '\u21D2',
'rarr': '\u2192',
'rarrap': '\u2975',
'rarrb': '\u21E5',
'rarrbfs': '\u2920',
'rarrc': '\u2933',
'rarrfs': '\u291E',
'rarrhk': '\u21AA',
'rarrlp': '\u21AC',
'rarrpl': '\u2945',
'rarrsim': '\u2974',
'Rarrtl': '\u2916',
'rarrtl': '\u21A3',
'rarrw': '\u219D',
'rAtail': '\u291C',
'ratail': '\u291A',
'ratio': '\u2236',
'rationals': '\u211A',
'RBarr': '\u2910',
'rBarr': '\u290F',
'rbarr': '\u290D',
'rbbrk': '\u2773',
'rbrace': '\u007D',
'rbrack': '\u005D',
'rbrke': '\u298C',
'rbrksld': '\u298E',
'rbrkslu': '\u2990',
'Rcaron': '\u0158',
'rcaron': '\u0159',
'Rcedil': '\u0156',
'rcedil': '\u0157',
'rceil': '\u2309',
'rcub': '\u007D',
'Rcy': '\u0420',
'rcy': '\u0440',
'rdca': '\u2937',
'rdldhar': '\u2969',
'rdquo': '\u201D',
'rdquor': '\u201D',
'rdsh': '\u21B3',
'Re': '\u211C',
'real': '\u211C',
'realine': '\u211B',
'realpart': '\u211C',
'reals': '\u211D',
'rect': '\u25AD',
'REG': '\u00AE',
'reg': '\u00AE',
'ReverseElement': '\u220B',
'ReverseEquilibrium': '\u21CB',
'ReverseUpEquilibrium': '\u296F',
'rfisht': '\u297D',
'rfloor': '\u230B',
'Rfr': '\u211C',
'rfr': '\uD835\uDD2F',
'rHar': '\u2964',
'rhard': '\u21C1',
'rharu': '\u21C0',
'rharul': '\u296C',
'Rho': '\u03A1',
'rho': '\u03C1',
'rhov': '\u03F1',
'RightAngleBracket': '\u27E9',
'RightArrow': '\u2192',
'Rightarrow': '\u21D2',
'rightarrow': '\u2192',
'RightArrowBar': '\u21E5',
'RightArrowLeftArrow': '\u21C4',
'rightarrowtail': '\u21A3',
'RightCeiling': '\u2309',
'RightDoubleBracket': '\u27E7',
'RightDownTeeVector': '\u295D',
'RightDownVector': '\u21C2',
'RightDownVectorBar': '\u2955',
'RightFloor': '\u230B',
'rightharpoondown': '\u21C1',
'rightharpoonup': '\u21C0',
'rightleftarrows': '\u21C4',
'rightleftharpoons': '\u21CC',
'rightrightarrows': '\u21C9',
'rightsquigarrow': '\u219D',
'RightTee': '\u22A2',
'RightTeeArrow': '\u21A6',
'RightTeeVector': '\u295B',
'rightthreetimes': '\u22CC',
'RightTriangle': '\u22B3',
'RightTriangleBar': '\u29D0',
'RightTriangleEqual': '\u22B5',
'RightUpDownVector': '\u294F',
'RightUpTeeVector': '\u295C',
'RightUpVector': '\u21BE',
'RightUpVectorBar': '\u2954',
'RightVector': '\u21C0',
'RightVectorBar': '\u2953',
'ring': '\u02DA',
'risingdotseq': '\u2253',
'rlarr': '\u21C4',
'rlhar': '\u21CC',
'rlm': '\u200F',
'rmoust': '\u23B1',
'rmoustache': '\u23B1',
'rnmid': '\u2AEE',
'roang': '\u27ED',
'roarr': '\u21FE',
'robrk': '\u27E7',
'ropar': '\u2986',
'Ropf': '\u211D',
'ropf': '\uD835\uDD63',
'roplus': '\u2A2E',
'rotimes': '\u2A35',
'RoundImplies': '\u2970',
'rpar': '\u0029',
'rpargt': '\u2994',
'rppolint': '\u2A12',
'rrarr': '\u21C9',
'Rrightarrow': '\u21DB',
'rsaquo': '\u203A',
'Rscr': '\u211B',
'rscr': '\uD835\uDCC7',
'Rsh': '\u21B1',
'rsh': '\u21B1',
'rsqb': '\u005D',
'rsquo': '\u2019',
'rsquor': '\u2019',
'rthree': '\u22CC',
'rtimes': '\u22CA',
'rtri': '\u25B9',
'rtrie': '\u22B5',
'rtrif': '\u25B8',
'rtriltri': '\u29CE',
'RuleDelayed': '\u29F4',
'ruluhar': '\u2968',
'rx': '\u211E',
'Sacute': '\u015A',
'sacute': '\u015B',
'sbquo': '\u201A',
'Sc': '\u2ABC',
'sc': '\u227B',
'scap': '\u2AB8',
'Scaron': '\u0160',
'scaron': '\u0161',
'sccue': '\u227D',
'scE': '\u2AB4',
'sce': '\u2AB0',
'Scedil': '\u015E',
'scedil': '\u015F',
'Scirc': '\u015C',
'scirc': '\u015D',
'scnap': '\u2ABA',
'scnE': '\u2AB6',
'scnsim': '\u22E9',
'scpolint': '\u2A13',
'scsim': '\u227F',
'Scy': '\u0421',
'scy': '\u0441',
'sdot': '\u22C5',
'sdotb': '\u22A1',
'sdote': '\u2A66',
'searhk': '\u2925',
'seArr': '\u21D8',
'searr': '\u2198',
'searrow': '\u2198',
'sect': '\u00A7',
'semi': '\u003B',
'seswar': '\u2929',
'setminus': '\u2216',
'setmn': '\u2216',
'sext': '\u2736',
'Sfr': '\uD835\uDD16',
'sfr': '\uD835\uDD30',
'sfrown': '\u2322',
'sharp': '\u266F',
'SHCHcy': '\u0429',
'shchcy': '\u0449',
'SHcy': '\u0428',
'shcy': '\u0448',
'ShortDownArrow': '\u2193',
'ShortLeftArrow': '\u2190',
'shortmid': '\u2223',
'shortparallel': '\u2225',
'ShortRightArrow': '\u2192',
'ShortUpArrow': '\u2191',
'shy': '\u00AD',
'Sigma': '\u03A3',
'sigma': '\u03C3',
'sigmaf': '\u03C2',
'sigmav': '\u03C2',
'sim': '\u223C',
'simdot': '\u2A6A',
'sime': '\u2243',
'simeq': '\u2243',
'simg': '\u2A9E',
'simgE': '\u2AA0',
'siml': '\u2A9D',
'simlE': '\u2A9F',
'simne': '\u2246',
'simplus': '\u2A24',
'simrarr': '\u2972',
'slarr': '\u2190',
'SmallCircle': '\u2218',
'smallsetminus': '\u2216',
'smashp': '\u2A33',
'smeparsl': '\u29E4',
'smid': '\u2223',
'smile': '\u2323',
'smt': '\u2AAA',
'smte': '\u2AAC',
'smtes': '\u2AAC\uFE00',
'SOFTcy': '\u042C',
'softcy': '\u044C',
'sol': '\u002F',
'solb': '\u29C4',
'solbar': '\u233F',
'Sopf': '\uD835\uDD4A',
'sopf': '\uD835\uDD64',
'spades': '\u2660',
'spadesuit': '\u2660',
'spar': '\u2225',
'sqcap': '\u2293',
'sqcaps': '\u2293\uFE00',
'sqcup': '\u2294',
'sqcups': '\u2294\uFE00',
'Sqrt': '\u221A',
'sqsub': '\u228F',
'sqsube': '\u2291',
'sqsubset': '\u228F',
'sqsubseteq': '\u2291',
'sqsup': '\u2290',
'sqsupe': '\u2292',
'sqsupset': '\u2290',
'sqsupseteq': '\u2292',
'squ': '\u25A1',
'Square': '\u25A1',
'square': '\u25A1',
'SquareIntersection': '\u2293',
'SquareSubset': '\u228F',
'SquareSubsetEqual': '\u2291',
'SquareSuperset': '\u2290',
'SquareSupersetEqual': '\u2292',
'SquareUnion': '\u2294',
'squarf': '\u25AA',
'squf': '\u25AA',
'srarr': '\u2192',
'Sscr': '\uD835\uDCAE',
'sscr': '\uD835\uDCC8',
'ssetmn': '\u2216',
'ssmile': '\u2323',
'sstarf': '\u22C6',
'Star': '\u22C6',
'star': '\u2606',
'starf': '\u2605',
'straightepsilon': '\u03F5',
'straightphi': '\u03D5',
'strns': '\u00AF',
'Sub': '\u22D0',
'sub': '\u2282',
'subdot': '\u2ABD',
'subE': '\u2AC5',
'sube': '\u2286',
'subedot': '\u2AC3',
'submult': '\u2AC1',
'subnE': '\u2ACB',
'subne': '\u228A',
'subplus': '\u2ABF',
'subrarr': '\u2979',
'Subset': '\u22D0',
'subset': '\u2282',
'subseteq': '\u2286',
'subseteqq': '\u2AC5',
'SubsetEqual': '\u2286',
'subsetneq': '\u228A',
'subsetneqq': '\u2ACB',
'subsim': '\u2AC7',
'subsub': '\u2AD5',
'subsup': '\u2AD3',
'succ': '\u227B',
'succapprox': '\u2AB8',
'succcurlyeq': '\u227D',
'Succeeds': '\u227B',
'SucceedsEqual': '\u2AB0',
'SucceedsSlantEqual': '\u227D',
'SucceedsTilde': '\u227F',
'succeq': '\u2AB0',
'succnapprox': '\u2ABA',
'succneqq': '\u2AB6',
'succnsim': '\u22E9',
'succsim': '\u227F',
'SuchThat': '\u220B',
'Sum': '\u2211',
'sum': '\u2211',
'sung': '\u266A',
'Sup': '\u22D1',
'sup': '\u2283',
'sup1': '\u00B9',
'sup2': '\u00B2',
'sup3': '\u00B3',
'supdot': '\u2ABE',
'supdsub': '\u2AD8',
'supE': '\u2AC6',
'supe': '\u2287',
'supedot': '\u2AC4',
'Superset': '\u2283',
'SupersetEqual': '\u2287',
'suphsol': '\u27C9',
'suphsub': '\u2AD7',
'suplarr': '\u297B',
'supmult': '\u2AC2',
'supnE': '\u2ACC',
'supne': '\u228B',
'supplus': '\u2AC0',
'Supset': '\u22D1',
'supset': '\u2283',
'supseteq': '\u2287',
'supseteqq': '\u2AC6',
'supsetneq': '\u228B',
'supsetneqq': '\u2ACC',
'supsim': '\u2AC8',
'supsub': '\u2AD4',
'supsup': '\u2AD6',
'swarhk': '\u2926',
'swArr': '\u21D9',
'swarr': '\u2199',
'swarrow': '\u2199',
'swnwar': '\u292A',
'szlig': '\u00DF',
'Tab': '\u0009',
'target': '\u2316',
'Tau': '\u03A4',
'tau': '\u03C4',
'tbrk': '\u23B4',
'Tcaron': '\u0164',
'tcaron': '\u0165',
'Tcedil': '\u0162',
'tcedil': '\u0163',
'Tcy': '\u0422',
'tcy': '\u0442',
'tdot': '\u20DB',
'telrec': '\u2315',
'Tfr': '\uD835\uDD17',
'tfr': '\uD835\uDD31',
'there4': '\u2234',
'Therefore': '\u2234',
'therefore': '\u2234',
'Theta': '\u0398',
'theta': '\u03B8',
'thetasym': '\u03D1',
'thetav': '\u03D1',
'thickapprox': '\u2248',
'thicksim': '\u223C',
'ThickSpace': '\u205F\u200A',
'thinsp': '\u2009',
'ThinSpace': '\u2009',
'thkap': '\u2248',
'thksim': '\u223C',
'THORN': '\u00DE',
'thorn': '\u00FE',
'Tilde': '\u223C',
'tilde': '\u02DC',
'TildeEqual': '\u2243',
'TildeFullEqual': '\u2245',
'TildeTilde': '\u2248',
'times': '\u00D7',
'timesb': '\u22A0',
'timesbar': '\u2A31',
'timesd': '\u2A30',
'tint': '\u222D',
'toea': '\u2928',
'top': '\u22A4',
'topbot': '\u2336',
'topcir': '\u2AF1',
'Topf': '\uD835\uDD4B',
'topf': '\uD835\uDD65',
'topfork': '\u2ADA',
'tosa': '\u2929',
'tprime': '\u2034',
'TRADE': '\u2122',
'trade': '\u2122',
'triangle': '\u25B5',
'triangledown': '\u25BF',
'triangleleft': '\u25C3',
'trianglelefteq': '\u22B4',
'triangleq': '\u225C',
'triangleright': '\u25B9',
'trianglerighteq': '\u22B5',
'tridot': '\u25EC',
'trie': '\u225C',
'triminus': '\u2A3A',
'TripleDot': '\u20DB',
'triplus': '\u2A39',
'trisb': '\u29CD',
'tritime': '\u2A3B',
'trpezium': '\u23E2',
'Tscr': '\uD835\uDCAF',
'tscr': '\uD835\uDCC9',
'TScy': '\u0426',
'tscy': '\u0446',
'TSHcy': '\u040B',
'tshcy': '\u045B',
'Tstrok': '\u0166',
'tstrok': '\u0167',
'twixt': '\u226C',
'twoheadleftarrow': '\u219E',
'twoheadrightarrow': '\u21A0',
'Uacute': '\u00DA',
'uacute': '\u00FA',
'Uarr': '\u219F',
'uArr': '\u21D1',
'uarr': '\u2191',
'Uarrocir': '\u2949',
'Ubrcy': '\u040E',
'ubrcy': '\u045E',
'Ubreve': '\u016C',
'ubreve': '\u016D',
'Ucirc': '\u00DB',
'ucirc': '\u00FB',
'Ucy': '\u0423',
'ucy': '\u0443',
'udarr': '\u21C5',
'Udblac': '\u0170',
'udblac': '\u0171',
'udhar': '\u296E',
'ufisht': '\u297E',
'Ufr': '\uD835\uDD18',
'ufr': '\uD835\uDD32',
'Ugrave': '\u00D9',
'ugrave': '\u00F9',
'uHar': '\u2963',
'uharl': '\u21BF',
'uharr': '\u21BE',
'uhblk': '\u2580',
'ulcorn': '\u231C',
'ulcorner': '\u231C',
'ulcrop': '\u230F',
'ultri': '\u25F8',
'Umacr': '\u016A',
'umacr': '\u016B',
'uml': '\u00A8',
'UnderBar': '\u005F',
'UnderBrace': '\u23DF',
'UnderBracket': '\u23B5',
'UnderParenthesis': '\u23DD',
'Union': '\u22C3',
'UnionPlus': '\u228E',
'Uogon': '\u0172',
'uogon': '\u0173',
'Uopf': '\uD835\uDD4C',
'uopf': '\uD835\uDD66',
'UpArrow': '\u2191',
'Uparrow': '\u21D1',
'uparrow': '\u2191',
'UpArrowBar': '\u2912',
'UpArrowDownArrow': '\u21C5',
'UpDownArrow': '\u2195',
'Updownarrow': '\u21D5',
'updownarrow': '\u2195',
'UpEquilibrium': '\u296E',
'upharpoonleft': '\u21BF',
'upharpoonright': '\u21BE',
'uplus': '\u228E',
'UpperLeftArrow': '\u2196',
'UpperRightArrow': '\u2197',
'Upsi': '\u03D2',
'upsi': '\u03C5',
'upsih': '\u03D2',
'Upsilon': '\u03A5',
'upsilon': '\u03C5',
'UpTee': '\u22A5',
'UpTeeArrow': '\u21A5',
'upuparrows': '\u21C8',
'urcorn': '\u231D',
'urcorner': '\u231D',
'urcrop': '\u230E',
'Uring': '\u016E',
'uring': '\u016F',
'urtri': '\u25F9',
'Uscr': '\uD835\uDCB0',
'uscr': '\uD835\uDCCA',
'utdot': '\u22F0',
'Utilde': '\u0168',
'utilde': '\u0169',
'utri': '\u25B5',
'utrif': '\u25B4',
'uuarr': '\u21C8',
'Uuml': '\u00DC',
'uuml': '\u00FC',
'uwangle': '\u29A7',
'vangrt': '\u299C',
'varepsilon': '\u03F5',
'varkappa': '\u03F0',
'varnothing': '\u2205',
'varphi': '\u03D5',
'varpi': '\u03D6',
'varpropto': '\u221D',
'vArr': '\u21D5',
'varr': '\u2195',
'varrho': '\u03F1',
'varsigma': '\u03C2',
'varsubsetneq': '\u228A\uFE00',
'varsubsetneqq': '\u2ACB\uFE00',
'varsupsetneq': '\u228B\uFE00',
'varsupsetneqq': '\u2ACC\uFE00',
'vartheta': '\u03D1',
'vartriangleleft': '\u22B2',
'vartriangleright': '\u22B3',
'Vbar': '\u2AEB',
'vBar': '\u2AE8',
'vBarv': '\u2AE9',
'Vcy': '\u0412',
'vcy': '\u0432',
'VDash': '\u22AB',
'Vdash': '\u22A9',
'vDash': '\u22A8',
'vdash': '\u22A2',
'Vdashl': '\u2AE6',
'Vee': '\u22C1',
'vee': '\u2228',
'veebar': '\u22BB',
'veeeq': '\u225A',
'vellip': '\u22EE',
'Verbar': '\u2016',
'verbar': '\u007C',
'Vert': '\u2016',
'vert': '\u007C',
'VerticalBar': '\u2223',
'VerticalLine': '\u007C',
'VerticalSeparator': '\u2758',
'VerticalTilde': '\u2240',
'VeryThinSpace': '\u200A',
'Vfr': '\uD835\uDD19',
'vfr': '\uD835\uDD33',
'vltri': '\u22B2',
'vnsub': '\u2282\u20D2',
'vnsup': '\u2283\u20D2',
'Vopf': '\uD835\uDD4D',
'vopf': '\uD835\uDD67',
'vprop': '\u221D',
'vrtri': '\u22B3',
'Vscr': '\uD835\uDCB1',
'vscr': '\uD835\uDCCB',
'vsubnE': '\u2ACB\uFE00',
'vsubne': '\u228A\uFE00',
'vsupnE': '\u2ACC\uFE00',
'vsupne': '\u228B\uFE00',
'Vvdash': '\u22AA',
'vzigzag': '\u299A',
'Wcirc': '\u0174',
'wcirc': '\u0175',
'wedbar': '\u2A5F',
'Wedge': '\u22C0',
'wedge': '\u2227',
'wedgeq': '\u2259',
'weierp': '\u2118',
'Wfr': '\uD835\uDD1A',
'wfr': '\uD835\uDD34',
'Wopf': '\uD835\uDD4E',
'wopf': '\uD835\uDD68',
'wp': '\u2118',
'wr': '\u2240',
'wreath': '\u2240',
'Wscr': '\uD835\uDCB2',
'wscr': '\uD835\uDCCC',
'xcap': '\u22C2',
'xcirc': '\u25EF',
'xcup': '\u22C3',
'xdtri': '\u25BD',
'Xfr': '\uD835\uDD1B',
'xfr': '\uD835\uDD35',
'xhArr': '\u27FA',
'xharr': '\u27F7',
'Xi': '\u039E',
'xi': '\u03BE',
'xlArr': '\u27F8',
'xlarr': '\u27F5',
'xmap': '\u27FC',
'xnis': '\u22FB',
'xodot': '\u2A00',
'Xopf': '\uD835\uDD4F',
'xopf': '\uD835\uDD69',
'xoplus': '\u2A01',
'xotime': '\u2A02',
'xrArr': '\u27F9',
'xrarr': '\u27F6',
'Xscr': '\uD835\uDCB3',
'xscr': '\uD835\uDCCD',
'xsqcup': '\u2A06',
'xuplus': '\u2A04',
'xutri': '\u25B3',
'xvee': '\u22C1',
'xwedge': '\u22C0',
'Yacute': '\u00DD',
'yacute': '\u00FD',
'YAcy': '\u042F',
'yacy': '\u044F',
'Ycirc': '\u0176',
'ycirc': '\u0177',
'Ycy': '\u042B',
'ycy': '\u044B',
'yen': '\u00A5',
'Yfr': '\uD835\uDD1C',
'yfr': '\uD835\uDD36',
'YIcy': '\u0407',
'yicy': '\u0457',
'Yopf': '\uD835\uDD50',
'yopf': '\uD835\uDD6A',
'Yscr': '\uD835\uDCB4',
'yscr': '\uD835\uDCCE',
'YUcy': '\u042E',
'yucy': '\u044E',
'Yuml': '\u0178',
'yuml': '\u00FF',
'Zacute': '\u0179',
'zacute': '\u017A',
'Zcaron': '\u017D',
'zcaron': '\u017E',
'Zcy': '\u0417',
'zcy': '\u0437',
'Zdot': '\u017B',
'zdot': '\u017C',
'zeetrf': '\u2128',
'ZeroWidthSpace': '\u200B',
'Zeta': '\u0396',
'zeta': '\u03B6',
'Zfr': '\u2128',
'zfr': '\uD835\uDD37',
'ZHcy': '\u0416',
'zhcy': '\u0436',
'zigrarr': '\u21DD',
'Zopf': '\u2124',
'zopf': '\uD835\uDD6B',
'Zscr': '\uD835\uDCB5',
'zscr': '\uD835\uDCCF',
'zwj': '\u200D',
'zwnj': '\u200C',
};
// The &ngsp; pseudo-entity is denoting a space. see:
// https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart
exports.NGSP_UNICODE = '\uE500';
exports.NAMED_ENTITIES['ngsp'] = exports.NGSP_UNICODE;

35

lib/compiler/src/parse_util.d.ts

@@ -1,2 +0,1 @@

import { CompileIdentifierMetadata } from './compile_metadata';
export declare class ParseLocation {

@@ -23,8 +22,30 @@ file: ParseSourceFile;

end: ParseLocation;
fullStart: ParseLocation;
details: string | null;
constructor(start: ParseLocation, end: ParseLocation, details?: string | null);
/**
* Create an object that holds information about spans of tokens/nodes captured during
* lexing/parsing of text.
*
* @param start
* The location of the start of the span (having skipped leading trivia).
* Skipping leading trivia makes source-spans more "user friendly", since things like HTML
* elements will appear to begin at the start of the opening tag, rather than at the start of any
* leading trivia, which could include newlines.
*
* @param end
* The location of the end of the span.
*
* @param fullStart
* The start of the token without skipping the leading trivia.
* This is used by tooling that splits tokens further, such as extracting Angular interpolations
* from text tokens. Such tooling creates new source-spans relative to the original token's
* source-span. If leading trivia characters have been skipped then the new source-spans may be
* incorrectly offset.
*
* @param details
* Additional information (such as identifier names) that should be associated with the span.
*/
constructor(start: ParseLocation, end: ParseLocation, fullStart?: ParseLocation, details?: string | null);
toString(): string;
}
export declare const EMPTY_PARSE_LOCATION: ParseLocation;
export declare const EMPTY_SOURCE_SPAN: ParseSourceSpan;
export declare enum ParseErrorLevel {

@@ -42,3 +63,2 @@ WARNING = 0,

}
export declare function typeSourceSpan(kind: string, type: CompileIdentifierMetadata): ParseSourceSpan;
/**

@@ -53,1 +73,6 @@ * Generates Source Span object for a given R3 Type for JIT mode.

export declare function r3JitTypeSourceSpan(kind: string, typeName: string, sourceUrl: string): ParseSourceSpan;
export declare function identifierName(compileIdentifier: CompileIdentifierMetadata | null | undefined): string | null;
export interface CompileIdentifierMetadata {
reference: any;
}
export declare function sanitizeIdentifier(name: string): string;

93

lib/compiler/src/parse_util.js

@@ -1,6 +0,4 @@

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -10,5 +8,5 @@ * Use of this source code is governed by an MIT-style license that can be

*/
const chars = require("./chars");
const compile_metadata_1 = require("./compile_metadata");
class ParseLocation {
import * as chars from "./chars.js";
import { stringify } from "./util.js";
export class ParseLocation {
constructor(file, offset, line, col) {

@@ -35,3 +33,3 @@ this.file = file;

line--;
const priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode(chars.$LF));
const priorLine = source.substring(0, offset - 1).lastIndexOf(String.fromCharCode(chars.$LF));
col = priorLine > 0 ? offset - priorLine : offset;

@@ -97,4 +95,3 @@ }

}
exports.ParseLocation = ParseLocation;
class ParseSourceFile {
export class ParseSourceFile {
constructor(content, url) {

@@ -105,7 +102,30 @@ this.content = content;

}
exports.ParseSourceFile = ParseSourceFile;
class ParseSourceSpan {
constructor(start, end, details = null) {
export class ParseSourceSpan {
/**
* Create an object that holds information about spans of tokens/nodes captured during
* lexing/parsing of text.
*
* @param start
* The location of the start of the span (having skipped leading trivia).
* Skipping leading trivia makes source-spans more "user friendly", since things like HTML
* elements will appear to begin at the start of the opening tag, rather than at the start of any
* leading trivia, which could include newlines.
*
* @param end
* The location of the end of the span.
*
* @param fullStart
* The start of the token without skipping the leading trivia.
* This is used by tooling that splits tokens further, such as extracting Angular interpolations
* from text tokens. Such tooling creates new source-spans relative to the original token's
* source-span. If leading trivia characters have been skipped then the new source-spans may be
* incorrectly offset.
*
* @param details
* Additional information (such as identifier names) that should be associated with the span.
*/
constructor(start, end, fullStart = start, details = null) {
this.start = start;
this.end = end;
this.fullStart = fullStart;
this.details = details;

@@ -117,11 +137,8 @@ }

}
exports.ParseSourceSpan = ParseSourceSpan;
exports.EMPTY_PARSE_LOCATION = new ParseLocation(new ParseSourceFile('', ''), 0, 0, 0);
exports.EMPTY_SOURCE_SPAN = new ParseSourceSpan(exports.EMPTY_PARSE_LOCATION, exports.EMPTY_PARSE_LOCATION);
var ParseErrorLevel;
export var ParseErrorLevel;
(function (ParseErrorLevel) {
ParseErrorLevel[ParseErrorLevel["WARNING"] = 0] = "WARNING";
ParseErrorLevel[ParseErrorLevel["ERROR"] = 1] = "ERROR";
})(ParseErrorLevel = exports.ParseErrorLevel || (exports.ParseErrorLevel = {}));
class ParseError {
})(ParseErrorLevel || (ParseErrorLevel = {}));
export class ParseError {
constructor(span, msg, level = ParseErrorLevel.ERROR) {

@@ -142,11 +159,2 @@ this.span = span;

}
exports.ParseError = ParseError;
function typeSourceSpan(kind, type) {
const moduleUrl = compile_metadata_1.identifierModuleUrl(type);
const sourceFileName = moduleUrl != null ? `in ${kind} ${compile_metadata_1.identifierName(type)} in ${moduleUrl}` :
`in ${kind} ${compile_metadata_1.identifierName(type)}`;
const sourceFile = new ParseSourceFile('', sourceFileName);
return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1));
}
exports.typeSourceSpan = typeSourceSpan;
/**

@@ -160,3 +168,3 @@ * Generates Source Span object for a given R3 Type for JIT mode.

*/
function r3JitTypeSourceSpan(kind, typeName, sourceUrl) {
export function r3JitTypeSourceSpan(kind, typeName, sourceUrl) {
const sourceFileName = `in ${kind} ${typeName} in ${sourceUrl}`;

@@ -166,2 +174,29 @@ const sourceFile = new ParseSourceFile('', sourceFileName);

}
exports.r3JitTypeSourceSpan = r3JitTypeSourceSpan;
let _anonymousTypeIndex = 0;
export function identifierName(compileIdentifier) {
if (!compileIdentifier || !compileIdentifier.reference) {
return null;
}
const ref = compileIdentifier.reference;
if (ref['__anonymousType']) {
return ref['__anonymousType'];
}
if (ref['__forward_ref__']) {
// We do not want to try to stringify a `forwardRef()` function because that would cause the
// inner function to be evaluated too early, defeating the whole point of the `forwardRef`.
return '__forward_ref__';
}
let identifier = stringify(ref);
if (identifier.indexOf('(') >= 0) {
// case: anonymous functions!
identifier = `anonymous_${_anonymousTypeIndex++}`;
ref['__anonymousType'] = identifier;
}
else {
identifier = sanitizeIdentifier(identifier);
}
return identifier;
}
export function sanitizeIdentifier(name) {
return name.replace(/\W/g, '_');
}

60

lib/compiler/src/util.d.ts
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -8,54 +8,11 @@ * Use of this source code is governed by an MIT-style license that can be

*/
import { ConstantPool } from './constant_pool';
import * as o from './output/output_ast';
import { ParseError } from './parse_util';
export declare function dashCaseToCamelCase(input: string): string;
export declare function splitAtColon(input: string, defaultValues: string[]): string[];
export declare function splitAtPeriod(input: string, defaultValues: string[]): string[];
export declare function visitValue(value: any, visitor: ValueVisitor, context: any): any;
export declare function isDefined(val: any): boolean;
export declare function noUndefined<T>(val: T | undefined): T;
export interface ValueVisitor {
visitArray(arr: any[], context: any): any;
visitStringMap(map: {
[key: string]: any;
}, context: any): any;
visitPrimitive(value: any, context: any): any;
visitOther(value: any, context: any): any;
}
export declare class ValueTransformer implements ValueVisitor {
visitArray(arr: any[], context: any): any;
visitStringMap(map: {
[key: string]: any;
}, context: any): any;
visitPrimitive(value: any, context: any): any;
visitOther(value: any, context: any): any;
}
export declare type SyncAsync<T> = T | Promise<T>;
export declare const SyncAsync: {
assertSync: <T>(value: SyncAsync<T>) => T;
then: <T, R>(value: SyncAsync<T>, cb: (value: T) => SyncAsync<R>) => SyncAsync<R>;
all: <T>(syncAsyncValues: SyncAsync<T>[]) => SyncAsync<T[]>;
};
export declare function error(msg: string): never;
export declare function syntaxError(msg: string, parseErrors?: ParseError[]): Error;
export declare function isSyntaxError(error: Error): boolean;
export declare function getParseErrors(error: Error): ParseError[];
export declare function escapeRegExp(s: string): string;
export declare function utf8Encode(str: string): string;
export interface OutputContext {
genFilePath: string;
statements: o.Statement[];
constantPool: ConstantPool;
importExpr(reference: any, typeParams?: o.Type[] | null, useSummaries?: boolean): o.Expression;
}
export declare type Byte = number;
export declare function utf8Encode(str: string): Byte[];
export declare function stringify(token: any): string;
/**
* Lazily retrieves the reference value from a forwardRef.
*/
export declare function resolveForwardRef(type: any): any;
/**
* Determine if the argument is shaped like a Promise
*/
export declare function isPromise(obj: any): obj is Promise<any>;
export declare class Version {

@@ -76,1 +33,12 @@ full: string;

export { _global as global };
export declare function newArray<T = any>(size: number): T[];
export declare function newArray<T>(size: number, value: T): T[];
/**
* Partitions a given array into 2 arrays, based on a boolean value returned by the condition
* function.
*
* @param arr Input array that should be partitioned
* @param conditionFn Condition function that is called for each item in a given array and returns a
* boolean value.
*/
export declare function partitionArray<T, F = T>(arr: (T | F)[], conditionFn: (value: T | F) => boolean): [T[], F[]];

168

lib/compiler/src/util.js

@@ -1,5 +0,4 @@

"use strict";
/**
* @license
* Copyright Google Inc. All Rights Reserved.
* Copyright Google LLC All Rights Reserved.
*

@@ -9,16 +8,12 @@ * Use of this source code is governed by an MIT-style license that can be

*/
Object.defineProperty(exports, "__esModule", { value: true });
const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
function dashCaseToCamelCase(input) {
export function dashCaseToCamelCase(input) {
return input.replace(DASH_CASE_REGEXP, (...m) => m[1].toUpperCase());
}
exports.dashCaseToCamelCase = dashCaseToCamelCase;
function splitAtColon(input, defaultValues) {
export function splitAtColon(input, defaultValues) {
return _splitAt(input, ':', defaultValues);
}
exports.splitAtColon = splitAtColon;
function splitAtPeriod(input, defaultValues) {
export function splitAtPeriod(input, defaultValues) {
return _splitAt(input, '.', defaultValues);
}
exports.splitAtPeriod = splitAtPeriod;
function _splitAt(input, character, defaultValues) {

@@ -30,82 +25,14 @@ const characterIndex = input.indexOf(character);

}
function visitValue(value, visitor, context) {
if (Array.isArray(value)) {
return visitor.visitArray(value, context);
}
if (isStrictStringMap(value)) {
return visitor.visitStringMap(value, context);
}
if (value == null || typeof value == 'string' || typeof value == 'number' ||
typeof value == 'boolean') {
return visitor.visitPrimitive(value, context);
}
return visitor.visitOther(value, context);
}
exports.visitValue = visitValue;
function isDefined(val) {
return val !== null && val !== undefined;
}
exports.isDefined = isDefined;
function noUndefined(val) {
export function noUndefined(val) {
return val === undefined ? null : val;
}
exports.noUndefined = noUndefined;
class ValueTransformer {
visitArray(arr, context) {
return arr.map(value => visitValue(value, this, context));
}
visitStringMap(map, context) {
const result = {};
Object.keys(map).forEach(key => { result[key] = visitValue(map[key], this, context); });
return result;
}
visitPrimitive(value, context) { return value; }
visitOther(value, context) { return value; }
}
exports.ValueTransformer = ValueTransformer;
exports.SyncAsync = {
assertSync: (value) => {
if (isPromise(value)) {
throw new Error(`Illegal state: value cannot be a promise`);
}
return value;
},
then: (value, cb) => { return isPromise(value) ? value.then(cb) : cb(value); },
all: (syncAsyncValues) => {
return syncAsyncValues.some(isPromise) ? Promise.all(syncAsyncValues) : syncAsyncValues;
}
};
function error(msg) {
export function error(msg) {
throw new Error(`Internal Error: ${msg}`);
}
exports.error = error;
function syntaxError(msg, parseErrors) {
const error = Error(msg);
error[ERROR_SYNTAX_ERROR] = true;
if (parseErrors)
error[ERROR_PARSE_ERRORS] = parseErrors;
return error;
}
exports.syntaxError = syntaxError;
const ERROR_SYNTAX_ERROR = 'ngSyntaxError';
const ERROR_PARSE_ERRORS = 'ngParseErrors';
function isSyntaxError(error) {
return error[ERROR_SYNTAX_ERROR];
}
exports.isSyntaxError = isSyntaxError;
function getParseErrors(error) {
return error[ERROR_PARSE_ERRORS] || [];
}
exports.getParseErrors = getParseErrors;
// Escape characters that have a special meaning in Regular Expressions
function escapeRegExp(s) {
export function escapeRegExp(s) {
return s.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
}
exports.escapeRegExp = escapeRegExp;
const STRING_MAP_PROTO = Object.getPrototypeOf({});
function isStrictStringMap(obj) {
return typeof obj === 'object' && obj !== null && Object.getPrototypeOf(obj) === STRING_MAP_PROTO;
}
function utf8Encode(str) {
let encoded = '';
export function utf8Encode(str) {
let encoded = [];
for (let index = 0; index < str.length; index++) {

@@ -123,12 +50,12 @@ let codePoint = str.charCodeAt(index);

if (codePoint <= 0x7f) {
encoded += String.fromCharCode(codePoint);
encoded.push(codePoint);
}
else if (codePoint <= 0x7ff) {
encoded += String.fromCharCode(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80);
encoded.push(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80);
}
else if (codePoint <= 0xffff) {
encoded += String.fromCharCode((codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
encoded.push((codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
}
else if (codePoint <= 0x1fffff) {
encoded += String.fromCharCode(((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
encoded.push(((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);
}

@@ -138,8 +65,7 @@ }

}
exports.utf8Encode = utf8Encode;
function stringify(token) {
export function stringify(token) {
if (typeof token === 'string') {
return token;
}
if (token instanceof Array) {
if (Array.isArray(token)) {
return '[' + token.map(stringify).join(', ') + ']';

@@ -168,25 +94,3 @@ }

}
exports.stringify = stringify;
/**
* Lazily retrieves the reference value from a forwardRef.
*/
function resolveForwardRef(type) {
if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__')) {
return type();
}
else {
return type;
}
}
exports.resolveForwardRef = resolveForwardRef;
/**
* Determine if the argument is shaped like a Promise
*/
function isPromise(obj) {
// allow any Promise/A+ compliant thenable.
// It's up to the caller to ensure that obj.then conforms to the spec
return !!obj && typeof obj.then === 'function';
}
exports.isPromise = isPromise;
class Version {
export class Version {
constructor(full) {

@@ -200,10 +104,32 @@ this.full = full;

}
exports.Version = Version;
const __window = typeof window !== 'undefined' && window;
const __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
self instanceof WorkerGlobalScope && self;
const __global = typeof global !== 'undefined' && global;
// Check __global first, because in Node tests both __global and __window may be defined and _global
// should be __global in that case.
const _global = __global || __window || __self;
exports.global = _global;
// Check `global` first, because in Node tests both `global` and `window` may be defined and our
// `_global` variable should point to the NodeJS `global` in that case. Note: Typeof/Instanceof
// checks are considered side-effects in Terser. We explicitly mark this as side-effect free:
// https://github.com/terser/terser/issues/250.
const _global = ( /* @__PURE__ */(() => (typeof global !== 'undefined' && global) || (typeof window !== 'undefined' && window) ||
(typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
self instanceof WorkerGlobalScope && self))());
export { _global as global };
export function newArray(size, value) {
const list = [];
for (let i = 0; i < size; i++) {
list.push(value);
}
return list;
}
/**
* Partitions a given array into 2 arrays, based on a boolean value returned by the condition
* function.
*
* @param arr Input array that should be partitioned
* @param conditionFn Condition function that is called for each item in a given array and returns a
* boolean value.
*/
export function partitionArray(arr, conditionFn) {
const truthy = [];
const falsy = [];
for (const item of arr) {
(conditionFn(item) ? truthy : falsy).push(item);
}
return [truthy, falsy];
}

28

package.json
{
"name": "angular-html-parser",
"version": "1.8.0",
"version": "2.0.0",
"description": "A HTML parser extracted from Angular with some modifications",
"main": "lib/angular-html-parser/src/index.js",
"types": "lib/angular-html-parser/src/index.d.ts",
"repository": "https://github.com/ikatyang/angular-html-parser",
"homepage": "https://github.com/ikatyang/angular-html-parser/blob/master/packages/angular-html-parser#readme",
"repository": "https://github.com/prettier/angular-html-parser",
"homepage": "https://github.com/prettier/angular-html-parser/blob/master/packages/angular-html-parser#readme",
"author": {

@@ -19,17 +19,20 @@ "name": "Ika",

"build": "tsc -p tsconfig.build.json",
"test": "ts-node --transpileOnly --project tsconfig.test.json -r tsconfig-paths/register node_modules/.bin/jasmine ../compiler/test/ml_parser/*_spec.ts ./test/*_spec.ts",
"postbuild": "jscodeshift -t postbuild-codemod.ts lib --extensions=js,ts --parser=ts",
"test": "ts-node --project tsconfig.test.json -r tsconfig-paths/register node_modules/.bin/jasmine ../compiler/test/ml_parser/*_spec.ts ./test/*_spec.ts",
"release": "standard-version"
},
"dependencies": {
"tslib": "^1.9.3"
"tslib": "2.4.0"
},
"devDependencies": {
"jasmine": "3.2.0",
"standard-version": "4.4.0",
"ts-node": "7.0.1",
"tsconfig-paths": "3.6.0",
"typescript": "3.1.3"
"@types/jscodeshift": "0.11.5",
"jasmine": "4.4.0",
"jscodeshift": "0.13.1",
"standard-version": "9.5.0",
"ts-node": "10.9.1",
"tsconfig-paths": "4.1.0",
"typescript": "4.8.4"
},
"engines": {
"node": ">= 6"
"node": ">= 14"
},

@@ -39,3 +42,4 @@ "files": [

"/ThirdPartyNoticeText.txt"
]
],
"type": "module"
}

19

README.md
# angular-html-parser
[![npm](https://img.shields.io/npm/v/angular-html-parser.svg)](https://www.npmjs.com/package/angular-html-parser)
[![build](https://img.shields.io/travis/com/ikatyang/angular-html-parser/master.svg)](https://travis-ci.com/ikatyang/angular-html-parser/builds)
A HTML parser extracted from Angular with some [modifications](#modifications)
An HTML parser extracted from Angular with some [modifications](#modifications)
[Changelog](https://github.com/ikatyang/angular-html-parser/blob/master/packages/angular-html-parser/CHANGELOG.md)
[Changelog](https://github.com/prettier/angular-html-parser/blob/master/packages/angular-html-parser/CHANGELOG.md)

@@ -25,3 +24,3 @@ ## Install

const { rootNodes, errors } = ngHtmlParser.parse('<div>hello world</div>');
const {rootNodes, errors} = ngHtmlParser.parse('<div>hello world</div>');
```

@@ -42,3 +41,3 @@

/**
* support [`htm`](https://github.com/developit/htm) component closing tags (`<//>`)
* support [`htm`](https://github.com/developit/htm) component closing tags (`<//>`)
*

@@ -59,3 +58,8 @@ * defaults to false

*/
getTagContentType?: (tagName: string, prefix: string, hasParent: boolean) => void | ng.TagContentType,
getTagContentType?: (
tagName: string,
prefix: string,
hasParent: boolean,
attrs: Array<{prefix: string; name: string; value?: string | undefined}>
) => void | ng.TagContentType;
}

@@ -72,4 +76,5 @@ ```

- support [bogus comments](https://www.w3.org/TR/html5/syntax.html#bogus-comment-state) (`<!...>`, `<?...>`)
- support full [named entities](https://html.spec.whatwg.org/multipage/entities.json)
- ~~support full [named entities](https://html.spec.whatwg.org/multipage/entities.json)~~ (fixed upstream)
- add `type` property to nodes
- value span for attributes includes quotes

@@ -76,0 +81,0 @@ ## Development

CHANGELOG.md
lib/compiler/src/aot/static_symbol.d.ts
lib/compiler/src/aot/static_symbol.js
lib/compiler/src/ast_path.d.ts
lib/compiler/src/ast_path.js
lib/compiler/src/compile_metadata.d.ts
lib/compiler/src/compile_metadata.js
lib/compiler/src/compile_reflector.d.ts
lib/compiler/src/compile_reflector.js
lib/compiler/src/constant_pool.d.ts
lib/compiler/src/constant_pool.js
lib/compiler/src/core.d.ts
lib/compiler/src/core.js
lib/compiler/src/lifecycle_reflector.d.ts
lib/compiler/src/lifecycle_reflector.js
lib/compiler/src/output/output_ast.d.ts
lib/compiler/src/output/output_ast.js
lib/compiler/src/selector.d.ts
lib/compiler/src/selector.js
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc