@glimmer/syntax
Version:
883 lines (719 loc) • 96.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.normalize = normalize;
exports.BlockContext = void 0;
var _util = require("@glimmer/util");
var _printer = _interopRequireDefault(require("../generation/printer"));
var _tokenizerEventHandlers = require("../parser/tokenizer-event-handlers");
var _slice = require("../source/slice");
var _spanList = require("../source/span-list");
var _symbolTable = require("../symbol-table");
var _syntaxError = require("../syntax-error");
var _utils = require("../utils");
var _parserBuilders = _interopRequireDefault(require("../v1/parser-builders"));
var ASTv2 = _interopRequireWildcard(require("./api"));
var _builders = require("./builders");
var _looseResolution = require("./loose-resolution");
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function normalize(source, options = {}) {
var _a;
let ast = (0, _tokenizerEventHandlers.preprocess)(source, options);
let normalizeOptions = (0, _util.assign)({
strictMode: false,
locals: []
}, options);
let top = _symbolTable.SymbolTable.top(normalizeOptions.locals, (_a = // eslint-disable-next-line @typescript-eslint/unbound-method
options.customizeComponentName) !== null && _a !== void 0 ? _a : name => name);
let block = new BlockContext(source, normalizeOptions, top);
let normalizer = new StatementNormalizer(block);
let astV2 = new TemplateChildren(block.loc(ast.loc), ast.body.map(b => normalizer.normalize(b)), block).assertTemplate(top);
let locals = top.getUsedTemplateLocals();
return [astV2, locals];
}
/**
* A `BlockContext` represents the block that a particular AST node is contained inside of.
*
* `BlockContext` is aware of template-wide options (such as strict mode), as well as the bindings
* that are in-scope within that block.
*
* Concretely, it has the `PrecompileOptions` and current `SymbolTable`, and provides
* facilities for working with those options.
*
* `BlockContext` is stateless.
*/
class BlockContext {
constructor(source, options, table) {
this.source = source;
this.options = options;
this.table = table;
this.builder = new _builders.Builder();
}
get strict() {
return this.options.strictMode || false;
}
loc(loc) {
return this.source.spanFor(loc);
}
resolutionFor(node, resolution) {
if (this.strict) {
return {
resolution: ASTv2.STRICT_RESOLUTION
};
}
if (this.isFreeVar(node)) {
let r = resolution(node);
if (r === null) {
return {
resolution: 'error',
path: printPath(node),
head: printHead(node)
};
}
return {
resolution: r
};
} else {
return {
resolution: ASTv2.STRICT_RESOLUTION
};
}
}
isFreeVar(callee) {
if (callee.type === 'PathExpression') {
if (callee.head.type !== 'VarHead') {
return false;
}
return !this.table.has(callee.head.name);
} else if (callee.path.type === 'PathExpression') {
return this.isFreeVar(callee.path);
} else {
return false;
}
}
hasBinding(name) {
return this.table.has(name);
}
child(blockParams) {
return new BlockContext(this.source, this.options, this.table.child(blockParams));
}
customizeComponentName(input) {
if (this.options.customizeComponentName) {
return this.options.customizeComponentName(input);
} else {
return input;
}
}
}
/**
* An `ExpressionNormalizer` normalizes expressions within a block.
*
* `ExpressionNormalizer` is stateless.
*/
exports.BlockContext = BlockContext;
class ExpressionNormalizer {
constructor(block) {
this.block = block;
}
normalize(expr, resolution) {
switch (expr.type) {
case 'NullLiteral':
case 'BooleanLiteral':
case 'NumberLiteral':
case 'StringLiteral':
case 'UndefinedLiteral':
return this.block.builder.literal(expr.value, this.block.loc(expr.loc));
case 'PathExpression':
return this.path(expr, resolution);
case 'SubExpression':
{
let resolution = this.block.resolutionFor(expr, _looseResolution.SexpSyntaxContext);
if (resolution.resolution === 'error') {
throw (0, _syntaxError.generateSyntaxError)(`You attempted to invoke a path (\`${resolution.path}\`) but ${resolution.head} was not in scope`, expr.loc);
}
return this.block.builder.sexp(this.callParts(expr, resolution.resolution), this.block.loc(expr.loc));
}
}
}
path(expr, resolution) {
let headOffsets = this.block.loc(expr.head.loc);
let tail = []; // start with the head
let offset = headOffsets;
for (let part of expr.tail) {
offset = offset.sliceStartChars({
chars: part.length,
skipStart: 1
});
tail.push(new _slice.SourceSlice({
loc: offset,
chars: part
}));
}
return this.block.builder.path(this.ref(expr.head, resolution), tail, this.block.loc(expr.loc));
}
/**
* The `callParts` method takes ASTv1.CallParts as well as a syntax context and normalizes
* it to an ASTv2 CallParts.
*/
callParts(parts, context) {
let {
path,
params,
hash
} = parts;
let callee = this.normalize(path, context);
let paramList = params.map(p => this.normalize(p, ASTv2.ARGUMENT_RESOLUTION));
let paramLoc = _spanList.SpanList.range(paramList, callee.loc.collapse('end'));
let namedLoc = this.block.loc(hash.loc);
let argsLoc = _spanList.SpanList.range([paramLoc, namedLoc]);
let positional = this.block.builder.positional(params.map(p => this.normalize(p, ASTv2.ARGUMENT_RESOLUTION)), paramLoc);
let named = this.block.builder.named(hash.pairs.map(p => this.namedArgument(p)), this.block.loc(hash.loc));
return {
callee,
args: this.block.builder.args(positional, named, argsLoc)
};
}
namedArgument(pair) {
let offsets = this.block.loc(pair.loc);
let keyOffsets = offsets.sliceStartChars({
chars: pair.key.length
});
return this.block.builder.namedArgument(new _slice.SourceSlice({
chars: pair.key,
loc: keyOffsets
}), this.normalize(pair.value, ASTv2.ARGUMENT_RESOLUTION));
}
/**
* The `ref` method normalizes an `ASTv1.PathHead` into an `ASTv2.VariableReference`.
* This method is extremely important, because it is responsible for normalizing free
* variables into an an ASTv2.PathHead *with appropriate context*.
*
* The syntax context is originally determined by the syntactic position that this `PathHead`
* came from, and is ultimately attached to the `ASTv2.VariableReference` here. In ASTv2,
* the `VariableReference` node bears full responsibility for loose mode rules that control
* the behavior of free variables.
*/
ref(head, resolution) {
let {
block
} = this;
let {
builder,
table
} = block;
let offsets = block.loc(head.loc);
switch (head.type) {
case 'ThisHead':
return builder.self(offsets);
case 'AtHead':
{
let symbol = table.allocateNamed(head.name);
return builder.at(head.name, symbol, offsets);
}
case 'VarHead':
{
if (block.hasBinding(head.name)) {
let [symbol, isRoot] = table.get(head.name);
return block.builder.localVar(head.name, symbol, isRoot, offsets);
} else {
let context = block.strict ? ASTv2.STRICT_RESOLUTION : resolution;
let symbol = block.table.allocateFree(head.name, context);
return block.builder.freeVar({
name: head.name,
context,
symbol,
loc: offsets
});
}
}
}
}
}
/**
* `TemplateNormalizer` normalizes top-level ASTv1 statements to ASTv2.
*/
class StatementNormalizer {
constructor(block) {
this.block = block;
}
normalize(node) {
switch (node.type) {
case 'PartialStatement':
throw new Error(`Handlebars partial syntax ({{> ...}}) is not allowed in Glimmer`);
case 'BlockStatement':
return this.BlockStatement(node);
case 'ElementNode':
return new ElementNormalizer(this.block).ElementNode(node);
case 'MustacheStatement':
return this.MustacheStatement(node);
// These are the same in ASTv2
case 'MustacheCommentStatement':
return this.MustacheCommentStatement(node);
case 'CommentStatement':
{
let loc = this.block.loc(node.loc);
return new ASTv2.HtmlComment({
loc,
text: loc.slice({
skipStart: 4,
skipEnd: 3
}).toSlice(node.value)
});
}
case 'TextNode':
return new ASTv2.HtmlText({
loc: this.block.loc(node.loc),
chars: node.chars
});
}
}
MustacheCommentStatement(node) {
let loc = this.block.loc(node.loc);
let textLoc;
if (loc.asString().slice(0, 5) === '{{!--') {
textLoc = loc.slice({
skipStart: 5,
skipEnd: 4
});
} else {
textLoc = loc.slice({
skipStart: 3,
skipEnd: 2
});
}
return new ASTv2.GlimmerComment({
loc,
text: textLoc.toSlice(node.value)
});
}
/**
* Normalizes an ASTv1.MustacheStatement to an ASTv2.AppendStatement
*/
MustacheStatement(mustache) {
let {
escaped
} = mustache;
let loc = this.block.loc(mustache.loc); // Normalize the call parts in AppendSyntaxContext
let callParts = this.expr.callParts({
path: mustache.path,
params: mustache.params,
hash: mustache.hash
}, (0, _looseResolution.AppendSyntaxContext)(mustache));
let value = callParts.args.isEmpty() ? callParts.callee : this.block.builder.sexp(callParts, loc);
return this.block.builder.append({
table: this.block.table,
trusting: !escaped,
value
}, loc);
}
/**
* Normalizes a ASTv1.BlockStatement to an ASTv2.BlockStatement
*/
BlockStatement(block) {
let {
program,
inverse
} = block;
let loc = this.block.loc(block.loc);
let resolution = this.block.resolutionFor(block, _looseResolution.BlockSyntaxContext);
if (resolution.resolution === 'error') {
throw (0, _syntaxError.generateSyntaxError)(`You attempted to invoke a path (\`{{#${resolution.path}}}\`) but ${resolution.head} was not in scope`, loc);
}
let callParts = this.expr.callParts(block, resolution.resolution);
return this.block.builder.blockStatement((0, _util.assign)({
symbols: this.block.table,
program: this.Block(program),
inverse: inverse ? this.Block(inverse) : null
}, callParts), loc);
}
Block({
body,
loc,
blockParams
}) {
let child = this.block.child(blockParams);
let normalizer = new StatementNormalizer(child);
return new BlockChildren(this.block.loc(loc), body.map(b => normalizer.normalize(b)), this.block).assertBlock(child.table);
}
get expr() {
return new ExpressionNormalizer(this.block);
}
}
class ElementNormalizer {
constructor(ctx) {
this.ctx = ctx;
}
/**
* Normalizes an ASTv1.ElementNode to:
*
* - ASTv2.NamedBlock if the tag name begins with `:`
* - ASTv2.Component if the tag name matches the component heuristics
* - ASTv2.SimpleElement if the tag name doesn't match the component heuristics
*
* A tag name represents a component if:
*
* - it begins with `@`
* - it is exactly `this` or begins with `this.`
* - the part before the first `.` is a reference to an in-scope variable binding
* - it begins with an uppercase character
*/
ElementNode(element) {
let {
tag,
selfClosing,
comments
} = element;
let loc = this.ctx.loc(element.loc);
let [tagHead, ...rest] = tag.split('.'); // the head, attributes and modifiers are in the current scope
let path = this.classifyTag(tagHead, rest, element.loc);
let attrs = element.attributes.filter(a => a.name[0] !== '@').map(a => this.attr(a));
let args = element.attributes.filter(a => a.name[0] === '@').map(a => this.arg(a));
let modifiers = element.modifiers.map(m => this.modifier(m)); // the element's block params are in scope for the children
let child = this.ctx.child(element.blockParams);
let normalizer = new StatementNormalizer(child);
let childNodes = element.children.map(s => normalizer.normalize(s));
let el = this.ctx.builder.element({
selfClosing,
attrs,
componentArgs: args,
modifiers,
comments: comments.map(c => new StatementNormalizer(this.ctx).MustacheCommentStatement(c))
});
let children = new ElementChildren(el, loc, childNodes, this.ctx);
let offsets = this.ctx.loc(element.loc);
let tagOffsets = offsets.sliceStartChars({
chars: tag.length,
skipStart: 1
});
if (path === 'ElementHead') {
if (tag[0] === ':') {
return children.assertNamedBlock(tagOffsets.slice({
skipStart: 1
}).toSlice(tag.slice(1)), child.table);
} else {
return children.assertElement(tagOffsets.toSlice(tag), element.blockParams.length > 0);
}
}
if (element.selfClosing) {
return el.selfClosingComponent(path, loc);
} else {
let blocks = children.assertComponent(tag, child.table, element.blockParams.length > 0);
return el.componentWithNamedBlocks(path, blocks, loc);
}
}
modifier(m) {
let resolution = this.ctx.resolutionFor(m, _looseResolution.ModifierSyntaxContext);
if (resolution.resolution === 'error') {
throw (0, _syntaxError.generateSyntaxError)(`You attempted to invoke a path (\`{{#${resolution.path}}}\`) as a modifier, but ${resolution.head} was not in scope. Try adding \`this\` to the beginning of the path`, m.loc);
}
let callParts = this.expr.callParts(m, resolution.resolution);
return this.ctx.builder.modifier(callParts, this.ctx.loc(m.loc));
}
/**
* This method handles attribute values that are curlies, as well as curlies nested inside of
* interpolations:
*
* ```hbs
* <a href={{url}} />
* <a href="{{url}}.html" />
* ```
*/
mustacheAttr(mustache) {
// Normalize the call parts in AttrValueSyntaxContext
let sexp = this.ctx.builder.sexp(this.expr.callParts(mustache, (0, _looseResolution.AttrValueSyntaxContext)(mustache)), this.ctx.loc(mustache.loc)); // If there are no params or hash, just return the function part as its own expression
if (sexp.args.isEmpty()) {
return sexp.callee;
} else {
return sexp;
}
}
/**
* attrPart is the narrowed down list of valid attribute values that are also
* allowed as a concat part (you can't nest concats).
*/
attrPart(part) {
switch (part.type) {
case 'MustacheStatement':
return {
expr: this.mustacheAttr(part),
trusting: !part.escaped
};
case 'TextNode':
return {
expr: this.ctx.builder.literal(part.chars, this.ctx.loc(part.loc)),
trusting: true
};
}
}
attrValue(part) {
switch (part.type) {
case 'ConcatStatement':
{
let parts = part.parts.map(p => this.attrPart(p).expr);
return {
expr: this.ctx.builder.interpolate(parts, this.ctx.loc(part.loc)),
trusting: false
};
}
default:
return this.attrPart(part);
}
}
attr(m) {
false && (0, _util.assert)(m.name[0] !== '@', 'An attr name must not start with `@`');
if (m.name === '...attributes') {
return this.ctx.builder.splatAttr(this.ctx.table.allocateBlock('attrs'), this.ctx.loc(m.loc));
}
let offsets = this.ctx.loc(m.loc);
let nameSlice = offsets.sliceStartChars({
chars: m.name.length
}).toSlice(m.name);
let value = this.attrValue(m.value);
return this.ctx.builder.attr({
name: nameSlice,
value: value.expr,
trusting: value.trusting
}, offsets);
}
maybeDeprecatedCall(arg, part) {
if (this.ctx.strict) {
return null;
}
if (part.type !== 'MustacheStatement') {
return null;
}
let {
path
} = part;
if (path.type !== 'PathExpression') {
return null;
}
if (path.head.type !== 'VarHead') {
return null;
}
let {
name
} = path.head;
if (name === 'has-block' || name === 'has-block-params') {
return null;
}
if (this.ctx.hasBinding(name)) {
return null;
}
if (path.tail.length !== 0) {
return null;
}
if (part.params.length !== 0 || part.hash.pairs.length !== 0) {
return null;
}
let context = ASTv2.LooseModeResolution.attr();
let callee = this.ctx.builder.freeVar({
name,
context,
symbol: this.ctx.table.allocateFree(name, context),
loc: path.loc
});
return {
expr: this.ctx.builder.deprecatedCall(arg, callee, part.loc),
trusting: false
};
}
arg(arg) {
false && (0, _util.assert)(arg.name[0] === '@', 'An arg name must start with `@`');
let offsets = this.ctx.loc(arg.loc);
let nameSlice = offsets.sliceStartChars({
chars: arg.name.length
}).toSlice(arg.name);
let value = this.maybeDeprecatedCall(nameSlice, arg.value) || this.attrValue(arg.value);
return this.ctx.builder.arg({
name: nameSlice,
value: value.expr,
trusting: value.trusting
}, offsets);
}
/**
* This function classifies the head of an ASTv1.Element into an ASTv2.PathHead (if the
* element is a component) or `'ElementHead'` (if the element is a simple element).
*
* Rules:
*
* 1. If the variable is an `@arg`, return an `AtHead`
* 2. If the variable is `this`, return a `ThisHead`
* 3. If the variable is in the current scope:
* a. If the scope is the root scope, then return a Free `LocalVarHead`
* b. Else, return a standard `LocalVarHead`
* 4. If the tag name is a path and the variable is not in the current scope, Syntax Error
* 5. If the variable is uppercase return a FreeVar(ResolveAsComponentHead)
* 6. Otherwise, return `'ElementHead'`
*/
classifyTag(variable, tail, loc) {
let uppercase = (0, _utils.isUpperCase)(variable);
let inScope = variable[0] === '@' || variable === 'this' || this.ctx.hasBinding(variable);
if (this.ctx.strict && !inScope) {
if (uppercase) {
throw (0, _syntaxError.generateSyntaxError)(`Attempted to invoke a component that was not in scope in a strict mode template, \`<${variable}>\`. If you wanted to create an element with that name, convert it to lowercase - \`<${variable.toLowerCase()}>\``, loc);
} // In strict mode, values are always elements unless they are in scope
return 'ElementHead';
} // Since the parser handed us the HTML element name as a string, we need
// to convert it into an ASTv1 path so it can be processed using the
// expression normalizer.
let isComponent = inScope || uppercase;
let variableLoc = loc.sliceStartChars({
skipStart: 1,
chars: variable.length
});
let tailLength = tail.reduce((accum, part) => accum + 1 + part.length, 0);
let pathEnd = variableLoc.getEnd().move(tailLength);
let pathLoc = variableLoc.withEnd(pathEnd);
if (isComponent) {
let path = _parserBuilders.default.path({
head: _parserBuilders.default.head(variable, variableLoc),
tail,
loc: pathLoc
});
let resolution = this.ctx.resolutionFor(path, _looseResolution.ComponentSyntaxContext);
if (resolution.resolution === 'error') {
throw (0, _syntaxError.generateSyntaxError)(`You attempted to invoke a path (\`<${resolution.path}>\`) but ${resolution.head} was not in scope`, loc);
}
return new ExpressionNormalizer(this.ctx).normalize(path, resolution.resolution);
} // If the tag name wasn't a valid component but contained a `.`, it's
// a syntax error.
if (tail.length > 0) {
throw (0, _syntaxError.generateSyntaxError)(`You used ${variable}.${tail.join('.')} as a tag name, but ${variable} is not in scope`, loc);
}
return 'ElementHead';
}
get expr() {
return new ExpressionNormalizer(this.ctx);
}
}
class Children {
constructor(loc, children, block) {
this.loc = loc;
this.children = children;
this.block = block;
this.namedBlocks = children.filter(c => c instanceof ASTv2.NamedBlock);
this.hasSemanticContent = Boolean(children.filter(c => {
if (c instanceof ASTv2.NamedBlock) {
return false;
}
switch (c.type) {
case 'GlimmerComment':
case 'HtmlComment':
return false;
case 'HtmlText':
return !/^\s*$/.exec(c.chars);
default:
return true;
}
}).length);
this.nonBlockChildren = children.filter(c => !(c instanceof ASTv2.NamedBlock));
}
}
class TemplateChildren extends Children {
assertTemplate(table) {
if ((0, _util.isPresent)(this.namedBlocks)) {
throw (0, _syntaxError.generateSyntaxError)(`Unexpected named block at the top-level of a template`, this.loc);
}
return this.block.builder.template(table, this.nonBlockChildren, this.block.loc(this.loc));
}
}
class BlockChildren extends Children {
assertBlock(table) {
if ((0, _util.isPresent)(this.namedBlocks)) {
throw (0, _syntaxError.generateSyntaxError)(`Unexpected named block nested in a normal block`, this.loc);
}
return this.block.builder.block(table, this.nonBlockChildren, this.loc);
}
}
class ElementChildren extends Children {
constructor(el, loc, children, block) {
super(loc, children, block);
this.el = el;
}
assertNamedBlock(name, table) {
if (this.el.base.selfClosing) {
throw (0, _syntaxError.generateSyntaxError)(`<:${name.chars}/> is not a valid named block: named blocks cannot be self-closing`, this.loc);
}
if ((0, _util.isPresent)(this.namedBlocks)) {
throw (0, _syntaxError.generateSyntaxError)(`Unexpected named block inside <:${name.chars}> named block: named blocks cannot contain nested named blocks`, this.loc);
}
if (!(0, _utils.isLowerCase)(name.chars)) {
throw (0, _syntaxError.generateSyntaxError)(`<:${name.chars}> is not a valid named block, and named blocks must begin with a lowercase letter`, this.loc);
}
if (this.el.base.attrs.length > 0 || this.el.base.componentArgs.length > 0 || this.el.base.modifiers.length > 0) {
throw (0, _syntaxError.generateSyntaxError)(`named block <:${name.chars}> cannot have attributes, arguments, or modifiers`, this.loc);
}
let offsets = _spanList.SpanList.range(this.nonBlockChildren, this.loc);
return this.block.builder.namedBlock(name, this.block.builder.block(table, this.nonBlockChildren, offsets), this.loc);
}
assertElement(name, hasBlockParams) {
if (hasBlockParams) {
throw (0, _syntaxError.generateSyntaxError)(`Unexpected block params in <${name}>: simple elements cannot have block params`, this.loc);
}
if ((0, _util.isPresent)(this.namedBlocks)) {
let names = this.namedBlocks.map(b => b.name);
if (names.length === 1) {
throw (0, _syntaxError.generateSyntaxError)(`Unexpected named block <:foo> inside <${name.chars}> HTML element`, this.loc);
} else {
let printedNames = names.map(n => `<:${n.chars}>`).join(', ');
throw (0, _syntaxError.generateSyntaxError)(`Unexpected named blocks inside <${name.chars}> HTML element (${printedNames})`, this.loc);
}
}
return this.el.simple(name, this.nonBlockChildren, this.loc);
}
assertComponent(name, table, hasBlockParams) {
if ((0, _util.isPresent)(this.namedBlocks) && this.hasSemanticContent) {
throw (0, _syntaxError.generateSyntaxError)(`Unexpected content inside <${name}> component invocation: when using named blocks, the tag cannot contain other content`, this.loc);
}
if ((0, _util.isPresent)(this.namedBlocks)) {
if (hasBlockParams) {
throw (0, _syntaxError.generateSyntaxError)(`Unexpected block params list on <${name}> component invocation: when passing named blocks, the invocation tag cannot take block params`, this.loc);
}
let seenNames = new Set();
for (let block of this.namedBlocks) {
let name = block.name.chars;
if (seenNames.has(name)) {
throw (0, _syntaxError.generateSyntaxError)(`Component had two named blocks with the same name, \`<:${name}>\`. Only one block with a given name may be passed`, this.loc);
}
if (name === 'inverse' && seenNames.has('else') || name === 'else' && seenNames.has('inverse')) {
throw (0, _syntaxError.generateSyntaxError)(`Component has both <:else> and <:inverse> block. <:inverse> is an alias for <:else>`, this.loc);
}
seenNames.add(name);
}
return this.namedBlocks;
} else {
return [this.block.builder.namedBlock(_slice.SourceSlice.synthetic('default'), this.block.builder.block(table, this.nonBlockChildren, this.loc), this.loc)];
}
}
}
function printPath(node) {
if (node.type !== 'PathExpression' && node.path.type === 'PathExpression') {
return printPath(node.path);
} else {
return new _printer.default({
entityEncoding: 'raw'
}).print(node);
}
}
function printHead(node) {
if (node.type === 'PathExpression') {
switch (node.head.type) {
case 'AtHead':
case 'VarHead':
return node.head.name;
case 'ThisHead':
return 'this';
}
} else if (node.path.type === 'PathExpression') {
return printHead(node.path);
} else {
return new _printer.default({
entityEncoding: 'raw'
}).print(node);
}
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL0BnbGltbWVyL3N5bnRheC9saWIvdjItYS9ub3JtYWxpemUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFDQTs7QUFFQTs7QUFDQTs7QUFFQTs7QUFHQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFFQTs7QUFDQTs7QUFDQTs7QUFDQTs7Ozs7Ozs7QUFVTSxTQUFBLFNBQUEsQ0FBQSxNQUFBLEVBRUosT0FBQSxHQUZJLEVBQUEsRUFFMkI7OztBQUUvQixNQUFJLEdBQUcsR0FBRyx3Q0FBVSxNQUFWLEVBQVYsT0FBVSxDQUFWO0FBRUEsTUFBSSxnQkFBZ0IsR0FBRyxrQkFDckI7QUFDRSxJQUFBLFVBQVUsRUFEWixLQUFBO0FBRUUsSUFBQSxNQUFNLEVBQUU7QUFGVixHQURxQixFQUF2QixPQUF1QixDQUF2Qjs7QUFRQSxNQUFJLEdBQUcsR0FBRyx5QkFBQSxHQUFBLENBQ1IsZ0JBQWdCLENBRFIsTUFBQSxFQUNlLENBQUEsRUFBQSxHQUN2QjtBQUNBLEVBQUEsT0FBTyxDQUZnQixzQkFBQSxNQUFBLElBQUEsSUFFTyxFQUFBLEtBQUEsS0FGUCxDQUFBLEdBQUEsRUFBQSxHQUVhLElBQUQsSUFIckMsSUFBVSxDQUFWOztBQUtBLE1BQUksS0FBSyxHQUFHLElBQUEsWUFBQSxDQUFBLE1BQUEsRUFBQSxnQkFBQSxFQUFaLEdBQVksQ0FBWjtBQUNBLE1BQUksVUFBVSxHQUFHLElBQUEsbUJBQUEsQ0FBakIsS0FBaUIsQ0FBakI7QUFFQSxNQUFJLEtBQUssR0FBRyxJQUFBLGdCQUFBLENBQ1YsS0FBSyxDQUFMLEdBQUEsQ0FBVSxHQUFHLENBREgsR0FDVixDQURVLEVBRVYsR0FBRyxDQUFILElBQUEsQ0FBQSxHQUFBLENBQWMsQ0FBRCxJQUFPLFVBQVUsQ0FBVixTQUFBLENBRlYsQ0FFVSxDQUFwQixDQUZVLEVBQUEsS0FBQSxFQUFBLGNBQUEsQ0FBWixHQUFZLENBQVo7QUFNQSxNQUFJLE1BQU0sR0FBRyxHQUFHLENBQWhCLHFCQUFhLEVBQWI7QUFFQSxTQUFPLENBQUEsS0FBQSxFQUFQLE1BQU8sQ0FBUDtBQUNEO0FBRUQ7Ozs7Ozs7Ozs7Ozs7QUFXTSxNQUFBLFlBQUEsQ0FBbUI7QUFHdkIsRUFBQSxXQUFBLENBQUEsTUFBQSxFQUFBLE9BQUEsRUFBQSxLQUFBLEVBR3VCO0FBRlosU0FBQSxNQUFBLEdBQUEsTUFBQTtBQUNRLFNBQUEsT0FBQSxHQUFBLE9BQUE7QUFDUixTQUFBLEtBQUEsR0FBQSxLQUFBO0FBRVQsU0FBQSxPQUFBLEdBQWUsSUFBZixpQkFBZSxFQUFmO0FBQ0Q7O0FBRUQsTUFBQSxNQUFBLEdBQVU7QUFDUixXQUFPLEtBQUEsT0FBQSxDQUFBLFVBQUEsSUFBUCxLQUFBO0FBQ0Q7O0FBRUQsRUFBQSxHQUFHLENBQUEsR0FBQSxFQUFvQjtBQUNyQixXQUFPLEtBQUEsTUFBQSxDQUFBLE9BQUEsQ0FBUCxHQUFPLENBQVA7QUFDRDs7QUFFRCxFQUFBLGFBQWEsQ0FBQSxJQUFBLEVBQUEsVUFBQSxFQUVjO0FBRXpCLFFBQUksS0FBSixNQUFBLEVBQWlCO0FBQ2YsYUFBTztBQUFFLFFBQUEsVUFBVSxFQUFFLEtBQUssQ0FBQztBQUFwQixPQUFQO0FBQ0Q7O0FBRUQsUUFBSSxLQUFBLFNBQUEsQ0FBSixJQUFJLENBQUosRUFBMEI7QUFDeEIsVUFBSSxDQUFDLEdBQUcsVUFBVSxDQUFsQixJQUFrQixDQUFsQjs7QUFFQSxVQUFJLENBQUMsS0FBTCxJQUFBLEVBQWdCO0FBQ2QsZUFBTztBQUNMLFVBQUEsVUFBVSxFQURMLE9BQUE7QUFFTCxVQUFBLElBQUksRUFBRSxTQUFTLENBRlYsSUFFVSxDQUZWO0FBR0wsVUFBQSxJQUFJLEVBQUUsU0FBUyxDQUFBLElBQUE7QUFIVixTQUFQO0FBS0Q7O0FBRUQsYUFBTztBQUFFLFFBQUEsVUFBVSxFQUFFO0FBQWQsT0FBUDtBQVhGLEtBQUEsTUFZTztBQUNMLGFBQU87QUFBRSxRQUFBLFVBQVUsRUFBRSxLQUFLLENBQUM7QUFBcEIsT0FBUDtBQUNEO0FBQ0Y7O0FBRU8sRUFBQSxTQUFTLENBQUEsTUFBQSxFQUE4QztBQUM3RCxRQUFJLE1BQU0sQ0FBTixJQUFBLEtBQUosZ0JBQUEsRUFBc0M7QUFDcEMsVUFBSSxNQUFNLENBQU4sSUFBQSxDQUFBLElBQUEsS0FBSixTQUFBLEVBQW9DO0FBQ2xDLGVBQUEsS0FBQTtBQUNEOztBQUVELGFBQU8sQ0FBQyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsTUFBTSxDQUFOLElBQUEsQ0FBdkIsSUFBUSxDQUFSO0FBTEYsS0FBQSxNQU1PLElBQUksTUFBTSxDQUFOLElBQUEsQ0FBQSxJQUFBLEtBQUosZ0JBQUEsRUFBMkM7QUFDaEQsYUFBTyxLQUFBLFNBQUEsQ0FBZSxNQUFNLENBQTVCLElBQU8sQ0FBUDtBQURLLEtBQUEsTUFFQTtBQUNMLGFBQUEsS0FBQTtBQUNEO0FBQ0Y7O0FBRUQsRUFBQSxVQUFVLENBQUEsSUFBQSxFQUFhO0FBQ3JCLFdBQU8sS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFQLElBQU8sQ0FBUDtBQUNEOztBQUVELEVBQUEsS0FBSyxDQUFBLFdBQUEsRUFBc0I7QUFDekIsV0FBTyxJQUFBLFlBQUEsQ0FBaUIsS0FBakIsTUFBQSxFQUE4QixLQUE5QixPQUFBLEVBQTRDLEtBQUEsS0FBQSxDQUFBLEtBQUEsQ0FBbkQsV0FBbUQsQ0FBNUMsQ0FBUDtBQUNEOztBQUVELEVBQUEsc0JBQXNCLENBQUEsS0FBQSxFQUFjO0FBQ2xDLFFBQUksS0FBQSxPQUFBLENBQUosc0JBQUEsRUFBeUM7QUFDdkMsYUFBTyxLQUFBLE9BQUEsQ0FBQSxzQkFBQSxDQUFQLEtBQU8sQ0FBUDtBQURGLEtBQUEsTUFFTztBQUNMLGFBQUEsS0FBQTtBQUNEO0FBQ0Y7O0FBeEVzQjtBQTJFekI7Ozs7Ozs7OztBQUtBLE1BQUEsb0JBQUEsQ0FBMEI7QUFDeEIsRUFBQSxXQUFBLENBQUEsS0FBQSxFQUF1QztBQUFuQixTQUFBLEtBQUEsR0FBQSxLQUFBO0FBQXVCOztBQWUzQyxFQUFBLFNBQVMsQ0FBQSxJQUFBLEVBQUEsVUFBQSxFQUU0QjtBQUVuQyxZQUFRLElBQUksQ0FBWixJQUFBO0FBQ0UsV0FBQSxhQUFBO0FBQ0EsV0FBQSxnQkFBQTtBQUNBLFdBQUEsZUFBQTtBQUNBLFdBQUEsZUFBQTtBQUNBLFdBQUEsa0JBQUE7QUFDRSxlQUFPLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxPQUFBLENBQTJCLElBQUksQ0FBL0IsS0FBQSxFQUF1QyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsSUFBSSxDQUFqRSxHQUE4QyxDQUF2QyxDQUFQOztBQUNGLFdBQUEsZ0JBQUE7QUFDRSxlQUFPLEtBQUEsSUFBQSxDQUFBLElBQUEsRUFBUCxVQUFPLENBQVA7O0FBQ0YsV0FBQSxlQUFBO0FBQXNCO0FBQ3BCLGNBQUksVUFBVSxHQUFHLEtBQUEsS0FBQSxDQUFBLGFBQUEsQ0FBQSxJQUFBLEVBQWpCLGtDQUFpQixDQUFqQjs7QUFFQSxjQUFJLFVBQVUsQ0FBVixVQUFBLEtBQUosT0FBQSxFQUF1QztBQUNyQyxrQkFBTSxzQ0FDSixxQ0FBcUMsVUFBVSxDQUFDLElBQUksV0FBVyxVQUFVLENBQUMsSUFEbkQsbUJBQW5CLEVBRUosSUFBSSxDQUZOLEdBQU0sQ0FBTjtBQUlEOztBQUVELGlCQUFPLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxJQUFBLENBQ0wsS0FBQSxTQUFBLENBQUEsSUFBQSxFQUFxQixVQUFVLENBRDFCLFVBQ0wsQ0FESyxFQUVMLEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBZSxJQUFJLENBRnJCLEdBRUUsQ0FGSyxDQUFQO0FBSUQ7QUF2Qkg7QUF5QkQ7O0FBRU8sRUFBQSxJQUFJLENBQUEsSUFBQSxFQUFBLFVBQUEsRUFFeUI7QUFFbkMsUUFBSSxXQUFXLEdBQUcsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLElBQUksQ0FBSixJQUFBLENBQWpDLEdBQWtCLENBQWxCO0FBRUEsUUFBSSxJQUFJLEdBSjJCLEVBSW5DLENBSm1DLENBTW5DOztBQUNBLFFBQUksTUFBTSxHQUFWLFdBQUE7O0FBRUEsU0FBSyxJQUFMLElBQUEsSUFBaUIsSUFBSSxDQUFyQixJQUFBLEVBQTRCO0FBQzFCLE1BQUEsTUFBTSxHQUFHLE1BQU0sQ0FBTixlQUFBLENBQXVCO0FBQUUsUUFBQSxLQUFLLEVBQUUsSUFBSSxDQUFiLE1BQUE7QUFBc0IsUUFBQSxTQUFTLEVBQUU7QUFBakMsT0FBdkIsQ0FBVDtBQUNBLE1BQUEsSUFBSSxDQUFKLElBQUEsQ0FDRSxJQUFBLGtCQUFBLENBQWdCO0FBQ2QsUUFBQSxHQUFHLEVBRFcsTUFBQTtBQUVkLFFBQUEsS0FBSyxFQUFFO0FBRk8sT0FBaEIsQ0FERjtBQU1EOztBQUVELFdBQU8sS0FBQSxLQUFBLENBQUEsT0FBQSxDQUFBLElBQUEsQ0FBd0IsS0FBQSxHQUFBLENBQVMsSUFBSSxDQUFiLElBQUEsRUFBeEIsVUFBd0IsQ0FBeEIsRUFBQSxJQUFBLEVBQStELEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBZSxJQUFJLENBQXpGLEdBQXNFLENBQS9ELENBQVA7QUFDRDtBQUVEOzs7Ozs7QUFJQSxFQUFBLFNBQVMsQ0FBQSxLQUFBLEVBQUEsT0FBQSxFQUF5RDtBQUNoRSxRQUFJO0FBQUEsTUFBQSxJQUFBO0FBQUEsTUFBQSxNQUFBO0FBQWdCLE1BQUE7QUFBaEIsUUFBSixLQUFBO0FBRUEsUUFBSSxNQUFNLEdBQUcsS0FBQSxTQUFBLENBQUEsSUFBQSxFQUFiLE9BQWEsQ0FBYjtBQUNBLFFBQUksU0FBUyxHQUFHLE1BQU0sQ0FBTixHQUFBLENBQVksQ0FBRCxJQUFPLEtBQUEsU0FBQSxDQUFBLENBQUEsRUFBa0IsS0FBSyxDQUF6RCxtQkFBa0MsQ0FBbEIsQ0FBaEI7O0FBQ0EsUUFBSSxRQUFRLEdBQUcsbUJBQUEsS0FBQSxDQUFBLFNBQUEsRUFBMEIsTUFBTSxDQUFOLEdBQUEsQ0FBQSxRQUFBLENBQXpDLEtBQXlDLENBQTFCLENBQWY7O0FBQ0EsUUFBSSxRQUFRLEdBQUcsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLElBQUksQ0FBbEMsR0FBZSxDQUFmOztBQUNBLFFBQUksT0FBTyxHQUFHLG1CQUFBLEtBQUEsQ0FBZSxDQUFBLFFBQUEsRUFBN0IsUUFBNkIsQ0FBZixDQUFkOztBQUVBLFFBQUksVUFBVSxHQUFHLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxVQUFBLENBQ2YsTUFBTSxDQUFOLEdBQUEsQ0FBWSxDQUFELElBQU8sS0FBQSxTQUFBLENBQUEsQ0FBQSxFQUFrQixLQUFLLENBRDFCLG1CQUNHLENBQWxCLENBRGUsRUFBakIsUUFBaUIsQ0FBakI7QUFLQSxRQUFJLEtBQUssR0FBRyxLQUFBLEtBQUEsQ0FBQSxPQUFBLENBQUEsS0FBQSxDQUNWLElBQUksQ0FBSixLQUFBLENBQUEsR0FBQSxDQUFnQixDQUFELElBQU8sS0FBQSxhQUFBLENBRFosQ0FDWSxDQUF0QixDQURVLEVBRVYsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLElBQUksQ0FGckIsR0FFRSxDQUZVLENBQVo7QUFLQSxXQUFPO0FBQUEsTUFBQSxNQUFBO0FBRUwsTUFBQSxJQUFJLEVBQUUsS0FBQSxLQUFBLENBQUEsT0FBQSxDQUFBLElBQUEsQ0FBQSxVQUFBLEVBQUEsS0FBQSxFQUFBLE9BQUE7QUFGRCxLQUFQO0FBSUQ7O0FBRU8sRUFBQSxhQUFhLENBQUEsSUFBQSxFQUFxQjtBQUN4QyxRQUFJLE9BQU8sR0FBRyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsSUFBSSxDQUFqQyxHQUFjLENBQWQ7QUFFQSxRQUFJLFVBQVUsR0FBRyxPQUFPLENBQVAsZUFBQSxDQUF3QjtBQUFFLE1BQUEsS0FBSyxFQUFFLElBQUksQ0FBSixHQUFBLENBQVM7QUFBbEIsS0FBeEIsQ0FBakI7QUFFQSxXQUFPLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxhQUFBLENBQ0wsSUFBQSxrQkFBQSxDQUFnQjtBQUFFLE1BQUEsS0FBSyxFQUFFLElBQUksQ0FBYixHQUFBO0FBQW1CLE1BQUEsR0FBRyxFQUFFO0FBQXhCLEtBQWhCLENBREssRUFFTCxLQUFBLFNBQUEsQ0FBZSxJQUFJLENBQW5CLEtBQUEsRUFBMkIsS0FBSyxDQUZsQyxtQkFFRSxDQUZLLENBQVA7QUFJRDtBQUVEOzs7Ozs7Ozs7Ozs7QUFVUSxFQUFBLEdBQUcsQ0FBQSxJQUFBLEVBQUEsVUFBQSxFQUEwRDtBQUNuRSxRQUFJO0FBQUUsTUFBQTtBQUFGLFFBQUosSUFBQTtBQUNBLFFBQUk7QUFBQSxNQUFBLE9BQUE7QUFBVyxNQUFBO0FBQVgsUUFBSixLQUFBO0FBQ0EsUUFBSSxPQUFPLEdBQUcsS0FBSyxDQUFMLEdBQUEsQ0FBVSxJQUFJLENBQTVCLEdBQWMsQ0FBZDs7QUFFQSxZQUFRLElBQUksQ0FBWixJQUFBO0FBQ0UsV0FBQSxVQUFBO0FBQ0UsZUFBTyxPQUFPLENBQVAsSUFBQSxDQUFQLE9BQU8sQ0FBUDs7QUFDRixXQUFBLFFBQUE7QUFBZTtBQUNiLGNBQUksTUFBTSxHQUFHLEtBQUssQ0FBTCxhQUFBLENBQW9CLElBQUksQ0FBckMsSUFBYSxDQUFiO0FBQ0EsaUJBQU8sT0FBTyxDQUFQLEVBQUEsQ0FBVyxJQUFJLENBQWYsSUFBQSxFQUFBLE1BQUEsRUFBUCxPQUFPLENBQVA7QUFDRDs7QUFDRCxXQUFBLFNBQUE7QUFBZ0I7QUFDZCxjQUFJLEtBQUssQ0FBTCxVQUFBLENBQWlCLElBQUksQ0FBekIsSUFBSSxDQUFKLEVBQWlDO0FBQy9CLGdCQUFJLENBQUEsTUFBQSxFQUFBLE1BQUEsSUFBbUIsS0FBSyxDQUFMLEdBQUEsQ0FBVSxJQUFJLENBQXJDLElBQXVCLENBQXZCO0FBRUEsbUJBQU8sS0FBSyxDQUFMLE9BQUEsQ0FBQSxRQUFBLENBQXVCLElBQUksQ0FBM0IsSUFBQSxFQUFBLE1BQUEsRUFBQSxNQUFBLEVBQVAsT0FBTyxDQUFQO0FBSEYsV0FBQSxNQUlPO0FBQ0wsZ0JBQUksT0FBTyxHQUFHLEtBQUssQ0FBTCxNQUFBLEdBQWUsS0FBSyxDQUFwQixpQkFBQSxHQUFkLFVBQUE7QUFDQSxnQkFBSSxNQUFNLEdBQUcsS0FBSyxDQUFMLEtBQUEsQ0FBQSxZQUFBLENBQXlCLElBQUksQ0FBN0IsSUFBQSxFQUFiLE9BQWEsQ0FBYjtBQUVBLG1CQUFPLEtBQUssQ0FBTCxPQUFBLENBQUEsT0FBQSxDQUFzQjtBQUMzQixjQUFBLElBQUksRUFBRSxJQUFJLENBRGlCLElBQUE7QUFBQSxjQUFBLE9BQUE7QUFBQSxjQUFBLE1BQUE7QUFJM0IsY0FBQSxHQUFHLEVBQUU7QUFKc0IsYUFBdEIsQ0FBUDtBQU1EO0FBQ0Y7QUF2Qkg7QUF5QkQ7O0FBdkp1QjtBQTBKMUI7Ozs7O0FBR0EsTUFBQSxtQkFBQSxDQUF5QjtBQUN2QixFQUFBLFdBQUEsQ0FBQSxLQUFBLEVBQWdEO0FBQW5CLFNBQUEsS0FBQSxHQUFBLEtBQUE7QUFBdUI7O0FBRXBELEVBQUEsU0FBUyxDQUFBLElBQUEsRUFBc0I7QUFDN0IsWUFBUSxJQUFJLENBQVosSUFBQTtBQUNFLFdBQUEsa0JBQUE7QUFDRSxjQUFNLElBQUEsS0FBQSxDQUFOLGlFQUFNLENBQU47O0FBQ0YsV0FBQSxnQkFBQTtBQUNFLGVBQU8sS0FBQSxjQUFBLENBQVAsSUFBTyxDQUFQOztBQUNGLFdBQUEsYUFBQTtBQUNFLGVBQU8sSUFBQSxpQkFBQSxDQUFzQixLQUF0QixLQUFBLEVBQUEsV0FBQSxDQUFQLElBQU8sQ0FBUDs7QUFDRixXQUFBLG1CQUFBO0FBQ0UsZUFBTyxLQUFBLGlCQUFBLENBQVAsSUFBTyxDQUFQO0FBRUY7O0FBQ0EsV0FBQSwwQkFBQTtBQUNFLGVBQU8sS0FBQSx3QkFBQSxDQUFQLElBQU8sQ0FBUDs7QUFFRixXQUFBLGtCQUFBO0FBQXlCO0FBQ3ZCLGNBQUksR0FBRyxHQUFHLEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBZSxJQUFJLENBQTdCLEdBQVUsQ0FBVjtBQUNBLGlCQUFPLElBQUksS0FBSyxDQUFULFdBQUEsQ0FBc0I7QUFBQSxZQUFBLEdBQUE7QUFFM0IsWUFBQSxJQUFJLEVBQUUsR0FBRyxDQUFILEtBQUEsQ0FBVTtBQUFFLGNBQUEsU0FBUyxFQUFYLENBQUE7QUFBZ0IsY0FBQSxPQUFPLEVBQUU7QUFBekIsYUFBVixFQUFBLE9BQUEsQ0FBZ0QsSUFBSSxDQUFwRCxLQUFBO0FBRnFCLFdBQXRCLENBQVA7QUFJRDs7QUFFRCxXQUFBLFVBQUE7QUFDRSxlQUFPLElBQUksS0FBSyxDQUFULFFBQUEsQ0FBbUI7QUFDeEIsVUFBQSxHQUFHLEVBQUUsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLElBQUksQ0FEQSxHQUNuQixDQURtQjtBQUV4QixVQUFBLEtBQUssRUFBRSxJQUFJLENBQUM7QUFGWSxTQUFuQixDQUFQO0FBdkJKO0FBNEJEOztBQUVELEVBQUEsd0JBQXdCLENBQUEsSUFBQSxFQUFxQztBQUMzRCxRQUFJLEdBQUcsR0FBRyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsSUFBSSxDQUE3QixHQUFVLENBQVY7QUFDQSxRQUFBLE9BQUE7O0FBRUEsUUFBSSxHQUFHLENBQUgsUUFBQSxHQUFBLEtBQUEsQ0FBQSxDQUFBLEVBQUEsQ0FBQSxNQUFKLE9BQUEsRUFBNEM7QUFDMUMsTUFBQSxPQUFPLEdBQUcsR0FBRyxDQUFILEtBQUEsQ0FBVTtBQUFFLFFBQUEsU0FBUyxFQUFYLENBQUE7QUFBZ0IsUUFBQSxPQUFPLEVBQUU7QUFBekIsT0FBVixDQUFWO0FBREYsS0FBQSxNQUVPO0FBQ0wsTUFBQSxPQUFPLEdBQUcsR0FBRyxDQUFILEtBQUEsQ0FBVTtBQUFFLFFBQUEsU0FBUyxFQUFYLENBQUE7QUFBZ0IsUUFBQSxPQUFPLEVBQUU7QUFBekIsT0FBVixDQUFWO0FBQ0Q7O0FBRUQsV0FBTyxJQUFJLEtBQUssQ0FBVCxjQUFBLENBQXlCO0FBQUEsTUFBQSxHQUFBO0FBRTlCLE1BQUEsSUFBSSxFQUFFLE9BQU8sQ0FBUCxPQUFBLENBQWdCLElBQUksQ0FBcEIsS0FBQTtBQUZ3QixLQUF6QixDQUFQO0FBSUQ7QUFFRDs7Ozs7QUFHQSxFQUFBLGlCQUFpQixDQUFBLFFBQUEsRUFBa0M7QUFDakQsUUFBSTtBQUFFLE1BQUE7QUFBRixRQUFKLFFBQUE7QUFDQSxRQUFJLEdBQUcsR0FBRyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsUUFBUSxDQUZnQixHQUV2QyxDQUFWLENBRmlELENBSWpEOztBQUNBLFFBQUksU0FBUyxHQUFHLEtBQUEsSUFBQSxDQUFBLFNBQUEsQ0FDZDtBQUNFLE1BQUEsSUFBSSxFQUFFLFFBQVEsQ0FEaEIsSUFBQTtBQUVFLE1BQUEsTUFBTSxFQUFFLFFBQVEsQ0FGbEIsTUFBQTtBQUdFLE1BQUEsSUFBSSxFQUFFLFFBQVEsQ0FBQztBQUhqQixLQURjLEVBTWQsMENBTkYsUUFNRSxDQU5jLENBQWhCO0FBU0EsUUFBSSxLQUFLLEdBQUcsU0FBUyxDQUFULElBQUEsQ0FBQSxPQUFBLEtBQ1IsU0FBUyxDQURELE1BQUEsR0FFUixLQUFBLEtBQUEsQ0FBQSxPQUFBLENBQUEsSUFBQSxDQUFBLFNBQUEsRUFGSixHQUVJLENBRko7QUFJQSxXQUFPLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxNQUFBLENBQ0w7QUFDRSxNQUFBLEtBQUssRUFBRSxLQUFBLEtBQUEsQ0FEVCxLQUFBO0FBRUUsTUFBQSxRQUFRLEVBQUUsQ0FGWixPQUFBO0FBR0UsTUFBQTtBQUhGLEtBREssRUFBUCxHQUFPLENBQVA7QUFRRDtBQUVEOzs7OztBQUdBLEVBQUEsY0FBYyxDQUFBLEtBQUEsRUFBNEI7QUFDeEMsUUFBSTtBQUFBLE1BQUEsT0FBQTtBQUFXLE1BQUE7QUFBWCxRQUFKLEtBQUE7QUFDQSxRQUFJLEdBQUcsR0FBRyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsS0FBSyxDQUE5QixHQUFVLENBQVY7QUFFQSxRQUFJLFVBQVUsR0FBRyxLQUFBLEtBQUEsQ0FBQSxhQUFBLENBQUEsS0FBQSxFQUFqQixtQ0FBaUIsQ0FBakI7O0FBRUEsUUFBSSxVQUFVLENBQVYsVUFBQSxLQUFKLE9BQUEsRUFBdUM7QUFDckMsWUFBTSxzQ0FDSix3Q0FBd0MsVUFBVSxDQUFDLElBQUksYUFBYSxVQUFVLENBQUMsSUFEeEQsbUJBQW5CLEVBQU4sR0FBTSxDQUFOO0FBSUQ7O0FBRUQsUUFBSSxTQUFTLEdBQUcsS0FBQSxJQUFBLENBQUEsU0FBQSxDQUFBLEtBQUEsRUFBMkIsVUFBVSxDQUFyRCxVQUFnQixDQUFoQjtBQUVBLFdBQU8sS0FBQSxLQUFBLENBQUEsT0FBQSxDQUFBLGNBQUEsQ0FDTCxrQkFDRTtBQUNFLE1BQUEsT0FBTyxFQUFFLEtBQUEsS0FBQSxDQURYLEtBQUE7QUFFRSxNQUFBLE9BQU8sRUFBRSxLQUFBLEtBQUEsQ0FGWCxPQUVXLENBRlg7QUFHRSxNQUFBLE9BQU8sRUFBRSxPQUFPLEdBQUcsS0FBQSxLQUFBLENBQUgsT0FBRyxDQUFILEdBQXlCO0FBSDNDLEtBREYsRUFESyxTQUNMLENBREssRUFBUCxHQUFPLENBQVA7QUFXRDs7QUFFRCxFQUFBLEtBQUssQ0FBQztBQUFBLElBQUEsSUFBQTtBQUFBLElBQUEsR0FBQTtBQUFhLElBQUE7QUFBYixHQUFELEVBQXdDO0FBQzNDLFFBQUksS0FBSyxHQUFHLEtBQUEsS0FBQSxDQUFBLEtBQUEsQ0FBWixXQUFZLENBQVo7QUFDQSxRQUFJLFVBQVUsR0FBRyxJQUFBLG1CQUFBLENBQWpCLEtBQWlCLENBQWpCO0FBQ0EsV0FBTyxJQUFBLGFBQUEsQ0FDTCxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBREssR0FDTCxDQURLLEVBRUwsSUFBSSxDQUFKLEdBQUEsQ0FBVSxDQUFELElBQU8sVUFBVSxDQUFWLFNBQUEsQ0FGWCxDQUVXLENBQWhCLENBRkssRUFHTCxLQUhLLEtBQUEsRUFBQSxXQUFBLENBSU8sS0FBSyxDQUpuQixLQUFPLENBQVA7QUFLRDs7QUFFRCxNQUFBLElBQUEsR0FBZ0I7QUFDZCxXQUFPLElBQUEsb0JBQUEsQ0FBeUIsS0FBaEMsS0FBTyxDQUFQO0FBQ0Q7O0FBNUhzQjs7QUErSHpCLE1BQUEsaUJBQUEsQ0FBdUI7QUFDckIsRUFBQSxXQUFBLENBQUEsR0FBQSxFQUE4QztBQUFqQixTQUFBLEdBQUEsR0FBQSxHQUFBO0FBQXFCO0FBRWxEOzs7Ozs7Ozs7Ozs7Ozs7O0FBY0EsRUFBQSxXQUFXLENBQUEsT0FBQSxFQUEyQjtBQUNwQyxRQUFJO0FBQUEsTUFBQSxHQUFBO0FBQUEsTUFBQSxXQUFBO0FBQW9CLE1BQUE7QUFBcEIsUUFBSixPQUFBO0FBQ0EsUUFBSSxHQUFHLEdBQUcsS0FBQSxHQUFBLENBQUEsR0FBQSxDQUFhLE9BQU8sQ0FBOUIsR0FBVSxDQUFWO0FBRUEsUUFBSSxDQUFBLE9BQUEsRUFBVSxHQUFWLElBQUEsSUFBcUIsR0FBRyxDQUFILEtBQUEsQ0FKVyxHQUlYLENBQXpCLENBSm9DLENBTXBDOztBQUNBLFFBQUksSUFBSSxHQUFHLEtBQUEsV0FBQSxDQUFBLE9BQUEsRUFBQSxJQUFBLEVBQWdDLE9BQU8sQ0FBbEQsR0FBVyxDQUFYO0FBRUEsUUFBSSxLQUFLLEdBQUcsT0FBTyxDQUFQLFVBQUEsQ0FBQSxNQUFBLENBQTJCLENBQUQsSUFBTyxDQUFDLENBQUQsSUFBQSxDQUFBLENBQUEsTUFBakMsR0FBQSxFQUFBLEdBQUEsQ0FBeUQsQ0FBRCxJQUFPLEtBQUEsSUFBQSxDQUEzRSxDQUEyRSxDQUEvRCxDQUFaO0FBQ0EsUUFBSSxJQUFJLEdBQUcsT0FBTyxDQUFQLFVBQUEsQ0FBQSxNQUFBLENBQTJCLENBQUQsSUFBTyxDQUFDLENBQUQsSUFBQSxDQUFBLENBQUEsTUFBakMsR0FBQSxFQUFBLEdBQUEsQ0FBeUQsQ0FBRCxJQUFPLEtBQUEsR0FBQSxDQUExRSxDQUEwRSxDQUEvRCxDQUFYO0FBRUEsUUFBSSxTQUFTLEdBQUcsT0FBTyxDQUFQLFNBQUEsQ0FBQSxHQUFBLENBQXVCLENBQUQsSUFBTyxLQUFBLFFBQUEsQ0FaVCxDQVlTLENBQTdCLENBQWhCLENBWm9DLENBY3BDOztBQUNBLFFBQUksS0FBSyxHQUFHLEtBQUEsR0FBQSxDQUFBLEtBQUEsQ0FBZSxPQUFPLENBQWxDLFdBQVksQ0FBWjtBQUNBLFFBQUksVUFBVSxHQUFHLElBQUEsbUJBQUEsQ0FBakIsS0FBaUIsQ0FBakI7QUFFQSxRQUFJLFVBQVUsR0FBRyxPQUFPLENBQVAsUUFBQSxDQUFBLEdBQUEsQ0FBc0IsQ0FBRCxJQUFPLFVBQVUsQ0FBVixTQUFBLENBQTdDLENBQTZDLENBQTVCLENBQWpCO0FBRUEsUUFBSSxFQUFFLEdBQUcsS0FBQSxHQUFBLENBQUEsT0FBQSxDQUFBLE9BQUEsQ0FBeUI7QUFBQSxNQUFBLFdBQUE7QUFBQSxNQUFBLEtBQUE7QUFHaEMsTUFBQSxhQUFhLEVBSG1CLElBQUE7QUFBQSxNQUFBLFNBQUE7QUFLaEMsTUFBQSxRQUFRLEVBQUUsUUFBUSxDQUFSLEdBQUEsQ0FBYyxDQUFELElBQU8sSUFBQSxtQkFBQSxDQUF3QixLQUF4QixHQUFBLEVBQUEsd0JBQUEsQ0FBcEIsQ0FBb0IsQ0FBcEI7QUFMc0IsS0FBekIsQ0FBVDtBQVFBLFFBQUksUUFBUSxHQUFHLElBQUEsZUFBQSxDQUFBLEVBQUEsRUFBQSxHQUFBLEVBQUEsVUFBQSxFQUF5QyxLQUF4RCxHQUFlLENBQWY7QUFFQSxRQUFJLE9BQU8sR0FBRyxLQUFBLEdBQUEsQ0FBQSxHQUFBLENBQWEsT0FBTyxDQUFsQyxHQUFjLENBQWQ7QUFDQSxRQUFJLFVBQVUsR0FBRyxPQUFPLENBQVAsZUFBQSxDQUF3QjtBQUFFLE1BQUEsS0FBSyxFQUFFLEdBQUcsQ0FBWixNQUFBO0FBQXFCLE1BQUEsU0FBUyxFQUFFO0FBQWhDLEtBQXhCLENBQWpCOztBQUVBLFFBQUksSUFBSSxLQUFSLGFBQUEsRUFBNEI7QUFDMUIsVUFBSSxHQUFHLENBQUgsQ0FBRyxDQUFILEtBQUosR0FBQSxFQUFvQjtBQUNsQixlQUFPLFFBQVEsQ0FBUixnQkFBQSxDQUNMLFVBQVUsQ0FBVixLQUFBLENBQWlCO0FBQUUsVUFBQSxTQUFTLEVBQUU7QUFBYixTQUFqQixFQUFBLE9BQUEsQ0FBMkMsR0FBRyxDQUFILEtBQUEsQ0FEdEMsQ0FDc0MsQ0FBM0MsQ0FESyxFQUVMLEtBQUssQ0FGUCxLQUFPLENBQVA7QUFERixPQUFBLE1BS087QUFDTCxlQUFPLFFBQVEsQ0FBUixhQUFBLENBQXVCLFVBQVUsQ0FBVixPQUFBLENBQXZCLEdBQXVCLENBQXZCLEVBQWdELE9BQU8sQ0FBUCxXQUFBLENBQUEsTUFBQSxHQUF2RCxDQUFPLENBQVA7QUFDRDtBQUNGOztBQUVELFFBQUksT0FBTyxDQUFYLFdBQUEsRUFBeUI7QUFDdkIsYUFBTyxFQUFFLENBQUYsb0JBQUEsQ0FBQSxJQUFBLEVBQVAsR0FBTyxDQUFQO0FBREYsS0FBQSxNQUVPO0FBQ0wsVUFBSSxNQUFNLEdBQUcsUUFBUSxDQUFSLGVBQUEsQ0FBQSxHQUFBLEVBQThCLEtBQUssQ0FBbkMsS0FBQSxFQUEyQyxPQUFPLENBQVAsV0FBQSxDQUFBLE1BQUEsR0FBeEQsQ0FBYSxDQUFiO0FBQ0EsYUFBTyxFQUFFLENBQUYsd0JBQUEsQ0FBQSxJQUFBLEVBQUEsTUFBQSxFQUFQLEdBQU8sQ0FBUDtBQUNEO0FBQ0Y7O0FBRU8sRUFBQSxRQUFRLENBQUEsQ0FBQSxFQUFrQztBQUNoRCxRQUFJLFVBQVUsR0FBRyxLQUFBLEdBQUEsQ0FBQSxhQUFBLENBQUEsQ0FBQSxFQUFqQixzQ0FBaUIsQ0FBakI7O0FBRUEsUUFBSSxVQUFVLENBQVYsVUFBQSxLQUFKLE9BQUEsRUFBdUM7QUFDckMsWUFBTSxzQ0FDSix3Q0FBd0MsVUFBVSxDQUFDLElBQUksNEJBQTRCLFVBQVUsQ0FBQyxJQUR2RSxxRUFBbkIsRUFFSixDQUFDLENBRkgsR0FBTSxDQUFOO0FBSUQ7O0FBRUQsUUFBSSxTQUFTLEdBQUcsS0FBQSxJQUFBLENBQUEsU0FBQSxDQUFBLENBQUEsRUFBdUIsVUFBVSxDQUFqRCxVQUFnQixDQUFoQjtBQUNBLFdBQU8sS0FBQSxHQUFBLENBQUEsT0FBQSxDQUFBLFFBQUEsQ0FBQSxTQUFBLEVBQXFDLEtBQUEsR0FBQSxDQUFBLEdBQUEsQ0FBYSxDQUFDLENBQTFELEdBQTRDLENBQXJDLENBQVA7QUFDRDtBQUVEOzs7Ozs7Ozs7OztBQVNRLEVBQUEsWUFBWSxDQUFBLFFBQUEsRUFBa0M7QUFDcEQ7QUFDQSxRQUFJLElBQUksR0FBRyxLQUFBLEdBQUEsQ0FBQSxPQUFBLENBQUEsSUFBQSxDQUNULEtBQUEsSUFBQSxDQUFBLFNBQUEsQ0FBQSxRQUFBLEVBQThCLDZDQURyQixRQUNxQixDQUE5QixDQURTLEVBRVQsS0FBQSxHQUFBLENBQUEsR0FBQSxDQUFhLFFBQVEsQ0FKNkIsR0FJbEQsQ0FGUyxDQUFYLENBRm9ELENBT3BEOztBQUNBLFFBQUksSUFBSSxDQUFKLElBQUEsQ0FBSixPQUFJLEVBQUosRUFBeUI7QUFDdkIsYUFBTyxJQUFJLENBQVgsTUFBQTtBQURGLEtBQUEsTUFFTztBQUNMLGFBQUEsSUFBQTtBQUNEO0FBQ0Y7QUFFRDs7Ozs7O0FBSVEsRUFBQSxRQUFRLENBQUEsSUFBQSxFQUNnQztBQUU5QyxZQUFRLElBQUksQ0FBWixJQUFBO0FBQ0UsV0FBQSxtQkFBQTtBQUNFLGVBQU87QUFBRSxVQUFBLElBQUksRUFBRSxLQUFBLFlBQUEsQ0FBUixJQUFRLENBQVI7QUFBaUMsVUFBQSxRQUFRLEVBQUUsQ0FBQyxJQUFJLENBQUM7QUFBakQsU0FBUDs7QUFDRixXQUFBLFVBQUE7QUFDRSxlQUFPO0FBQ0wsVUFBQSxJQUFJLEVBQUUsS0FBQSxHQUFBLENBQUEsT0FBQSxDQUFBLE9BQUEsQ0FBeUIsSUFBSSxDQUE3QixLQUFBLEVBQXFDLEtBQUEsR0FBQSxDQUFBLEdBQUEsQ0FBYSxJQUFJLENBRHZELEdBQ3NDLENBQXJDLENBREQ7QUFFTCxVQUFBLFFBQVEsRUFBRTtBQUZMLFNBQVA7QUFKSjtBQVNEOztBQUVPLEVBQUEsU0FBUyxDQUFBLElBQUEsRUFDdUQ7QUFFdEUsWUFBUSxJQUFJLENBQVosSUFBQTtBQUNFLFdBQUEsaUJBQUE7QUFBd0I7QUFDdEIsY0FBSSxLQUFLLEdBQUcsSUFBSSxDQUFKLEtBQUEsQ0FBQSxHQUFBLENBQWdCLENBQUQsSUFBTyxLQUFBLFFBQUEsQ0FBQSxDQUFBLEVBQWxDLElBQVksQ0FBWjtBQUNBLGlCQUFPO0FBQ0wsWUFBQSxJQUFJLEVBQUUsS0FBQSxHQUFBLENBQUEsT0FBQSxDQUFBLFdBQUEsQ0FBQSxLQUFBLEVBQW9DLEtBQUEsR0FBQSxDQUFBLEdBQUEsQ0FBYSxJQUFJLENBRHRELEdBQ3FDLENBQXBDLENBREQ7QUFFTCxZQUFBLFFBQVEsRUFBRTtBQUZMLFdBQVA7QUFJRDs7QUFDRDtBQUNFLGVBQU8sS0FBQSxRQUFBLENBQVAsSUFBTyxDQUFQO0FBVEo7QUFXRDs7QUFFTyxFQUFBLElBQUksQ0FBQSxDQUFBLEVBQWtCO0FBQUEsYUFDNUIsa0JBQU8sQ0FBQyxDQUFELElBQUEsQ0FBQSxDQUFBLE1BQUQsR0FBTixFQUQ0QixzQ0FDNUIsQ0FENEI7O0FBRzVCLFFBQUksQ0FBQyxDQUFELElBQUEsS0FBSixlQUFBLEVBQWdDO0FBQzlCLGFBQU8sS0FBQSxHQUFBLENBQUEsT0FBQSxDQUFBLFNBQUEsQ0FBMkIsS0FBQSxHQUFBLENBQUEsS0FBQSxDQUFBLGFBQUEsQ0FBM0IsT0FBMkIsQ0FBM0IsRUFBa0UsS0FBQSxHQUFBLENBQUEsR0FBQSxDQUFhLENBQUMsQ0FBdkYsR0FBeUUsQ0FBbEUsQ0FBUDtBQUNEOztBQUVELFFBQUksT0FBTyxHQUFHLEtBQUEsR0FBQSxDQUFBLEdBQUEsQ0FBYSxDQUFDLENBQTVCLEdBQWMsQ0FBZDtBQUNBLFFBQUksU0FBUyxHQUFHLE9BQU8sQ0FBUCxlQUFBLENBQXdCO0FBQUUsTUFBQSxLQUFLLEVBQUUsQ0FBQyxDQUFELElBQUEsQ0FBTztBQUFoQixLQUF4QixFQUFBLE9BQUEsQ0FBMEQsQ0FBQyxDQUEzRSxJQUFnQixDQUFoQjtBQUVBLFFBQUksS0FBSyxHQUFHLEtBQUEsU0FBQSxDQUFlLENBQUMsQ0FBNUIsS0FBWSxDQUFaO0FBQ0EsV0FBTyxLQUFBLEdBQUEsQ0FBQSxPQUFBLENBQUEsSUFBQSxDQUNMO0FBQUUsTUFBQSxJQUFJLEVBQU4sU0FBQTtBQUFtQixNQUFBLEtBQUssRUFBRSxLQUFLLENBQS9CLElBQUE7QUFBc0MsTUFBQSxRQUFRLEVBQUUsS0FBSyxDQUFDO0FBQXRELEtBREssRUFBUCxPQUFPLENBQVA7QUFJRDs7QUFFTyxFQUFBLG1CQUFtQixDQUFBLEdBQUEsRUFBQSxJQUFBLEVBRTZDO0FBRXRFLFFBQUksS0FBQSxHQUFBLENBQUosTUFBQSxFQUFxQjtBQUNuQixhQUFBLElBQUE7QUFDRDs7QUFFRCxRQUFJLElBQUksQ0FBSixJQUFBLEtBQUosbUJBQUEsRUFBdUM7QUFDckMsYUFBQSxJQUFBO0FBQ0Q7O0FBRUQsUUFBSTtBQUFFLE1BQUE7QUFBRixRQUFKLElBQUE7O0FBRUEsUUFBSSxJQUFJLENBQUosSUFBQSxLQUFKLGdCQUFBLEVBQW9DO0FBQ2xDLGFBQUEsSUFBQTtBQUNEOztBQUVELFFBQUksSUFBSSxDQUFKLElBQUEsQ0FBQSxJQUFBLEtBQUosU0FBQSxFQUFrQztBQUNoQyxhQUFBLElBQUE7QUFDRDs7QUFFRCxRQUFJO0FBQUUsTUFBQTtBQUFGLFFBQVcsSUFBSSxDQUFuQixJQUFBOztBQUVBLFFBQUksSUFBSSxLQUFKLFdBQUEsSUFBd0IsSUFBSSxLQUFoQyxrQkFBQSxFQUF5RDtBQUN2RCxhQUFBLElBQUE7QUFDRDs7QUFFRCxRQUFJLEtBQUEsR0FBQSxDQUFBLFVBQUEsQ0FBSixJQUFJLENBQUosRUFBK0I7QUFDN0IsYUFBQSxJQUFBO0FBQ0Q7O0FBRUQsUUFBSSxJQUFJLENBQUosSUFBQSxDQUFBLE1BQUEsS0FBSixDQUFBLEVBQTRCO0FBQzFCLGFBQUEsSUFBQTtBQUNEOztBQUVELFFBQUksSUFBSSxDQUFKLE1BQUEsQ0FBQSxNQUFBLEtBQUEsQ0FBQSxJQUE0QixJQUFJLENBQUosSUFBQSxDQUFBLEtBQUEsQ0FBQSxNQUFBLEtBQWhDLENBQUEsRUFBOEQ7QUFDNUQsYUFBQSxJQUFBO0FBQ0Q7O0FBRUQsUUFBSSxPQUFPLEdBQUcsS0FBSyxDQUFMLG1CQUFBLENBQWQsSUFBYyxFQUFkO0FBRUEsUUFBSSxNQUFNLEdBQUcsS0FBQSxHQUFBLENBQUEsT0FBQSxDQUFBLE9BQUEsQ0FBeUI7QUFBQSxNQUFBLElBQUE7QUFBQSxNQUFBLE9BQUE7QUFHcEMsTUFBQSxNQUFNLEVBQUUsS0FBQSxHQUFBLENBQUEsS0FBQSxDQUFBLFlBQUEsQ0FBQSxJQUFBLEVBSDRCLE9BRzVCLENBSDRCO0FBSXBDLE1BQUEsR0FBRyxFQUFFLElBQUksQ0FBQztBQUowQixLQUF6QixDQUFiO0FBT0EsV0FBTztBQUNMLE1BQUEsSUFBSSxFQUFFLEtBQUEsR0FBQSxDQUFBLE9BQUEsQ0FBQSxjQUFBLENBQUEsR0FBQSxFQUFBLE1BQUEsRUFBNkMsSUFBSSxDQURsRCxHQUNDLENBREQ7QUFFTCxNQUFBLFFBQVEsRUFBRTtBQUZMLEtBQVA7QUFJRDs7QUFFTyxFQUFBLEdBQUcsQ0FBQSxHQUFBLEVBQW9CO0FBQUEsYUFDN0Isa0JBQU8sR0FBRyxDQUFILElBQUEsQ0FBQSxDQUFBLE1BQUQsR0FBTixFQUQ2QixpQ0FDN0IsQ0FENkI7QUFHN0IsUUFBSSxPQUFPLEdBQUcsS0FBQSxHQUFBLENBQUEsR0FBQSxDQUFhLEdBQUcsQ0FBOUIsR0FBYyxDQUFkO0FBQ0EsUUFBSSxTQUFTLEdBQUcsT0FBTyxDQUFQLGVBQUEsQ0FBd0I7QUFBRSxNQUFBLEtBQUssRUFBRSxHQUFHLENBQUgsSUFBQSxDQUFTO0FBQWxCLEtBQXhCLEVBQUEsT0FBQSxDQUE0RCxHQUFHLENBQS9FLElBQWdCLENBQWhCO0FBRUEsUUFBSSxLQUFLLEdBQUcsS0FBQSxtQkFBQSxDQUFBLFNBQUEsRUFBb0MsR0FBRyxDQUF2QyxLQUFBLEtBQWtELEtBQUEsU0FBQSxDQUFlLEdBQUcsQ0FBaEYsS0FBOEQsQ0FBOUQ7QUFDQSxXQUFPLEtBQUEsR0FBQSxDQUFBLE9BQUEsQ0FBQSxHQUFBLENBQ0w7QUFBRSxNQUFBLElBQUksRUFBTixTQUFBO0FBQW1CLE1BQUEsS0FBSyxFQUFFLEtBQUssQ0FBL0IsSUFBQTtBQUFzQyxNQUFBLFFBQVEsRUFBRSxLQUFLLENBQUM7QUFBdEQsS0FESyxFQUFQLE9BQU8sQ0FBUDtBQUlEO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBZVEsRUFBQSxXQUFXLENBQUEsUUFBQSxFQUFBLElBQUEsRUFBQSxHQUFBLEVBR0Y7QUFFZixRQUFJLFNBQVMsR0FBRyx3QkFBaEIsUUFBZ0IsQ0FBaEI7QUFDQSxRQUFJLE9BQU8sR0FBRyxRQUFRLENBQVIsQ0FBUSxDQUFSLEtBQUEsR0FBQSxJQUF1QixRQUFRLEtBQS9CLE1BQUEsSUFBOEMsS0FBQSxHQUFBLENBQUEsVUFBQSxDQUE1RCxRQUE0RCxDQUE1RDs7QUFFQSxRQUFJLEtBQUEsR0FBQSxDQUFBLE1BQUEsSUFBbUIsQ0FBdkIsT0FBQSxFQUFpQztBQUMvQixVQUFBLFNBQUEsRUFBZTtBQUNiLGNBQU0sc0NBQ0osdUZBQXVGLFFBQVEsd0ZBQXdGLFFBQVEsQ0FBUixXQUFBLEVBRGhLLEtBQW5CLEVBQU4sR0FBTSxDQUFOO0FBRjZCLE9BQUEsQ0FRL0I7OztBQUNBLGFBQUEsYUFBQTtBQWRhLEtBQUEsQ0FpQmY7QUFDQTtBQUNBOzs7QUFDQSxRQUFJLFdBQVcsR0FBRyxPQUFPLElBQXpCLFNBQUE7QUFFQSxRQUFJLFdBQVcsR0FBRyxHQUFHLENBQUgsZUFBQSxDQUFvQjtBQUFFLE1BQUEsU0FBUyxFQUFYLENBQUE7QUFBZ0IsTUFBQSxLQUFLLEVBQUUsUUFBUSxDQUFDO0FBQWhDLEtBQXBCLENBQWxCO0FBRUEsUUFBSSxVQUFVLEdBQUcsSUFBSSxDQUFKLE1BQUEsQ0FBWSxDQUFBLEtBQUEsRUFBQSxJQUFBLEtBQWlCLEtBQUssR0FBTCxDQUFBLEdBQVksSUFBSSxDQUE3QyxNQUFBLEVBQWpCLENBQWlCLENBQWpCO0FBQ0EsUUFBSSxPQUFPLEdBQUcsV0FBVyxDQUFYLE1BQUEsR0FBQSxJQUFBLENBQWQsVUFBYyxDQUFkO0FBQ0EsUUFBSSxPQUFPLEdBQUcsV0FBVyxDQUFYLE9BQUEsQ0FBZCxPQUFjLENBQWQ7O0FBRUEsUUFBQSxXQUFBLEVBQWlCO0FBQ2YsVUFBSSxJQUFJLEdBQUcsd0JBQUEsSUFBQSxDQUFPO0FBQ2hCLFFBQUEsSUFBSSxFQUFFLHdCQUFBLElBQUEsQ0FBQSxRQUFBLEVBRFUsV0FDVixDQURVO0FBQUEsUUFBQSxJQUFBO0FBR2hCLFFBQUEsR0FBRyxFQUFFO0FBSFcsT0FBUCxDQUFYOztBQU1BLFVBQUksVUFBVSxHQUFHLEtBQUEsR0FBQSxDQUFBLGFBQUEsQ0FBQSxJQUFBLEVBQWpCLHVDQUFpQixDQUFqQjs7QUFFQSxVQUFJLFVBQVUsQ0FBVixVQUFBLEtBQUosT0FBQSxFQUF1QztBQUNyQyxjQUFNLHNDQUNKLHNDQUFzQyxVQUFVLENBQUMsSUFBSSxZQUFZLFVBQVUsQ0FBQyxJQURyRCxtQkFBbkIsRUFBTixHQUFNLENBQU47QUFJRDs7QUFFRCxhQUFPLElBQUEsb0JBQUEsQ0FBeUIsS0FBekIsR0FBQSxFQUFBLFNBQUEsQ0FBQSxJQUFBL