@angular-eslint/bundled-angular-compiler
Version:
A CJS bundled version of @angular/compiler
1,475 lines (1,473 loc) • 1.06 MB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
AST: () => AST,
ASTWithName: () => ASTWithName,
ASTWithSource: () => ASTWithSource,
AbsoluteSourceSpan: () => AbsoluteSourceSpan,
ArrayType: () => ArrayType,
ArrowFunctionExpr: () => ArrowFunctionExpr,
Attribute: () => Attribute,
Binary: () => Binary,
BinaryOperator: () => BinaryOperator,
BinaryOperatorExpr: () => BinaryOperatorExpr,
BindingPipe: () => BindingPipe,
BindingType: () => BindingType,
Block: () => Block,
BlockParameter: () => BlockParameter,
BoundElementProperty: () => BoundElementProperty,
BuiltinType: () => BuiltinType,
BuiltinTypeName: () => BuiltinTypeName,
CUSTOM_ELEMENTS_SCHEMA: () => CUSTOM_ELEMENTS_SCHEMA,
Call: () => Call,
Chain: () => Chain,
ChangeDetectionStrategy: () => ChangeDetectionStrategy,
CommaExpr: () => CommaExpr,
Comment: () => Comment,
CompilerConfig: () => CompilerConfig,
Conditional: () => Conditional,
ConditionalExpr: () => ConditionalExpr,
ConstantPool: () => ConstantPool,
CssSelector: () => CssSelector,
DEFAULT_INTERPOLATION_CONFIG: () => DEFAULT_INTERPOLATION_CONFIG,
DYNAMIC_TYPE: () => DYNAMIC_TYPE,
DeclareFunctionStmt: () => DeclareFunctionStmt,
DeclareVarStmt: () => DeclareVarStmt,
DomElementSchemaRegistry: () => DomElementSchemaRegistry,
DynamicImportExpr: () => DynamicImportExpr,
EOF: () => EOF,
Element: () => Element,
ElementSchemaRegistry: () => ElementSchemaRegistry,
EmitterVisitorContext: () => EmitterVisitorContext,
EmptyExpr: () => EmptyExpr$1,
Expansion: () => Expansion,
ExpansionCase: () => ExpansionCase,
Expression: () => Expression,
ExpressionBinding: () => ExpressionBinding,
ExpressionStatement: () => ExpressionStatement,
ExpressionType: () => ExpressionType,
ExternalExpr: () => ExternalExpr,
ExternalReference: () => ExternalReference,
FactoryTarget: () => FactoryTarget$1,
FunctionExpr: () => FunctionExpr,
HtmlParser: () => HtmlParser,
HtmlTagDefinition: () => HtmlTagDefinition,
I18NHtmlParser: () => I18NHtmlParser,
IfStmt: () => IfStmt,
ImplicitReceiver: () => ImplicitReceiver,
InstantiateExpr: () => InstantiateExpr,
Interpolation: () => Interpolation$1,
InterpolationConfig: () => InterpolationConfig,
InvokeFunctionExpr: () => InvokeFunctionExpr,
JSDocComment: () => JSDocComment,
JitEvaluator: () => JitEvaluator,
KeyedRead: () => KeyedRead,
KeyedWrite: () => KeyedWrite,
LeadingComment: () => LeadingComment,
LetDeclaration: () => LetDeclaration,
Lexer: () => Lexer,
LiteralArray: () => LiteralArray,
LiteralArrayExpr: () => LiteralArrayExpr,
LiteralExpr: () => LiteralExpr,
LiteralMap: () => LiteralMap,
LiteralMapExpr: () => LiteralMapExpr,
LiteralPrimitive: () => LiteralPrimitive,
LocalizedString: () => LocalizedString,
MapType: () => MapType,
MessageBundle: () => MessageBundle,
NONE_TYPE: () => NONE_TYPE,
NO_ERRORS_SCHEMA: () => NO_ERRORS_SCHEMA,
NodeWithI18n: () => NodeWithI18n,
NonNullAssert: () => NonNullAssert,
NotExpr: () => NotExpr,
ParseError: () => ParseError,
ParseErrorLevel: () => ParseErrorLevel,
ParseLocation: () => ParseLocation,
ParseSourceFile: () => ParseSourceFile,
ParseSourceSpan: () => ParseSourceSpan,
ParseSpan: () => ParseSpan,
ParseTreeResult: () => ParseTreeResult,
ParsedEvent: () => ParsedEvent,
ParsedEventType: () => ParsedEventType,
ParsedProperty: () => ParsedProperty,
ParsedPropertyType: () => ParsedPropertyType,
ParsedVariable: () => ParsedVariable,
Parser: () => Parser,
ParserError: () => ParserError,
PrefixNot: () => PrefixNot,
PropertyRead: () => PropertyRead,
PropertyWrite: () => PropertyWrite,
R3BoundTarget: () => R3BoundTarget,
R3Identifiers: () => Identifiers,
R3NgModuleMetadataKind: () => R3NgModuleMetadataKind,
R3SelectorScopeMode: () => R3SelectorScopeMode,
R3TargetBinder: () => R3TargetBinder,
R3TemplateDependencyKind: () => R3TemplateDependencyKind,
ReadKeyExpr: () => ReadKeyExpr,
ReadPropExpr: () => ReadPropExpr,
ReadVarExpr: () => ReadVarExpr,
RecursiveAstVisitor: () => RecursiveAstVisitor,
RecursiveVisitor: () => RecursiveVisitor,
ResourceLoader: () => ResourceLoader,
ReturnStatement: () => ReturnStatement,
STRING_TYPE: () => STRING_TYPE,
SafeCall: () => SafeCall,
SafeKeyedRead: () => SafeKeyedRead,
SafePropertyRead: () => SafePropertyRead,
SelectorContext: () => SelectorContext,
SelectorListContext: () => SelectorListContext,
SelectorMatcher: () => SelectorMatcher,
Serializer: () => Serializer,
SplitInterpolation: () => SplitInterpolation,
Statement: () => Statement,
StmtModifier: () => StmtModifier,
StringToken: () => StringToken,
StringTokenKind: () => StringTokenKind,
TagContentType: () => TagContentType,
TaggedTemplateLiteralExpr: () => TaggedTemplateLiteralExpr,
TemplateBindingParseResult: () => TemplateBindingParseResult,
TemplateLiteral: () => TemplateLiteral,
TemplateLiteralElement: () => TemplateLiteralElement,
TemplateLiteralElementExpr: () => TemplateLiteralElementExpr,
TemplateLiteralExpr: () => TemplateLiteralExpr,
Text: () => Text,
ThisReceiver: () => ThisReceiver,
TmplAstBlockNode: () => BlockNode,
TmplAstBoundAttribute: () => BoundAttribute,
TmplAstBoundDeferredTrigger: () => BoundDeferredTrigger,
TmplAstBoundEvent: () => BoundEvent,
TmplAstBoundText: () => BoundText,
TmplAstContent: () => Content,
TmplAstDeferredBlock: () => DeferredBlock,
TmplAstDeferredBlockError: () => DeferredBlockError,
TmplAstDeferredBlockLoading: () => DeferredBlockLoading,
TmplAstDeferredBlockPlaceholder: () => DeferredBlockPlaceholder,
TmplAstDeferredTrigger: () => DeferredTrigger,
TmplAstElement: () => Element$1,
TmplAstForLoopBlock: () => ForLoopBlock,
TmplAstForLoopBlockEmpty: () => ForLoopBlockEmpty,
TmplAstHoverDeferredTrigger: () => HoverDeferredTrigger,
TmplAstIcu: () => Icu$1,
TmplAstIdleDeferredTrigger: () => IdleDeferredTrigger,
TmplAstIfBlock: () => IfBlock,
TmplAstIfBlockBranch: () => IfBlockBranch,
TmplAstImmediateDeferredTrigger: () => ImmediateDeferredTrigger,
TmplAstInteractionDeferredTrigger: () => InteractionDeferredTrigger,
TmplAstLetDeclaration: () => LetDeclaration$1,
TmplAstNeverDeferredTrigger: () => NeverDeferredTrigger,
TmplAstRecursiveVisitor: () => RecursiveVisitor$1,
TmplAstReference: () => Reference,
TmplAstSwitchBlock: () => SwitchBlock,
TmplAstSwitchBlockCase: () => SwitchBlockCase,
TmplAstTemplate: () => Template,
TmplAstText: () => Text$3,
TmplAstTextAttribute: () => TextAttribute,
TmplAstTimerDeferredTrigger: () => TimerDeferredTrigger,
TmplAstUnknownBlock: () => UnknownBlock,
TmplAstVariable: () => Variable,
TmplAstViewportDeferredTrigger: () => ViewportDeferredTrigger,
Token: () => Token,
TokenType: () => TokenType,
TransplantedType: () => TransplantedType,
TreeError: () => TreeError,
Type: () => Type,
TypeModifier: () => TypeModifier,
TypeofExpr: () => TypeofExpr,
TypeofExpression: () => TypeofExpression,
Unary: () => Unary,
UnaryOperator: () => UnaryOperator,
UnaryOperatorExpr: () => UnaryOperatorExpr,
VERSION: () => VERSION,
VariableBinding: () => VariableBinding,
Version: () => Version,
ViewEncapsulation: () => ViewEncapsulation,
WrappedNodeExpr: () => WrappedNodeExpr,
WriteKeyExpr: () => WriteKeyExpr,
WritePropExpr: () => WritePropExpr,
WriteVarExpr: () => WriteVarExpr,
Xliff: () => Xliff,
Xliff2: () => Xliff2,
Xmb: () => Xmb,
XmlParser: () => XmlParser,
Xtb: () => Xtb,
compileClassDebugInfo: () => compileClassDebugInfo,
compileClassMetadata: () => compileClassMetadata,
compileComponentClassMetadata: () => compileComponentClassMetadata,
compileComponentDeclareClassMetadata: () => compileComponentDeclareClassMetadata,
compileComponentFromMetadata: () => compileComponentFromMetadata,
compileDeclareClassMetadata: () => compileDeclareClassMetadata,
compileDeclareComponentFromMetadata: () => compileDeclareComponentFromMetadata,
compileDeclareDirectiveFromMetadata: () => compileDeclareDirectiveFromMetadata,
compileDeclareFactoryFunction: () => compileDeclareFactoryFunction,
compileDeclareInjectableFromMetadata: () => compileDeclareInjectableFromMetadata,
compileDeclareInjectorFromMetadata: () => compileDeclareInjectorFromMetadata,
compileDeclareNgModuleFromMetadata: () => compileDeclareNgModuleFromMetadata,
compileDeclarePipeFromMetadata: () => compileDeclarePipeFromMetadata,
compileDeferResolverFunction: () => compileDeferResolverFunction,
compileDirectiveFromMetadata: () => compileDirectiveFromMetadata,
compileFactoryFunction: () => compileFactoryFunction,
compileHmrInitializer: () => compileHmrInitializer,
compileHmrUpdateCallback: () => compileHmrUpdateCallback,
compileInjectable: () => compileInjectable,
compileInjector: () => compileInjector,
compileNgModule: () => compileNgModule,
compileOpaqueAsyncClassMetadata: () => compileOpaqueAsyncClassMetadata,
compilePipeFromMetadata: () => compilePipeFromMetadata,
computeMsgId: () => computeMsgId,
core: () => core,
createCssSelectorFromNode: () => createCssSelectorFromNode,
createInjectableType: () => createInjectableType,
createMayBeForwardRefExpression: () => createMayBeForwardRefExpression,
devOnlyGuardedExpression: () => devOnlyGuardedExpression,
emitDistinctChangesOnlyDefaultValue: () => emitDistinctChangesOnlyDefaultValue,
encapsulateStyle: () => encapsulateStyle,
findMatchingDirectivesAndPipes: () => findMatchingDirectivesAndPipes,
getHtmlTagDefinition: () => getHtmlTagDefinition,
getNsPrefix: () => getNsPrefix,
getSafePropertyAccessString: () => getSafePropertyAccessString,
identifierName: () => identifierName,
isNgContainer: () => isNgContainer,
isNgContent: () => isNgContent,
isNgTemplate: () => isNgTemplate,
jsDocComment: () => jsDocComment,
leadingComment: () => leadingComment,
literal: () => literal,
literalMap: () => literalMap,
makeBindingParser: () => makeBindingParser,
mergeNsAndName: () => mergeNsAndName,
outputAst: () => output_ast,
parseHostBindings: () => parseHostBindings,
parseTemplate: () => parseTemplate,
preserveWhitespacesDefault: () => preserveWhitespacesDefault,
publishFacade: () => publishFacade,
r3JitTypeSourceSpan: () => r3JitTypeSourceSpan,
sanitizeIdentifier: () => sanitizeIdentifier,
splitNsName: () => splitNsName,
tmplAstVisitAll: () => visitAll$1,
verifyHostBindings: () => verifyHostBindings,
visitAll: () => visitAll
});
module.exports = __toCommonJS(index_exports);
// ../../node_modules/.pnpm/@angular+compiler@19.2.1/node_modules/@angular/compiler/fesm2022/compiler.mjs
var _SELECTOR_REGEXP = new RegExp(
`(\\:not\\()|(([\\.\\#]?)[-\\w]+)|(?:\\[([-.\\w*\\\\$]+)(?:=(["']?)([^\\]"']*)\\5)?\\])|(\\))|(\\s*,\\s*)`,
// 8: ","
"g"
);
var CssSelector = class _CssSelector {
static {
__name(this, "CssSelector");
}
element = null;
classNames = [];
/**
* The selectors are encoded in pairs where:
* - even locations are attribute names
* - odd locations are attribute values.
*
* Example:
* Selector: `[key1=value1][key2]` would parse to:
* ```
* ['key1', 'value1', 'key2', '']
* ```
*/
attrs = [];
notSelectors = [];
static parse(selector) {
const results = [];
const _addResult = /* @__PURE__ */ __name((res, cssSel) => {
if (cssSel.notSelectors.length > 0 && !cssSel.element && cssSel.classNames.length == 0 && cssSel.attrs.length == 0) {
cssSel.element = "*";
}
res.push(cssSel);
}, "_addResult");
let cssSelector = new _CssSelector();
let match;
let current = cssSelector;
let inNot = false;
_SELECTOR_REGEXP.lastIndex = 0;
while (match = _SELECTOR_REGEXP.exec(selector)) {
if (match[
1
/* SelectorRegexp.NOT */
]) {
if (inNot) {
throw new Error("Nesting :not in a selector is not allowed");
}
inNot = true;
current = new _CssSelector();
cssSelector.notSelectors.push(current);
}
const tag = match[
2
/* SelectorRegexp.TAG */
];
if (tag) {
const prefix = match[
3
/* SelectorRegexp.PREFIX */
];
if (prefix === "#") {
current.addAttribute("id", tag.slice(1));
} else if (prefix === ".") {
current.addClassName(tag.slice(1));
} else {
current.setElement(tag);
}
}
const attribute2 = match[
4
/* SelectorRegexp.ATTRIBUTE */
];
if (attribute2) {
current.addAttribute(current.unescapeAttribute(attribute2), match[
6
/* SelectorRegexp.ATTRIBUTE_VALUE */
]);
}
if (match[
7
/* SelectorRegexp.NOT_END */
]) {
inNot = false;
current = cssSelector;
}
if (match[
8
/* SelectorRegexp.SEPARATOR */
]) {
if (inNot) {
throw new Error("Multiple selectors in :not are not supported");
}
_addResult(results, cssSelector);
cssSelector = current = new _CssSelector();
}
}
_addResult(results, cssSelector);
return results;
}
/**
* Unescape `\$` sequences from the CSS attribute selector.
*
* This is needed because `$` can have a special meaning in CSS selectors,
* but we might want to match an attribute that contains `$`.
* [MDN web link for more
* info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors).
* @param attr the attribute to unescape.
* @returns the unescaped string.
*/
unescapeAttribute(attr) {
let result = "";
let escaping = false;
for (let i = 0; i < attr.length; i++) {
const char = attr.charAt(i);
if (char === "\\") {
escaping = true;
continue;
}
if (char === "$" && !escaping) {
throw new Error(`Error in attribute selector "${attr}". Unescaped "$" is not supported. Please escape with "\\$".`);
}
escaping = false;
result += char;
}
return result;
}
/**
* Escape `$` sequences from the CSS attribute selector.
*
* This is needed because `$` can have a special meaning in CSS selectors,
* with this method we are escaping `$` with `\$'.
* [MDN web link for more
* info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors).
* @param attr the attribute to escape.
* @returns the escaped string.
*/
escapeAttribute(attr) {
return attr.replace(/\\/g, "\\\\").replace(/\$/g, "\\$");
}
isElementSelector() {
return this.hasElementSelector() && this.classNames.length == 0 && this.attrs.length == 0 && this.notSelectors.length === 0;
}
hasElementSelector() {
return !!this.element;
}
setElement(element2 = null) {
this.element = element2;
}
getAttrs() {
const result = [];
if (this.classNames.length > 0) {
result.push("class", this.classNames.join(" "));
}
return result.concat(this.attrs);
}
addAttribute(name, value = "") {
this.attrs.push(name, value && value.toLowerCase() || "");
}
addClassName(name) {
this.classNames.push(name.toLowerCase());
}
toString() {
let res = this.element || "";
if (this.classNames) {
this.classNames.forEach((klass) => res += `.${klass}`);
}
if (this.attrs) {
for (let i = 0; i < this.attrs.length; i += 2) {
const name = this.escapeAttribute(this.attrs[i]);
const value = this.attrs[i + 1];
res += `[${name}${value ? "=" + value : ""}]`;
}
}
this.notSelectors.forEach((notSelector) => res += `:not(${notSelector})`);
return res;
}
};
var SelectorMatcher = class _SelectorMatcher {
static {
__name(this, "SelectorMatcher");
}
static createNotMatcher(notSelectors) {
const notMatcher = new _SelectorMatcher();
notMatcher.addSelectables(notSelectors, null);
return notMatcher;
}
_elementMap = /* @__PURE__ */ new Map();
_elementPartialMap = /* @__PURE__ */ new Map();
_classMap = /* @__PURE__ */ new Map();
_classPartialMap = /* @__PURE__ */ new Map();
_attrValueMap = /* @__PURE__ */ new Map();
_attrValuePartialMap = /* @__PURE__ */ new Map();
_listContexts = [];
addSelectables(cssSelectors, callbackCtxt) {
let listContext = null;
if (cssSelectors.length > 1) {
listContext = new SelectorListContext(cssSelectors);
this._listContexts.push(listContext);
}
for (let i = 0; i < cssSelectors.length; i++) {
this._addSelectable(cssSelectors[i], callbackCtxt, listContext);
}
}
/**
* Add an object that can be found later on by calling `match`.
* @param cssSelector A css selector
* @param callbackCtxt An opaque object that will be given to the callback of the `match` function
*/
_addSelectable(cssSelector, callbackCtxt, listContext) {
let matcher = this;
const element2 = cssSelector.element;
const classNames = cssSelector.classNames;
const attrs = cssSelector.attrs;
const selectable = new SelectorContext(cssSelector, callbackCtxt, listContext);
if (element2) {
const isTerminal = attrs.length === 0 && classNames.length === 0;
if (isTerminal) {
this._addTerminal(matcher._elementMap, element2, selectable);
} else {
matcher = this._addPartial(matcher._elementPartialMap, element2);
}
}
if (classNames) {
for (let i = 0; i < classNames.length; i++) {
const isTerminal = attrs.length === 0 && i === classNames.length - 1;
const className = classNames[i];
if (isTerminal) {
this._addTerminal(matcher._classMap, className, selectable);
} else {
matcher = this._addPartial(matcher._classPartialMap, className);
}
}
}
if (attrs) {
for (let i = 0; i < attrs.length; i += 2) {
const isTerminal = i === attrs.length - 2;
const name = attrs[i];
const value = attrs[i + 1];
if (isTerminal) {
const terminalMap = matcher._attrValueMap;
let terminalValuesMap = terminalMap.get(name);
if (!terminalValuesMap) {
terminalValuesMap = /* @__PURE__ */ new Map();
terminalMap.set(name, terminalValuesMap);
}
this._addTerminal(terminalValuesMap, value, selectable);
} else {
const partialMap = matcher._attrValuePartialMap;
let partialValuesMap = partialMap.get(name);
if (!partialValuesMap) {
partialValuesMap = /* @__PURE__ */ new Map();
partialMap.set(name, partialValuesMap);
}
matcher = this._addPartial(partialValuesMap, value);
}
}
}
}
_addTerminal(map, name, selectable) {
let terminalList = map.get(name);
if (!terminalList) {
terminalList = [];
map.set(name, terminalList);
}
terminalList.push(selectable);
}
_addPartial(map, name) {
let matcher = map.get(name);
if (!matcher) {
matcher = new _SelectorMatcher();
map.set(name, matcher);
}
return matcher;
}
/**
* Find the objects that have been added via `addSelectable`
* whose css selector is contained in the given css selector.
* @param cssSelector A css selector
* @param matchedCallback This callback will be called with the object handed into `addSelectable`
* @return boolean true if a match was found
*/
match(cssSelector, matchedCallback) {
let result = false;
const element2 = cssSelector.element;
const classNames = cssSelector.classNames;
const attrs = cssSelector.attrs;
for (let i = 0; i < this._listContexts.length; i++) {
this._listContexts[i].alreadyMatched = false;
}
result = this._matchTerminal(this._elementMap, element2, cssSelector, matchedCallback) || result;
result = this._matchPartial(this._elementPartialMap, element2, cssSelector, matchedCallback) || result;
if (classNames) {
for (let i = 0; i < classNames.length; i++) {
const className = classNames[i];
result = this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result;
result = this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) || result;
}
}
if (attrs) {
for (let i = 0; i < attrs.length; i += 2) {
const name = attrs[i];
const value = attrs[i + 1];
const terminalValuesMap = this._attrValueMap.get(name);
if (value) {
result = this._matchTerminal(terminalValuesMap, "", cssSelector, matchedCallback) || result;
}
result = this._matchTerminal(terminalValuesMap, value, cssSelector, matchedCallback) || result;
const partialValuesMap = this._attrValuePartialMap.get(name);
if (value) {
result = this._matchPartial(partialValuesMap, "", cssSelector, matchedCallback) || result;
}
result = this._matchPartial(partialValuesMap, value, cssSelector, matchedCallback) || result;
}
}
return result;
}
/** @internal */
_matchTerminal(map, name, cssSelector, matchedCallback) {
if (!map || typeof name !== "string") {
return false;
}
let selectables = map.get(name) || [];
const starSelectables = map.get("*");
if (starSelectables) {
selectables = selectables.concat(starSelectables);
}
if (selectables.length === 0) {
return false;
}
let selectable;
let result = false;
for (let i = 0; i < selectables.length; i++) {
selectable = selectables[i];
result = selectable.finalize(cssSelector, matchedCallback) || result;
}
return result;
}
/** @internal */
_matchPartial(map, name, cssSelector, matchedCallback) {
if (!map || typeof name !== "string") {
return false;
}
const nestedSelector = map.get(name);
if (!nestedSelector) {
return false;
}
return nestedSelector.match(cssSelector, matchedCallback);
}
};
var SelectorListContext = class {
static {
__name(this, "SelectorListContext");
}
selectors;
alreadyMatched = false;
constructor(selectors) {
this.selectors = selectors;
}
};
var SelectorContext = class {
static {
__name(this, "SelectorContext");
}
selector;
cbContext;
listContext;
notSelectors;
constructor(selector, cbContext, listContext) {
this.selector = selector;
this.cbContext = cbContext;
this.listContext = listContext;
this.notSelectors = selector.notSelectors;
}
finalize(cssSelector, callback) {
let result = true;
if (this.notSelectors.length > 0 && (!this.listContext || !this.listContext.alreadyMatched)) {
const notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors);
result = !notMatcher.match(cssSelector, null);
}
if (result && callback && (!this.listContext || !this.listContext.alreadyMatched)) {
if (this.listContext) {
this.listContext.alreadyMatched = true;
}
callback(this.selector, this.cbContext);
}
return result;
}
};
var emitDistinctChangesOnlyDefaultValue = true;
var ViewEncapsulation;
(function(ViewEncapsulation2) {
ViewEncapsulation2[ViewEncapsulation2["Emulated"] = 0] = "Emulated";
ViewEncapsulation2[ViewEncapsulation2["None"] = 2] = "None";
ViewEncapsulation2[ViewEncapsulation2["ShadowDom"] = 3] = "ShadowDom";
})(ViewEncapsulation || (ViewEncapsulation = {}));
var ChangeDetectionStrategy;
(function(ChangeDetectionStrategy2) {
ChangeDetectionStrategy2[ChangeDetectionStrategy2["OnPush"] = 0] = "OnPush";
ChangeDetectionStrategy2[ChangeDetectionStrategy2["Default"] = 1] = "Default";
})(ChangeDetectionStrategy || (ChangeDetectionStrategy = {}));
var InputFlags;
(function(InputFlags2) {
InputFlags2[InputFlags2["None"] = 0] = "None";
InputFlags2[InputFlags2["SignalBased"] = 1] = "SignalBased";
InputFlags2[InputFlags2["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
})(InputFlags || (InputFlags = {}));
var CUSTOM_ELEMENTS_SCHEMA = {
name: "custom-elements"
};
var NO_ERRORS_SCHEMA = {
name: "no-errors-schema"
};
var Type$1 = Function;
var SecurityContext;
(function(SecurityContext2) {
SecurityContext2[SecurityContext2["NONE"] = 0] = "NONE";
SecurityContext2[SecurityContext2["HTML"] = 1] = "HTML";
SecurityContext2[SecurityContext2["STYLE"] = 2] = "STYLE";
SecurityContext2[SecurityContext2["SCRIPT"] = 3] = "SCRIPT";
SecurityContext2[SecurityContext2["URL"] = 4] = "URL";
SecurityContext2[SecurityContext2["RESOURCE_URL"] = 5] = "RESOURCE_URL";
})(SecurityContext || (SecurityContext = {}));
var MissingTranslationStrategy;
(function(MissingTranslationStrategy2) {
MissingTranslationStrategy2[MissingTranslationStrategy2["Error"] = 0] = "Error";
MissingTranslationStrategy2[MissingTranslationStrategy2["Warning"] = 1] = "Warning";
MissingTranslationStrategy2[MissingTranslationStrategy2["Ignore"] = 2] = "Ignore";
})(MissingTranslationStrategy || (MissingTranslationStrategy = {}));
function parserSelectorToSimpleSelector(selector) {
const classes = selector.classNames && selector.classNames.length ? [8, ...selector.classNames] : [];
const elementName = selector.element && selector.element !== "*" ? selector.element : "";
return [elementName, ...selector.attrs, ...classes];
}
__name(parserSelectorToSimpleSelector, "parserSelectorToSimpleSelector");
function parserSelectorToNegativeSelector(selector) {
const classes = selector.classNames && selector.classNames.length ? [8, ...selector.classNames] : [];
if (selector.element) {
return [
1 | 4,
selector.element,
...selector.attrs,
...classes
];
} else if (selector.attrs.length) {
return [1 | 2, ...selector.attrs, ...classes];
} else {
return selector.classNames && selector.classNames.length ? [1 | 8, ...selector.classNames] : [];
}
}
__name(parserSelectorToNegativeSelector, "parserSelectorToNegativeSelector");
function parserSelectorToR3Selector(selector) {
const positive = parserSelectorToSimpleSelector(selector);
const negative = selector.notSelectors && selector.notSelectors.length ? selector.notSelectors.map((notSelector) => parserSelectorToNegativeSelector(notSelector)) : [];
return positive.concat(...negative);
}
__name(parserSelectorToR3Selector, "parserSelectorToR3Selector");
function parseSelectorToR3Selector(selector) {
return selector ? CssSelector.parse(selector).map(parserSelectorToR3Selector) : [];
}
__name(parseSelectorToR3Selector, "parseSelectorToR3Selector");
var core = /* @__PURE__ */ Object.freeze({
__proto__: null,
emitDistinctChangesOnlyDefaultValue,
get ViewEncapsulation() {
return ViewEncapsulation;
},
get ChangeDetectionStrategy() {
return ChangeDetectionStrategy;
},
get InputFlags() {
return InputFlags;
},
CUSTOM_ELEMENTS_SCHEMA,
NO_ERRORS_SCHEMA,
Type: Type$1,
get SecurityContext() {
return SecurityContext;
},
get MissingTranslationStrategy() {
return MissingTranslationStrategy;
},
parseSelectorToR3Selector
});
var textEncoder;
function digest$1(message) {
return message.id || computeDigest(message);
}
__name(digest$1, "digest$1");
function computeDigest(message) {
return sha1(serializeNodes(message.nodes).join("") + `[${message.meaning}]`);
}
__name(computeDigest, "computeDigest");
function decimalDigest(message) {
return message.id || computeDecimalDigest(message);
}
__name(decimalDigest, "decimalDigest");
function computeDecimalDigest(message) {
const visitor = new _SerializerIgnoreIcuExpVisitor();
const parts = message.nodes.map((a) => a.visit(visitor, null));
return computeMsgId(parts.join(""), message.meaning);
}
__name(computeDecimalDigest, "computeDecimalDigest");
var _SerializerVisitor = class {
static {
__name(this, "_SerializerVisitor");
}
visitText(text2, context) {
return text2.value;
}
visitContainer(container, context) {
return `[${container.children.map((child) => child.visit(this)).join(", ")}]`;
}
visitIcu(icu, context) {
const strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
return `{${icu.expression}, ${icu.type}, ${strCases.join(", ")}}`;
}
visitTagPlaceholder(ph, context) {
return ph.isVoid ? `<ph tag name="${ph.startName}"/>` : `<ph tag name="${ph.startName}">${ph.children.map((child) => child.visit(this)).join(", ")}</ph name="${ph.closeName}">`;
}
visitPlaceholder(ph, context) {
return ph.value ? `<ph name="${ph.name}">${ph.value}</ph>` : `<ph name="${ph.name}"/>`;
}
visitIcuPlaceholder(ph, context) {
return `<ph icu name="${ph.name}">${ph.value.visit(this)}</ph>`;
}
visitBlockPlaceholder(ph, context) {
return `<ph block name="${ph.startName}">${ph.children.map((child) => child.visit(this)).join(", ")}</ph name="${ph.closeName}">`;
}
};
var serializerVisitor$1 = new _SerializerVisitor();
function serializeNodes(nodes) {
return nodes.map((a) => a.visit(serializerVisitor$1, null));
}
__name(serializeNodes, "serializeNodes");
var _SerializerIgnoreIcuExpVisitor = class extends _SerializerVisitor {
static {
__name(this, "_SerializerIgnoreIcuExpVisitor");
}
visitIcu(icu) {
let strCases = Object.keys(icu.cases).map((k) => `${k} {${icu.cases[k].visit(this)}}`);
return `{${icu.type}, ${strCases.join(", ")}}`;
}
};
function sha1(str) {
textEncoder ??= new TextEncoder();
const utf8 = [...textEncoder.encode(str)];
const words32 = bytesToWords32(utf8, Endian.Big);
const len = utf8.length * 8;
const w = new Uint32Array(80);
let a = 1732584193, b = 4023233417, c = 2562383102, d = 271733878, e = 3285377520;
words32[len >> 5] |= 128 << 24 - len % 32;
words32[(len + 64 >> 9 << 4) + 15] = len;
for (let i = 0; i < words32.length; i += 16) {
const h0 = a, h1 = b, h2 = c, h3 = d, h4 = e;
for (let j = 0; j < 80; j++) {
if (j < 16) {
w[j] = words32[i + j];
} else {
w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
}
const fkVal = fk(j, b, c, d);
const f = fkVal[0];
const k = fkVal[1];
const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);
e = d;
d = c;
c = rol32(b, 30);
b = a;
a = temp;
}
a = add32(a, h0);
b = add32(b, h1);
c = add32(c, h2);
d = add32(d, h3);
e = add32(e, h4);
}
return toHexU32(a) + toHexU32(b) + toHexU32(c) + toHexU32(d) + toHexU32(e);
}
__name(sha1, "sha1");
function toHexU32(value) {
return (value >>> 0).toString(16).padStart(8, "0");
}
__name(toHexU32, "toHexU32");
function fk(index, b, c, d) {
if (index < 20) {
return [b & c | ~b & d, 1518500249];
}
if (index < 40) {
return [b ^ c ^ d, 1859775393];
}
if (index < 60) {
return [b & c | b & d | c & d, 2400959708];
}
return [b ^ c ^ d, 3395469782];
}
__name(fk, "fk");
function fingerprint(str) {
textEncoder ??= new TextEncoder();
const utf8 = textEncoder.encode(str);
const view = new DataView(utf8.buffer, utf8.byteOffset, utf8.byteLength);
let hi = hash32(view, utf8.length, 0);
let lo = hash32(view, utf8.length, 102072);
if (hi == 0 && (lo == 0 || lo == 1)) {
hi = hi ^ 319790063;
lo = lo ^ -1801410264;
}
return BigInt.asUintN(32, BigInt(hi)) << BigInt(32) | BigInt.asUintN(32, BigInt(lo));
}
__name(fingerprint, "fingerprint");
function computeMsgId(msg, meaning = "") {
let msgFingerprint = fingerprint(msg);
if (meaning) {
msgFingerprint = BigInt.asUintN(64, msgFingerprint << BigInt(1)) | msgFingerprint >> BigInt(63) & BigInt(1);
msgFingerprint += fingerprint(meaning);
}
return BigInt.asUintN(63, msgFingerprint).toString();
}
__name(computeMsgId, "computeMsgId");
function hash32(view, length, c) {
let a = 2654435769, b = 2654435769;
let index = 0;
const end = length - 12;
for (; index <= end; index += 12) {
a += view.getUint32(index, true);
b += view.getUint32(index + 4, true);
c += view.getUint32(index + 8, true);
const res = mix(a, b, c);
a = res[0], b = res[1], c = res[2];
}
const remainder = length - index;
c += length;
if (remainder >= 4) {
a += view.getUint32(index, true);
index += 4;
if (remainder >= 8) {
b += view.getUint32(index, true);
index += 4;
if (remainder >= 9) {
c += view.getUint8(index++) << 8;
}
if (remainder >= 10) {
c += view.getUint8(index++) << 16;
}
if (remainder === 11) {
c += view.getUint8(index++) << 24;
}
} else {
if (remainder >= 5) {
b += view.getUint8(index++);
}
if (remainder >= 6) {
b += view.getUint8(index++) << 8;
}
if (remainder === 7) {
b += view.getUint8(index++) << 16;
}
}
} else {
if (remainder >= 1) {
a += view.getUint8(index++);
}
if (remainder >= 2) {
a += view.getUint8(index++) << 8;
}
if (remainder === 3) {
a += view.getUint8(index++) << 16;
}
}
return mix(a, b, c)[2];
}
__name(hash32, "hash32");
function mix(a, b, c) {
a -= b;
a -= c;
a ^= c >>> 13;
b -= c;
b -= a;
b ^= a << 8;
c -= a;
c -= b;
c ^= b >>> 13;
a -= b;
a -= c;
a ^= c >>> 12;
b -= c;
b -= a;
b ^= a << 16;
c -= a;
c -= b;
c ^= b >>> 5;
a -= b;
a -= c;
a ^= c >>> 3;
b -= c;
b -= a;
b ^= a << 10;
c -= a;
c -= b;
c ^= b >>> 15;
return [a, b, c];
}
__name(mix, "mix");
var Endian;
(function(Endian2) {
Endian2[Endian2["Little"] = 0] = "Little";
Endian2[Endian2["Big"] = 1] = "Big";
})(Endian || (Endian = {}));
function add32(a, b) {
return add32to64(a, b)[1];
}
__name(add32, "add32");
function add32to64(a, b) {
const low = (a & 65535) + (b & 65535);
const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
return [high >>> 16, high << 16 | low & 65535];
}
__name(add32to64, "add32to64");
function rol32(a, count) {
return a << count | a >>> 32 - count;
}
__name(rol32, "rol32");
function bytesToWords32(bytes, endian) {
const size = bytes.length + 3 >>> 2;
const words32 = [];
for (let i = 0; i < size; i++) {
words32[i] = wordAt(bytes, i * 4, endian);
}
return words32;
}
__name(bytesToWords32, "bytesToWords32");
function byteAt(bytes, index) {
return index >= bytes.length ? 0 : bytes[index];
}
__name(byteAt, "byteAt");
function wordAt(bytes, index, endian) {
let word = 0;
if (endian === Endian.Big) {
for (let i = 0; i < 4; i++) {
word += byteAt(bytes, index + i) << 24 - 8 * i;
}
} else {
for (let i = 0; i < 4; i++) {
word += byteAt(bytes, index + i) << 8 * i;
}
}
return word;
}
__name(wordAt, "wordAt");
var TypeModifier;
(function(TypeModifier2) {
TypeModifier2[TypeModifier2["None"] = 0] = "None";
TypeModifier2[TypeModifier2["Const"] = 1] = "Const";
})(TypeModifier || (TypeModifier = {}));
var Type = class {
static {
__name(this, "Type");
}
modifiers;
constructor(modifiers = TypeModifier.None) {
this.modifiers = modifiers;
}
hasModifier(modifier) {
return (this.modifiers & modifier) !== 0;
}
};
var BuiltinTypeName;
(function(BuiltinTypeName2) {
BuiltinTypeName2[BuiltinTypeName2["Dynamic"] = 0] = "Dynamic";
BuiltinTypeName2[BuiltinTypeName2["Bool"] = 1] = "Bool";
BuiltinTypeName2[BuiltinTypeName2["String"] = 2] = "String";
BuiltinTypeName2[BuiltinTypeName2["Int"] = 3] = "Int";
BuiltinTypeName2[BuiltinTypeName2["Number"] = 4] = "Number";
BuiltinTypeName2[BuiltinTypeName2["Function"] = 5] = "Function";
BuiltinTypeName2[BuiltinTypeName2["Inferred"] = 6] = "Inferred";
BuiltinTypeName2[BuiltinTypeName2["None"] = 7] = "None";
})(BuiltinTypeName || (BuiltinTypeName = {}));
var BuiltinType = class extends Type {
static {
__name(this, "BuiltinType");
}
name;
constructor(name, modifiers) {
super(modifiers);
this.name = name;
}
visitType(visitor, context) {
return visitor.visitBuiltinType(this, context);
}
};
var ExpressionType = class extends Type {
static {
__name(this, "ExpressionType");
}
value;
typeParams;
constructor(value, modifiers, typeParams = null) {
super(modifiers);
this.value = value;
this.typeParams = typeParams;
}
visitType(visitor, context) {
return visitor.visitExpressionType(this, context);
}
};
var ArrayType = class extends Type {
static {
__name(this, "ArrayType");
}
of;
constructor(of, modifiers) {
super(modifiers);
this.of = of;
}
visitType(visitor, context) {
return visitor.visitArrayType(this, context);
}
};
var MapType = class extends Type {
static {
__name(this, "MapType");
}
valueType;
constructor(valueType, modifiers) {
super(modifiers);
this.valueType = valueType || null;
}
visitType(visitor, context) {
return visitor.visitMapType(this, context);
}
};
var TransplantedType = class extends Type {
static {
__name(this, "TransplantedType");
}
type;
constructor(type, modifiers) {
super(modifiers);
this.type = type;
}
visitType(visitor, context) {
return visitor.visitTransplantedType(this, context);
}
};
var DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);
var INFERRED_TYPE = new BuiltinType(BuiltinTypeName.Inferred);
var BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);
var INT_TYPE = new BuiltinType(BuiltinTypeName.Int);
var NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);
var STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
var FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);
var NONE_TYPE = new BuiltinType(BuiltinTypeName.None);
var UnaryOperator;
(function(UnaryOperator2) {
UnaryOperator2[UnaryOperator2["Minus"] = 0] = "Minus";
UnaryOperator2[UnaryOperator2["Plus"] = 1] = "Plus";
})(UnaryOperator || (UnaryOperator = {}));
var BinaryOperator;
(function(BinaryOperator2) {
BinaryOperator2[BinaryOperator2["Equals"] = 0] = "Equals";
BinaryOperator2[BinaryOperator2["NotEquals"] = 1] = "NotEquals";
BinaryOperator2[BinaryOperator2["Identical"] = 2] = "Identical";
BinaryOperator2[BinaryOperator2["NotIdentical"] = 3] = "NotIdentical";
BinaryOperator2[BinaryOperator2["Minus"] = 4] = "Minus";
BinaryOperator2[BinaryOperator2["Plus"] = 5] = "Plus";
BinaryOperator2[BinaryOperator2["Divide"] = 6] = "Divide";
BinaryOperator2[BinaryOperator2["Multiply"] = 7] = "Multiply";
BinaryOperator2[BinaryOperator2["Modulo"] = 8] = "Modulo";
BinaryOperator2[BinaryOperator2["And"] = 9] = "And";
BinaryOperator2[BinaryOperator2["Or"] = 10] = "Or";
BinaryOperator2[BinaryOperator2["BitwiseOr"] = 11] = "BitwiseOr";
BinaryOperator2[BinaryOperator2["BitwiseAnd"] = 12] = "BitwiseAnd";
BinaryOperator2[BinaryOperator2["Lower"] = 13] = "Lower";
BinaryOperator2[BinaryOperator2["LowerEquals"] = 14] = "LowerEquals";
BinaryOperator2[BinaryOperator2["Bigger"] = 15] = "Bigger";
BinaryOperator2[BinaryOperator2["BiggerEquals"] = 16] = "BiggerEquals";
BinaryOperator2[BinaryOperator2["NullishCoalesce"] = 17] = "NullishCoalesce";
})(BinaryOperator || (BinaryOperator = {}));
function nullSafeIsEquivalent(base, other) {
if (base == null || other == null) {
return base == other;
}
return base.isEquivalent(other);
}
__name(nullSafeIsEquivalent, "nullSafeIsEquivalent");
function areAllEquivalentPredicate(base, other, equivalentPredicate) {
const len = base.length;
if (len !== other.length) {
return false;
}
for (let i = 0; i < len; i++) {
if (!equivalentPredicate(base[i], other[i])) {
return false;
}
}
return true;
}
__name(areAllEquivalentPredicate, "areAllEquivalentPredicate");
function areAllEquivalent(base, other) {
return areAllEquivalentPredicate(base, other, (baseElement, otherElement) => baseElement.isEquivalent(otherElement));
}
__name(areAllEquivalent, "areAllEquivalent");
var Expression = class {
static {
__name(this, "Expression");
}
type;
sourceSpan;
constructor(type, sourceSpan) {
this.type = type || null;
this.sourceSpan = sourceSpan || null;
}
prop(name, sourceSpan) {
return new ReadPropExpr(this, name, null, sourceSpan);
}
key(index, type, sourceSpan) {
return new ReadKeyExpr(this, index, type, sourceSpan);
}
callFn(params, sourceSpan, pure) {
return new InvokeFunctionExpr(this, params, null, sourceSpan, pure);
}
instantiate(params, type, sourceSpan) {
return new InstantiateExpr(this, params, type, sourceSpan);
}
conditional(trueCase, falseCase = null, sourceSpan) {
return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan);
}
equals(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs, null, sourceSpan);
}
notEquals(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs, null, sourceSpan);
}
identical(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs, null, sourceSpan);
}
notIdentical(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs, null, sourceSpan);
}
minus(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs, null, sourceSpan);
}
plus(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs, null, sourceSpan);
}
divide(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs, null, sourceSpan);
}
multiply(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs, null, sourceSpan);
}
modulo(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs, null, sourceSpan);
}
and(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);
}
bitwiseOr(rhs, sourceSpan, parens = true) {
return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan, parens);
}
bitwiseAnd(rhs, sourceSpan, parens = true) {
return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);
}
or(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);
}
lower(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs, null, sourceSpan);
}
lowerEquals(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs, null, sourceSpan);
}
bigger(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs, null, sourceSpan);
}
biggerEquals(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan);
}
isBlank(sourceSpan) {
return this.equals(TYPED_NULL_EXPR, sourceSpan);
}
nullishCoalesce(rhs, sourceSpan) {
return new BinaryOperatorExpr(BinaryOperator.NullishCoalesce, this, rhs, null, sourceSpan);
}
toStmt() {
return new ExpressionStatement(this, null);
}
};
var ReadVarExpr = class _ReadVarExpr extends Expression {
static {
__name(this, "ReadVarExpr");
}
name;
constructor(name, type, sourceSpan) {
super(type, sourceSpan);
this.name = name;
}
isEquivalent(e) {
return e instanceof _ReadVarExpr && this.name === e.name;
}
isConstant() {
return false;
}
visitExpression(visitor, context) {
return visitor.visitReadVarExpr(this, context);
}
clone() {
return new _ReadVarExpr(this.name, this.type, this.sourceSpan);
}
set(value) {
return new WriteVarExpr(this.name, value, null, this.sourceSpan);
}
};
var TypeofExpr = class _TypeofExpr extends Expression {
static {
__name(this, "TypeofExpr");
}
expr;
constructor(expr, type, sourceSpan) {
super(type, sourceSpan);
this.expr = expr;
}
visitExpression(visitor, context) {
return visitor.visitTypeofExpr(this, context);
}
isEquivalent(e) {
return e instanceof _TypeofExpr && e.expr.isEquivalent(this.expr);
}
isConstant() {
return this.expr.isConstant();
}
clone() {
return new _TypeofExpr(this.expr.clone());
}
};
var WrappedNodeExpr = class _WrappedNodeExpr extends Expression {
static {
__name(this, "WrappedNodeExpr");
}
node;
constructor(node, type, sourceSpan) {
super(type, sourceSpan);
this.node = node;
}
isEquivalent(e) {
return e instanceof _WrappedNodeExpr && this.node === e.node;
}
isConstant() {
return false;
}
visitExpression(visitor, context) {
return visitor.visitWrappedNodeExpr(this, context);
}
clone() {
return new _WrappedNodeExpr(this.node, this.type, this.sourceSpan);
}
};
var WriteVarExpr = class _WriteVarExpr extends Expression {
static {
__name(this, "WriteVarExpr");
}
name;
value;
constructor(name, value, type, sourceSpan) {
super(type || value.type, sourceSpan);
this.name = name;
this.value = value;
}
isEquivalent(e) {
return e instanceof _WriteVarExpr && this.name === e.name && this.value.isEquivalent(e.value);
}
isConstant() {
return false;
}
visitExpression(visitor, context) {
return visitor.visitWriteVarExpr(this, context);
}
clone() {
return new _WriteVarExpr(this.name, this.value.clone(), this.type, this.sourceSpan);
}
toDeclStmt(type, modifiers) {
return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);
}
toConstDecl() {
return this.toDeclStmt(INFERRED_TYPE, StmtModifier.Final);
}
};
var WriteKeyExpr = class _WriteKeyExpr extends Expression {
static {
__name(this, "WriteKeyExpr");
}
receiver;
index;
value;
constructor(receiver, index, value, type, sourceSpan) {
super(type || value.type, sourceSpan);
this.receiver = receiver;
this.index = index;
this.value = value;
}
isEquivalent(e) {
return e instanceof _WriteKeyExpr && this.receiver.isEquivalent(e.receiver) && this.index.isEquivalent(e.index) && this.value.isEquivalent(e.value);
}
isConstant() {
return false;
}
visitExpression(visitor, context) {
return visitor.visitWriteKeyExpr(this, context);
}
clone() {
return new _WriteKeyExpr(this.receiver.clone(), this.index.clone(), this.value.clone(), this.type, this.sourceSpan);
}
};
var WritePropExpr = class _WritePropExpr extends Expression {
static {
__name(this, "WritePropExpr");
}
receiver;
name;
value;
constructor(receiver, name, value, type, sourceSpan) {
super(type || value.type, sourceSpan);
this.receiver = receiver;
this.name = name;
this.value = value;
}
isEquivalent(e) {
return e instanceof _WritePropExpr && this.receiver.isEquivalent(e.receiver) && this.name === e.name && this.value.isEquivalent(e.value);
}
isConstant() {
return false;
}
visitExpression(visitor, context) {
return visitor.visitWritePropExpr(this, context);
}
clone() {
return new _WritePropExpr(this.receiver.clone(), this.name, this.value.clone(), this.type, this.sourceSpan);
}
};
var InvokeFunctionExpr = class _InvokeFunctionExpr extends Expression {
static {
__name(this, "InvokeFunctionExpr");
}
fn;
args;
pure;
constructor(fn2, args, type, sourceSpan, pure = false) {
super(type, sourceSpan);
this.fn = fn2;
this.args = args;
this.pure = pure;
}
// An alias for fn, which allows other logic to handle calls and property reads together.
get receiver() {
return this.fn;
}
isEquivalent(e) {
return e instanceof _InvokeFunctionExpr && this.fn.isEquivalent(e.fn) && areAllEquivalent(this.args, e.args) && this.pure === e.pure;
}
isConstant() {
return false;
}
visitExpression(visitor, context) {
return visitor.visitInvokeFunctionExpr(this, context);
}
clone() {
return new _InvokeFunctionExpr(this.fn.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan, this.pure);
}
};
var TaggedTemplateLiteralExpr = class _TaggedTemplateLiteralExpr extends Expression {
static {
__name(this, "TaggedTemplateLiteralExpr");
}
tag;
template;
constructor(tag, template2, type, sourceSpan) {
super(type, sourceSpan);
this.tag = tag;
this.template = template2;
}
isEquivalent(e) {
return e instanceof _TaggedTemplateLiteralExpr && this.tag.isEquivalent(e.tag) && this.template.isEquivalent(e.template);
}
isConstant() {
return false;
}
visitExpression(visitor, context) {
return visitor.visitTaggedTemplateLiteralExpr(this, context);
}
clone() {
return new _TaggedTemplateLiteralExpr(this.tag.clone(), this.template.clone(), this.type, this.sourceSpan);
}
};
var InstantiateExpr = class _InstantiateExpr extends Expression {
static {
__name(this, "InstantiateExpr");
}
classExpr;
args;
constructor(classExpr, args, type, sourceSpan) {
super(type, sourceSpan);
this.classExpr = classExpr;
this.args = args;
}
isEquivalent(e) {
return e instanceof _Instantiat