diff --git a/docs/index.html b/docs/index.html
index fcd2d200..d31e982b 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,9 +1,18 @@
Prettier
-
-
-
+
+
+
+
@@ -94,7 +103,7 @@
-
+
@@ -113,6 +122,7 @@
-
diff --git a/docs/index.js b/docs/index.js
new file mode 100644
index 00000000..c34a63e2
--- /dev/null
+++ b/docs/index.js
@@ -0,0 +1,12425 @@
+'use strict';
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var require$$0 = _interopDefault(require('assert'));
+
+function assertDoc(val) {
+ if (
+ !(typeof val === "string" || (val != null && typeof val.type === "string"))
+ ) {
+ throw new Error(
+ "Value " + JSON.stringify(val) + " is not a valid document"
+ );
+ }
+}
+
+function concat$1(parts) {
+ parts.forEach(assertDoc);
+
+ // We cannot do this until we change `printJSXElement` to not
+ // access the internals of a document directly.
+ // if(parts.length === 1) {
+ // // If it's a single document, no need to concat it.
+ // return parts[0];
+ // }
+ return { type: "concat", parts };
+}
+
+function indent$1(contents) {
+ assertDoc(contents);
+
+ return { type: "indent", contents };
+}
+
+function align(n, contents) {
+ assertDoc(contents);
+
+ return { type: "align", contents, n };
+}
+
+function group(contents, opts) {
+ opts = opts || {};
+
+ assertDoc(contents);
+
+ return {
+ type: "group",
+ contents: contents,
+ break: !!opts.shouldBreak,
+ expandedStates: opts.expandedStates
+ };
+}
+
+function conditionalGroup(states, opts) {
+ return group(
+ states[0],
+ Object.assign(opts || {}, { expandedStates: states })
+ );
+}
+
+function fill(parts) {
+ parts.forEach(assertDoc);
+
+ return { type: "fill", parts };
+}
+
+function ifBreak(breakContents, flatContents) {
+ if (breakContents) {
+ assertDoc(breakContents);
+ }
+ if (flatContents) {
+ assertDoc(flatContents);
+ }
+
+ return { type: "if-break", breakContents, flatContents };
+}
+
+function lineSuffix$1(contents) {
+ assertDoc(contents);
+ return { type: "line-suffix", contents };
+}
+
+const lineSuffixBoundary = { type: "line-suffix-boundary" };
+const breakParent$1 = { type: "break-parent" };
+const line = { type: "line" };
+const softline = { type: "line", soft: true };
+const hardline$1 = concat$1([{ type: "line", hard: true }, breakParent$1]);
+const literalline = concat$1([
+ { type: "line", hard: true, literal: true },
+ breakParent$1
+]);
+
+function join$1(sep, arr) {
+ const res = [];
+
+ for (let i = 0; i < arr.length; i++) {
+ if (i !== 0) {
+ res.push(sep);
+ }
+
+ res.push(arr[i]);
+ }
+
+ return concat$1(res);
+}
+
+function addAlignmentToDoc(doc, size, tabWidth) {
+ let aligned = doc;
+ if (size > 0) {
+ // Use indent to add tabs for all the levels of tabs we need
+ for (let i = 0; i < Math.floor(size / tabWidth); ++i) {
+ aligned = indent$1(aligned);
+ }
+ // Use align for all the spaces that are needed
+ aligned = align(size % tabWidth, aligned);
+ // size is absolute from 0 and not relative to the current
+ // indentation, so we use -Infinity to reset the indentation to 0
+ aligned = align(-Infinity, aligned);
+ }
+ return aligned;
+}
+
+var docBuilders$1 = {
+ concat: concat$1,
+ join: join$1,
+ line,
+ softline,
+ hardline: hardline$1,
+ literalline,
+ group,
+ conditionalGroup,
+ fill,
+ lineSuffix: lineSuffix$1,
+ lineSuffixBoundary,
+ breakParent: breakParent$1,
+ ifBreak,
+ indent: indent$1,
+ align,
+ addAlignmentToDoc
+};
+
+function isExportDeclaration(node) {
+ if (node) {
+ switch (node.type) {
+ case "ExportDeclaration":
+ case "ExportDefaultDeclaration":
+ case "ExportDefaultSpecifier":
+ case "DeclareExportDeclaration":
+ case "ExportNamedDeclaration":
+ case "ExportAllDeclaration":
+ return true;
+ }
+ }
+
+ return false;
+}
+
+function getParentExportDeclaration(path) {
+ const parentNode = path.getParentNode();
+ if (path.getName() === "declaration" && isExportDeclaration(parentNode)) {
+ return parentNode;
+ }
+
+ return null;
+}
+
+function getPenultimate(arr) {
+ if (arr.length > 1) {
+ return arr[arr.length - 2];
+ }
+ return null;
+}
+
+function getLast(arr) {
+ if (arr.length > 0) {
+ return arr[arr.length - 1];
+ }
+ return null;
+}
+
+function skip(chars) {
+ return (text, index, opts) => {
+ const backwards = opts && opts.backwards;
+
+ // Allow `skip` functions to be threaded together without having
+ // to check for failures (did someone say monads?).
+ if (index === false) {
+ return false;
+ }
+
+ const length = text.length;
+ let cursor = index;
+ while (cursor >= 0 && cursor < length) {
+ const c = text.charAt(cursor);
+ if (chars instanceof RegExp) {
+ if (!chars.test(c)) {
+ return cursor;
+ }
+ } else if (chars.indexOf(c) === -1) {
+ return cursor;
+ }
+
+ backwards ? cursor-- : cursor++;
+ }
+
+ if (cursor === -1 || cursor === length) {
+ // If we reached the beginning or end of the file, return the
+ // out-of-bounds cursor. It's up to the caller to handle this
+ // correctly. We don't want to indicate `false` though if it
+ // actually skipped valid characters.
+ return cursor;
+ }
+ return false;
+ };
+}
+
+const skipWhitespace = skip(/\s/);
+const skipSpaces = skip(" \t");
+const skipToLineEnd = skip(",; \t");
+const skipEverythingButNewLine = skip(/[^\r\n]/);
+
+function skipInlineComment(text, index) {
+ if (index === false) {
+ return false;
+ }
+
+ if (text.charAt(index) === "/" && text.charAt(index + 1) === "*") {
+ for (let i = index + 2; i < text.length; ++i) {
+ if (text.charAt(i) === "*" && text.charAt(i + 1) === "/") {
+ return i + 2;
+ }
+ }
+ }
+ return index;
+}
+
+function skipTrailingComment(text, index) {
+ if (index === false) {
+ return false;
+ }
+
+ if (text.charAt(index) === "/" && text.charAt(index + 1) === "/") {
+ return skipEverythingButNewLine(text, index);
+ }
+ return index;
+}
+
+// This one doesn't use the above helper function because it wants to
+// test \r\n in order and `skip` doesn't support ordering and we only
+// want to skip one newline. It's simple to implement.
+function skipNewline(text, index, opts) {
+ const backwards = opts && opts.backwards;
+ if (index === false) {
+ return false;
+ }
+
+ const atIndex = text.charAt(index);
+ if (backwards) {
+ if (text.charAt(index - 1) === "\r" && atIndex === "\n") {
+ return index - 2;
+ }
+ if (
+ atIndex === "\n" ||
+ atIndex === "\r" ||
+ atIndex === "\u2028" ||
+ atIndex === "\u2029"
+ ) {
+ return index - 1;
+ }
+ } else {
+ if (atIndex === "\r" && text.charAt(index + 1) === "\n") {
+ return index + 2;
+ }
+ if (
+ atIndex === "\n" ||
+ atIndex === "\r" ||
+ atIndex === "\u2028" ||
+ atIndex === "\u2029"
+ ) {
+ return index + 1;
+ }
+ }
+
+ return index;
+}
+
+function hasNewline(text, index, opts) {
+ opts = opts || {};
+ const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts);
+ const idx2 = skipNewline(text, idx, opts);
+ return idx !== idx2;
+}
+
+function hasNewlineInRange(text, start, end) {
+ for (let i = start; i < end; ++i) {
+ if (text.charAt(i) === "\n") {
+ return true;
+ }
+ }
+ return false;
+}
+
+// Note: this function doesn't ignore leading comments unlike isNextLineEmpty
+function isPreviousLineEmpty(text, node) {
+ let idx = locStart$1(node) - 1;
+ idx = skipSpaces(text, idx, { backwards: true });
+ idx = skipNewline(text, idx, { backwards: true });
+ idx = skipSpaces(text, idx, { backwards: true });
+ const idx2 = skipNewline(text, idx, { backwards: true });
+ return idx !== idx2;
+}
+
+function isNextLineEmpty(text, node) {
+ let oldIdx = null;
+ let idx = locEnd$1(node);
+ while (idx !== oldIdx) {
+ // We need to skip all the potential trailing inline comments
+ oldIdx = idx;
+ idx = skipToLineEnd(text, idx);
+ idx = skipInlineComment(text, idx);
+ idx = skipSpaces(text, idx);
+ }
+ idx = skipTrailingComment(text, idx);
+ idx = skipNewline(text, idx);
+ return hasNewline(text, idx);
+}
+
+function getNextNonSpaceNonCommentCharacter$1(text, node) {
+ let oldIdx = null;
+ let idx = locEnd$1(node);
+ while (idx !== oldIdx) {
+ oldIdx = idx;
+ idx = skipSpaces(text, idx);
+ idx = skipInlineComment(text, idx);
+ idx = skipTrailingComment(text, idx);
+ idx = skipNewline(text, idx);
+ }
+ return text.charAt(idx);
+}
+
+function hasSpaces(text, index, opts) {
+ opts = opts || {};
+ const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts);
+ return idx !== index;
+}
+
+function locStart$1(node) {
+ if (node.decorators && node.decorators.length > 0) {
+ return locStart$1(node.decorators[0]);
+ }
+ if (node.range) {
+ return node.range[0];
+ }
+ if (typeof node.start === "number") {
+ return node.start;
+ }
+ if (node.source) {
+ return lineColumnToIndex(node.source.start, node.source.input.css) - 1;
+ }
+}
+
+function locEnd$1(node) {
+ if (node.range) {
+ return node.range[1];
+ }
+ if (typeof node.end === "number") {
+ return node.end;
+ }
+ if (node.source) {
+ return lineColumnToIndex(node.source.end, node.source.input.css);
+ }
+}
+
+// Super inefficient, needs to be cached.
+function lineColumnToIndex(lineColumn, text) {
+ let index = 0;
+ for (let i = 0; i < lineColumn.line - 1; ++i) {
+ index = text.indexOf("\n", index) + 1;
+ if (index === -1) {
+ return -1;
+ }
+ }
+ return index + lineColumn.column;
+}
+
+function setLocStart(node, index) {
+ if (node.range) {
+ node.range[0] = index;
+ } else {
+ node.start = index;
+ }
+}
+
+function setLocEnd(node, index) {
+ if (node.range) {
+ node.range[1] = index;
+ } else {
+ node.end = index;
+ }
+}
+
+const PRECEDENCE = {};
+[
+ ["||"],
+ ["&&"],
+ ["|"],
+ ["^"],
+ ["&"],
+ ["==", "===", "!=", "!=="],
+ ["<", ">", "<=", ">=", "in", "instanceof"],
+ [">>", "<<", ">>>"],
+ ["+", "-"],
+ ["*", "/", "%"],
+ ["**"]
+].forEach((tier, i) => {
+ tier.forEach(op => {
+ PRECEDENCE[op] = i;
+ });
+});
+
+function getPrecedence(op) {
+ return PRECEDENCE[op];
+}
+
+// Tests if an expression starts with `{`, or (if forbidFunctionAndClass holds) `function` or `class`.
+// Will be overzealous if there's already necessary grouping parentheses.
+function startsWithNoLookaheadToken(node, forbidFunctionAndClass) {
+ node = getLeftMost(node);
+ switch (node.type) {
+ case "FunctionExpression":
+ case "ClassExpression":
+ return forbidFunctionAndClass;
+ case "ObjectExpression":
+ return true;
+ case "MemberExpression":
+ return startsWithNoLookaheadToken(node.object, forbidFunctionAndClass);
+ case "TaggedTemplateExpression":
+ if (node.tag.type === "FunctionExpression") {
+ // IIFEs are always already parenthesized
+ return false;
+ }
+ return startsWithNoLookaheadToken(node.tag, forbidFunctionAndClass);
+ case "CallExpression":
+ if (node.callee.type === "FunctionExpression") {
+ // IIFEs are always already parenthesized
+ return false;
+ }
+ return startsWithNoLookaheadToken(node.callee, forbidFunctionAndClass);
+ case "ConditionalExpression":
+ return startsWithNoLookaheadToken(node.test, forbidFunctionAndClass);
+ case "UpdateExpression":
+ return (
+ !node.prefix &&
+ startsWithNoLookaheadToken(node.argument, forbidFunctionAndClass)
+ );
+ case "BindExpression":
+ return (
+ node.object &&
+ startsWithNoLookaheadToken(node.object, forbidFunctionAndClass)
+ );
+ case "SequenceExpression":
+ return startsWithNoLookaheadToken(
+ node.expressions[0],
+ forbidFunctionAndClass
+ );
+ default:
+ return false;
+ }
+}
+
+function getLeftMost(node) {
+ if (node.left) {
+ return getLeftMost(node.left);
+ } else {
+ return node;
+ }
+}
+
+function hasBlockComments(node) {
+ return node.comments && node.comments.some(isBlockComment);
+}
+
+function isBlockComment(comment) {
+ return comment.type === "Block" || comment.type === "CommentBlock";
+}
+
+function getAlignmentSize(value, tabWidth, startIndex) {
+ startIndex = startIndex || 0;
+
+ let size = 0;
+ for (let i = startIndex; i < value.length; ++i) {
+ if (value[i] === "\t") {
+ // Tabs behave in a way that they are aligned to the nearest
+ // multiple of tabWidth:
+ // 0 -> 4, 1 -> 4, 2 -> 4, 3 -> 4
+ // 4 -> 8, 5 -> 8, 6 -> 8, 7 -> 8 ...
+ size = size + tabWidth - size % tabWidth;
+ } else {
+ size++;
+ }
+ }
+
+ return size;
+}
+
+var util$2 = {
+ getPrecedence,
+ isExportDeclaration,
+ getParentExportDeclaration,
+ getPenultimate,
+ getLast,
+ getNextNonSpaceNonCommentCharacter: getNextNonSpaceNonCommentCharacter$1,
+ skipWhitespace,
+ skipSpaces,
+ skipNewline,
+ isNextLineEmpty,
+ isPreviousLineEmpty,
+ hasNewline,
+ hasNewlineInRange,
+ hasSpaces,
+ locStart: locStart$1,
+ locEnd: locEnd$1,
+ setLocStart,
+ setLocEnd,
+ startsWithNoLookaheadToken,
+ hasBlockComments,
+ isBlockComment,
+ getAlignmentSize
+};
+
+const assert = require$$0;
+const docBuilders = docBuilders$1;
+const concat = docBuilders.concat;
+const hardline = docBuilders.hardline;
+const breakParent = docBuilders.breakParent;
+const indent = docBuilders.indent;
+const lineSuffix = docBuilders.lineSuffix;
+const join = docBuilders.join;
+const util$1 = util$2;
+const childNodesCacheKey = Symbol("child-nodes");
+const locStart = util$1.locStart;
+const locEnd = util$1.locEnd;
+const getNextNonSpaceNonCommentCharacter =
+ util$1.getNextNonSpaceNonCommentCharacter;
+
+function getSortedChildNodes(node, text, resultArray) {
+ if (!node) {
+ return;
+ }
+
+ if (resultArray) {
+ if (
+ node &&
+ node.type &&
+ node.type !== "CommentBlock" &&
+ node.type !== "CommentLine" &&
+ node.type !== "Line" &&
+ node.type !== "Block" &&
+ node.type !== "EmptyStatement" &&
+ node.type !== "TemplateElement"
+ ) {
+ // This reverse insertion sort almost always takes constant
+ // time because we almost always (maybe always?) append the
+ // nodes in order anyway.
+ let i;
+ for (i = resultArray.length - 1; i >= 0; --i) {
+ if (
+ locStart(resultArray[i]) <= locStart(node) &&
+ locEnd(resultArray[i]) <= locEnd(node)
+ ) {
+ break;
+ }
+ }
+ resultArray.splice(i + 1, 0, node);
+ return;
+ }
+ } else if (node[childNodesCacheKey]) {
+ return node[childNodesCacheKey];
+ }
+
+ let names;
+ if (node && typeof node === "object") {
+ names = Object.keys(node).filter(
+ n =>
+ n !== "enclosingNode" && n !== "precedingNode" && n !== "followingNode"
+ );
+ } else {
+ return;
+ }
+
+ if (!resultArray) {
+ Object.defineProperty(node, childNodesCacheKey, {
+ value: (resultArray = []),
+ enumerable: false
+ });
+ }
+
+ for (let i = 0, nameCount = names.length; i < nameCount; ++i) {
+ getSortedChildNodes(node[names[i]], text, resultArray);
+ }
+
+ return resultArray;
+}
+
+// As efficiently as possible, decorate the comment object with
+// .precedingNode, .enclosingNode, and/or .followingNode properties, at
+// least one of which is guaranteed to be defined.
+function decorateComment(node, comment, text) {
+ const childNodes = getSortedChildNodes(node, text);
+ let precedingNode, followingNode;
+ // Time to dust off the old binary search robes and wizard hat.
+ let left = 0, right = childNodes.length;
+ while (left < right) {
+ const middle = (left + right) >> 1;
+ const child = childNodes[middle];
+
+ if (
+ locStart(child) - locStart(comment) <= 0 &&
+ locEnd(comment) - locEnd(child) <= 0
+ ) {
+ // The comment is completely contained by this child node.
+ comment.enclosingNode = child;
+
+ decorateComment(child, comment, text);
+ return; // Abandon the binary search at this level.
+ }
+
+ if (locEnd(child) - locStart(comment) <= 0) {
+ // This child node falls completely before the comment.
+ // Because we will never consider this node or any nodes
+ // before it again, this node must be the closest preceding
+ // node we have encountered so far.
+ precedingNode = child;
+ left = middle + 1;
+ continue;
+ }
+
+ if (locEnd(comment) - locStart(child) <= 0) {
+ // This child node falls completely after the comment.
+ // Because we will never consider this node or any nodes after
+ // it again, this node must be the closest following node we
+ // have encountered so far.
+ followingNode = child;
+ right = middle;
+ continue;
+ }
+
+ throw new Error("Comment location overlaps with node location");
+ }
+
+ // We don't want comments inside of different expressions inside of the same
+ // template literal to move to another expression.
+ if (
+ comment.enclosingNode &&
+ comment.enclosingNode.type === "TemplateLiteral"
+ ) {
+ const quasis = comment.enclosingNode.quasis;
+ const commentIndex = findExpressionIndexForComment(quasis, comment);
+
+ if (
+ precedingNode &&
+ findExpressionIndexForComment(quasis, precedingNode) !== commentIndex
+ ) {
+ precedingNode = null;
+ }
+ if (
+ followingNode &&
+ findExpressionIndexForComment(quasis, followingNode) !== commentIndex
+ ) {
+ followingNode = null;
+ }
+ }
+
+ if (precedingNode) {
+ comment.precedingNode = precedingNode;
+ }
+
+ if (followingNode) {
+ comment.followingNode = followingNode;
+ }
+}
+
+function attach(comments, ast, text) {
+ if (!Array.isArray(comments)) {
+ return;
+ }
+
+ const tiesToBreak = [];
+
+ comments.forEach((comment, i) => {
+ decorateComment(ast, comment, text);
+
+ const precedingNode = comment.precedingNode;
+ const enclosingNode = comment.enclosingNode;
+ const followingNode = comment.followingNode;
+
+ const isLastComment = comments.length - 1 === i;
+
+ if (util$1.hasNewline(text, locStart(comment), { backwards: true })) {
+ // If a comment exists on its own line, prefer a leading comment.
+ // We also need to check if it's the first line of the file.
+ if (
+ handleLastFunctionArgComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+ ) ||
+ handleMemberExpressionComments(enclosingNode, followingNode, comment) ||
+ handleIfStatementComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+ ) ||
+ handleTryStatementComments(enclosingNode, followingNode, comment) ||
+ handleClassComments(enclosingNode, comment) ||
+ handleImportSpecifierComments(enclosingNode, comment) ||
+ handleObjectPropertyComments(enclosingNode, comment) ||
+ handleForComments(enclosingNode, precedingNode, comment) ||
+ handleUnionTypeComments(
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+ ) ||
+ handleOnlyComments(enclosingNode, ast, comment, isLastComment) ||
+ handleImportDeclarationComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment
+ ) ||
+ handleAssignmentPatternComments(enclosingNode, comment)
+ ) {
+ // We're good
+ } else if (followingNode) {
+ // Always a leading comment.
+ addLeadingComment(followingNode, comment);
+ } else if (precedingNode) {
+ addTrailingComment(precedingNode, comment);
+ } else if (enclosingNode) {
+ addDanglingComment(enclosingNode, comment);
+ } else {
+ // There are no nodes, let's attach it to the root of the ast
+ addDanglingComment(ast, comment);
+ }
+ } else if (util$1.hasNewline(text, locEnd(comment))) {
+ if (
+ handleLastFunctionArgComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+ ) ||
+ handleConditionalExpressionComments(
+ enclosingNode,
+ precedingNode,
+ followingNode,
+ comment,
+ text
+ ) ||
+ handleImportSpecifierComments(enclosingNode, comment) ||
+ handleIfStatementComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+ ) ||
+ handleClassComments(enclosingNode, comment) ||
+ handleLabeledStatementComments(enclosingNode, comment) ||
+ handleCallExpressionComments(precedingNode, enclosingNode, comment) ||
+ handlePropertyComments(enclosingNode, comment) ||
+ handleExportNamedDeclarationComments(enclosingNode, comment) ||
+ handleOnlyComments(enclosingNode, ast, comment, isLastComment) ||
+ handleClassMethodComments(enclosingNode, comment) ||
+ handleTypeAliasComments(enclosingNode, followingNode, comment) ||
+ handleVariableDeclaratorComments(enclosingNode, followingNode, comment)
+ ) {
+ // We're good
+ } else if (precedingNode) {
+ // There is content before this comment on the same line, but
+ // none after it, so prefer a trailing comment of the previous node.
+ addTrailingComment(precedingNode, comment);
+ } else if (followingNode) {
+ addLeadingComment(followingNode, comment);
+ } else if (enclosingNode) {
+ addDanglingComment(enclosingNode, comment);
+ } else {
+ // There are no nodes, let's attach it to the root of the ast
+ addDanglingComment(ast, comment);
+ }
+ } else {
+ if (
+ handleIfStatementComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+ ) ||
+ handleObjectPropertyAssignment(enclosingNode, precedingNode, comment) ||
+ handleCommentInEmptyParens(text, enclosingNode, comment) ||
+ handleOnlyComments(enclosingNode, ast, comment, isLastComment)
+ ) {
+ // We're good
+ } else if (precedingNode && followingNode) {
+ // Otherwise, text exists both before and after the comment on
+ // the same line. If there is both a preceding and following
+ // node, use a tie-breaking algorithm to determine if it should
+ // be attached to the next or previous node. In the last case,
+ // simply attach the right node;
+ const tieCount = tiesToBreak.length;
+ if (tieCount > 0) {
+ const lastTie = tiesToBreak[tieCount - 1];
+ if (lastTie.followingNode !== comment.followingNode) {
+ breakTies(tiesToBreak, text);
+ }
+ }
+ tiesToBreak.push(comment);
+ } else if (precedingNode) {
+ addTrailingComment(precedingNode, comment);
+ } else if (followingNode) {
+ addLeadingComment(followingNode, comment);
+ } else if (enclosingNode) {
+ addDanglingComment(enclosingNode, comment);
+ } else {
+ // There are no nodes, let's attach it to the root of the ast
+ addDanglingComment(ast, comment);
+ }
+ }
+ });
+
+ breakTies(tiesToBreak, text);
+
+ comments.forEach(comment => {
+ // These node references were useful for breaking ties, but we
+ // don't need them anymore, and they create cycles in the AST that
+ // may lead to infinite recursion if we don't delete them here.
+ delete comment.precedingNode;
+ delete comment.enclosingNode;
+ delete comment.followingNode;
+ });
+}
+
+function breakTies(tiesToBreak, text) {
+ const tieCount = tiesToBreak.length;
+ if (tieCount === 0) {
+ return;
+ }
+
+ const precedingNode = tiesToBreak[0].precedingNode;
+ const followingNode = tiesToBreak[0].followingNode;
+ let gapEndPos = locStart(followingNode);
+
+ // Iterate backwards through tiesToBreak, examining the gaps
+ // between the tied comments. In order to qualify as leading, a
+ // comment must be separated from followingNode by an unbroken series of
+ // whitespace-only gaps (or other comments).
+ let indexOfFirstLeadingComment;
+ for (
+ indexOfFirstLeadingComment = tieCount;
+ indexOfFirstLeadingComment > 0;
+ --indexOfFirstLeadingComment
+ ) {
+ const comment = tiesToBreak[indexOfFirstLeadingComment - 1];
+ assert.strictEqual(comment.precedingNode, precedingNode);
+ assert.strictEqual(comment.followingNode, followingNode);
+
+ const gap = text.slice(locEnd(comment), gapEndPos);
+ if (/\S/.test(gap)) {
+ // The gap string contained something other than whitespace.
+ break;
+ }
+
+ gapEndPos = locStart(comment);
+ }
+
+ tiesToBreak.forEach((comment, i) => {
+ if (i < indexOfFirstLeadingComment) {
+ addTrailingComment(precedingNode, comment);
+ } else {
+ addLeadingComment(followingNode, comment);
+ }
+ });
+
+ tiesToBreak.length = 0;
+}
+
+function addCommentHelper(node, comment) {
+ const comments = node.comments || (node.comments = []);
+ comments.push(comment);
+ comment.printed = false;
+}
+
+function addLeadingComment(node, comment) {
+ comment.leading = true;
+ comment.trailing = false;
+ addCommentHelper(node, comment);
+}
+
+function addDanglingComment(node, comment) {
+ comment.leading = false;
+ comment.trailing = false;
+ addCommentHelper(node, comment);
+}
+
+function addTrailingComment(node, comment) {
+ comment.leading = false;
+ comment.trailing = true;
+ addCommentHelper(node, comment);
+}
+
+function addBlockStatementFirstComment(node, comment) {
+ const body = node.body.filter(n => n.type !== "EmptyStatement");
+ if (body.length === 0) {
+ addDanglingComment(node, comment);
+ } else {
+ addLeadingComment(body[0], comment);
+ }
+}
+
+function addBlockOrNotComment(node, comment) {
+ if (node.type === "BlockStatement") {
+ addBlockStatementFirstComment(node, comment);
+ } else {
+ addLeadingComment(node, comment);
+ }
+}
+
+// There are often comments before the else clause of if statements like
+//
+// if (1) { ... }
+// // comment
+// else { ... }
+//
+// They are being attached as leading comments of the BlockExpression which
+// is not well printed. What we want is to instead move the comment inside
+// of the block and make it leadingComment of the first element of the block
+// or dangling comment of the block if there is nothing inside
+//
+// if (1) { ... }
+// else {
+// // comment
+// ...
+// }
+function handleIfStatementComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+) {
+ if (
+ !enclosingNode ||
+ enclosingNode.type !== "IfStatement" ||
+ !followingNode
+ ) {
+ return false;
+ }
+
+ // We unfortunately have no way using the AST or location of nodes to know
+ // if the comment is positioned before or after the condition parenthesis:
+ // if (a /* comment */) {}
+ // if (a) /* comment */ {}
+ // The only workaround I found is to look at the next character to see if
+ // it is a ).
+ if (getNextNonSpaceNonCommentCharacter(text, comment) === ")") {
+ addTrailingComment(precedingNode, comment);
+ return true;
+ }
+
+ if (followingNode.type === "BlockStatement") {
+ addBlockStatementFirstComment(followingNode, comment);
+ return true;
+ }
+
+ if (followingNode.type === "IfStatement") {
+ addBlockOrNotComment(followingNode.consequent, comment);
+ return true;
+ }
+
+ return false;
+}
+
+// Same as IfStatement but for TryStatement
+function handleTryStatementComments(enclosingNode, followingNode, comment) {
+ if (
+ !enclosingNode ||
+ enclosingNode.type !== "TryStatement" ||
+ !followingNode
+ ) {
+ return false;
+ }
+
+ if (followingNode.type === "BlockStatement") {
+ addBlockStatementFirstComment(followingNode, comment);
+ return true;
+ }
+
+ if (followingNode.type === "TryStatement") {
+ addBlockOrNotComment(followingNode.finalizer, comment);
+ return true;
+ }
+
+ if (followingNode.type === "CatchClause") {
+ addBlockOrNotComment(followingNode.body, comment);
+ return true;
+ }
+
+ return false;
+}
+
+function handleMemberExpressionComments(enclosingNode, followingNode, comment) {
+ if (
+ enclosingNode &&
+ enclosingNode.type === "MemberExpression" &&
+ followingNode &&
+ followingNode.type === "Identifier"
+ ) {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+
+ return false;
+}
+
+function handleConditionalExpressionComments(
+ enclosingNode,
+ precedingNode,
+ followingNode,
+ comment,
+ text
+) {
+ const isSameLineAsPrecedingNode =
+ precedingNode &&
+ !util$1.hasNewlineInRange(text, locEnd(precedingNode), locStart(comment));
+
+ if (
+ (!precedingNode || !isSameLineAsPrecedingNode) &&
+ enclosingNode &&
+ enclosingNode.type === "ConditionalExpression" &&
+ followingNode
+ ) {
+ addLeadingComment(followingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleObjectPropertyAssignment(enclosingNode, precedingNode, comment) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "ObjectProperty" ||
+ enclosingNode.type === "Property") &&
+ enclosingNode.shorthand &&
+ enclosingNode.key === precedingNode &&
+ enclosingNode.value.type === "AssignmentPattern"
+ ) {
+ addTrailingComment(enclosingNode.value.left, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleCommentInEmptyParens(text, enclosingNode, comment) {
+ if (getNextNonSpaceNonCommentCharacter(text, comment) !== ")") {
+ return false;
+ }
+
+ // Only add dangling comments to fix the case when no params are present,
+ // i.e. a function without any argument.
+ if (
+ enclosingNode &&
+ (((enclosingNode.type === "FunctionDeclaration" ||
+ enclosingNode.type === "FunctionExpression" ||
+ enclosingNode.type === "ArrowFunctionExpression" ||
+ enclosingNode.type === "ClassMethod" ||
+ enclosingNode.type === "ObjectMethod") &&
+ enclosingNode.params.length === 0) ||
+ (enclosingNode.type === "CallExpression" &&
+ enclosingNode.arguments.length === 0))
+ ) {
+ addDanglingComment(enclosingNode, comment);
+ return true;
+ }
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "MethodDefinition" &&
+ enclosingNode.value.params.length === 0)
+ ) {
+ addDanglingComment(enclosingNode.value, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleLastFunctionArgComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+) {
+ // Type definitions functions
+ if (
+ precedingNode &&
+ precedingNode.type === "FunctionTypeParam" &&
+ enclosingNode &&
+ enclosingNode.type === "FunctionTypeAnnotation" &&
+ followingNode &&
+ followingNode.type !== "FunctionTypeParam"
+ ) {
+ addTrailingComment(precedingNode, comment);
+ return true;
+ }
+
+ // Real functions
+ if (
+ precedingNode &&
+ (precedingNode.type === "Identifier" ||
+ precedingNode.type === "AssignmentPattern") &&
+ enclosingNode &&
+ (enclosingNode.type === "ArrowFunctionExpression" ||
+ enclosingNode.type === "FunctionExpression" ||
+ enclosingNode.type === "FunctionDeclaration" ||
+ enclosingNode.type === "ObjectMethod" ||
+ enclosingNode.type === "ClassMethod") &&
+ getNextNonSpaceNonCommentCharacter(text, comment) === ")"
+ ) {
+ addTrailingComment(precedingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleClassComments(enclosingNode, comment) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "ClassDeclaration" ||
+ enclosingNode.type === "ClassExpression")
+ ) {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleImportSpecifierComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "ImportSpecifier") {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleObjectPropertyComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "ObjectProperty") {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleLabeledStatementComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "LabeledStatement") {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleCallExpressionComments(precedingNode, enclosingNode, comment) {
+ if (
+ enclosingNode &&
+ enclosingNode.type === "CallExpression" &&
+ precedingNode &&
+ enclosingNode.callee === precedingNode &&
+ enclosingNode.arguments.length > 0
+ ) {
+ addLeadingComment(enclosingNode.arguments[0], comment);
+ return true;
+ }
+ return false;
+}
+
+function handleUnionTypeComments(
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "UnionTypeAnnotation" ||
+ enclosingNode.type === "TSUnionType")
+ ) {
+ addTrailingComment(precedingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handlePropertyComments(enclosingNode, comment) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "Property" ||
+ enclosingNode.type === "ObjectProperty")
+ ) {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleExportNamedDeclarationComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "ExportNamedDeclaration") {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleOnlyComments(enclosingNode, ast, comment, isLastComment) {
+ // With Flow the enclosingNode is undefined so use the AST instead.
+ if (ast && ast.body && ast.body.length === 0) {
+ if (isLastComment) {
+ addDanglingComment(ast, comment);
+ } else {
+ addLeadingComment(ast, comment);
+ }
+ return true;
+ } else if (
+ enclosingNode &&
+ enclosingNode.type === "Program" &&
+ enclosingNode.body.length === 0 &&
+ enclosingNode.directives &&
+ enclosingNode.directives.length === 0
+ ) {
+ if (isLastComment) {
+ addDanglingComment(enclosingNode, comment);
+ } else {
+ addLeadingComment(enclosingNode, comment);
+ }
+ return true;
+ }
+ return false;
+}
+
+function handleForComments(enclosingNode, precedingNode, comment) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "ForInStatement" ||
+ enclosingNode.type === "ForOfStatement")
+ ) {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleImportDeclarationComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment
+) {
+ if (
+ precedingNode &&
+ enclosingNode &&
+ enclosingNode.type === "ImportDeclaration" &&
+ util$1.hasNewline(text, util$1.locEnd(comment))
+ ) {
+ addTrailingComment(precedingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleAssignmentPatternComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "AssignmentPattern") {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleClassMethodComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "ClassMethod") {
+ addTrailingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleTypeAliasComments(enclosingNode, followingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "TypeAlias") {
+ addLeadingComment(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleVariableDeclaratorComments(
+ enclosingNode,
+ followingNode,
+ comment
+) {
+ if (
+ enclosingNode &&
+ enclosingNode.type === "VariableDeclarator" &&
+ followingNode &&
+ (followingNode.type === "ObjectExpression" ||
+ followingNode.type === "ArrayExpression")
+ ) {
+ addLeadingComment(followingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function printComment(commentPath, options) {
+ const comment = commentPath.getValue();
+ comment.printed = true;
+
+ switch (comment.type) {
+ case "CommentBlock":
+ case "Block":
+ return "/*" + comment.value + "*/";
+ case "CommentLine":
+ case "Line":
+ // Don't print the shebang, it's taken care of in index.js
+ if (options.originalText.slice(util$1.locStart(comment)).startsWith("#!")) {
+ return "";
+ }
+ return "//" + comment.value;
+ default:
+ throw new Error("Not a comment: " + JSON.stringify(comment));
+ }
+}
+
+function findExpressionIndexForComment(quasis, comment) {
+ const startPos = locStart(comment) - 1;
+
+ for (let i = 1; i < quasis.length; ++i) {
+ if (startPos < getQuasiRange(quasis[i]).start) {
+ return i - 1;
+ }
+ }
+
+ // We haven't found it, it probably means that some of the locations are off.
+ // Let's just return the first one.
+ return 0;
+}
+
+function getQuasiRange(expr) {
+ if (expr.start !== undefined) {
+ // Babylon
+ return { start: expr.start, end: expr.end };
+ }
+ // Flow
+ return { start: expr.range[0], end: expr.range[1] };
+}
+
+function printLeadingComment(commentPath, print, options) {
+ const comment = commentPath.getValue();
+ const contents = printComment(commentPath, options);
+ if (!contents) {
+ return "";
+ }
+ const isBlock = util$1.isBlockComment(comment);
+
+ // Leading block comments should see if they need to stay on the
+ // same line or not.
+ if (isBlock) {
+ return concat([
+ contents,
+ util$1.hasNewline(options.originalText, locEnd(comment)) ? hardline : " "
+ ]);
+ }
+
+ return concat([contents, hardline]);
+}
+
+function printTrailingComment(commentPath, print, options) {
+ const comment = commentPath.getValue();
+ const contents = printComment(commentPath, options);
+ if (!contents) {
+ return "";
+ }
+ const isBlock = util$1.isBlockComment(comment);
+
+ if (
+ util$1.hasNewline(options.originalText, locStart(comment), {
+ backwards: true
+ })
+ ) {
+ // This allows comments at the end of nested structures:
+ // {
+ // x: 1,
+ // y: 2
+ // // A comment
+ // }
+ // Those kinds of comments are almost always leading comments, but
+ // here it doesn't go "outside" the block and turns it into a
+ // trailing comment for `2`. We can simulate the above by checking
+ // if this a comment on its own line; normal trailing comments are
+ // always at the end of another expression.
+
+ const isLineBeforeEmpty = util$1.isPreviousLineEmpty(
+ options.originalText,
+ comment
+ );
+
+ return lineSuffix(
+ concat([hardline, isLineBeforeEmpty ? hardline : "", contents])
+ );
+ } else if (isBlock) {
+ // Trailing block comments never need a newline
+ return concat([" ", contents]);
+ }
+
+ return concat([lineSuffix(" " + contents), !isBlock ? breakParent : ""]);
+}
+
+function printDanglingComments(path, options, sameIndent) {
+ const parts = [];
+ const node = path.getValue();
+
+ if (!node || !node.comments) {
+ return "";
+ }
+
+ path.each(commentPath => {
+ const comment = commentPath.getValue();
+ if (comment && !comment.leading && !comment.trailing) {
+ parts.push(printComment(commentPath, options));
+ }
+ }, "comments");
+
+ if (parts.length === 0) {
+ return "";
+ }
+
+ if (sameIndent) {
+ return join(hardline, parts);
+ }
+ return indent(concat([hardline, join(hardline, parts)]));
+}
+
+function printComments(path, print, options, needsSemi) {
+ const value = path.getValue();
+ const printed = print(path);
+ const comments = value && value.comments;
+
+ if (!comments || comments.length === 0) {
+ return printed;
+ }
+
+ const leadingParts = [];
+ const trailingParts = [needsSemi ? ";" : "", printed];
+
+ path.each(commentPath => {
+ const comment = commentPath.getValue();
+ const leading = comment.leading;
+ const trailing = comment.trailing;
+
+ if (leading) {
+ const contents = printLeadingComment(commentPath, print, options);
+ if (!contents) {
+ return;
+ }
+ leadingParts.push(contents);
+
+ const text = options.originalText;
+ if (util$1.hasNewline(text, util$1.skipNewline(text, util$1.locEnd(comment)))) {
+ leadingParts.push(hardline);
+ }
+ } else if (trailing) {
+ trailingParts.push(printTrailingComment(commentPath, print, options));
+ }
+ }, "comments");
+
+ return concat(leadingParts.concat(trailingParts));
+}
+
+var comments$1 = {
+ attach,
+ printComments,
+ printDanglingComments,
+ getSortedChildNodes
+};
+
+var name = "prettier";
+var version$1 = "1.4.0-beta";
+var description = "Prettier is an opinionated JavaScript formatter";
+var bin = {"prettier":"./bin/prettier.js"};
+var repository = "prettier/prettier";
+var author = "James Long";
+var license = "MIT";
+var main = "./index.js";
+var dependencies = {"babel-code-frame":"6.22.0","babylon":"7.0.0-beta.10","chalk":"1.1.3","esutils":"2.0.2","flow-parser":"0.47.0","get-stdin":"5.0.1","glob":"7.1.1","jest-validate":"20.0.0","minimist":"1.2.0"};
+var devDependencies = {"cross-spawn":"^5.1.0","diff":"3.2.0","eslint":"^3.19.0","eslint-plugin-prettier":"^2.1.1","jest":"20.0.0","mkdirp":"^0.5.1","postcss":"^6.0.1","postcss-less":"^1.0.0","postcss-media-query-parser":"^0.2.3","postcss-scss":"1.0.0","postcss-selector-parser":"^2.2.3","postcss-values-parser":"git://github.com/shellscape/postcss-values-parser.git#5e351360479116f3fe309602cdd15b0a233bc29f","prettier":"^1.3.1","rimraf":"^2.6.1","rollup":"0.41.1","rollup-plugin-commonjs":"7.0.0","rollup-plugin-json":"2.1.0","rollup-plugin-node-builtins":"2.0.0","rollup-plugin-node-globals":"1.1.0","rollup-plugin-node-resolve":"2.0.0","rollup-plugin-replace":"1.1.1","typescript":"2.3.2","typescript-eslint-parser":"git://github.com/eslint/typescript-eslint-parser.git#3dcba7d53f61f51069ed84b57e053802c014d703","uglify-es":"mishoo/UglifyJS2#harmony","webpack":"^2.6.1"};
+var scripts = {"test":"jest","test-integration":"jest tests_integration","lint":"eslint .","build":"./scripts/build/build.sh","build:docs":"rollup -c docs/rollup.config.js"};
+var jest = {"setupFiles":["/tests_config/run_spec.js"],"snapshotSerializers":["/tests_config/raw-serializer.js"],"testRegex":"jsfmt\\.spec\\.js$|__tests__/.*\\.js$","testPathIgnorePatterns":["tests/new_react","tests/more_react"]};
+var _package = {
+ name: name,
+ version: version$1,
+ description: description,
+ bin: bin,
+ repository: repository,
+ author: author,
+ license: license,
+ main: main,
+ dependencies: dependencies,
+ devDependencies: devDependencies,
+ scripts: scripts,
+ jest: jest
+};
+
+var _package$1 = Object.freeze({
+ name: name,
+ version: version$1,
+ description: description,
+ bin: bin,
+ repository: repository,
+ author: author,
+ license: license,
+ main: main,
+ dependencies: dependencies,
+ devDependencies: devDependencies,
+ scripts: scripts,
+ jest: jest,
+ default: _package
+});
+
+const assert$2 = require$$0;
+const util$5 = util$2;
+const startsWithNoLookaheadToken$1 = util$5.startsWithNoLookaheadToken;
+
+function FastPath$1(value) {
+ assert$2.ok(this instanceof FastPath$1);
+ this.stack = [value];
+}
+
+// The name of the current property is always the penultimate element of
+// this.stack, and always a String.
+FastPath$1.prototype.getName = function getName() {
+ const s = this.stack;
+ const len = s.length;
+ if (len > 1) {
+ return s[len - 2];
+ }
+ // Since the name is always a string, null is a safe sentinel value to
+ // return if we do not know the name of the (root) value.
+ return null;
+};
+
+// The value of the current property is always the final element of
+// this.stack.
+FastPath$1.prototype.getValue = function getValue() {
+ const s = this.stack;
+ return s[s.length - 1];
+};
+
+function getNodeHelper(path, count) {
+ const s = path.stack;
+
+ for (let i = s.length - 1; i >= 0; i -= 2) {
+ const value = s[i];
+
+ if (value && !Array.isArray(value) && --count < 0) {
+ return value;
+ }
+ }
+
+ return null;
+}
+
+FastPath$1.prototype.getNode = function getNode(count) {
+ return getNodeHelper(this, ~~count);
+};
+
+FastPath$1.prototype.getParentNode = function getParentNode(count) {
+ return getNodeHelper(this, ~~count + 1);
+};
+
+// Temporarily push properties named by string arguments given after the
+// callback function onto this.stack, then call the callback with a
+// reference to this (modified) FastPath object. Note that the stack will
+// be restored to its original state after the callback is finished, so it
+// is probably a mistake to retain a reference to the path.
+FastPath$1.prototype.call = function call(callback /*, name1, name2, ... */) {
+ const s = this.stack;
+ const origLen = s.length;
+ let value = s[origLen - 1];
+ const argc = arguments.length;
+ for (let i = 1; i < argc; ++i) {
+ const name = arguments[i];
+ value = value[name];
+ s.push(name, value);
+ }
+ const result = callback(this);
+ s.length = origLen;
+ return result;
+};
+
+// Similar to FastPath.prototype.call, except that the value obtained by
+// accessing this.getValue()[name1][name2]... should be array-like. The
+// callback will be called with a reference to this path object for each
+// element of the array.
+FastPath$1.prototype.each = function each(callback /*, name1, name2, ... */) {
+ const s = this.stack;
+ const origLen = s.length;
+ let value = s[origLen - 1];
+ const argc = arguments.length;
+
+ for (let i = 1; i < argc; ++i) {
+ const name = arguments[i];
+ value = value[name];
+ s.push(name, value);
+ }
+
+ for (let i = 0; i < value.length; ++i) {
+ if (i in value) {
+ s.push(i, value[i]);
+ // If the callback needs to know the value of i, call
+ // path.getName(), assuming path is the parameter name.
+ callback(this);
+ s.length -= 2;
+ }
+ }
+
+ s.length = origLen;
+};
+
+// Similar to FastPath.prototype.each, except that the results of the
+// callback function invocations are stored in an array and returned at
+// the end of the iteration.
+FastPath$1.prototype.map = function map(callback /*, name1, name2, ... */) {
+ const s = this.stack;
+ const origLen = s.length;
+ let value = s[origLen - 1];
+ const argc = arguments.length;
+
+ for (let i = 1; i < argc; ++i) {
+ const name = arguments[i];
+ value = value[name];
+ s.push(name, value);
+ }
+
+ const result = new Array(value.length);
+
+ for (let i = 0; i < value.length; ++i) {
+ if (i in value) {
+ s.push(i, value[i]);
+ result[i] = callback(this, i);
+ s.length -= 2;
+ }
+ }
+
+ s.length = origLen;
+
+ return result;
+};
+
+FastPath$1.prototype.needsParens = function() {
+ const parent = this.getParentNode();
+ if (!parent) {
+ return false;
+ }
+
+ const name = this.getName();
+ const node = this.getNode();
+
+ // If the value of this path is some child of a Node and not a Node
+ // itself, then it doesn't need parentheses. Only Node objects (in
+ // fact, only Expression nodes) need parentheses.
+ if (this.getValue() !== node) {
+ return false;
+ }
+
+ // Only statements don't need parentheses.
+ if (isStatement(node)) {
+ return false;
+ }
+
+ // Identifiers never need parentheses.
+ if (node.type === "Identifier") {
+ return false;
+ }
+
+ if (parent.type === "ParenthesizedExpression") {
+ return false;
+ }
+
+ // Add parens around the extends clause of a class. It is needed for almost
+ // all expressions.
+ if (
+ (parent.type === "ClassDeclaration" || parent.type === "ClassExpression") &&
+ parent.superClass === node &&
+ (node.type === "ArrowFunctionExpression" ||
+ node.type === "AssignmentExpression" ||
+ node.type === "AwaitExpression" ||
+ node.type === "BinaryExpression" ||
+ node.type === "ConditionalExpression" ||
+ node.type === "LogicalExpression" ||
+ node.type === "NewExpression" ||
+ node.type === "ObjectExpression" ||
+ node.type === "ParenthesizedExpression" ||
+ node.type === "SequenceExpression" ||
+ node.type === "TaggedTemplateExpression" ||
+ node.type === "UnaryExpression" ||
+ node.type === "UpdateExpression" ||
+ node.type === "YieldExpression")
+ ) {
+ return true;
+ }
+
+ if (
+ (parent.type === "ArrowFunctionExpression" &&
+ parent.body === node &&
+ startsWithNoLookaheadToken$1(node, /* forbidFunctionAndClass */ false)) ||
+ (parent.type === "ExpressionStatement" &&
+ startsWithNoLookaheadToken$1(node, /* forbidFunctionAndClass */ true))
+ ) {
+ return true;
+ }
+
+ switch (node.type) {
+ case "CallExpression":
+ if (parent.type === "NewExpression" && parent.callee === node) {
+ return true;
+ }
+ return false;
+
+ case "SpreadElement":
+ case "SpreadProperty":
+ return (
+ parent.type === "MemberExpression" &&
+ name === "object" &&
+ parent.object === node
+ );
+
+ case "UpdateExpression":
+ if (parent.type === "UnaryExpression") {
+ return (
+ node.prefix &&
+ ((node.operator === "++" && parent.operator === "+") ||
+ (node.operator === "--" && parent.operator === "-"))
+ );
+ }
+ // else fallthrough
+ case "UnaryExpression":
+ switch (parent.type) {
+ case "UnaryExpression":
+ return (
+ node.operator === parent.operator &&
+ (node.operator === "+" || node.operator === "-")
+ );
+
+ case "MemberExpression":
+ return name === "object" && parent.object === node;
+
+ case "TaggedTemplateExpression":
+ return true;
+
+ case "NewExpression":
+ case "CallExpression":
+ return name === "callee" && parent.callee === node;
+
+ case "BinaryExpression":
+ return parent.operator === "**" && name === "left";
+
+ default:
+ return false;
+ }
+
+ case "BinaryExpression": {
+ if (parent.type === "UpdateExpression") {
+ return true;
+ }
+
+ const isLeftOfAForStatement = node => {
+ let i = 0;
+ while (node) {
+ const parent = this.getParentNode(i++);
+ if (!parent) {
+ return false;
+ }
+ if (parent.type === "ForStatement" && parent.init === node) {
+ return true;
+ }
+ node = parent;
+ }
+ return false;
+ };
+ if (node.operator === "in" && isLeftOfAForStatement(node)) {
+ return true;
+ }
+ }
+ // fallthrough
+ case "TSTypeAssertionExpression":
+ case "TSAsExpression":
+ case "LogicalExpression":
+ switch (parent.type) {
+ case "CallExpression":
+ case "NewExpression":
+ return name === "callee" && parent.callee === node;
+
+ case "ClassDeclaration":
+ return name === "superClass" && parent.superClass === node;
+ case "TSTypeAssertionExpression":
+ case "TaggedTemplateExpression":
+ case "UnaryExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ case "AwaitExpression":
+ case "TSAsExpression":
+ case "TSNonNullExpression":
+ return true;
+
+ case "MemberExpression":
+ return name === "object" && parent.object === node;
+
+ case "BinaryExpression":
+ case "LogicalExpression": {
+ if (!node.operator) {
+ return true;
+ }
+
+ const po = parent.operator;
+ const pp = util$5.getPrecedence(po);
+ const no = node.operator;
+ const np = util$5.getPrecedence(no);
+
+ if (po === "||" && no === "&&") {
+ return true;
+ }
+
+ if (pp > np) {
+ return true;
+ }
+
+ if (no === "**" && po === "**") {
+ return name === "left";
+ }
+
+ if (pp === np && name === "right") {
+ assert$2.strictEqual(parent.right, node);
+ return true;
+ }
+
+ // Add parenthesis when working with binary operators
+ // It's not stricly needed but helps with code understanding
+ if (["|", "^", "&", ">>", "<<", ">>>"].indexOf(po) !== -1) {
+ return true;
+ }
+
+ return false;
+ }
+
+ default:
+ return false;
+ }
+
+ case "SequenceExpression":
+ switch (parent.type) {
+ case "ReturnStatement":
+ return false;
+
+ case "ForStatement":
+ // Although parentheses wouldn't hurt around sequence
+ // expressions in the head of for loops, traditional style
+ // dictates that e.g. i++, j++ should not be wrapped with
+ // parentheses.
+ return false;
+
+ case "ExpressionStatement":
+ return name !== "expression";
+
+ default:
+ // Otherwise err on the side of overparenthesization, adding
+ // explicit exceptions above if this proves overzealous.
+ return true;
+ }
+
+ case "YieldExpression":
+ if (
+ parent.type === "UnaryExpression" ||
+ parent.type === "AwaitExpression"
+ ) {
+ return true;
+ }
+ // else fallthrough
+ case "AwaitExpression":
+ switch (parent.type) {
+ case "TaggedTemplateExpression":
+ case "BinaryExpression":
+ case "LogicalExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ return true;
+
+ case "MemberExpression":
+ return parent.object === node;
+
+ case "NewExpression":
+ case "CallExpression":
+ return parent.callee === node;
+
+ case "ConditionalExpression":
+ return parent.test === node;
+
+ default:
+ return false;
+ }
+
+ case "ArrayTypeAnnotation":
+ return parent.type === "NullableTypeAnnotation";
+
+ case "IntersectionTypeAnnotation":
+ case "UnionTypeAnnotation":
+ return (
+ parent.type === "ArrayTypeAnnotation" ||
+ parent.type === "NullableTypeAnnotation" ||
+ parent.type === "IntersectionTypeAnnotation" ||
+ parent.type === "UnionTypeAnnotation"
+ );
+
+ case "NullableTypeAnnotation":
+ return parent.type === "ArrayTypeAnnotation";
+
+ case "FunctionTypeAnnotation":
+ return (
+ parent.type === "UnionTypeAnnotation" ||
+ parent.type === "IntersectionTypeAnnotation"
+ );
+
+ case "NumericLiteral":
+ case "Literal":
+ return (
+ parent.type === "MemberExpression" &&
+ typeof node.value === "number" &&
+ name === "object" &&
+ parent.object === node
+ );
+
+ case "AssignmentExpression": {
+ const grandParent = this.getParentNode(1);
+
+ if (parent.type === "ArrowFunctionExpression" && parent.body === node) {
+ return true;
+ } else if (
+ parent.type === "ClassProperty" &&
+ parent.key === node &&
+ parent.computed
+ ) {
+ return false;
+ } else if (
+ parent.type === "TSPropertySignature" &&
+ parent.name === node
+ ) {
+ return false;
+ } else if (
+ parent.type === "ForStatement" &&
+ (parent.init === node || parent.update === node)
+ ) {
+ return false;
+ } else if (parent.type === "ExpressionStatement") {
+ return node.left.type === "ObjectPattern";
+ } else if (parent.type === "TSPropertySignature" && parent.key === node) {
+ return false;
+ } else if (parent.type === "AssignmentExpression") {
+ return false;
+ } else if (
+ parent.type === "SequenceExpression" &&
+ grandParent &&
+ grandParent.type === "ForStatement" &&
+ (grandParent.init === parent || grandParent.update === parent)
+ ) {
+ return false;
+ }
+ return true;
+ }
+ case "ConditionalExpression":
+ switch (parent.type) {
+ case "TaggedTemplateExpression":
+ case "UnaryExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ case "BinaryExpression":
+ case "LogicalExpression":
+ case "ExportDefaultDeclaration":
+ case "AwaitExpression":
+ case "JSXSpreadAttribute":
+ case "TSTypeAssertionExpression":
+ case "TSAsExpression":
+ case "TSNonNullExpression":
+ return true;
+
+ case "NewExpression":
+ case "CallExpression":
+ return name === "callee" && parent.callee === node;
+
+ case "ConditionalExpression":
+ return name === "test" && parent.test === node;
+
+ case "MemberExpression":
+ return name === "object" && parent.object === node;
+
+ default:
+ return false;
+ }
+
+ case "FunctionExpression":
+ switch (parent.type) {
+ case "CallExpression":
+ return name === "callee"; // Not strictly necessary, but it's clearer to the reader if IIFEs are wrapped in parentheses.
+ case "TaggedTemplateExpression":
+ return true; // This is basically a kind of IIFE.
+ case "ExportDefaultDeclaration":
+ return true;
+ default:
+ return false;
+ }
+
+ case "ArrowFunctionExpression":
+ switch (parent.type) {
+ case "CallExpression":
+ return name === "callee";
+
+ case "NewExpression":
+ return name === "callee";
+
+ case "MemberExpression":
+ return name === "object";
+
+ case "TSAsExpression":
+ case "BindExpression":
+ case "TaggedTemplateExpression":
+ case "UnaryExpression":
+ case "LogicalExpression":
+ case "BinaryExpression":
+ case "AwaitExpression":
+ case "TSTypeAssertionExpression":
+ return true;
+
+ case "ConditionalExpression":
+ return name === "test";
+
+ default:
+ return false;
+ }
+
+ case "ClassExpression":
+ return parent.type === "ExportDefaultDeclaration";
+
+ case "StringLiteral":
+ return parent.type === "ExpressionStatement"; // To avoid becoming a directive
+ }
+
+ return false;
+};
+
+function isStatement(node) {
+ return (
+ node.type === "BlockStatement" ||
+ node.type === "BreakStatement" ||
+ node.type === "ClassBody" ||
+ node.type === "ClassDeclaration" ||
+ node.type === "ClassMethod" ||
+ node.type === "ClassProperty" ||
+ node.type === "ContinueStatement" ||
+ node.type === "DebuggerStatement" ||
+ node.type === "DeclareClass" ||
+ node.type === "DeclareExportAllDeclaration" ||
+ node.type === "DeclareExportDeclaration" ||
+ node.type === "DeclareFunction" ||
+ node.type === "DeclareInterface" ||
+ node.type === "DeclareModule" ||
+ node.type === "DeclareModuleExports" ||
+ node.type === "DeclareVariable" ||
+ node.type === "DoWhileStatement" ||
+ node.type === "ExportAllDeclaration" ||
+ node.type === "ExportDefaultDeclaration" ||
+ node.type === "ExportNamedDeclaration" ||
+ node.type === "ExpressionStatement" ||
+ node.type === "ForAwaitStatement" ||
+ node.type === "ForInStatement" ||
+ node.type === "ForOfStatement" ||
+ node.type === "ForStatement" ||
+ node.type === "FunctionDeclaration" ||
+ node.type === "IfStatement" ||
+ node.type === "ImportDeclaration" ||
+ node.type === "InterfaceDeclaration" ||
+ node.type === "LabeledStatement" ||
+ node.type === "MethodDefinition" ||
+ node.type === "ReturnStatement" ||
+ node.type === "SwitchStatement" ||
+ node.type === "ThrowStatement" ||
+ node.type === "TryStatement" ||
+ node.type === "TSAbstractClassDeclaration" ||
+ node.type === "TSEnumDeclaration" ||
+ node.type === "TSImportEqualsDeclaration" ||
+ node.type === "TSInterfaceDeclaration" ||
+ node.type === "TSModuleDeclaration" ||
+ node.type === "TSNamespaceExportDeclaration" ||
+ node.type === "TSNamespaceFunctionDeclaration" ||
+ node.type === "TypeAlias" ||
+ node.type === "VariableDeclaration" ||
+ node.type === "WhileStatement" ||
+ node.type === "WithStatement"
+ );
+}
+
+var fastPath = FastPath$1;
+
+function createCommonjsModule(fn, module) {
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var ast = createCommonjsModule(function (module) {
+/*
+ Copyright (C) 2013 Yusuke Suzuki
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+(function () {
+ 'use strict';
+
+ function isExpression(node) {
+ if (node == null) { return false; }
+ switch (node.type) {
+ case 'ArrayExpression':
+ case 'AssignmentExpression':
+ case 'BinaryExpression':
+ case 'CallExpression':
+ case 'ConditionalExpression':
+ case 'FunctionExpression':
+ case 'Identifier':
+ case 'Literal':
+ case 'LogicalExpression':
+ case 'MemberExpression':
+ case 'NewExpression':
+ case 'ObjectExpression':
+ case 'SequenceExpression':
+ case 'ThisExpression':
+ case 'UnaryExpression':
+ case 'UpdateExpression':
+ return true;
+ }
+ return false;
+ }
+
+ function isIterationStatement(node) {
+ if (node == null) { return false; }
+ switch (node.type) {
+ case 'DoWhileStatement':
+ case 'ForInStatement':
+ case 'ForStatement':
+ case 'WhileStatement':
+ return true;
+ }
+ return false;
+ }
+
+ function isStatement(node) {
+ if (node == null) { return false; }
+ switch (node.type) {
+ case 'BlockStatement':
+ case 'BreakStatement':
+ case 'ContinueStatement':
+ case 'DebuggerStatement':
+ case 'DoWhileStatement':
+ case 'EmptyStatement':
+ case 'ExpressionStatement':
+ case 'ForInStatement':
+ case 'ForStatement':
+ case 'IfStatement':
+ case 'LabeledStatement':
+ case 'ReturnStatement':
+ case 'SwitchStatement':
+ case 'ThrowStatement':
+ case 'TryStatement':
+ case 'VariableDeclaration':
+ case 'WhileStatement':
+ case 'WithStatement':
+ return true;
+ }
+ return false;
+ }
+
+ function isSourceElement(node) {
+ return isStatement(node) || node != null && node.type === 'FunctionDeclaration';
+ }
+
+ function trailingStatement(node) {
+ switch (node.type) {
+ case 'IfStatement':
+ if (node.alternate != null) {
+ return node.alternate;
+ }
+ return node.consequent;
+
+ case 'LabeledStatement':
+ case 'ForStatement':
+ case 'ForInStatement':
+ case 'WhileStatement':
+ case 'WithStatement':
+ return node.body;
+ }
+ return null;
+ }
+
+ function isProblematicIfStatement(node) {
+ var current;
+
+ if (node.type !== 'IfStatement') {
+ return false;
+ }
+ if (node.alternate == null) {
+ return false;
+ }
+ current = node.consequent;
+ do {
+ if (current.type === 'IfStatement') {
+ if (current.alternate == null) {
+ return true;
+ }
+ }
+ current = trailingStatement(current);
+ } while (current);
+
+ return false;
+ }
+
+ module.exports = {
+ isExpression: isExpression,
+ isStatement: isStatement,
+ isIterationStatement: isIterationStatement,
+ isSourceElement: isSourceElement,
+ isProblematicIfStatement: isProblematicIfStatement,
+
+ trailingStatement: trailingStatement
+ };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+});
+
+var code = createCommonjsModule(function (module) {
+/*
+ Copyright (C) 2013-2014 Yusuke Suzuki
+ Copyright (C) 2014 Ivan Nikulin
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+(function () {
+ 'use strict';
+
+ var ES6Regex, ES5Regex, NON_ASCII_WHITESPACES, IDENTIFIER_START, IDENTIFIER_PART, ch;
+
+ // See `tools/generate-identifier-regex.js`.
+ ES5Regex = {
+ // ECMAScript 5.1/Unicode v7.0.0 NonAsciiIdentifierStart:
+ NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,
+ // ECMAScript 5.1/Unicode v7.0.0 NonAsciiIdentifierPart:
+ NonAsciiIdentifierPart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/
+ };
+
+ ES6Regex = {
+ // ECMAScript 6/Unicode v7.0.0 NonAsciiIdentifierStart:
+ NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDE00-\uDE11\uDE13-\uDE2B\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDE00-\uDE2F\uDE44\uDE80-\uDEAA]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF98]|\uD809[\uDC00-\uDC6E]|[\uD80C\uD840-\uD868\uD86A-\uD86C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D]|\uD87E[\uDC00-\uDE1D]/,
+ // ECMAScript 6/Unicode v7.0.0 NonAsciiIdentifierPart:
+ NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDD0-\uDDDA\uDE00-\uDE11\uDE13-\uDE37\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF01-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF98]|\uD809[\uDC00-\uDC6E]|[\uD80C\uD840-\uD868\uD86A-\uD86C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
+ };
+
+ function isDecimalDigit(ch) {
+ return 0x30 <= ch && ch <= 0x39; // 0..9
+ }
+
+ function isHexDigit(ch) {
+ return 0x30 <= ch && ch <= 0x39 || // 0..9
+ 0x61 <= ch && ch <= 0x66 || // a..f
+ 0x41 <= ch && ch <= 0x46; // A..F
+ }
+
+ function isOctalDigit(ch) {
+ return ch >= 0x30 && ch <= 0x37; // 0..7
+ }
+
+ // 7.2 White Space
+
+ NON_ASCII_WHITESPACES = [
+ 0x1680, 0x180E,
+ 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A,
+ 0x202F, 0x205F,
+ 0x3000,
+ 0xFEFF
+ ];
+
+ function isWhiteSpace(ch) {
+ return ch === 0x20 || ch === 0x09 || ch === 0x0B || ch === 0x0C || ch === 0xA0 ||
+ ch >= 0x1680 && NON_ASCII_WHITESPACES.indexOf(ch) >= 0;
+ }
+
+ // 7.3 Line Terminators
+
+ function isLineTerminator(ch) {
+ return ch === 0x0A || ch === 0x0D || ch === 0x2028 || ch === 0x2029;
+ }
+
+ // 7.6 Identifier Names and Identifiers
+
+ function fromCodePoint(cp) {
+ if (cp <= 0xFFFF) { return String.fromCharCode(cp); }
+ var cu1 = String.fromCharCode(Math.floor((cp - 0x10000) / 0x400) + 0xD800);
+ var cu2 = String.fromCharCode(((cp - 0x10000) % 0x400) + 0xDC00);
+ return cu1 + cu2;
+ }
+
+ IDENTIFIER_START = new Array(0x80);
+ for(ch = 0; ch < 0x80; ++ch) {
+ IDENTIFIER_START[ch] =
+ ch >= 0x61 && ch <= 0x7A || // a..z
+ ch >= 0x41 && ch <= 0x5A || // A..Z
+ ch === 0x24 || ch === 0x5F; // $ (dollar) and _ (underscore)
+ }
+
+ IDENTIFIER_PART = new Array(0x80);
+ for(ch = 0; ch < 0x80; ++ch) {
+ IDENTIFIER_PART[ch] =
+ ch >= 0x61 && ch <= 0x7A || // a..z
+ ch >= 0x41 && ch <= 0x5A || // A..Z
+ ch >= 0x30 && ch <= 0x39 || // 0..9
+ ch === 0x24 || ch === 0x5F; // $ (dollar) and _ (underscore)
+ }
+
+ function isIdentifierStartES5(ch) {
+ return ch < 0x80 ? IDENTIFIER_START[ch] : ES5Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch));
+ }
+
+ function isIdentifierPartES5(ch) {
+ return ch < 0x80 ? IDENTIFIER_PART[ch] : ES5Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch));
+ }
+
+ function isIdentifierStartES6(ch) {
+ return ch < 0x80 ? IDENTIFIER_START[ch] : ES6Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch));
+ }
+
+ function isIdentifierPartES6(ch) {
+ return ch < 0x80 ? IDENTIFIER_PART[ch] : ES6Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch));
+ }
+
+ module.exports = {
+ isDecimalDigit: isDecimalDigit,
+ isHexDigit: isHexDigit,
+ isOctalDigit: isOctalDigit,
+ isWhiteSpace: isWhiteSpace,
+ isLineTerminator: isLineTerminator,
+ isIdentifierStartES5: isIdentifierStartES5,
+ isIdentifierPartES5: isIdentifierPartES5,
+ isIdentifierStartES6: isIdentifierStartES6,
+ isIdentifierPartES6: isIdentifierPartES6
+ };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+});
+
+var keyword = createCommonjsModule(function (module) {
+/*
+ Copyright (C) 2013 Yusuke Suzuki
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+(function () {
+ 'use strict';
+
+ var code$$1 = code;
+
+ function isStrictModeReservedWordES6(id) {
+ switch (id) {
+ case 'implements':
+ case 'interface':
+ case 'package':
+ case 'private':
+ case 'protected':
+ case 'public':
+ case 'static':
+ case 'let':
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ function isKeywordES5(id, strict) {
+ // yield should not be treated as keyword under non-strict mode.
+ if (!strict && id === 'yield') {
+ return false;
+ }
+ return isKeywordES6(id, strict);
+ }
+
+ function isKeywordES6(id, strict) {
+ if (strict && isStrictModeReservedWordES6(id)) {
+ return true;
+ }
+
+ switch (id.length) {
+ case 2:
+ return (id === 'if') || (id === 'in') || (id === 'do');
+ case 3:
+ return (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');
+ case 4:
+ return (id === 'this') || (id === 'else') || (id === 'case') ||
+ (id === 'void') || (id === 'with') || (id === 'enum');
+ case 5:
+ return (id === 'while') || (id === 'break') || (id === 'catch') ||
+ (id === 'throw') || (id === 'const') || (id === 'yield') ||
+ (id === 'class') || (id === 'super');
+ case 6:
+ return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
+ (id === 'switch') || (id === 'export') || (id === 'import');
+ case 7:
+ return (id === 'default') || (id === 'finally') || (id === 'extends');
+ case 8:
+ return (id === 'function') || (id === 'continue') || (id === 'debugger');
+ case 10:
+ return (id === 'instanceof');
+ default:
+ return false;
+ }
+ }
+
+ function isReservedWordES5(id, strict) {
+ return id === 'null' || id === 'true' || id === 'false' || isKeywordES5(id, strict);
+ }
+
+ function isReservedWordES6(id, strict) {
+ return id === 'null' || id === 'true' || id === 'false' || isKeywordES6(id, strict);
+ }
+
+ function isRestrictedWord(id) {
+ return id === 'eval' || id === 'arguments';
+ }
+
+ function isIdentifierNameES5(id) {
+ var i, iz, ch;
+
+ if (id.length === 0) { return false; }
+
+ ch = id.charCodeAt(0);
+ if (!code$$1.isIdentifierStartES5(ch)) {
+ return false;
+ }
+
+ for (i = 1, iz = id.length; i < iz; ++i) {
+ ch = id.charCodeAt(i);
+ if (!code$$1.isIdentifierPartES5(ch)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ function decodeUtf16(lead, trail) {
+ return (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+ }
+
+ function isIdentifierNameES6(id) {
+ var i, iz, ch, lowCh, check;
+
+ if (id.length === 0) { return false; }
+
+ check = code$$1.isIdentifierStartES6;
+ for (i = 0, iz = id.length; i < iz; ++i) {
+ ch = id.charCodeAt(i);
+ if (0xD800 <= ch && ch <= 0xDBFF) {
+ ++i;
+ if (i >= iz) { return false; }
+ lowCh = id.charCodeAt(i);
+ if (!(0xDC00 <= lowCh && lowCh <= 0xDFFF)) {
+ return false;
+ }
+ ch = decodeUtf16(ch, lowCh);
+ }
+ if (!check(ch)) {
+ return false;
+ }
+ check = code$$1.isIdentifierPartES6;
+ }
+ return true;
+ }
+
+ function isIdentifierES5(id, strict) {
+ return isIdentifierNameES5(id) && !isReservedWordES5(id, strict);
+ }
+
+ function isIdentifierES6(id, strict) {
+ return isIdentifierNameES6(id) && !isReservedWordES6(id, strict);
+ }
+
+ module.exports = {
+ isKeywordES5: isKeywordES5,
+ isKeywordES6: isKeywordES6,
+ isReservedWordES5: isReservedWordES5,
+ isReservedWordES6: isReservedWordES6,
+ isRestrictedWord: isRestrictedWord,
+ isIdentifierNameES5: isIdentifierNameES5,
+ isIdentifierNameES6: isIdentifierNameES6,
+ isIdentifierES5: isIdentifierES5,
+ isIdentifierES6: isIdentifierES6
+ };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+});
+
+var utils = createCommonjsModule(function (module, exports) {
+/*
+ Copyright (C) 2013 Yusuke Suzuki
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+(function () {
+ 'use strict';
+
+ exports.ast = ast;
+ exports.code = code;
+ exports.keyword = keyword;
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+});
+
+function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) {
+ function traverseDocRec(doc) {
+ let shouldRecurse = true;
+ if (onEnter) {
+ if (onEnter(doc) === false) {
+ shouldRecurse = false;
+ }
+ }
+
+ if (shouldRecurse) {
+ if (doc.type === "concat" || doc.type === "fill") {
+ for (let i = 0; i < doc.parts.length; i++) {
+ traverseDocRec(doc.parts[i]);
+ }
+ } else if (doc.type === "if-break") {
+ if (doc.breakContents) {
+ traverseDocRec(doc.breakContents);
+ }
+ if (doc.flatContents) {
+ traverseDocRec(doc.flatContents);
+ }
+ } else if (doc.type === "group" && doc.expandedStates) {
+ if (shouldTraverseConditionalGroups) {
+ doc.expandedStates.forEach(traverseDocRec);
+ } else {
+ traverseDocRec(doc.contents);
+ }
+ } else if (doc.contents) {
+ traverseDocRec(doc.contents);
+ }
+ }
+
+ if (onExit) {
+ onExit(doc);
+ }
+ }
+
+ traverseDocRec(doc);
+}
+
+function mapDoc(doc, func) {
+ doc = func(doc);
+
+ if (doc.type === "concat" || doc.type === "fill") {
+ return Object.assign({}, doc, {
+ parts: doc.parts.map(d => mapDoc(d, func))
+ });
+ } else if (doc.type === "if-break") {
+ return Object.assign({}, doc, {
+ breakContents: doc.breakContents && mapDoc(doc.breakContents, func),
+ flatContents: doc.flatContents && mapDoc(doc.flatContents, func)
+ });
+ } else if (doc.contents) {
+ return Object.assign({}, doc, { contents: mapDoc(doc.contents, func) });
+ } else {
+ return doc;
+ }
+}
+
+function findInDoc(doc, fn, defaultValue) {
+ let result = defaultValue;
+ let hasStopped = false;
+ traverseDoc(doc, doc => {
+ const maybeResult = fn(doc);
+ if (maybeResult !== undefined) {
+ hasStopped = true;
+ result = maybeResult;
+ }
+ if (hasStopped) {
+ return false;
+ }
+ });
+ return result;
+}
+
+function isEmpty$1(n) {
+ return typeof n === "string" && n.length === 0;
+}
+
+function isLineNext$1(doc) {
+ return findInDoc(
+ doc,
+ doc => {
+ if (typeof doc === "string") {
+ return false;
+ }
+ if (doc.type === "line") {
+ return true;
+ }
+ },
+ false
+ );
+}
+
+function willBreak$1(doc) {
+ return findInDoc(
+ doc,
+ doc => {
+ if (doc.type === "group" && doc.break) {
+ return true;
+ }
+ if (doc.type === "line" && doc.hard) {
+ return true;
+ }
+ if (doc.type === "break-parent") {
+ return true;
+ }
+ },
+ false
+ );
+}
+
+function breakParentGroup(groupStack) {
+ if (groupStack.length > 0) {
+ const parentGroup = groupStack[groupStack.length - 1];
+ // Breaks are not propagated through conditional groups because
+ // the user is expected to manually handle what breaks.
+ if (!parentGroup.expandedStates) {
+ parentGroup.break = true;
+ }
+ }
+ return null;
+}
+
+function propagateBreaks(doc) {
+ const alreadyVisited = new Map();
+ const groupStack = [];
+ traverseDoc(
+ doc,
+ doc => {
+ if (doc.type === "break-parent") {
+ breakParentGroup(groupStack);
+ }
+ if (doc.type === "group") {
+ groupStack.push(doc);
+ if (alreadyVisited.has(doc)) {
+ return false;
+ }
+ alreadyVisited.set(doc, true);
+ }
+ },
+ doc => {
+ if (doc.type === "group") {
+ const group = groupStack.pop();
+ if (group.break) {
+ breakParentGroup(groupStack);
+ }
+ }
+ },
+ /* shouldTraverseConditionalGroups */ true
+ );
+}
+
+var docUtils$1 = {
+ isEmpty: isEmpty$1,
+ willBreak: willBreak$1,
+ isLineNext: isLineNext$1,
+ traverseDoc,
+ mapDoc,
+ propagateBreaks
+};
+
+const assert$1 = require$$0;
+const comments$3 = comments$1;
+const FastPath = fastPath;
+const util$4 = util$2;
+const isIdentifierName = utils.keyword.isIdentifierNameES6;
+
+const docBuilders$3 = docBuilders$1;
+const concat$2 = docBuilders$3.concat;
+const join$2 = docBuilders$3.join;
+const line$1 = docBuilders$3.line;
+const hardline$2 = docBuilders$3.hardline;
+const softline$1 = docBuilders$3.softline;
+const literalline$1 = docBuilders$3.literalline;
+const group$1 = docBuilders$3.group;
+const indent$2 = docBuilders$3.indent;
+const align$1 = docBuilders$3.align;
+const conditionalGroup$1 = docBuilders$3.conditionalGroup;
+const fill$1 = docBuilders$3.fill;
+const ifBreak$1 = docBuilders$3.ifBreak;
+const breakParent$2 = docBuilders$3.breakParent;
+const lineSuffixBoundary$1 = docBuilders$3.lineSuffixBoundary;
+const addAlignmentToDoc$1 = docBuilders$3.addAlignmentToDoc;
+
+const docUtils = docUtils$1;
+const willBreak = docUtils.willBreak;
+const isLineNext = docUtils.isLineNext;
+const isEmpty = docUtils.isEmpty;
+
+function shouldPrintComma(options, level) {
+ level = level || "es5";
+
+ switch (options.trailingComma) {
+ case "all":
+ if (level === "all") {
+ return true;
+ }
+ // fallthrough
+ case "es5":
+ if (level === "es5") {
+ return true;
+ }
+ // fallthrough
+ case "none":
+ default:
+ return false;
+ }
+}
+
+function genericPrint(path, options, printPath, args) {
+ assert$1.ok(path instanceof FastPath);
+
+ const node = path.getValue();
+
+ // Escape hatch
+ if (
+ node &&
+ node.comments &&
+ node.comments.length > 0 &&
+ node.comments.some(comment => comment.value.trim() === "prettier-ignore")
+ ) {
+ return options.originalText.slice(util$4.locStart(node), util$4.locEnd(node));
+ }
+
+ const parts = [];
+ let needsParens = false;
+ const linesWithoutParens = genericPrintNoParens(
+ path,
+ options,
+ printPath,
+ args
+ );
+
+ if (!node || isEmpty(linesWithoutParens)) {
+ return linesWithoutParens;
+ }
+
+ if (
+ node.decorators &&
+ node.decorators.length > 0 &&
+ // If the parent node is an export declaration, it will be
+ // responsible for printing node.decorators.
+ !util$4.getParentExportDeclaration(path)
+ ) {
+ let separator = hardline$2;
+ path.each(decoratorPath => {
+ let prefix = "@";
+ let decorator = decoratorPath.getValue();
+ if (decorator.expression) {
+ decorator = decorator.expression;
+ prefix = "";
+ }
+
+ if (
+ node.decorators.length === 1 &&
+ (decorator.type === "Identifier" ||
+ decorator.type === "MemberExpression")
+ ) {
+ separator = " ";
+ }
+
+ parts.push(prefix, printPath(decoratorPath), separator);
+ }, "decorators");
+ } else if (
+ util$4.isExportDeclaration(node) &&
+ node.declaration &&
+ node.declaration.decorators
+ ) {
+ // Export declarations are responsible for printing any decorators
+ // that logically apply to node.declaration.
+ path.each(
+ decoratorPath => {
+ const decorator = decoratorPath.getValue();
+ const prefix = decorator.type === "Decorator" ||
+ decorator.type === "TSDecorator"
+ ? ""
+ : "@";
+ parts.push(prefix, printPath(decoratorPath), line$1);
+ },
+ "declaration",
+ "decorators"
+ );
+ } else {
+ // Nodes with decorators can't have parentheses, so we can avoid
+ // computing path.needsParens() except in this case.
+ needsParens = path.needsParens();
+ }
+
+ if (node.type) {
+ // HACK: ASI prevention in no-semi mode relies on knowledge of whether
+ // or not a paren has been inserted (see `exprNeedsASIProtection()`).
+ // For now, we're just passing that information by mutating the AST here,
+ // but it would be nice to find a cleaner way to do this.
+ node.needsParens = needsParens;
+ }
+
+ if (needsParens) {
+ parts.unshift("(");
+ }
+
+ parts.push(linesWithoutParens);
+
+ if (needsParens) {
+ parts.push(")");
+ }
+
+ return concat$2(parts);
+}
+
+function genericPrintNoParens(path, options, print, args) {
+ const n = path.getValue();
+ const semi = options.semi ? ";" : "";
+
+ if (!n) {
+ return "";
+ }
+
+ if (typeof n === "string") {
+ return n;
+ }
+
+ let parts = [];
+ switch (n.type) {
+ case "File":
+ return path.call(print, "program");
+ case "Program":
+ // Babel 6
+ if (n.directives) {
+ path.each(childPath => {
+ parts.push(print(childPath), semi, hardline$2);
+ if (
+ util$4.isNextLineEmpty(options.originalText, childPath.getValue())
+ ) {
+ parts.push(hardline$2);
+ }
+ }, "directives");
+ }
+
+ parts.push(
+ path.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body")
+ );
+
+ parts.push(
+ comments$3.printDanglingComments(path, options, /* sameIndent */ true)
+ );
+
+ // Only force a trailing newline if there were any contents.
+ if (n.body.length || n.comments) {
+ parts.push(hardline$2);
+ }
+
+ return concat$2(parts);
+ // Babel extension.
+ case "Noop":
+ case "EmptyStatement":
+ return "";
+ case "ExpressionStatement":
+ // Detect Flow-parsed directives
+ if (n.directive) {
+ return concat$2([nodeStr(n.expression, options, true), semi]);
+ }
+ return concat$2([path.call(print, "expression"), semi]); // Babel extension.
+ case "ParenthesizedExpression":
+ return concat$2(["(", path.call(print, "expression"), ")"]);
+ case "AssignmentExpression":
+ return printAssignment(
+ n.left,
+ path.call(print, "left"),
+ concat$2([" ", n.operator]),
+ n.right,
+ path.call(print, "right"),
+ options
+ );
+ case "BinaryExpression":
+ case "LogicalExpression": {
+ const parent = path.getParentNode();
+ const parentParent = path.getParentNode(1);
+ const isInsideParenthesis =
+ n !== parent.body &&
+ (parent.type === "IfStatement" ||
+ parent.type === "WhileStatement" ||
+ parent.type === "DoStatement");
+
+ const parts = printBinaryishExpressions(
+ path,
+ print,
+ options,
+ /* isNested */ false,
+ isInsideParenthesis
+ );
+
+ // if (
+ // this.hasPlugin("dynamicImports") && this.lookahead().type === tt.parenLeft
+ // ) {
+ //
+ // looks super weird, we want to break the children if the parent breaks
+ //
+ // if (
+ // this.hasPlugin("dynamicImports") &&
+ // this.lookahead().type === tt.parenLeft
+ // ) {
+ if (isInsideParenthesis) {
+ return concat$2(parts);
+ }
+
+ if (parent.type === "UnaryExpression") {
+ return group$1(
+ concat$2([indent$2(concat$2([softline$1, concat$2(parts)])), softline$1])
+ );
+ }
+
+ // Avoid indenting sub-expressions in assignment/return/etc statements.
+ if (
+ parent.type === "AssignmentExpression" ||
+ parent.type === "VariableDeclarator" ||
+ shouldInlineLogicalExpression(n) ||
+ parent.type === "ReturnStatement" ||
+ (parent.type === "JSXExpressionContainer" &&
+ parentParent.type === "JSXAttribute") ||
+ (n === parent.body && parent.type === "ArrowFunctionExpression") ||
+ (n !== parent.body && parent.type === "ForStatement")
+ ) {
+ return group$1(concat$2(parts));
+ }
+
+ const rest = concat$2(parts.slice(1));
+
+ return group$1(
+ concat$2([
+ // Don't include the initial expression in the indentation
+ // level. The first item is guaranteed to be the first
+ // left-most expression.
+ parts.length > 0 ? parts[0] : "",
+ indent$2(rest)
+ ])
+ );
+ }
+ case "AssignmentPattern":
+ return concat$2([
+ path.call(print, "left"),
+ " = ",
+ path.call(print, "right")
+ ]);
+ case "TSTypeAssertionExpression":
+ return concat$2([
+ "<",
+ path.call(print, "typeAnnotation"),
+ ">",
+ path.call(print, "expression")
+ ]);
+ case "MemberExpression": {
+ const parent = path.getParentNode();
+ let firstNonMemberParent;
+ let i = 0;
+ do {
+ firstNonMemberParent = path.getParentNode(i);
+ i++;
+ } while (
+ firstNonMemberParent && firstNonMemberParent.type === "MemberExpression"
+ );
+
+ const shouldInline =
+ (firstNonMemberParent &&
+ ((firstNonMemberParent.type === "VariableDeclarator" &&
+ firstNonMemberParent.id.type !== "Identifier") ||
+ (firstNonMemberParent.type === "AssignmentExpression" &&
+ firstNonMemberParent.left.type !== "Identifier"))) ||
+ n.computed ||
+ (n.object.type === "Identifier" &&
+ n.property.type === "Identifier" &&
+ parent.type !== "MemberExpression");
+
+ return concat$2([
+ path.call(print, "object"),
+ shouldInline
+ ? printMemberLookup(path, options, print)
+ : group$1(
+ indent$2(
+ concat$2([softline$1, printMemberLookup(path, options, print)])
+ )
+ )
+ ]);
+ }
+ case "MetaProperty":
+ return concat$2([
+ path.call(print, "meta"),
+ ".",
+ path.call(print, "property")
+ ]);
+ case "BindExpression":
+ if (n.object) {
+ parts.push(path.call(print, "object"));
+ }
+
+ parts.push("::", path.call(print, "callee"));
+
+ return concat$2(parts);
+ case "Path":
+ return join$2(".", n.body);
+ case "Identifier": {
+ const parentNode = path.getParentNode();
+ const isFunctionDeclarationIdentifier =
+ parentNode.type === "DeclareFunction" && parentNode.id === n;
+
+ return concat$2([
+ n.name,
+ n.optional ? "?" : "",
+ n.typeAnnotation && !isFunctionDeclarationIdentifier ? ": " : "",
+ path.call(print, "typeAnnotation")
+ ]);
+ }
+ case "SpreadElement":
+ case "SpreadElementPattern":
+ case "RestProperty":
+ case "ExperimentalRestProperty":
+ case "ExperimentalSpreadProperty":
+ case "SpreadProperty":
+ case "SpreadPropertyPattern":
+ case "RestElement":
+ case "ObjectTypeSpreadProperty":
+ return concat$2([
+ "...",
+ path.call(print, "argument"),
+ n.typeAnnotation ? ": " : "",
+ path.call(print, "typeAnnotation")
+ ]);
+ case "FunctionDeclaration":
+ case "FunctionExpression":
+ case "TSNamespaceFunctionDeclaration":
+ if (isNodeStartingWithDeclare(n, options)) {
+ parts.push("declare ");
+ }
+ parts.push(printFunctionDeclaration(path, print, options));
+ return concat$2(parts);
+ case "ArrowFunctionExpression": {
+ if (n.async) {
+ parts.push("async ");
+ }
+
+ parts.push(printFunctionTypeParameters(path, options, print));
+
+ if (canPrintParamsWithoutParens(n)) {
+ parts.push(path.call(print, "params", 0));
+ } else {
+ parts.push(
+ group$1(
+ concat$2([
+ printFunctionParams(
+ path,
+ print,
+ options,
+ args && (args.expandLastArg || args.expandFirstArg)
+ ),
+ printReturnType(path, print)
+ ])
+ )
+ );
+ }
+
+ parts.push(" =>");
+
+ const body = path.call(bodyPath => print(bodyPath, args), "body");
+ const collapsed = concat$2([concat$2(parts), " ", body]);
+
+ // We want to always keep these types of nodes on the same line
+ // as the arrow.
+ if (
+ !hasLeadingOwnLineComment(options.originalText, n.body) &&
+ (n.body.type === "ArrayExpression" ||
+ n.body.type === "ObjectExpression" ||
+ n.body.type === "BlockStatement" ||
+ n.body.type === "SequenceExpression" ||
+ isTemplateOnItsOwnLine(n.body, options.originalText) ||
+ n.body.type === "ArrowFunctionExpression")
+ ) {
+ return group$1(collapsed);
+ }
+
+ // if the arrow function is expanded as last argument, we are adding a
+ // level of indentation and need to add a softline to align the closing )
+ // with the opening (.
+ const shouldAddSoftLine = args && args.expandLastArg;
+
+ // In order to avoid confusion between
+ // a => a ? a : a
+ // a <= a ? a : a
+ const shouldAddParens =
+ n.body.type === "ConditionalExpression" &&
+ !util$4.startsWithNoLookaheadToken(
+ n.body,
+ /* forbidFunctionAndClass */ false
+ );
+
+ return group$1(
+ concat$2([
+ concat$2(parts),
+ group$1(
+ concat$2([
+ indent$2(
+ concat$2([
+ line$1,
+ shouldAddParens ? ifBreak$1("", "(") : "",
+ body,
+ shouldAddParens ? ifBreak$1("", ")") : ""
+ ])
+ ),
+ shouldAddSoftLine
+ ? concat$2([
+ ifBreak$1(shouldPrintComma(options, "all") ? "," : ""),
+ softline$1
+ ])
+ : ""
+ ])
+ )
+ ])
+ );
+ }
+ case "MethodDefinition":
+ case "TSAbstractMethodDefinition":
+ if (n.static) {
+ parts.push("static ");
+ }
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.type === "TSAbstractMethodDefinition") {
+ parts.push("abstract ");
+ }
+
+ parts.push(printMethod(path, options, print));
+
+ return concat$2(parts);
+ case "YieldExpression":
+ parts.push("yield");
+
+ if (n.delegate) {
+ parts.push("*");
+ }
+ if (n.argument) {
+ parts.push(" ", path.call(print, "argument"));
+ }
+
+ return concat$2(parts);
+ case "AwaitExpression":
+ parts.push("await");
+
+ if (n.all) {
+ parts.push("*");
+ }
+ if (n.argument) {
+ parts.push(" ", path.call(print, "argument"));
+ }
+
+ return concat$2(parts);
+ case "ModuleDeclaration":
+ parts.push("module", path.call(print, "id"));
+
+ if (n.source) {
+ assert$1.ok(!n.body);
+
+ parts.push("from", path.call(print, "source"));
+ } else {
+ parts.push(path.call(print, "body"));
+ }
+
+ return join$2(" ", parts);
+ case "ImportSpecifier":
+ if (n.imported) {
+ if (n.importKind) {
+ parts.push(path.call(print, "importKind"), " ");
+ }
+
+ parts.push(path.call(print, "imported"));
+
+ if (n.local && n.local.name !== n.imported.name) {
+ parts.push(" as ", path.call(print, "local"));
+ }
+ } else if (n.id) {
+ parts.push(path.call(print, "id"));
+
+ if (n.name) {
+ parts.push(" as ", path.call(print, "name"));
+ }
+ }
+
+ return concat$2(parts);
+ case "ExportSpecifier":
+ if (n.local) {
+ parts.push(path.call(print, "local"));
+
+ if (n.exported && n.exported.name !== n.local.name) {
+ parts.push(" as ", path.call(print, "exported"));
+ }
+ } else if (n.id) {
+ parts.push(path.call(print, "id"));
+
+ if (n.name) {
+ parts.push(" as ", path.call(print, "name"));
+ }
+ }
+
+ return concat$2(parts);
+ case "ExportBatchSpecifier":
+ return "*";
+ case "ImportNamespaceSpecifier":
+ parts.push("* as ");
+
+ if (n.local) {
+ parts.push(path.call(print, "local"));
+ } else if (n.id) {
+ parts.push(path.call(print, "id"));
+ }
+
+ return concat$2(parts);
+ case "ImportDefaultSpecifier":
+ if (n.local) {
+ return path.call(print, "local");
+ }
+
+ return path.call(print, "id");
+ case "ExportDeclaration":
+ case "ExportDefaultDeclaration":
+ case "ExportNamedDeclaration":
+ return printExportDeclaration(path, options, print);
+ case "ExportAllDeclaration":
+ parts.push("export *");
+
+ if (n.exported) {
+ parts.push(" as ", path.call(print, "exported"));
+ }
+
+ parts.push(" from ", path.call(print, "source"), semi);
+
+ return concat$2(parts);
+ case "ExportNamespaceSpecifier":
+ case "ExportDefaultSpecifier":
+ return path.call(print, "exported");
+ case "ImportDeclaration": {
+ parts.push("import ");
+
+ if (n.importKind && n.importKind !== "value") {
+ parts.push(n.importKind + " ");
+ }
+
+ const standalones = [];
+ const grouped = [];
+ if (n.specifiers && n.specifiers.length > 0) {
+ path.each(specifierPath => {
+ const value = specifierPath.getValue();
+ if (
+ value.type === "ImportDefaultSpecifier" ||
+ value.type === "ImportNamespaceSpecifier"
+ ) {
+ standalones.push(print(specifierPath));
+ } else {
+ grouped.push(print(specifierPath));
+ }
+ }, "specifiers");
+
+ if (standalones.length > 0) {
+ parts.push(join$2(", ", standalones));
+ }
+
+ if (standalones.length > 0 && grouped.length > 0) {
+ parts.push(", ");
+ }
+
+ if (
+ grouped.length === 1 &&
+ n.specifiers &&
+ !n.specifiers.some(node => node.comments)
+ ) {
+ parts.push(
+ concat$2([
+ "{",
+ options.bracketSpacing ? " " : "",
+ concat$2(grouped),
+ options.bracketSpacing ? " " : "",
+ "}"
+ ])
+ );
+ } else if (grouped.length >= 1) {
+ parts.push(
+ group$1(
+ concat$2([
+ "{",
+ indent$2(
+ concat$2([
+ options.bracketSpacing ? line$1 : softline$1,
+ join$2(concat$2([",", line$1]), grouped)
+ ])
+ ),
+ ifBreak$1(shouldPrintComma(options) ? "," : ""),
+ options.bracketSpacing ? line$1 : softline$1,
+ "}"
+ ])
+ )
+ );
+ }
+
+ parts.push(" ", "from ");
+ } else if (n.importKind && n.importKind === "type") {
+ parts.push("{} from ");
+ }
+
+ parts.push(path.call(print, "source"), semi);
+
+ return concat$2(parts);
+ }
+
+ case "Import":
+ return "import";
+ case "BlockStatement": {
+ const naked = path.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body");
+
+ const hasContent = n.body.find(node => node.type !== "EmptyStatement");
+ const hasDirectives = n.directives && n.directives.length > 0;
+
+ const parent = path.getParentNode();
+ const parentParent = path.getParentNode(1);
+ if (
+ !hasContent &&
+ !hasDirectives &&
+ !n.comments &&
+ (parent.type === "ArrowFunctionExpression" ||
+ parent.type === "FunctionExpression" ||
+ parent.type === "FunctionDeclaration" ||
+ parent.type === "ObjectMethod" ||
+ parent.type === "ClassMethod" ||
+ parent.type === "ForStatement" ||
+ parent.type === "WhileStatement" ||
+ parent.type === "DoWhileStatement" ||
+ (parent.type === "CatchClause" && !parentParent.finalizer))
+ ) {
+ return "{}";
+ }
+
+ parts.push("{");
+
+ // Babel 6
+ if (hasDirectives) {
+ path.each(childPath => {
+ parts.push(indent$2(concat$2([hardline$2, print(childPath), semi])));
+ }, "directives");
+ }
+
+ if (hasContent) {
+ parts.push(indent$2(concat$2([hardline$2, naked])));
+ }
+
+ parts.push(comments$3.printDanglingComments(path, options));
+ parts.push(hardline$2, "}");
+
+ return concat$2(parts);
+ }
+ case "ReturnStatement":
+ parts.push("return");
+
+ if (n.argument) {
+ if (returnArgumentHasLeadingComment(options, n.argument)) {
+ parts.push(
+ concat$2([
+ " (",
+ indent$2(concat$2([softline$1, path.call(print, "argument")])),
+ line$1,
+ ")"
+ ])
+ );
+ } else if (
+ n.argument.type === "LogicalExpression" ||
+ n.argument.type === "BinaryExpression"
+ ) {
+ parts.push(
+ group$1(
+ concat$2([
+ ifBreak$1(" (", " "),
+ indent$2(concat$2([softline$1, path.call(print, "argument")])),
+ softline$1,
+ ifBreak$1(")")
+ ])
+ )
+ );
+ } else {
+ parts.push(" ", path.call(print, "argument"));
+ }
+ }
+
+ if (hasDanglingComments(n)) {
+ parts.push(
+ " ",
+ comments$3.printDanglingComments(path, options, /* sameIndent */ true)
+ );
+ }
+
+ parts.push(semi);
+
+ return concat$2(parts);
+ case "CallExpression": {
+ if (
+ // We want to keep require calls as a unit
+ (n.callee.type === "Identifier" && n.callee.name === "require") ||
+ // Template literals as single arguments
+ (n.arguments.length === 1 &&
+ isTemplateOnItsOwnLine(n.arguments[0], options.originalText)) ||
+ // Keep test declarations on a single line
+ // e.g. `it('long name', () => {`
+ (n.callee.type === "Identifier" &&
+ (n.callee.name === "it" ||
+ n.callee.name === "test" ||
+ n.callee.name === "describe") &&
+ n.arguments.length === 2 &&
+ (n.arguments[0].type === "StringLiteral" ||
+ n.arguments[0].type === "TemplateLiteral" ||
+ (n.arguments[0].type === "Literal" &&
+ typeof n.arguments[0].value === "string")) &&
+ (n.arguments[1].type === "FunctionExpression" ||
+ n.arguments[1].type === "ArrowFunctionExpression") &&
+ n.arguments[1].params.length <= 1)
+ ) {
+ return concat$2([
+ path.call(print, "callee"),
+ path.call(print, "typeParameters"),
+ concat$2(["(", join$2(", ", path.map(print, "arguments")), ")"])
+ ]);
+ }
+
+ // We detect calls on member lookups and possibly print them in a
+ // special chain format. See `printMemberChain` for more info.
+ if (n.callee.type === "MemberExpression") {
+ return printMemberChain(path, options, print);
+ }
+
+ return concat$2([
+ path.call(print, "callee"),
+ printFunctionTypeParameters(path, options, print),
+ printArgumentsList(path, options, print)
+ ]);
+ }
+ case "TSInterfaceDeclaration":
+ parts.push(
+ n.abstract ? "abstract " : "",
+ printTypeScriptModifiers(path, options, print),
+ "interface ",
+ path.call(print, "id"),
+ n.typeParameters ? path.call(print, "typeParameters") : "",
+ " "
+ );
+
+ if (n.heritage.length) {
+ parts.push("extends ", join$2(", ", path.map(print, "heritage")), " ");
+ }
+
+ parts.push(path.call(print, "body"));
+
+ return concat$2(parts);
+ case "ObjectExpression":
+ case "ObjectPattern":
+ case "TSInterfaceBody":
+ case "ObjectTypeAnnotation":
+ case "TSTypeLiteral": {
+ const isTypeAnnotation = n.type === "ObjectTypeAnnotation";
+ const isTypeScriptInterfaceBody = n.type === "TSInterfaceBody";
+ // Leave this here because we *might* want to make this
+ // configurable later -- flow accepts ";" for type separators,
+ // typescript accepts ";" and newlines
+ let separator = isTypeAnnotation ? "," : ",";
+ if (isTypeScriptInterfaceBody) {
+ separator = semi;
+ }
+ const fields = [];
+ const leftBrace = n.exact ? "{|" : "{";
+ const rightBrace = n.exact ? "|}" : "}";
+ const parent = path.getParentNode(0);
+
+ let propertiesField;
+
+ if (n.type === "TSTypeLiteral") {
+ propertiesField = "members";
+ } else if (n.type === "TSInterfaceBody") {
+ propertiesField = "body";
+ } else {
+ propertiesField = "properties";
+ }
+
+ if (isTypeAnnotation) {
+ fields.push("indexers", "callProperties");
+ }
+ fields.push(propertiesField);
+
+ // Unfortunately, things are grouped together in the ast can be
+ // interleaved in the source code. So we need to reorder them before
+ // printing them.
+ const propsAndLoc = [];
+ fields.forEach(field => {
+ path.each(childPath => {
+ const node = childPath.getValue();
+ propsAndLoc.push({
+ node: node,
+ printed: print(childPath),
+ loc: util$4.locStart(node)
+ });
+ }, field);
+ });
+
+ let separatorParts = [];
+ const props = propsAndLoc.sort((a, b) => a.loc - b.loc).map(prop => {
+ const result = concat$2(separatorParts.concat(group$1(prop.printed)));
+ separatorParts = [separator, line$1];
+ if (util$4.isNextLineEmpty(options.originalText, prop.node)) {
+ separatorParts.push(hardline$2);
+ }
+ return result;
+ });
+
+ const lastElem = util$4.getLast(n[propertiesField]);
+
+ const canHaveTrailingSeparator = !(lastElem &&
+ (lastElem.type === "RestProperty" || lastElem.type === "RestElement"));
+
+ let content;
+ if (props.length === 0 && !n.typeAnnotation) {
+ if (!hasDanglingComments(n)) {
+ return concat$2([leftBrace, rightBrace]);
+ }
+
+ content = group$1(
+ concat$2([
+ leftBrace,
+ comments$3.printDanglingComments(path, options),
+ softline$1,
+ rightBrace
+ ])
+ );
+ } else {
+ content = concat$2([
+ leftBrace,
+ indent$2(
+ concat$2([options.bracketSpacing ? line$1 : softline$1, concat$2(props)])
+ ),
+ ifBreak$1(
+ canHaveTrailingSeparator &&
+ (separator !== "," || shouldPrintComma(options))
+ ? separator
+ : ""
+ ),
+ concat$2([options.bracketSpacing ? line$1 : softline$1, rightBrace]),
+ n.typeAnnotation ? ": " : "",
+ path.call(print, "typeAnnotation")
+ ]);
+ }
+
+ // If we inline the object as first argument of the parent, we don't want
+ // to create another group so that the object breaks before the return
+ // type
+ const parentParentParent = path.getParentNode(2);
+ if (
+ (n.type === "ObjectPattern" &&
+ parent &&
+ shouldHugArguments(parent) &&
+ parent.params[0] === n) ||
+ (shouldHugType(n) &&
+ parentParentParent &&
+ shouldHugArguments(parentParentParent) &&
+ parentParentParent.params[0].typeAnnotation.typeAnnotation === n)
+ ) {
+ return content;
+ }
+
+ const shouldBreak =
+ n.type !== "ObjectPattern" &&
+ util$4.hasNewlineInRange(
+ options.originalText,
+ util$4.locStart(n),
+ util$4.locEnd(n)
+ );
+
+ return group$1(content, { shouldBreak });
+ }
+ case "PropertyPattern":
+ return concat$2([
+ path.call(print, "key"),
+ ": ",
+ path.call(print, "pattern")
+ ]);
+ // Babel 6
+ case "ObjectProperty": // Non-standard AST node type.
+ case "Property":
+ if (n.method || n.kind === "get" || n.kind === "set") {
+ return printMethod(path, options, print);
+ }
+
+ if (n.shorthand) {
+ parts.push(path.call(print, "value"));
+ } else {
+ let printedLeft;
+ if (n.computed) {
+ printedLeft = concat$2(["[", path.call(print, "key"), "]"]);
+ } else {
+ printedLeft = printPropertyKey(path, options, print);
+ }
+ parts.push(
+ printAssignment(
+ n.key,
+ printedLeft,
+ ":",
+ n.value,
+ path.call(print, "value"),
+ options
+ )
+ );
+ }
+
+ return concat$2(parts); // Babel 6
+ case "ClassMethod":
+ if (n.static) {
+ parts.push("static ");
+ }
+
+ parts = parts.concat(printObjectMethod(path, options, print));
+
+ return concat$2(parts); // Babel 6
+ case "ObjectMethod":
+ return printObjectMethod(path, options, print);
+ case "TSDecorator":
+ case "Decorator":
+ return concat$2(["@", path.call(print, "expression")]);
+ case "ArrayExpression":
+ case "ArrayPattern":
+ if (n.elements.length === 0) {
+ if (!hasDanglingComments(n)) {
+ parts.push("[]");
+ } else {
+ parts.push(
+ group$1(
+ concat$2([
+ "[",
+ comments$3.printDanglingComments(path, options),
+ softline$1,
+ "]"
+ ])
+ )
+ );
+ }
+ } else {
+ const lastElem = util$4.getLast(n.elements);
+ const canHaveTrailingComma = !(lastElem &&
+ lastElem.type === "RestElement");
+
+ // JavaScript allows you to have empty elements in an array which
+ // changes its length based on the number of commas. The algorithm
+ // is that if the last argument is null, we need to force insert
+ // a comma to ensure JavaScript recognizes it.
+ // [,].length === 1
+ // [1,].length === 1
+ // [1,,].length === 2
+ //
+ // Note that util.getLast returns null if the array is empty, but
+ // we already check for an empty array just above so we are safe
+ const needsForcedTrailingComma =
+ canHaveTrailingComma && lastElem === null;
+
+ parts.push(
+ group$1(
+ concat$2([
+ "[",
+ indent$2(
+ concat$2([
+ softline$1,
+ printArrayItems(path, options, "elements", print)
+ ])
+ ),
+ needsForcedTrailingComma ? "," : "",
+ ifBreak$1(
+ canHaveTrailingComma &&
+ !needsForcedTrailingComma &&
+ shouldPrintComma(options)
+ ? ","
+ : ""
+ ),
+ comments$3.printDanglingComments(
+ path,
+ options,
+ /* sameIndent */ true
+ ),
+ softline$1,
+ "]"
+ ])
+ )
+ );
+ }
+
+ if (n.typeAnnotation) {
+ parts.push(": ", path.call(print, "typeAnnotation"));
+ }
+
+ return concat$2(parts);
+ case "SequenceExpression": {
+ const parent = path.getParentNode();
+ const shouldInline =
+ parent.type === "ReturnStatement" ||
+ parent.type === "ForStatement" ||
+ parent.type === "ExpressionStatement";
+
+ if (shouldInline) {
+ return join$2(", ", path.map(print, "expressions"));
+ }
+ return group$1(
+ concat$2([
+ indent$2(
+ concat$2([
+ softline$1,
+ join$2(concat$2([",", line$1]), path.map(print, "expressions"))
+ ])
+ ),
+ softline$1
+ ])
+ );
+ }
+ case "ThisExpression":
+ return "this";
+ case "Super":
+ return "super";
+ case "NullLiteral": // Babel 6 Literal split
+ return "null";
+ case "RegExpLiteral": // Babel 6 Literal split
+ return printRegex(n);
+ case "NumericLiteral": // Babel 6 Literal split
+ return printNumber(n.extra.raw);
+ case "BooleanLiteral": // Babel 6 Literal split
+ case "StringLiteral": // Babel 6 Literal split
+ case "Literal":
+ if (n.regex) {
+ return printRegex(n.regex);
+ }
+ if (typeof n.value === "number") {
+ return printNumber(n.raw);
+ }
+ if (typeof n.value !== "string") {
+ return "" + n.value;
+ }
+ return nodeStr(n, options); // Babel 6
+ case "Directive":
+ return path.call(print, "value"); // Babel 6
+ case "DirectiveLiteral":
+ return nodeStr(n, options);
+ case "ModuleSpecifier":
+ if (n.local) {
+ throw new Error("The ESTree ModuleSpecifier type should be abstract");
+ }
+
+ // The Esprima ModuleSpecifier type is just a string-valued
+ // Literal identifying the imported-from module.
+ return nodeStr(n, options);
+ case "UnaryExpression":
+ parts.push(n.operator);
+
+ if (/[a-z]$/.test(n.operator)) {
+ parts.push(" ");
+ }
+
+ parts.push(path.call(print, "argument"));
+
+ return concat$2(parts);
+ case "UpdateExpression":
+ parts.push(path.call(print, "argument"), n.operator);
+
+ if (n.prefix) {
+ parts.reverse();
+ }
+
+ return concat$2(parts);
+ case "ConditionalExpression": {
+ const parent = path.getParentNode();
+ const printed = concat$2([
+ line$1,
+ "? ",
+ n.consequent.type === "ConditionalExpression" ? ifBreak$1("", "(") : "",
+ align$1(2, path.call(print, "consequent")),
+ n.consequent.type === "ConditionalExpression" ? ifBreak$1("", ")") : "",
+ line$1,
+ ": ",
+ align$1(2, path.call(print, "alternate"))
+ ]);
+
+ return group$1(
+ concat$2([
+ path.call(print, "test"),
+ parent.type === "ConditionalExpression" ? printed : indent$2(printed)
+ ])
+ );
+ }
+ case "NewExpression":
+ parts.push(
+ "new ",
+ path.call(print, "callee"),
+ printFunctionTypeParameters(path, options, print)
+ );
+
+ if (n.arguments) {
+ parts.push(printArgumentsList(path, options, print));
+ }
+
+ return concat$2(parts);
+ case "VariableDeclaration": {
+ const printed = path.map(childPath => {
+ return print(childPath);
+ }, "declarations");
+
+ const hasValue = n.declarations.some(decl => decl.init);
+
+ parts = [
+ isNodeStartingWithDeclare(n, options) ? "declare " : "",
+ n.kind,
+ printed.length ? concat$2([" ", printed[0]]) : "",
+ indent$2(
+ concat$2(
+ printed
+ .slice(1)
+ .map(p => concat$2([",", hasValue ? hardline$2 : line$1, p]))
+ )
+ )
+ ];
+
+ // We generally want to terminate all variable declarations with a
+ // semicolon, except when they in the () part of for loops.
+ const parentNode = path.getParentNode();
+
+ const isParentForLoop =
+ parentNode.type === "ForStatement" ||
+ parentNode.type === "ForInStatement" ||
+ parentNode.type === "ForOfStatement" ||
+ parentNode.type === "ForAwaitStatement";
+
+ if (!(isParentForLoop && parentNode.body !== n)) {
+ parts.push(semi);
+ }
+
+ return group$1(concat$2(parts));
+ }
+ case "VariableDeclarator":
+ return printAssignment(
+ n.id,
+ concat$2([path.call(print, "id"), path.call(print, "typeParameters")]),
+ " =",
+ n.init,
+ n.init && path.call(print, "init"),
+ options
+ );
+ case "WithStatement":
+ return group$1(
+ concat$2([
+ "with (",
+ path.call(print, "object"),
+ ")",
+ adjustClause(n.body, path.call(print, "body"))
+ ])
+ );
+ case "IfStatement": {
+ const con = adjustClause(n.consequent, path.call(print, "consequent"));
+ const opening = group$1(
+ concat$2([
+ "if (",
+ group$1(
+ concat$2([
+ indent$2(concat$2([softline$1, path.call(print, "test")])),
+ softline$1
+ ])
+ ),
+ ")",
+ con
+ ])
+ );
+
+ parts.push(opening);
+
+ if (n.alternate) {
+ if (n.consequent.type === "BlockStatement") {
+ parts.push(" else");
+ } else {
+ parts.push(hardline$2, "else");
+ }
+
+ parts.push(
+ group$1(
+ adjustClause(
+ n.alternate,
+ path.call(print, "alternate"),
+ n.alternate.type === "IfStatement"
+ )
+ )
+ );
+ }
+
+ return concat$2(parts);
+ }
+ case "ForStatement": {
+ const body = adjustClause(n.body, path.call(print, "body"));
+
+ // We want to keep dangling comments above the loop to stay consistent.
+ // Any comment positioned between the for statement and the parentheses
+ // is going to be printed before the statement.
+ const dangling = comments$3.printDanglingComments(
+ path,
+ options,
+ /* sameLine */ true
+ );
+ const printedComments = dangling ? concat$2([dangling, softline$1]) : "";
+
+ if (!n.init && !n.test && !n.update) {
+ return concat$2([printedComments, group$1(concat$2(["for (;;)", body]))]);
+ }
+
+ return concat$2([
+ printedComments,
+ group$1(
+ concat$2([
+ "for (",
+ group$1(
+ concat$2([
+ indent$2(
+ concat$2([
+ softline$1,
+ path.call(print, "init"),
+ ";",
+ line$1,
+ path.call(print, "test"),
+ ";",
+ line$1,
+ path.call(print, "update")
+ ])
+ ),
+ softline$1
+ ])
+ ),
+ ")",
+ body
+ ])
+ )
+ ]);
+ }
+ case "WhileStatement":
+ return group$1(
+ concat$2([
+ "while (",
+ group$1(
+ concat$2([
+ indent$2(concat$2([softline$1, path.call(print, "test")])),
+ softline$1
+ ])
+ ),
+ ")",
+ adjustClause(n.body, path.call(print, "body"))
+ ])
+ );
+ case "ForInStatement":
+ // Note: esprima can't actually parse "for each (".
+ return group$1(
+ concat$2([
+ n.each ? "for each (" : "for (",
+ path.call(print, "left"),
+ " in ",
+ path.call(print, "right"),
+ ")",
+ adjustClause(n.body, path.call(print, "body"))
+ ])
+ );
+
+ case "ForOfStatement":
+ case "ForAwaitStatement": {
+ // Babylon 7 removed ForAwaitStatement in favor of ForOfStatement
+ // with `"await": true`:
+ // https://github.com/estree/estree/pull/138
+ const isAwait = n.type === "ForAwaitStatement" || n.await;
+
+ return group$1(
+ concat$2([
+ "for",
+ isAwait ? " await" : "",
+ " (",
+ path.call(print, "left"),
+ " of ",
+ path.call(print, "right"),
+ ")",
+ adjustClause(n.body, path.call(print, "body"))
+ ])
+ );
+ }
+
+ case "DoWhileStatement": {
+ const clause = adjustClause(n.body, path.call(print, "body"));
+ const doBody = group$1(concat$2(["do", clause]));
+ parts = [doBody];
+
+ if (n.body.type === "BlockStatement") {
+ parts.push(" ");
+ } else {
+ parts.push(hardline$2);
+ }
+ parts.push("while (");
+
+ parts.push(
+ group$1(concat$2([indent$2(softline$1), path.call(print, "test"), softline$1])),
+ ")",
+ semi
+ );
+
+ return concat$2(parts);
+ }
+ case "DoExpression":
+ return concat$2(["do ", path.call(print, "body")]);
+ case "BreakStatement":
+ parts.push("break");
+
+ if (n.label) {
+ parts.push(" ", path.call(print, "label"));
+ }
+
+ parts.push(semi);
+
+ return concat$2(parts);
+ case "ContinueStatement":
+ parts.push("continue");
+
+ if (n.label) {
+ parts.push(" ", path.call(print, "label"));
+ }
+
+ parts.push(semi);
+
+ return concat$2(parts);
+ case "LabeledStatement":
+ if (n.body.type === "EmptyStatement") {
+ return concat$2([path.call(print, "label"), ":;"]);
+ }
+
+ return concat$2([
+ path.call(print, "label"),
+ ": ",
+ path.call(print, "body")
+ ]);
+ case "TryStatement":
+ parts.push("try ", path.call(print, "block"));
+
+ if (n.handler) {
+ parts.push(" ", path.call(print, "handler"));
+ } else if (n.handlers) {
+ path.each(handlerPath => {
+ parts.push(" ", print(handlerPath));
+ }, "handlers");
+ }
+
+ if (n.finalizer) {
+ parts.push(" finally ", path.call(print, "finalizer"));
+ }
+
+ return concat$2(parts);
+ case "CatchClause":
+ parts.push("catch (", path.call(print, "param"));
+
+ if (n.guard) {
+ // Note: esprima does not recognize conditional catch clauses.
+ parts.push(" if ", path.call(print, "guard"));
+ }
+
+ parts.push(") ", path.call(print, "body"));
+
+ return concat$2(parts);
+ case "ThrowStatement":
+ return concat$2(["throw ", path.call(print, "argument"), semi]);
+ // Note: ignoring n.lexical because it has no printing consequences.
+ case "SwitchStatement":
+ return concat$2([
+ "switch (",
+ path.call(print, "discriminant"),
+ ") {",
+ n.cases.length > 0
+ ? indent$2(
+ concat$2([
+ hardline$2,
+ join$2(
+ hardline$2,
+ path.map(casePath => {
+ const caseNode = casePath.getValue();
+ return concat$2([
+ casePath.call(print),
+ n.cases.indexOf(caseNode) !== n.cases.length - 1 &&
+ util$4.isNextLineEmpty(options.originalText, caseNode)
+ ? hardline$2
+ : ""
+ ]);
+ }, "cases")
+ )
+ ])
+ )
+ : "",
+ hardline$2,
+ "}"
+ ]);
+ case "SwitchCase": {
+ if (n.test) {
+ parts.push("case ", path.call(print, "test"), ":");
+ } else {
+ parts.push("default:");
+ }
+
+ const consequent = n.consequent.filter(
+ node => node.type !== "EmptyStatement"
+ );
+
+ if (consequent.length > 0) {
+ const cons = path.call(consequentPath => {
+ return join$2(
+ hardline$2,
+ consequentPath
+ .map((p, i) => {
+ if (n.consequent[i].type === "EmptyStatement") {
+ return null;
+ }
+ const shouldAddLine =
+ i !== n.consequent.length - 1 &&
+ util$4.isNextLineEmpty(options.originalText, p.getValue());
+ return concat$2([print(p), shouldAddLine ? hardline$2 : ""]);
+ })
+ .filter(e => e !== null)
+ );
+ }, "consequent");
+
+ parts.push(
+ consequent.length === 1 && consequent[0].type === "BlockStatement"
+ ? concat$2([" ", cons])
+ : indent$2(concat$2([hardline$2, cons]))
+ );
+ }
+
+ return concat$2(parts);
+ }
+ // JSX extensions below.
+ case "DebuggerStatement":
+ return concat$2(["debugger", semi]);
+ case "JSXAttribute":
+ parts.push(path.call(print, "name"));
+
+ if (n.value) {
+ let res;
+ if (isStringLiteral(n.value)) {
+ const value = n.value.extra ? n.value.extra.raw : n.value.raw;
+ res = '"' + value.slice(1, -1).replace(/"/g, """) + '"';
+ } else {
+ res = path.call(print, "value");
+ }
+ parts.push("=", res);
+ }
+
+ return concat$2(parts);
+ case "JSXIdentifier":
+ // Can be removed when this is fixed:
+ // https://github.com/eslint/typescript-eslint-parser/issues/257
+ if (n.object && n.property) {
+ return join$2(".", [
+ path.call(print, "object"),
+ path.call(print, "property")
+ ]);
+ }
+ return "" + n.name;
+ case "JSXNamespacedName":
+ return join$2(":", [
+ path.call(print, "namespace"),
+ path.call(print, "name")
+ ]);
+ case "JSXMemberExpression":
+ return join$2(".", [
+ path.call(print, "object"),
+ path.call(print, "property")
+ ]);
+ case "TSQualifiedName":
+ return join$2(".", [path.call(print, "left"), path.call(print, "right")]);
+ case "JSXSpreadAttribute":
+ return concat$2(["{...", path.call(print, "argument"), "}"]);
+ case "JSXExpressionContainer": {
+ const parent = path.getParentNode(0);
+
+ const shouldInline =
+ n.expression.type === "ArrayExpression" ||
+ n.expression.type === "ObjectExpression" ||
+ n.expression.type === "ArrowFunctionExpression" ||
+ n.expression.type === "CallExpression" ||
+ n.expression.type === "FunctionExpression" ||
+ n.expression.type === "JSXEmptyExpression" ||
+ n.expression.type === "TemplateLiteral" ||
+ n.expression.type === "TaggedTemplateExpression" ||
+ (parent.type === "JSXElement" &&
+ (n.expression.type === "ConditionalExpression" ||
+ isBinaryish(n.expression)));
+
+ if (shouldInline) {
+ return group$1(
+ concat$2(["{", path.call(print, "expression"), lineSuffixBoundary$1, "}"])
+ );
+ }
+
+ return group$1(
+ concat$2([
+ "{",
+ indent$2(concat$2([softline$1, path.call(print, "expression")])),
+ softline$1,
+ lineSuffixBoundary$1,
+ "}"
+ ])
+ );
+ }
+ case "JSXElement": {
+ const elem = comments$3.printComments(
+ path,
+ () => printJSXElement(path, options, print),
+ options
+ );
+ return maybeWrapJSXElementInParens(path, elem);
+ }
+ case "JSXOpeningElement": {
+ const n = path.getValue();
+
+ // don't break up opening elements with a single long text attribute
+ if (
+ n.attributes.length === 1 &&
+ n.attributes[0].value &&
+ isStringLiteral(n.attributes[0].value)
+ ) {
+ return group$1(
+ concat$2([
+ "<",
+ path.call(print, "name"),
+ " ",
+ concat$2(path.map(print, "attributes")),
+ n.selfClosing ? " />" : ">"
+ ])
+ );
+ }
+
+ return group$1(
+ concat$2([
+ "<",
+ path.call(print, "name"),
+ concat$2([
+ indent$2(
+ concat$2(
+ path.map(attr => concat$2([line$1, print(attr)]), "attributes")
+ )
+ ),
+ n.selfClosing ? line$1 : options.jsxBracketSameLine ? ">" : softline$1
+ ]),
+ n.selfClosing ? "/>" : options.jsxBracketSameLine ? "" : ">"
+ ])
+ );
+ }
+ case "JSXClosingElement":
+ return concat$2([""]);
+ case "JSXText":
+ throw new Error("JSXTest should be handled by JSXElement");
+ case "JSXEmptyExpression": {
+ const requiresHardline =
+ n.comments && !n.comments.every(util$4.isBlockComment);
+
+ return concat$2([
+ comments$3.printDanglingComments(
+ path,
+ options,
+ /* sameIndent */ !requiresHardline
+ ),
+ requiresHardline ? hardline$2 : ""
+ ]);
+ }
+ case "TypeAnnotatedIdentifier":
+ return concat$2([
+ path.call(print, "annotation"),
+ " ",
+ path.call(print, "identifier")
+ ]);
+ case "ClassBody":
+ if (!n.comments && n.body.length === 0) {
+ return "{}";
+ }
+
+ return concat$2([
+ "{",
+ n.body.length > 0
+ ? indent$2(
+ concat$2([
+ hardline$2,
+ path.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body")
+ ])
+ )
+ : comments$3.printDanglingComments(path, options),
+ hardline$2,
+ "}"
+ ]);
+ case "ClassPropertyDefinition":
+ parts.push("static ", path.call(print, "definition"));
+
+ if (
+ n.definition.type !== "MethodDefinition" &&
+ n.definition.type !== "TSAbstractMethodDefinition"
+ ) {
+ parts.push(semi);
+ }
+
+ return concat$2(parts);
+ case "ClassProperty":
+ case "TSAbstractClassProperty": {
+ if (n.static) {
+ parts.push("static ");
+ }
+ const variance = getFlowVariance(n);
+ if (variance) {
+ parts.push(variance);
+ }
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.type === "TSAbstractClassProperty") {
+ parts.push("abstract ");
+ }
+ if (n.computed) {
+ parts.push("[", path.call(print, "key"), "]");
+ } else {
+ parts.push(printPropertyKey(path, options, print));
+ }
+ if (n.typeAnnotation) {
+ parts.push(": ", path.call(print, "typeAnnotation"));
+ }
+ if (n.value) {
+ parts.push(
+ " =",
+ printAssignmentRight(
+ n.value,
+ path.call(print, "value"),
+ false, // canBreak
+ options
+ )
+ );
+ }
+
+ parts.push(semi);
+
+ return concat$2(parts);
+ }
+ case "ClassDeclaration":
+ case "ClassExpression":
+ case "TSAbstractClassDeclaration":
+ if (isNodeStartingWithDeclare(n, options)) {
+ parts.push("declare ");
+ }
+ parts.push(concat$2(printClass(path, options, print)));
+ return concat$2(parts);
+ case "TSInterfaceHeritage":
+ parts.push(path.call(print, "id"));
+
+ if (n.typeParameters) {
+ parts.push(path.call(print, "typeParameters"));
+ }
+
+ return concat$2(parts);
+ case "TSHeritageClause":
+ return join$2(", ", path.map(print, "types"));
+ case "TSExpressionWithTypeArguments":
+ return concat$2([
+ path.call(print, "expression"),
+ printTypeParameters(path, options, print, "typeArguments")
+ ]);
+ case "TemplateElement":
+ return join$2(literalline$1, n.value.raw.split(/\r?\n/g));
+ case "TemplateLiteral": {
+ const expressions = path.map(print, "expressions");
+
+ parts.push("`");
+
+ path.each(childPath => {
+ const i = childPath.getName();
+
+ parts.push(print(childPath));
+
+ if (i < expressions.length) {
+ // For a template literal of the following form:
+ // `someQuery {
+ // ${call({
+ // a,
+ // b,
+ // })}
+ // }`
+ // the expression is on its own line (there is a \n in the previous
+ // quasi literal), therefore we want to indent the JavaScript
+ // expression inside at the beginning of ${ instead of the beginning
+ // of the `.
+ let size = 0;
+ const value = childPath.getValue().value.raw;
+ const index = value.lastIndexOf("\n");
+ const tabWidth = options.tabWidth;
+ if (index !== -1) {
+ size = util$4.getAlignmentSize(
+ // All the leading whitespaces
+ value.slice(index + 1).match(/^[ \t]*/)[0],
+ tabWidth
+ );
+ }
+
+ const aligned = addAlignmentToDoc$1(expressions[i], size, tabWidth);
+
+ parts.push("${", aligned, lineSuffixBoundary$1, "}");
+ }
+ }, "quasis");
+
+ parts.push("`");
+
+ return concat$2(parts);
+ }
+ // These types are unprintable because they serve as abstract
+ // supertypes for other (printable) types.
+ case "TaggedTemplateExpression":
+ return concat$2([path.call(print, "tag"), path.call(print, "quasi")]);
+ case "Node":
+ case "Printable":
+ case "SourceLocation":
+ case "Position":
+ case "Statement":
+ case "Function":
+ case "Pattern":
+ case "Expression":
+ case "Declaration":
+ case "Specifier":
+ case "NamedSpecifier":
+ case "Comment":
+ case "MemberTypeAnnotation": // Flow
+ case "Type":
+ throw new Error("unprintable type: " + JSON.stringify(n.type));
+ // Type Annotations for Facebook Flow, typically stripped out or
+ // transformed away before printing.
+ case "TypeAnnotation":
+ if (n.typeAnnotation) {
+ return path.call(print, "typeAnnotation");
+ }
+
+ return "";
+ case "TSTupleType":
+ case "TupleTypeAnnotation": {
+ const typesField = n.type === "TSTupleType" ? "elementTypes" : "types";
+ return group$1(
+ concat$2([
+ "[",
+ indent$2(
+ concat$2([
+ softline$1,
+ printArrayItems(path, options, typesField, print)
+ ])
+ ),
+ ifBreak$1(shouldPrintComma(options) ? "," : ""),
+ comments$3.printDanglingComments(path, options, /* sameIndent */ true),
+ softline$1,
+ "]"
+ ])
+ );
+ }
+
+ case "ExistsTypeAnnotation":
+ return "*";
+ case "EmptyTypeAnnotation":
+ return "empty";
+ case "AnyTypeAnnotation":
+ return "any";
+ case "MixedTypeAnnotation":
+ return "mixed";
+ case "ArrayTypeAnnotation":
+ return concat$2([path.call(print, "elementType"), "[]"]);
+ case "BooleanTypeAnnotation":
+ return "boolean";
+ case "BooleanLiteralTypeAnnotation":
+ return "" + n.value;
+ case "DeclareClass":
+ return printFlowDeclaration(path, printClass(path, options, print));
+ case "DeclareFunction":
+ // For TypeScript the DeclareFunction node shares the AST
+ // structure with FunctionDeclaration
+ if (n.params) {
+ return concat$2([
+ "declare ",
+ printFunctionDeclaration(path, print, options)
+ ]);
+ }
+ return printFlowDeclaration(path, [
+ "function ",
+ path.call(print, "id"),
+ n.predicate ? " " : "",
+ path.call(print, "predicate"),
+ semi
+ ]);
+ case "DeclareModule":
+ return printFlowDeclaration(path, [
+ "module ",
+ path.call(print, "id"),
+ " ",
+ path.call(print, "body")
+ ]);
+ case "DeclareModuleExports":
+ return printFlowDeclaration(path, [
+ "module.exports",
+ ": ",
+ path.call(print, "typeAnnotation"),
+ semi
+ ]);
+ case "DeclareVariable":
+ return printFlowDeclaration(path, ["var ", path.call(print, "id"), semi]);
+ case "DeclareExportAllDeclaration":
+ return concat$2(["declare export * from ", path.call(print, "source")]);
+ case "DeclareExportDeclaration":
+ return concat$2(["declare ", printExportDeclaration(path, options, print)]);
+ case "FunctionTypeAnnotation":
+ case "TSFunctionType": {
+ // FunctionTypeAnnotation is ambiguous:
+ // declare function foo(a: B): void; OR
+ // var A: (a: B) => void;
+ const parent = path.getParentNode(0);
+ const parentParent = path.getParentNode(1);
+ const parentParentParent = path.getParentNode(2);
+ let isArrowFunctionTypeAnnotation =
+ n.type === "TSFunctionType" ||
+ !((!getFlowVariance(parent) &&
+ !parent.optional &&
+ parent.type === "ObjectTypeProperty") ||
+ parent.type === "ObjectTypeCallProperty" ||
+ (parentParentParent &&
+ parentParentParent.type === "DeclareFunction"));
+
+ let needsColon =
+ isArrowFunctionTypeAnnotation && parent.type === "TypeAnnotation";
+
+ // Sadly we can't put it inside of FastPath::needsColon because we are
+ // printing ":" as part of the expression and it would put parenthesis
+ // around :(
+ const needsParens =
+ needsColon &&
+ isArrowFunctionTypeAnnotation &&
+ parent.type === "TypeAnnotation" &&
+ parentParent.type === "ArrowFunctionExpression";
+
+ if (isObjectTypePropertyAFunction(parent)) {
+ isArrowFunctionTypeAnnotation = true;
+ needsColon = true;
+ }
+
+ if (needsParens) {
+ parts.push("(");
+ }
+
+ parts.push(
+ printFunctionTypeParameters(path, options, print),
+ printFunctionParams(path, print, options)
+ );
+
+ // The returnType is not wrapped in a TypeAnnotation, so the colon
+ // needs to be added separately.
+ if (n.returnType || n.predicate || n.typeAnnotation) {
+ parts.push(
+ isArrowFunctionTypeAnnotation ? " => " : ": ",
+ path.call(print, "returnType"),
+ path.call(print, "predicate"),
+ path.call(print, "typeAnnotation")
+ );
+ }
+ if (needsParens) {
+ parts.push(")");
+ }
+
+ return group$1(concat$2(parts));
+ }
+ case "FunctionTypeParam":
+ return concat$2([
+ path.call(print, "name"),
+ n.optional ? "?" : "",
+ n.name ? ": " : "",
+ path.call(print, "typeAnnotation")
+ ]);
+ case "GenericTypeAnnotation":
+ return concat$2([
+ path.call(print, "id"),
+ path.call(print, "typeParameters")
+ ]);
+ case "DeclareInterface":
+ case "InterfaceDeclaration": {
+ if (
+ n.type === "DeclareInterface" ||
+ isNodeStartingWithDeclare(n, options)
+ ) {
+ parts.push("declare ");
+ }
+
+ parts.push(
+ "interface ",
+ path.call(print, "id"),
+ path.call(print, "typeParameters")
+ );
+
+ if (n["extends"].length > 0) {
+ parts.push(
+ group$1(
+ indent$2(
+ concat$2([line$1, "extends ", join$2(", ", path.map(print, "extends"))])
+ )
+ )
+ );
+ }
+
+ parts.push(" ");
+ parts.push(path.call(print, "body"));
+
+ return group$1(concat$2(parts));
+ }
+ case "ClassImplements":
+ case "InterfaceExtends":
+ return concat$2([
+ path.call(print, "id"),
+ path.call(print, "typeParameters")
+ ]);
+ case "TSIntersectionType":
+ case "IntersectionTypeAnnotation": {
+ const types = path.map(print, "types");
+ const result = [];
+ for (let i = 0; i < types.length; ++i) {
+ if (i === 0) {
+ result.push(types[i]);
+ } else if (
+ n.types[i - 1].type !== "ObjectTypeAnnotation" &&
+ n.types[i].type !== "ObjectTypeAnnotation"
+ ) {
+ // If no object is involved, go to the next line if it breaks
+ result.push(indent$2(concat$2([" &", line$1, types[i]])));
+ } else {
+ // If you go from object to non-object or vis-versa, then inline it
+ result.push(" & ", i > 1 ? indent$2(types[i]) : types[i]);
+ }
+ }
+ return group$1(concat$2(result));
+ }
+ case "TSUnionType":
+ case "UnionTypeAnnotation": {
+ // single-line variation
+ // A | B | C
+
+ // multi-line variation
+ // | A
+ // | B
+ // | C
+
+ const parent = path.getParentNode();
+ // If there's a leading comment, the parent is doing the indentation
+ const shouldIndent =
+ parent.type !== "TypeParameterInstantiation" &&
+ parent.type !== "GenericTypeAnnotation" &&
+ !((parent.type === "TypeAlias" ||
+ parent.type === "VariableDeclarator") &&
+ hasLeadingOwnLineComment(options.originalText, n));
+
+ // {
+ // a: string
+ // } | null | void
+ // should be inlined and not be printed in the multi-line variant
+ const shouldHug = shouldHugType(n);
+
+ // We want to align the children but without its comment, so it looks like
+ // | child1
+ // // comment
+ // | child2
+ const printed = path.map(typePath => {
+ let printedType = typePath.call(print);
+ if (!shouldHug && shouldIndent) {
+ printedType = align$1(2, printedType);
+ }
+ return comments$3.printComments(typePath, () => printedType, options);
+ }, "types");
+
+ if (shouldHug) {
+ return join$2(" | ", printed);
+ }
+
+ const code = concat$2([
+ ifBreak$1(concat$2([shouldIndent ? line$1 : "", "| "])),
+ join$2(concat$2([line$1, "| "]), printed)
+ ]);
+
+ return group$1(shouldIndent ? indent$2(code) : code);
+ }
+ case "NullableTypeAnnotation":
+ return concat$2(["?", path.call(print, "typeAnnotation")]);
+ case "NullLiteralTypeAnnotation":
+ return "null";
+ case "ThisTypeAnnotation":
+ return "this";
+ case "NumberTypeAnnotation":
+ return "number";
+ case "ObjectTypeCallProperty":
+ if (n.static) {
+ parts.push("static ");
+ }
+
+ parts.push(path.call(print, "value"));
+
+ return concat$2(parts);
+ case "ObjectTypeIndexer": {
+ const variance = getFlowVariance(n);
+ return concat$2([
+ variance || "",
+ "[",
+ path.call(print, "id"),
+ n.id ? ": " : "",
+ path.call(print, "key"),
+ "]: ",
+ path.call(print, "value")
+ ]);
+ }
+ case "ObjectTypeProperty": {
+ const variance = getFlowVariance(n);
+
+ return concat$2([
+ n.static ? "static " : "",
+ isGetterOrSetter(n) ? n.kind + " " : "",
+ variance || "",
+ path.call(print, "key"),
+ n.optional ? "?" : "",
+ isFunctionNotation(n) ? "" : ": ",
+ path.call(print, "value")
+ ]);
+ }
+ case "QualifiedTypeIdentifier":
+ return concat$2([
+ path.call(print, "qualification"),
+ ".",
+ path.call(print, "id")
+ ]);
+ case "StringLiteralTypeAnnotation":
+ return nodeStr(n, options);
+ case "NumberLiteralTypeAnnotation":
+ assert$1.strictEqual(typeof n.value, "number");
+
+ if (n.extra != null) {
+ return printNumber(n.extra.raw);
+ } else {
+ return printNumber(n.raw);
+ }
+ case "StringTypeAnnotation":
+ return "string";
+ case "DeclareTypeAlias":
+ case "TypeAlias": {
+ if (
+ n.type === "DeclareTypeAlias" ||
+ isNodeStartingWithDeclare(n, options)
+ ) {
+ parts.push("declare ");
+ }
+
+ const canBreak = n.right.type === "StringLiteralTypeAnnotation";
+
+ const printed = printAssignmentRight(
+ n.right,
+ path.call(print, "right"),
+ canBreak,
+ options
+ );
+
+ parts.push(
+ "type ",
+ path.call(print, "id"),
+ path.call(print, "typeParameters"),
+ " =",
+ printed,
+ semi
+ );
+
+ return group$1(concat$2(parts));
+ }
+ case "TypeCastExpression":
+ return concat$2([
+ "(",
+ path.call(print, "expression"),
+ ": ",
+ path.call(print, "typeAnnotation"),
+ ")"
+ ]);
+ case "TypeParameterDeclaration":
+ case "TypeParameterInstantiation":
+ return printTypeParameters(path, options, print, "params");
+ case "TypeParameter": {
+ const variance = getFlowVariance(n);
+
+ if (variance) {
+ parts.push(variance);
+ }
+
+ parts.push(path.call(print, "name"));
+
+ if (n.bound) {
+ parts.push(": ");
+ parts.push(path.call(print, "bound"));
+ }
+
+ if (n.constraint) {
+ parts.push(" extends ", path.call(print, "constraint"));
+ }
+
+ if (n["default"]) {
+ parts.push(" = ", path.call(print, "default"));
+ }
+
+ return concat$2(parts);
+ }
+ case "TypeofTypeAnnotation":
+ return concat$2(["typeof ", path.call(print, "argument")]);
+ case "VoidTypeAnnotation":
+ return "void";
+ case "NullTypeAnnotation":
+ return "null";
+ case "InferredPredicate":
+ return "%checks";
+ // Unhandled types below. If encountered, nodes of these types should
+ // be either left alone or desugared into AST types that are fully
+ // supported by the pretty-printer.
+ case "DeclaredPredicate":
+ return concat$2(["%checks(", path.call(print, "value"), ")"]);
+ case "TSAbstractKeyword":
+ return "abstract";
+ case "TSAnyKeyword":
+ return "any";
+ case "TSAsyncKeyword":
+ return "async";
+ case "TSBooleanKeyword":
+ return "boolean";
+ case "TSConstKeyword":
+ return "const";
+ case "TSDeclareKeyword":
+ return "declare";
+ case "TSExportKeyword":
+ return "export";
+ case "TSNeverKeyword":
+ return "never";
+ case "TSNumberKeyword":
+ return "number";
+ case "TSObjectKeyword":
+ return "object";
+ case "TSProtectedKeyword":
+ return "protected";
+ case "TSPrivateKeyword":
+ return "private";
+ case "TSPublicKeyword":
+ return "public";
+ case "TSReadonlyKeyword":
+ return "readonly";
+ case "TSSymbolKeyword":
+ return "symbol";
+ case "TSStaticKeyword":
+ return "static";
+ case "TSStringKeyword":
+ return "string";
+ case "TSUndefinedKeyword":
+ return "undefined";
+ case "TSVoidKeyword":
+ return "void";
+ case "TSAsExpression":
+ return concat$2([
+ path.call(print, "expression"),
+ " as ",
+ path.call(print, "typeAnnotation")
+ ]);
+ case "TSArrayType":
+ return concat$2([path.call(print, "elementType"), "[]"]);
+ case "TSPropertySignature": {
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.export) {
+ parts.push("export ");
+ }
+ if (n.static) {
+ parts.push("static ");
+ }
+ if (n.readonly) {
+ parts.push("readonly ");
+ }
+
+ if (n.computed) {
+ parts.push("[");
+ }
+
+ parts.push(path.call(print, "key"));
+
+ if (n.computed) {
+ parts.push("]");
+ }
+
+ if (n.optional) {
+ parts.push("?");
+ }
+
+ if (n.typeAnnotation) {
+ parts.push(": ");
+ parts.push(path.call(print, "typeAnnotation"));
+ }
+
+ // This isn't valid semantically, but it's in the AST so we can print it.
+ if (n.initializer) {
+ parts.push(" = ", path.call(print, "initializer"));
+ }
+
+ return concat$2(parts);
+ }
+ case "TSParameterProperty":
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.export) {
+ parts.push("export ");
+ }
+ if (n.static) {
+ parts.push("static ");
+ }
+ if (n.readonly) {
+ parts.push("readonly ");
+ }
+
+ parts.push(path.call(print, "parameter"));
+
+ return concat$2(parts);
+ case "TSTypeReference":
+ return concat$2([
+ path.call(print, "typeName"),
+ printTypeParameters(path, options, print, "typeParameters")
+ ]);
+ case "TSTypeQuery":
+ return concat$2(["typeof ", path.call(print, "exprName")]);
+ case "TSParenthesizedType":
+ return concat$2(["(", path.call(print, "typeAnnotation"), ")"]);
+ case "TSIndexSignature": {
+ let printedParams = [];
+ if (n.params) {
+ printedParams = path.map(print, "params");
+ }
+ if (n.parameters) {
+ printedParams = path.map(print, "parameters");
+ }
+
+ return concat$2([
+ n.accessibility ? concat$2([n.accessibility, " "]) : "",
+ n.export ? "export " : "",
+ n.static ? "static " : "",
+ n.readonly ? "readonly " : "",
+ "[",
+ path.call(print, "index"),
+ // This should only contain a single element, however TypeScript parses
+ // it using parseDelimitedList that uses commas as delimiter.
+ join$2(", ", printedParams),
+ "]: ",
+ path.call(print, "typeAnnotation")
+ ]);
+ }
+ case "TSTypePredicate":
+ return concat$2([
+ path.call(print, "parameterName"),
+ " is ",
+ path.call(print, "typeAnnotation")
+ ]);
+ case "TSNonNullExpression":
+ return concat$2([path.call(print, "expression"), "!"]);
+ case "TSThisType":
+ return "this";
+ case "TSLastTypeNode":
+ return path.call(print, "literal");
+ case "TSIndexedAccessType":
+ return concat$2([
+ path.call(print, "objectType"),
+ "[",
+ path.call(print, "indexType"),
+ "]"
+ ]);
+ case "TSConstructSignature":
+ case "TSConstructorType":
+ case "TSCallSignature": {
+ if (n.type !== "TSCallSignature") {
+ parts.push("new ");
+ }
+ const isType = n.type === "TSConstructorType";
+
+ if (n.typeParameters) {
+ parts.push(printTypeParameters(path, options, print, "typeParameters"));
+ }
+
+ const params = n.params
+ ? path.map(print, "params")
+ : path.map(print, "parameters");
+ parts.push("(", join$2(", ", params), ")");
+ if (n.typeAnnotation) {
+ parts.push(isType ? " => " : ": ", path.call(print, "typeAnnotation"));
+ }
+ return concat$2(parts);
+ }
+ case "TSTypeOperator":
+ return concat$2(["keyof ", path.call(print, "typeAnnotation")]);
+ case "TSMappedType":
+ return group$1(
+ concat$2([
+ "{",
+ indent$2(
+ concat$2([
+ options.bracketSpacing ? line$1 : softline$1,
+ n.readonlyToken
+ ? concat$2([path.call(print, "readonlyToken"), " "])
+ : "",
+ printTypeScriptModifiers(path, options, print),
+ "[",
+ path.call(print, "typeParameter"),
+ "]",
+ n.questionToken ? "?" : "",
+ ": ",
+ path.call(print, "typeAnnotation")
+ ])
+ ),
+ comments$3.printDanglingComments(path, options, /* sameIndent */ true),
+ options.bracketSpacing ? line$1 : softline$1,
+ "}"
+ ])
+ );
+ case "TSTypeParameter":
+ parts.push(path.call(print, "name"));
+
+ if (n.constraint) {
+ parts.push(" in ", path.call(print, "constraint"));
+ }
+
+ return concat$2(parts);
+ case "TSMethodSignature":
+ parts.push(
+ n.accessibility ? concat$2([n.accessibility, " "]) : "",
+ n.export ? "export " : "",
+ n.static ? "static " : "",
+ n.readonly ? "readonly " : "",
+ n.computed ? "[" : "",
+ path.call(print, "key"),
+ n.computed ? "]" : "",
+ n.optional ? "?" : "",
+ printFunctionTypeParameters(path, options, print),
+ printFunctionParams(path, print, options)
+ );
+
+ if (n.typeAnnotation) {
+ parts.push(": ", path.call(print, "typeAnnotation"));
+ }
+ return concat$2(parts);
+ case "TSNamespaceExportDeclaration":
+ if (n.declaration) {
+ parts.push("export ", path.call(print, "declaration"));
+ } else {
+ parts.push("export as namespace ", path.call(print, "name"));
+
+ if (options.semi) {
+ parts.push(";");
+ }
+ }
+
+ return group$1(concat$2(parts));
+ case "TSEnumDeclaration":
+ if (n.modifiers) {
+ parts.push(printTypeScriptModifiers(path, options, print));
+ }
+
+ parts.push("enum ", path.call(print, "name"), " ");
+
+ if (n.members.length === 0) {
+ parts.push(
+ group$1(
+ concat$2([
+ "{",
+ comments$3.printDanglingComments(path, options),
+ softline$1,
+ "}"
+ ])
+ )
+ );
+ } else {
+ parts.push(
+ group$1(
+ concat$2([
+ "{",
+ options.bracketSpacing ? line$1 : softline$1,
+ indent$2(
+ concat$2([
+ softline$1,
+ printArrayItems(path, options, "members", print)
+ ])
+ ),
+ comments$3.printDanglingComments(
+ path,
+ options,
+ /* sameIndent */ true
+ ),
+ softline$1,
+ options.bracketSpacing ? line$1 : softline$1,
+ "}"
+ ])
+ )
+ );
+ }
+
+ return concat$2(parts);
+ case "TSEnumMember":
+ parts.push(path.call(print, "name"));
+ if (n.initializer) {
+ parts.push(" = ", path.call(print, "initializer"));
+ }
+ return concat$2(parts);
+ case "TSImportEqualsDeclaration":
+ parts.push(
+ printTypeScriptModifiers(path, options, print),
+ "import ",
+ path.call(print, "name"),
+ " = ",
+ path.call(print, "moduleReference")
+ );
+
+ if (options.semi) {
+ parts.push(";");
+ }
+
+ return group$1(concat$2(parts));
+ case "TSExternalModuleReference":
+ return concat$2(["require(", path.call(print, "expression"), ")"]);
+ case "TSModuleDeclaration": {
+ const parent = path.getParentNode();
+ const isExternalModule = isLiteral(n.name);
+ const parentIsDeclaration = parent.type === "TSModuleDeclaration";
+ const bodyIsDeclaration = n.body && n.body.type === "TSModuleDeclaration";
+
+ if (parentIsDeclaration) {
+ parts.push(".");
+ } else {
+ parts.push(printTypeScriptModifiers(path, options, print));
+
+ // Global declaration looks like this:
+ // declare global { ... }
+ const isGlobalDeclaration =
+ n.name.type === "Identifier" &&
+ n.name.name === "global" &&
+ n.modifiers &&
+ n.modifiers.some(modifier => modifier.type === "TSDeclareKeyword");
+
+ if (!isGlobalDeclaration) {
+ parts.push(isExternalModule ? "module " : "namespace ");
+ }
+ }
+
+ parts.push(path.call(print, "name"));
+
+ if (bodyIsDeclaration) {
+ parts.push(path.call(print, "body"));
+ } else if (n.body) {
+ parts.push(
+ " {",
+ indent$2(
+ concat$2([
+ line$1,
+ path.call(
+ bodyPath =>
+ comments$3.printDanglingComments(bodyPath, options, true),
+ "body"
+ ),
+ group$1(path.call(print, "body"))
+ ])
+ ),
+ line$1,
+ "}"
+ );
+ } else {
+ parts.push(semi);
+ }
+
+ return concat$2(parts);
+ }
+ case "TSModuleBlock":
+ return path.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body");
+ // postcss
+ case "css-root": {
+ return concat$2([printNodeSequence(path, options, print), hardline$2]);
+ }
+ case "css-comment": {
+ if (n.raws.content) {
+ return n.raws.content;
+ }
+ const text = options.originalText.slice(util$4.locStart(n), util$4.locEnd(n));
+ const rawText = n.raws.text || n.text;
+ // Workaround a bug where the location is off.
+ // https://github.com/postcss/postcss-scss/issues/63
+ if (text.indexOf(rawText) === -1) {
+ if (n.raws.inline) {
+ return concat$2(["// ", rawText]);
+ }
+ return concat$2(["/* ", rawText, " */"]);
+ }
+ return text;
+ }
+ case "css-rule": {
+ return concat$2([
+ path.call(print, "selector"),
+ n.important ? " !important" : "",
+ n.nodes
+ ? concat$2([
+ " {",
+ n.nodes.length > 0
+ ? indent$2(
+ concat$2([hardline$2, printNodeSequence(path, options, print)])
+ )
+ : "",
+ hardline$2,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ case "css-decl": {
+ return concat$2([
+ n.raws.before.replace(/[\s;]/g, ""),
+ n.prop,
+ ": ",
+ path.call(print, "value"),
+ n.important ? " !important" : "",
+ n.nodes
+ ? concat$2([
+ " {",
+ indent$2(
+ concat$2([softline$1, printNodeSequence(path, options, print)])
+ ),
+ softline$1,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ case "css-atrule": {
+ const hasParams =
+ n.params &&
+ !(n.params.type === "media-query-list" && n.params.value === "");
+ return concat$2([
+ "@",
+ n.name,
+ hasParams ? concat$2([" ", path.call(print, "params")]) : "",
+ n.nodes
+ ? concat$2([
+ " {",
+ indent$2(
+ concat$2([
+ n.nodes.length > 0 ? softline$1 : "",
+ printNodeSequence(path, options, print)
+ ])
+ ),
+ softline$1,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ case "css-import": {
+ return concat$2([
+ "@",
+ n.name,
+ " ",
+ n.directives ? concat$2([n.directives, " "]) : "",
+ n.importPath,
+ ";"
+ ]);
+ }
+ // postcss-media-query-parser
+ case "media-query-list": {
+ const parts = [];
+ path.each(childPath => {
+ const node = childPath.getValue();
+ if (node.type === "media-query" && node.value === "") {
+ return;
+ }
+ parts.push(childPath.call(print));
+ }, "nodes");
+ return join$2(", ", parts);
+ }
+ case "media-query": {
+ return join$2(" ", path.map(print, "nodes"));
+ }
+ case "media-type": {
+ return n.value;
+ }
+ case "media-feature-expression": {
+ if (!n.nodes) {
+ return n.value;
+ }
+ return concat$2(["(", concat$2(path.map(print, "nodes")), ")"]);
+ }
+ case "media-feature": {
+ return n.value.replace(/ +/g, " ");
+ }
+ case "media-colon": {
+ return concat$2([n.value, " "]);
+ }
+ case "media-value": {
+ return n.value;
+ }
+ case "media-keyword": {
+ return n.value;
+ }
+ case "media-url": {
+ return n.value;
+ }
+ case "media-unknown": {
+ return n.value;
+ }
+ // postcss-selector-parser
+ case "selector-root": {
+ return group$1(join$2(concat$2([",", line$1]), path.map(print, "nodes")));
+ }
+ case "selector-comment": {
+ return n.value;
+ }
+ case "selector-string": {
+ return n.value;
+ }
+ case "selector-tag": {
+ return n.value;
+ }
+ case "selector-id": {
+ return concat$2(["#", n.value]);
+ }
+ case "selector-class": {
+ return concat$2([".", n.value]);
+ }
+ case "selector-attribute": {
+ return concat$2([
+ "[",
+ n.attribute,
+ n.operator ? n.operator : "",
+ n.value ? n.value : "",
+ n.insensitive ? " i" : "",
+ "]"
+ ]);
+ }
+ case "selector-combinator": {
+ if (n.value === "+" || n.value === ">" || n.value === "~") {
+ const parent = path.getParentNode();
+ const leading = parent.type === "selector-selector" &&
+ parent.nodes[0] === n
+ ? ""
+ : line$1;
+ return concat$2([leading, n.value, " "]);
+ }
+ return n.value;
+ }
+ case "selector-universal": {
+ return n.value;
+ }
+ case "selector-selector": {
+ return group$1(indent$2(concat$2(path.map(print, "nodes"))));
+ }
+ case "selector-pseudo": {
+ return concat$2([
+ n.value,
+ n.nodes && n.nodes.length > 0
+ ? concat$2(["(", join$2(", ", path.map(print, "nodes")), ")"])
+ : ""
+ ]);
+ }
+ case "selector-nesting": {
+ return printValue(n.value);
+ }
+ // postcss-values-parser
+ case "value-root": {
+ return path.call(print, "group");
+ }
+ case "value-comma_group": {
+ const printed = path.map(print, "groups");
+ const parts = [];
+ for (let i = 0; i < n.groups.length; ++i) {
+ parts.push(printed[i]);
+ if (
+ i !== n.groups.length - 1 &&
+ n.groups[i + 1].raws &&
+ n.groups[i + 1].raws.before !== ""
+ ) {
+ if (
+ n.groups[i + 1].type === "value-operator" &&
+ ["+", "-", "/", "*", "%"].indexOf(n.groups[i + 1].value) !== -1
+ ) {
+ parts.push(" ");
+ } else {
+ parts.push(line$1);
+ }
+ }
+ }
+
+ return group$1(indent$2(concat$2(parts)));
+ }
+ case "value-paren_group": {
+ const parent = path.getParentNode();
+ const isURLCall =
+ parent && parent.type === "value-func" && parent.value === "url";
+
+ if (
+ isURLCall &&
+ (n.groups.length === 1 ||
+ (n.groups.length > 0 &&
+ n.groups[0].type === "value-comma_group" &&
+ n.groups[0].groups.length > 0 &&
+ n.groups[0].groups[0].type === "value-word" &&
+ n.groups[0].groups[0].value === "data"))
+ ) {
+ return concat$2([
+ n.open ? path.call(print, "open") : "",
+ join$2(",", path.map(print, "groups")),
+ n.close ? path.call(print, "close") : ""
+ ]);
+ }
+
+ if (!n.open) {
+ return group$1(
+ indent$2(join$2(concat$2([",", line$1]), path.map(print, "groups")))
+ );
+ }
+
+ return group$1(
+ concat$2([
+ n.open ? path.call(print, "open") : "",
+ indent$2(
+ concat$2([
+ softline$1,
+ join$2(concat$2([",", line$1]), path.map(print, "groups"))
+ ])
+ ),
+ softline$1,
+ n.close ? path.call(print, "close") : ""
+ ])
+ );
+ }
+ case "value-value": {
+ return path.call(print, "group");
+ }
+ case "value-func": {
+ return concat$2([n.value, path.call(print, "group")]);
+ }
+ case "value-paren": {
+ if (n.raws.before !== "") {
+ return concat$2([line$1, n.value]);
+ }
+ return n.value;
+ }
+ case "value-number": {
+ return concat$2([n.value, n.unit]);
+ }
+ case "value-operator": {
+ return n.value;
+ }
+ case "value-word": {
+ return n.value;
+ }
+ case "value-colon": {
+ return n.value;
+ }
+ case "value-comma": {
+ return concat$2([n.value, " "]);
+ }
+ case "value-string": {
+ return concat$2([
+ n.quoted ? n.raws.quote : "",
+ n.value,
+ n.quoted ? n.raws.quote : ""
+ ]);
+ }
+ case "value-atword": {
+ return concat$2(["@", n.value]);
+ }
+
+ default:
+ throw new Error("unknown type: " + JSON.stringify(n.type));
+ }
+}
+
+function printValue(value) {
+ return value;
+}
+
+function printNodeSequence(path, options, print) {
+ const node = path.getValue();
+ const parts = [];
+ let i = 0;
+ path.map(pathChild => {
+ parts.push(pathChild.call(print));
+ if (i !== node.nodes.length - 1) {
+ if (
+ node.nodes[i + 1].type === "css-comment" &&
+ !util$4.hasNewline(
+ options.originalText,
+ util$4.locStart(node.nodes[i + 1]),
+ { backwards: true }
+ )
+ ) {
+ parts.push(" ");
+ } else {
+ parts.push(hardline$2);
+ if (util$4.isNextLineEmpty(options.originalText, pathChild.getValue())) {
+ parts.push(hardline$2);
+ }
+ }
+ }
+ i++;
+ }, "nodes");
+
+ return concat$2(parts);
+}
+
+function printStatementSequence(path, options, print) {
+ const printed = [];
+
+ const bodyNode = path.getNode();
+ const isClass = bodyNode.type === "ClassBody";
+
+ path.map((stmtPath, i) => {
+ const stmt = stmtPath.getValue();
+
+ // Just in case the AST has been modified to contain falsy
+ // "statements," it's safer simply to skip them.
+ if (!stmt) {
+ return;
+ }
+
+ // Skip printing EmptyStatement nodes to avoid leaving stray
+ // semicolons lying around.
+ if (stmt.type === "EmptyStatement") {
+ return;
+ }
+
+ const stmtPrinted = print(stmtPath);
+ const text = options.originalText;
+ const parts = [];
+
+ // in no-semi mode, prepend statement with semicolon if it might break ASI
+ if (!options.semi && !isClass && stmtNeedsASIProtection(stmtPath)) {
+ if (stmt.comments && stmt.comments.some(comment => comment.leading)) {
+ // Note: stmtNeedsASIProtection requires stmtPath to already be printed
+ // as it reads needsParens which is mutated on the instance
+ parts.push(print(stmtPath, { needsSemi: true }));
+ } else {
+ parts.push(";", stmtPrinted);
+ }
+ } else {
+ parts.push(stmtPrinted);
+ }
+
+ if (!options.semi && isClass) {
+ if (classPropMayCauseASIProblems(stmtPath)) {
+ parts.push(";");
+ } else if (stmt.type === "ClassProperty") {
+ const nextChild = bodyNode.body[i + 1];
+ if (classChildNeedsASIProtection(nextChild)) {
+ parts.push(";");
+ }
+ }
+ }
+
+ if (util$4.isNextLineEmpty(text, stmt) && !isLastStatement(stmtPath)) {
+ parts.push(hardline$2);
+ }
+
+ printed.push(concat$2(parts));
+ });
+
+ return join$2(hardline$2, printed);
+}
+
+function printPropertyKey(path, options, print) {
+ const node = path.getNode();
+ const key = node.key;
+
+ if (isStringLiteral(key) && isIdentifierName(key.value) && !node.computed) {
+ // 'a' -> a
+ return path.call(
+ keyPath => comments$3.printComments(keyPath, () => key.value, options),
+ "key"
+ );
+ }
+ return path.call(print, "key");
+}
+
+function printMethod(path, options, print) {
+ const node = path.getNode();
+ const semi = options.semi ? ";" : "";
+ const kind = node.kind;
+ const parts = [];
+
+ if (node.type === "ObjectMethod" || node.type === "ClassMethod") {
+ node.value = node;
+ }
+
+ if (node.value.async) {
+ parts.push("async ");
+ }
+
+ if (!kind || kind === "init" || kind === "method" || kind === "constructor") {
+ if (node.value.generator) {
+ parts.push("*");
+ }
+ } else {
+ assert$1.ok(kind === "get" || kind === "set");
+
+ parts.push(kind, " ");
+ }
+
+ let key = printPropertyKey(path, options, print);
+
+ if (node.computed) {
+ key = concat$2(["[", key, "]"]);
+ }
+
+ parts.push(
+ key,
+ concat$2(
+ path.call(
+ valuePath => [
+ printFunctionTypeParameters(valuePath, options, print),
+ group$1(
+ concat$2([
+ printFunctionParams(valuePath, print, options),
+ printReturnType(valuePath, print)
+ ])
+ )
+ ],
+ "value"
+ )
+ )
+ );
+
+ if (!node.value.body || node.value.body.length === 0) {
+ parts.push(semi);
+ } else {
+ parts.push(" ", path.call(print, "value", "body"));
+ }
+
+ return concat$2(parts);
+}
+
+function couldGroupArg(arg) {
+ return (
+ (arg.type === "ObjectExpression" && arg.properties.length > 0) ||
+ (arg.type === "ArrayExpression" && arg.elements.length > 0) ||
+ arg.type === "FunctionExpression" ||
+ (arg.type === "ArrowFunctionExpression" &&
+ (arg.body.type === "BlockStatement" ||
+ arg.body.type === "ArrowFunctionExpression" ||
+ arg.body.type === "ObjectExpression" ||
+ arg.body.type === "ArrayExpression" ||
+ arg.body.type === "CallExpression" ||
+ arg.body.type === "JSXElement"))
+ );
+}
+
+function shouldGroupLastArg(args) {
+ const lastArg = util$4.getLast(args);
+ const penultimateArg = util$4.getPenultimate(args);
+ return (
+ (!lastArg.comments || !lastArg.comments.length) &&
+ couldGroupArg(lastArg) &&
+ // If the last two arguments are of the same type,
+ // disable last element expansion.
+ (!penultimateArg || penultimateArg.type !== lastArg.type)
+ );
+}
+
+function shouldGroupFirstArg(args) {
+ if (args.length !== 2) {
+ return false;
+ }
+
+ const firstArg = args[0];
+ const secondArg = args[1];
+ return (
+ (!firstArg.comments || !firstArg.comments.length) &&
+ (firstArg.type === "FunctionExpression" ||
+ (firstArg.type === "ArrowFunctionExpression" &&
+ firstArg.body.type === "BlockStatement")) &&
+ !couldGroupArg(secondArg)
+ );
+}
+
+function printArgumentsList(path, options, print) {
+ const printed = path.map(print, "arguments");
+ if (printed.length === 0) {
+ return concat$2([
+ "(",
+ comments$3.printDanglingComments(path, options, /* sameIndent */ true),
+ ")"
+ ]);
+ }
+
+ const args = path.getValue().arguments;
+ // This is just an optimization; I think we could return the
+ // conditional group for all function calls, but it's more expensive
+ // so only do it for specific forms.
+ const shouldGroupFirst = shouldGroupFirstArg(args);
+ const shouldGroupLast = shouldGroupLastArg(args);
+ if (shouldGroupFirst || shouldGroupLast) {
+ const shouldBreak = shouldGroupFirst
+ ? printed.slice(1).some(willBreak)
+ : printed.slice(0, -1).some(willBreak);
+
+ // We want to print the last argument with a special flag
+ let printedExpanded;
+ let i = 0;
+ path.each(argPath => {
+ if (shouldGroupFirst && i === 0) {
+ printedExpanded = [
+ argPath.call(p => print(p, { expandFirstArg: true }))
+ ].concat(printed.slice(1));
+ }
+ if (shouldGroupLast && i === args.length - 1) {
+ printedExpanded = printed
+ .slice(0, -1)
+ .concat(argPath.call(p => print(p, { expandLastArg: true })));
+ }
+ i++;
+ }, "arguments");
+
+ return concat$2([
+ printed.some(willBreak) ? breakParent$2 : "",
+ conditionalGroup$1(
+ [
+ concat$2(["(", join$2(concat$2([", "]), printedExpanded), ")"]),
+ shouldGroupFirst
+ ? concat$2([
+ "(",
+ group$1(printedExpanded[0], { shouldBreak: true }),
+ printed.length > 1 ? ", " : "",
+ join$2(concat$2([",", line$1]), printed.slice(1)),
+ ")"
+ ])
+ : concat$2([
+ "(",
+ join$2(concat$2([",", line$1]), printed.slice(0, -1)),
+ printed.length > 1 ? ", " : "",
+ group$1(util$4.getLast(printedExpanded), {
+ shouldBreak: true
+ }),
+ ")"
+ ]),
+ group$1(
+ concat$2([
+ "(",
+ indent$2(concat$2([line$1, join$2(concat$2([",", line$1]), printed)])),
+ shouldPrintComma(options, "all") ? "," : "",
+ line$1,
+ ")"
+ ]),
+ { shouldBreak: true }
+ )
+ ],
+ { shouldBreak }
+ )
+ ]);
+ }
+
+ return group$1(
+ concat$2([
+ "(",
+ indent$2(concat$2([softline$1, join$2(concat$2([",", line$1]), printed)])),
+ ifBreak$1(shouldPrintComma(options, "all") ? "," : ""),
+ softline$1,
+ ")"
+ ]),
+ { shouldBreak: printed.some(willBreak) }
+ );
+}
+
+function printFunctionTypeParameters(path, options, print) {
+ const fun = path.getValue();
+ const paramsFieldIsArray = Array.isArray(fun["typeParameters"]);
+
+ if (fun.typeParameters) {
+ // for TSFunctionType typeParameters is an array
+ // for FunctionTypeAnnotation it's a single node
+ if (paramsFieldIsArray) {
+ return concat$2("<", join$2(", ", path.map(print, "typeParameters")), ">");
+ } else {
+ return path.call(print, "typeParameters");
+ }
+ } else {
+ return "";
+ }
+}
+
+function printFunctionParams(path, print, options, expandArg) {
+ const fun = path.getValue();
+ const paramsField = fun.parameters ? "parameters" : "params";
+
+ let printed = [];
+ if (fun[paramsField]) {
+ printed = path.map(print, paramsField);
+ }
+
+ if (fun.defaults) {
+ path.each(defExprPath => {
+ const i = defExprPath.getName();
+ const p = printed[i];
+
+ if (p && defExprPath.getValue()) {
+ printed[i] = concat$2([p, " = ", print(defExprPath)]);
+ }
+ }, "defaults");
+ }
+
+ if (fun.rest) {
+ printed.push(concat$2(["...", path.call(print, "rest")]));
+ }
+
+ if (printed.length === 0) {
+ return concat$2([
+ "(",
+ comments$3.printDanglingComments(path, options, /* sameIndent */ true),
+ ")"
+ ]);
+ }
+
+ const lastParam = util$4.getLast(fun[paramsField]);
+
+ // If the parent is a call with the first/last argument expansion and this is the
+ // params of the first/last argument, we dont want the arguments to break and instead
+ // want the whole expression to be on a new line.
+ //
+ // Good: Bad:
+ // verylongcall( verylongcall((
+ // (a, b) => { a,
+ // } b,
+ // }) ) => {
+ // })
+ if (expandArg) {
+ return group$1(concat$2(["(", join$2(", ", printed.map(removeLines)), ")"]));
+ }
+
+ // Single object destructuring should hug
+ //
+ // function({
+ // a,
+ // b,
+ // c
+ // }) {}
+ if (shouldHugArguments(fun)) {
+ return concat$2(["(", join$2(", ", printed), ")"]);
+ }
+
+ const parent = path.getParentNode();
+
+ const flowTypeAnnotations = [
+ "AnyTypeAnnotation",
+ "NullLiteralTypeAnnotation",
+ "GenericTypeAnnotation",
+ "ThisTypeAnnotation",
+ "NumberTypeAnnotation",
+ "VoidTypeAnnotation",
+ "NullTypeAnnotation",
+ "EmptyTypeAnnotation",
+ "MixedTypeAnnotation",
+ "BooleanTypeAnnotation",
+ "BooleanLiteralTypeAnnotation",
+ "StringTypeAnnotation"
+ ];
+
+ const isFlowShorthandWithOneArg =
+ (isObjectTypePropertyAFunction(parent) ||
+ isTypeAnnotationAFunction(parent) ||
+ parent.type === "TypeAlias" ||
+ parent.type === "UnionTypeAnnotation" ||
+ parent.type === "TSUnionType" ||
+ parent.type === "IntersectionTypeAnnotation" ||
+ (parent.type === "FunctionTypeAnnotation" &&
+ parent.returnType === fun)) &&
+ fun[paramsField].length === 1 &&
+ fun[paramsField][0].name === null &&
+ fun[paramsField][0].typeAnnotation &&
+ flowTypeAnnotations.indexOf(fun[paramsField][0].typeAnnotation.type) !==
+ -1 &&
+ !(fun[paramsField][0].typeAnnotation.type === "GenericTypeAnnotation" &&
+ fun[paramsField][0].typeAnnotation.typeParameters) &&
+ !fun.rest;
+
+ if (isFlowShorthandWithOneArg) {
+ return concat$2(printed);
+ }
+
+ const canHaveTrailingComma =
+ !(lastParam && lastParam.type === "RestElement") && !fun.rest;
+
+ return concat$2([
+ "(",
+ indent$2(concat$2([softline$1, join$2(concat$2([",", line$1]), printed)])),
+ ifBreak$1(
+ canHaveTrailingComma && shouldPrintComma(options, "all") ? "," : ""
+ ),
+ softline$1,
+ ")"
+ ]);
+}
+
+function canPrintParamsWithoutParens(node) {
+ return (
+ node.params.length === 1 &&
+ !node.rest &&
+ node.params[0].type === "Identifier" &&
+ !node.params[0].typeAnnotation &&
+ !util$4.hasBlockComments(node.params[0]) &&
+ !node.params[0].optional &&
+ !node.predicate &&
+ !node.returnType
+ );
+}
+
+function printFunctionDeclaration(path, print, options) {
+ const n = path.getValue();
+ const parts = [];
+
+ if (n.async) {
+ parts.push("async ");
+ }
+
+ parts.push("function");
+
+ if (n.generator) {
+ parts.push("*");
+ }
+ if (n.id) {
+ parts.push(" ", path.call(print, "id"));
+ }
+
+ parts.push(
+ printFunctionTypeParameters(path, options, print),
+ group$1(
+ concat$2([
+ printFunctionParams(path, print, options),
+ printReturnType(path, print)
+ ])
+ ),
+ n.body ? " " : "",
+ path.call(print, "body")
+ );
+
+ return concat$2(parts);
+}
+
+function printObjectMethod(path, options, print) {
+ const objMethod = path.getValue();
+ const parts = [];
+
+ if (objMethod.async) {
+ parts.push("async ");
+ }
+ if (objMethod.generator) {
+ parts.push("*");
+ }
+ if (
+ objMethod.method ||
+ objMethod.kind === "get" ||
+ objMethod.kind === "set"
+ ) {
+ return printMethod(path, options, print);
+ }
+
+ const key = printPropertyKey(path, options, print);
+
+ if (objMethod.computed) {
+ parts.push("[", key, "]");
+ } else {
+ parts.push(key);
+ }
+
+ parts.push(
+ printFunctionTypeParameters(path, options, print),
+ group$1(
+ concat$2([
+ printFunctionParams(path, print, options),
+ printReturnType(path, print)
+ ])
+ ),
+ " ",
+ path.call(print, "body")
+ );
+
+ return concat$2(parts);
+}
+
+function printReturnType(path, print) {
+ const n = path.getValue();
+ const parts = [path.call(print, "returnType")];
+
+ // prepend colon to TypeScript type annotation
+ if (n.returnType && n.returnType.typeAnnotation) {
+ parts.unshift(": ");
+ }
+
+ if (n.predicate) {
+ // The return type will already add the colon, but otherwise we
+ // need to do it ourselves
+ parts.push(n.returnType ? " " : ": ", path.call(print, "predicate"));
+ }
+
+ return concat$2(parts);
+}
+
+function printExportDeclaration(path, options, print) {
+ const decl = path.getValue();
+ const semi = options.semi ? ";" : "";
+ const parts = ["export "];
+
+ if (decl["default"] || decl.type === "ExportDefaultDeclaration") {
+ parts.push("default ");
+ }
+
+ parts.push(
+ comments$3.printDanglingComments(path, options, /* sameIndent */ true)
+ );
+
+ if (decl.declaration) {
+ parts.push(path.call(print, "declaration"));
+
+ if (
+ decl.type === "ExportDefaultDeclaration" &&
+ (decl.declaration.type !== "ClassDeclaration" &&
+ decl.declaration.type !== "FunctionDeclaration")
+ ) {
+ parts.push(semi);
+ }
+ } else {
+ if (decl.specifiers && decl.specifiers.length > 0) {
+ if (
+ decl.specifiers.length === 1 &&
+ decl.specifiers[0].type === "ExportBatchSpecifier"
+ ) {
+ parts.push("*");
+ } else {
+ const specifiers = [];
+ const defaultSpecifiers = [];
+ const namespaceSpecifiers = [];
+
+ path.map(specifierPath => {
+ const specifierType = path.getValue().type;
+ if (specifierType === "ExportSpecifier") {
+ specifiers.push(print(specifierPath));
+ } else if (specifierType === "ExportDefaultSpecifier") {
+ defaultSpecifiers.push(print(specifierPath));
+ } else if (specifierType === "ExportNamespaceSpecifier") {
+ namespaceSpecifiers.push(concat$2(["* as ", print(specifierPath)]));
+ }
+ }, "specifiers");
+
+ const isNamespaceFollowed =
+ namespaceSpecifiers.length !== 0 &&
+ (specifiers.length !== 0 || defaultSpecifiers.length !== 0);
+ const isDefaultFollowed =
+ defaultSpecifiers.length !== 0 && specifiers.length !== 0;
+
+ parts.push(
+ decl.exportKind === "type" ? "type " : "",
+ concat$2(namespaceSpecifiers),
+ concat$2([isNamespaceFollowed ? ", " : ""]),
+ concat$2(defaultSpecifiers),
+ concat$2([isDefaultFollowed ? ", " : ""]),
+ specifiers.length !== 0
+ ? group$1(
+ concat$2([
+ "{",
+ indent$2(
+ concat$2([
+ options.bracketSpacing ? line$1 : softline$1,
+ join$2(concat$2([",", line$1]), specifiers)
+ ])
+ ),
+ ifBreak$1(shouldPrintComma(options) ? "," : ""),
+ options.bracketSpacing ? line$1 : softline$1,
+ "}"
+ ])
+ )
+ : ""
+ );
+ }
+ } else {
+ parts.push("{}");
+ }
+
+ if (decl.source) {
+ parts.push(" from ", path.call(print, "source"));
+ }
+
+ parts.push(semi);
+ }
+
+ return concat$2(parts);
+}
+
+function printFlowDeclaration(path, parts) {
+ const parentExportDecl = util$4.getParentExportDeclaration(path);
+
+ if (parentExportDecl) {
+ assert$1.strictEqual(parentExportDecl.type, "DeclareExportDeclaration");
+ } else {
+ // If the parent node has type DeclareExportDeclaration, then it
+ // will be responsible for printing the "declare" token. Otherwise
+ // it needs to be printed with this non-exported declaration node.
+ parts.unshift("declare ");
+ }
+
+ return concat$2(parts);
+}
+
+function getFlowVariance(path) {
+ if (!path.variance) {
+ return null;
+ }
+
+ // Babylon 7.0 currently uses variance node type, and flow should
+ // follow suit soon:
+ // https://github.com/babel/babel/issues/4722
+ const variance = path.variance.kind || path.variance;
+
+ switch (variance) {
+ case "plus":
+ return "+";
+
+ case "minus":
+ return "-";
+
+ default:
+ return variance;
+ }
+}
+
+function printTypeScriptModifiers(path, options, print) {
+ const n = path.getValue();
+ if (!n.modifiers || !n.modifiers.length) {
+ return "";
+ }
+ return concat$2([join$2(" ", path.map(print, "modifiers")), " "]);
+}
+
+function printTypeParameters(path, options, print, paramsKey) {
+ const n = path.getValue();
+
+ if (!n[paramsKey]) {
+ return "";
+ }
+
+ // for TypeParameterDeclaration typeParameters is a single node
+ if (!Array.isArray(n[paramsKey])) {
+ return path.call(print, paramsKey);
+ }
+
+ const shouldInline =
+ n[paramsKey].length === 1 &&
+ (shouldHugType(n[paramsKey][0]) ||
+ (n[paramsKey][0].type === "GenericTypeAnnotation" &&
+ shouldHugType(n[paramsKey][0].id)) ||
+ n[paramsKey][0].type === "NullableTypeAnnotation");
+
+ if (shouldInline) {
+ return concat$2(["<", join$2(", ", path.map(print, paramsKey)), ">"]);
+ }
+
+ return group$1(
+ concat$2([
+ "<",
+ indent$2(
+ concat$2([
+ softline$1,
+ join$2(concat$2([",", line$1]), path.map(print, paramsKey))
+ ])
+ ),
+ ifBreak$1(
+ options.parser !== "typescript" && shouldPrintComma(options, "all")
+ ? ","
+ : ""
+ ),
+ softline$1,
+ ">"
+ ])
+ );
+}
+
+function printClass(path, options, print) {
+ const n = path.getValue();
+ const parts = [];
+
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.type === "TSAbstractClassDeclaration") {
+ parts.push("abstract ");
+ }
+
+ parts.push("class");
+
+ if (n.id) {
+ parts.push(" ", path.call(print, "id"));
+ }
+
+ parts.push(path.call(print, "typeParameters"));
+
+ const partsGroup = [];
+ if (n.superClass) {
+ parts.push(
+ " extends ",
+ path.call(print, "superClass"),
+ path.call(print, "superTypeParameters")
+ );
+ } else if (n.extends && n.extends.length > 0) {
+ parts.push(" extends ", join$2(", ", path.map(print, "extends")));
+ }
+
+ if (n["implements"] && n["implements"].length > 0) {
+ partsGroup.push(
+ line$1,
+ "implements ",
+ group$1(indent$2(join$2(concat$2([",", line$1]), path.map(print, "implements"))))
+ );
+ }
+
+ if (partsGroup.length > 0) {
+ parts.push(group$1(indent$2(concat$2(partsGroup))));
+ }
+
+ parts.push(" ", path.call(print, "body"));
+
+ return parts;
+}
+
+function printMemberLookup(path, options, print) {
+ const property = path.call(print, "property");
+ const n = path.getValue();
+
+ if (!n.computed) {
+ return concat$2([".", property]);
+ }
+
+ if (
+ !n.property ||
+ (n.property.type === "Literal" && typeof n.property.value === "number") ||
+ n.property.type === "NumericLiteral"
+ ) {
+ return concat$2(["[", property, "]"]);
+ }
+
+ return group$1(
+ concat$2(["[", indent$2(concat$2([softline$1, property])), softline$1, "]"])
+ );
+}
+
+// We detect calls on member expressions specially to format a
+// comman pattern better. The pattern we are looking for is this:
+//
+// arr
+// .map(x => x + 1)
+// .filter(x => x > 10)
+// .some(x => x % 2)
+//
+// The way it is structured in the AST is via a nested sequence of
+// MemberExpression and CallExpression. We need to traverse the AST
+// and make groups out of it to print it in the desired way.
+function printMemberChain(path, options, print) {
+ // The first phase is to linearize the AST by traversing it down.
+ //
+ // a().b()
+ // has the following AST structure:
+ // CallExpression(MemberExpression(CallExpression(Identifier)))
+ // and we transform it into
+ // [Identifier, CallExpression, MemberExpression, CallExpression]
+ const printedNodes = [];
+
+ function rec(path) {
+ const node = path.getValue();
+ if (node.type === "CallExpression") {
+ printedNodes.unshift({
+ node: node,
+ printed: comments$3.printComments(
+ path,
+ () =>
+ concat$2([
+ printFunctionTypeParameters(path, options, print),
+ printArgumentsList(path, options, print)
+ ]),
+ options
+ )
+ });
+ path.call(callee => rec(callee), "callee");
+ } else if (node.type === "MemberExpression") {
+ printedNodes.unshift({
+ node: node,
+ printed: comments$3.printComments(
+ path,
+ () => printMemberLookup(path, options, print),
+ options
+ )
+ });
+ path.call(object => rec(object), "object");
+ } else {
+ printedNodes.unshift({
+ node: node,
+ printed: path.call(print)
+ });
+ }
+ }
+ // Note: the comments of the root node have already been printed, so we
+ // need to extract this first call without printing them as they would
+ // if handled inside of the recursive call.
+ printedNodes.unshift({
+ node: path.getValue(),
+ printed: concat$2([
+ printFunctionTypeParameters(path, options, print),
+ printArgumentsList(path, options, print)
+ ])
+ });
+ path.call(callee => rec(callee), "callee");
+
+ // Once we have a linear list of printed nodes, we want to create groups out
+ // of it.
+ //
+ // a().b.c().d().e
+ // will be grouped as
+ // [
+ // [Identifier, CallExpression],
+ // [MemberExpression, MemberExpression, CallExpression],
+ // [MemberExpression, CallExpression],
+ // [MemberExpression],
+ // ]
+ // so that we can print it as
+ // a()
+ // .b.c()
+ // .d()
+ // .e
+
+ // The first group is the first node followed by
+ // - as many CallExpression as possible
+ // < fn()()() >.something()
+ // - then, as many MemberExpression as possible but the last one
+ // < this.items >.something()
+ const groups = [];
+ let currentGroup = [printedNodes[0]];
+ let i = 1;
+ for (; i < printedNodes.length; ++i) {
+ if (printedNodes[i].node.type === "CallExpression") {
+ currentGroup.push(printedNodes[i]);
+ } else {
+ break;
+ }
+ }
+ for (; i + 1 < printedNodes.length; ++i) {
+ if (
+ printedNodes[i].node.type === "MemberExpression" &&
+ printedNodes[i + 1].node.type === "MemberExpression"
+ ) {
+ currentGroup.push(printedNodes[i]);
+ } else {
+ break;
+ }
+ }
+ groups.push(currentGroup);
+ currentGroup = [];
+
+ // Then, each following group is a sequence of MemberExpression followed by
+ // a sequence of CallExpression. To compute it, we keep adding things to the
+ // group until we has seen a CallExpression in the past and reach a
+ // MemberExpression
+ let hasSeenCallExpression = false;
+ for (; i < printedNodes.length; ++i) {
+ if (
+ hasSeenCallExpression &&
+ printedNodes[i].node.type === "MemberExpression"
+ ) {
+ // [0] should be appended at the end of the group instead of the
+ // beginning of the next one
+ if (printedNodes[i].node.computed) {
+ currentGroup.push(printedNodes[i]);
+ continue;
+ }
+
+ groups.push(currentGroup);
+ currentGroup = [];
+ hasSeenCallExpression = false;
+ }
+
+ if (printedNodes[i].node.type === "CallExpression") {
+ hasSeenCallExpression = true;
+ }
+ currentGroup.push(printedNodes[i]);
+
+ if (
+ printedNodes[i].node.comments &&
+ printedNodes[i].node.comments.some(comment => comment.trailing)
+ ) {
+ groups.push(currentGroup);
+ currentGroup = [];
+ hasSeenCallExpression = false;
+ }
+ }
+ if (currentGroup.length > 0) {
+ groups.push(currentGroup);
+ }
+
+ // There are cases like Object.keys(), Observable.of(), _.values() where
+ // they are the subject of all the chained calls and therefore should
+ // be kept on the same line:
+ //
+ // Object.keys(items)
+ // .filter(x => x)
+ // .map(x => x)
+ //
+ // In order to detect those cases, we use an heuristic: if the first
+ // node is just an identifier with the name starting with a capital
+ // letter, just a sequence of _$ or this. The rationale is that they are
+ // likely to be factories.
+ const shouldMerge =
+ groups.length >= 2 &&
+ !groups[1][0].node.comments &&
+ groups[0].length === 1 &&
+ (groups[0][0].node.type === "ThisExpression" ||
+ (groups[0][0].node.type === "Identifier" &&
+ groups[0][0].node.name.match(/(^[A-Z])|^[_$]+$/)));
+
+ function printGroup(printedGroup) {
+ return concat$2(printedGroup.map(tuple => tuple.printed));
+ }
+
+ function printIndentedGroup(groups) {
+ if (groups.length === 0) {
+ return "";
+ }
+ return indent$2(
+ group$1(concat$2([hardline$2, join$2(hardline$2, groups.map(printGroup))]))
+ );
+ }
+
+ const printedGroups = groups.map(printGroup);
+ const oneLine = concat$2(printedGroups);
+
+ const flatGroups = groups
+ .slice(0, shouldMerge ? 3 : 2)
+ .reduce((res, group) => res.concat(group), []);
+
+ const hasComment =
+ flatGroups.slice(1).some(node => hasLeadingComment(node.node)) ||
+ flatGroups.slice(0, -1).some(node => hasTrailingComment(node.node));
+
+ // If we only have a single `.`, we shouldn't do anything fancy and just
+ // render everything concatenated together.
+ if (
+ groups.length <= (shouldMerge ? 3 : 2) &&
+ !hasComment &&
+ // (a || b).map() should be break before .map() instead of ||
+ groups[0][0].node.type !== "LogicalExpression"
+ ) {
+ return group$1(oneLine);
+ }
+
+ const expanded = concat$2([
+ printGroup(groups[0]),
+ shouldMerge ? concat$2(groups.slice(1, 2).map(printGroup)) : "",
+ printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))
+ ]);
+
+ // If there's a comment, we don't want to print in one line.
+ if (hasComment) {
+ return group$1(expanded);
+ }
+
+ // If any group but the last one has a hard line, we want to force expand
+ // it. If the last group is a function it's okay to inline if it fits.
+ if (printedGroups.slice(0, -1).some(willBreak)) {
+ return group$1(expanded);
+ }
+
+ return concat$2([
+ // We only need to check `oneLine` because if `expanded` is chosen
+ // that means that the parent group has already been broken
+ // naturally
+ willBreak(oneLine) ? breakParent$2 : "",
+ conditionalGroup$1([oneLine, expanded])
+ ]);
+}
+
+function isEmptyJSXElement(node) {
+ if (node.children.length === 0) {
+ return true;
+ }
+ if (node.children.length > 1) {
+ return false;
+ }
+
+ // if there is one child but it's just a newline, treat as empty
+ const value = node.children[0].value;
+ if (!/\S/.test(value) && /\n/.test(value)) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+// JSX Children are strange, mostly for two reasons:
+// 1. JSX reads newlines into string values, instead of skipping them like JS
+// 2. up to one whitespace between elements within a line is significant,
+// but not between lines.
+//
+// So for one thing, '\n' needs to be parsed out of string literals
+// and turned into hardlines (with string boundaries otherwise using softline)
+//
+// For another, leading, trailing, and lone whitespace all need to
+// turn themselves into the rather ugly `{' '}` when breaking.
+//
+// Finally we print JSX using the `fill` doc primitive.
+// This requires that we give it an array of alternating
+// content and whitespace elements.
+// To ensure this we add dummy `""` content elements as needed.
+function printJSXChildren(path, options, print, jsxWhitespace) {
+ const n = path.getValue();
+ const children = [];
+
+ // using `map` instead of `each` because it provides `i`
+ path.map((childPath, i) => {
+ const child = childPath.getValue();
+ if (isLiteral(child) && typeof child.value === "string") {
+ const value = child.raw || child.extra.raw;
+
+ // Contains a non-whitespace character
+ if (/[^ \n\r\t]/.test(value)) {
+ // treat each line of text as its own entity
+ value.split(/(\r?\n\s*)/).forEach(textLine => {
+ const newlines = textLine.match(/\n/g);
+ if (newlines) {
+ children.push("");
+ children.push(hardline$2);
+
+ // allow one extra newline
+ if (newlines.length > 1) {
+ children.push("");
+ children.push(hardline$2);
+ }
+ return;
+ }
+
+ if (textLine.length === 0) {
+ return;
+ }
+
+ const beginSpace = /^[ \n\r\t]+/.test(textLine);
+ if (beginSpace) {
+ children.push("");
+ children.push(jsxWhitespace);
+ }
+
+ const stripped = textLine.replace(/^[ \n\r\t]+|[ \n\r\t]+$/g, "");
+ // Split text into words separated by "line"s.
+ stripped.split(/([ \n\r\t]+)/).forEach(word => {
+ const space = /[ \n\r\t]+/.test(word);
+ if (space) {
+ children.push(line$1);
+ } else {
+ children.push(word);
+ }
+ });
+
+ const endSpace = /[ \n\r\t]+$/.test(textLine);
+ if (endSpace) {
+ children.push(jsxWhitespace);
+ } else {
+ // Ideally this would be a `softline` to allow a break between
+ // tags and text.
+ // Unfortunately Facebook have a custom translation pipeline
+ // (https://github.com/prettier/prettier/issues/1581#issuecomment-300975032)
+ // that uses the JSX syntax, but does not follow the React whitespace
+ // rules.
+ // Ensuring that we never have a break between tags and text in JSX
+ // will allow Facebook to adopt Prettier without too much of an
+ // adverse effect on formatting algorithm.
+ children.push("");
+ }
+ });
+ } else if (/\n/.test(value)) {
+ children.push("");
+ children.push(hardline$2);
+
+ // allow one extra newline
+ if (value.match(/\n/g).length > 1) {
+ children.push("");
+ children.push(hardline$2);
+ }
+ } else if (/[ \n\r\t]/.test(value)) {
+ // whitespace(s)-only without newlines,
+ // eg; one or more spaces separating two elements
+ for (let i = 0; i < value.length; ++i) {
+ // Because fill expects alternating content and whitespace parts
+ // we need to include an empty content part before each JSX
+ // whitespace.
+ children.push("");
+ children.push(jsxWhitespace);
+ }
+ }
+ } else {
+ children.push(print(childPath));
+
+ const next = n.children[i + 1];
+ const followedByJSXElement = next && !isLiteral(next);
+ if (followedByJSXElement) {
+ children.push(softline$1);
+ } else {
+ // Ideally this would be a softline as well.
+ // See the comment above about the Facebook translation pipeline as
+ // to why this is an empty string.
+ children.push("");
+ }
+ }
+ }, "children");
+
+ return children;
+}
+
+// JSX expands children from the inside-out, instead of the outside-in.
+// This is both to break children before attributes,
+// and to ensure that when children break, their parents do as well.
+//
+// Any element that is written without any newlines and fits on a single line
+// is left that way.
+// Not only that, any user-written-line containing multiple JSX siblings
+// should also be kept on one line if possible,
+// so each user-written-line is wrapped in its own group.
+//
+// Elements that contain newlines or don't fit on a single line (recursively)
+// are fully-split, using hardline and shouldBreak: true.
+//
+// To support that case properly, all leading and trailing spaces
+// are stripped from the list of children, and replaced with a single hardline.
+function printJSXElement(path, options, print) {
+ const n = path.getValue();
+
+ // Turn into
+ if (isEmptyJSXElement(n)) {
+ n.openingElement.selfClosing = true;
+ delete n.closingElement;
+ }
+
+ const openingLines = path.call(print, "openingElement");
+ const closingLines = path.call(print, "closingElement");
+
+ if (
+ n.children.length === 1 &&
+ n.children[0].type === "JSXExpressionContainer" &&
+ (n.children[0].expression.type === "TemplateLiteral" ||
+ n.children[0].expression.type === "TaggedTemplateExpression")
+ ) {
+ return concat$2([
+ openingLines,
+ concat$2(path.map(print, "children")),
+ closingLines
+ ]);
+ }
+
+ // If no children, just print the opening element
+ if (n.openingElement.selfClosing) {
+ assert$1.ok(!n.closingElement);
+ return openingLines;
+ }
+ // Record any breaks. Should never go from true to false, only false to true.
+ let forcedBreak = willBreak(openingLines);
+
+ const rawJsxWhitespace = options.singleQuote ? "{' '}" : '{" "}';
+ const jsxWhitespace = ifBreak$1(concat$2([softline$1, rawJsxWhitespace]), " ");
+
+ const children = printJSXChildren(path, options, print, jsxWhitespace);
+
+ // Remove multiple filler empty strings
+ // These can occur when a text element is followed by a newline.
+ for (let i = children.length - 2; i >= 0; i--) {
+ if (children[i] === "" && children[i + 1] === "") {
+ children.splice(i, 2);
+ }
+ }
+
+ // Trim trailing lines (or empty strings), recording if there was a hardline
+ let numTrailingHard = 0;
+ while (
+ children.length &&
+ (isLineNext(util$4.getLast(children)) || isEmpty(util$4.getLast(children)))
+ ) {
+ if (willBreak(util$4.getLast(children))) {
+ ++numTrailingHard;
+ forcedBreak = true;
+ }
+ children.pop();
+ }
+ // allow one extra newline
+ if (numTrailingHard > 1) {
+ children.push("");
+ children.push(hardline$2);
+ }
+
+ // Trim leading lines (or empty strings), recording if there was a hardline
+ let numLeadingHard = 0;
+ while (
+ children.length &&
+ (isLineNext(children[0]) || isEmpty(children[0])) &&
+ (isLineNext(children[1]) || isEmpty(children[1]))
+ ) {
+ if (willBreak(children[0]) || willBreak(children[1])) {
+ ++numLeadingHard;
+ forcedBreak = true;
+ }
+ children.shift();
+ children.shift();
+ }
+ // allow one extra newline
+ if (numLeadingHard > 1) {
+ children.unshift(hardline$2);
+ children.unshift("");
+ }
+
+ // Tweak how we format children if outputting this element over multiple lines.
+ // Also detect whether we will force this element to output over multiple lines.
+ const multilineChildren = [];
+ children.forEach((child, i) => {
+ // Ensure that we display leading, trailing, and solitary whitespace as
+ // `{" "}` when outputting this element over multiple lines.
+ if (child === jsxWhitespace) {
+ if (i === 1 && children[i - 1] === "") {
+ multilineChildren.push(rawJsxWhitespace);
+ return;
+ } else if (i === children.length - 1) {
+ multilineChildren.push(concat$2([hardline$2, rawJsxWhitespace]));
+ return;
+ } else if (willBreak(children[i - 1]) || willBreak(children[i + 1])) {
+ // If we come before or after a JSX element that is multiline
+ // ensure the JSX whitespace appears on a line by itself.
+ // NOTE: Currently this only detects elements that are already
+ // multiline before formatting!
+ multilineChildren.push(concat$2([hardline$2, rawJsxWhitespace, hardline$2]));
+ return;
+ }
+ }
+
+ multilineChildren.push(child);
+
+ if (willBreak(child)) {
+ forcedBreak = true;
+ }
+ });
+
+ const multiLineElem = group$1(
+ concat$2([
+ openingLines,
+ indent$2(concat$2([hardline$2, fill$1(multilineChildren)])),
+ hardline$2,
+ closingLines
+ ])
+ );
+
+ if (forcedBreak) {
+ return multiLineElem;
+ }
+
+ return conditionalGroup$1([
+ group$1(concat$2([openingLines, fill$1(children), closingLines])),
+ multiLineElem
+ ]);
+}
+
+function maybeWrapJSXElementInParens(path, elem) {
+ const parent = path.getParentNode();
+ if (!parent) {
+ return elem;
+ }
+
+ const NO_WRAP_PARENTS = {
+ ArrayExpression: true,
+ JSXElement: true,
+ JSXExpressionContainer: true,
+ ExpressionStatement: true,
+ CallExpression: true,
+ ConditionalExpression: true,
+ LogicalExpression: true,
+ ArrowFunctionExpression: true
+ };
+ if (NO_WRAP_PARENTS[parent.type]) {
+ return elem;
+ }
+
+ return group$1(
+ concat$2([
+ ifBreak$1("("),
+ indent$2(concat$2([softline$1, elem])),
+ softline$1,
+ ifBreak$1(")")
+ ])
+ );
+}
+
+function isBinaryish(node) {
+ return node.type === "BinaryExpression" || node.type === "LogicalExpression";
+}
+
+function shouldInlineLogicalExpression(node) {
+ if (node.type !== "LogicalExpression") {
+ return false;
+ }
+
+ if (
+ node.right.type === "ObjectExpression" &&
+ node.right.properties.length !== 0
+ ) {
+ return true;
+ }
+
+ if (
+ node.right.type === "ArrayExpression" &&
+ node.right.elements.length !== 0
+ ) {
+ return true;
+ }
+
+ return false;
+}
+
+// For binary expressions to be consistent, we need to group
+// subsequent operators with the same precedence level under a single
+// group. Otherwise they will be nested such that some of them break
+// onto new lines but not all. Operators with the same precedence
+// level should either all break or not. Because we group them by
+// precedence level and the AST is structured based on precedence
+// level, things are naturally broken up correctly, i.e. `&&` is
+// broken before `+`.
+function printBinaryishExpressions(
+ path,
+ print,
+ options,
+ isNested,
+ isInsideParenthesis
+) {
+ let parts = [];
+ const node = path.getValue();
+
+ // We treat BinaryExpression and LogicalExpression nodes the same.
+ if (isBinaryish(node)) {
+ // Put all operators with the same precedence level in the same
+ // group. The reason we only need to do this with the `left`
+ // expression is because given an expression like `1 + 2 - 3`, it
+ // is always parsed like `((1 + 2) - 3)`, meaning the `left` side
+ // is where the rest of the expression will exist. Binary
+ // expressions on the right side mean they have a difference
+ // precedence level and should be treated as a separate group, so
+ // print them normally. (This doesn't hold for the `**` operator,
+ // which is unique in that it is right-associative.)
+ if (
+ util$4.getPrecedence(node.left.operator) ===
+ util$4.getPrecedence(node.operator) &&
+ node.operator !== "**"
+ ) {
+ // Flatten them out by recursively calling this function.
+ parts = parts.concat(
+ path.call(
+ left =>
+ printBinaryishExpressions(
+ left,
+ print,
+ options,
+ /* isNested */ true,
+ isInsideParenthesis
+ ),
+ "left"
+ )
+ );
+ } else {
+ parts.push(path.call(print, "left"));
+ }
+
+ const right = concat$2([
+ node.operator,
+ shouldInlineLogicalExpression(node) ? " " : line$1,
+ path.call(print, "right")
+ ]);
+
+ // If there's only a single binary expression, we want to create a group
+ // in order to avoid having a small right part like -1 be on its own line.
+ const parent = path.getParentNode();
+ const shouldGroup =
+ !(isInsideParenthesis && node.type === "LogicalExpression") &&
+ parent.type !== node.type &&
+ node.left.type !== node.type &&
+ node.right.type !== node.type;
+
+ parts.push(" ", shouldGroup ? group$1(right) : right);
+
+ // The root comments are already printed, but we need to manually print
+ // the other ones since we don't call the normal print on BinaryExpression,
+ // only for the left and right parts
+ if (isNested && node.comments) {
+ parts = comments$3.printComments(path, () => concat$2(parts), options);
+ }
+ } else {
+ // Our stopping case. Simply print the node normally.
+ parts.push(path.call(print));
+ }
+
+ return parts;
+}
+
+function printAssignmentRight(rightNode, printedRight, canBreak, options) {
+ if (hasLeadingOwnLineComment(options.originalText, rightNode)) {
+ return indent$2(concat$2([hardline$2, printedRight]));
+ }
+
+ if (canBreak) {
+ return indent$2(concat$2([line$1, printedRight]));
+ }
+
+ return concat$2([" ", printedRight]);
+}
+
+function printAssignment(
+ leftNode,
+ printedLeft,
+ operator,
+ rightNode,
+ printedRight,
+ options
+) {
+ if (!rightNode) {
+ return printedLeft;
+ }
+
+ const canBreak =
+ (isBinaryish(rightNode) && !shouldInlineLogicalExpression(rightNode)) ||
+ ((leftNode.type === "Identifier" ||
+ isStringLiteral(leftNode) ||
+ leftNode.type === "MemberExpression") &&
+ (isStringLiteral(rightNode) || isMemberExpressionChain(rightNode)));
+
+ const printed = printAssignmentRight(
+ rightNode,
+ printedRight,
+ canBreak,
+ options
+ );
+
+ return group$1(concat$2([printedLeft, operator, printed]));
+}
+
+function adjustClause(node, clause, forceSpace) {
+ if (node.type === "EmptyStatement") {
+ return ";";
+ }
+
+ if (node.type === "BlockStatement" || forceSpace) {
+ return concat$2([" ", clause]);
+ }
+
+ return indent$2(concat$2([line$1, clause]));
+}
+
+function nodeStr(node, options, isFlowDirectiveLiteral) {
+ const raw = node.extra ? node.extra.raw : node.raw;
+ // `rawContent` is the string exactly like it appeared in the input source
+ // code, with its enclosing quote.
+ const rawContent = raw.slice(1, -1);
+
+ const double = { quote: '"', regex: /"/g };
+ const single = { quote: "'", regex: /'/g };
+
+ const preferred = options.singleQuote ? single : double;
+ const alternate = preferred === single ? double : single;
+
+ let shouldUseAlternateQuote = false;
+ const isDirectiveLiteral =
+ isFlowDirectiveLiteral || node.type === "DirectiveLiteral";
+ let canChangeDirectiveQuotes = false;
+
+ // If `rawContent` contains at least one of the quote preferred for enclosing
+ // the string, we might want to enclose with the alternate quote instead, to
+ // minimize the number of escaped quotes.
+ // Also check for the alternate quote, to determine if we're allowed to swap
+ // the quotes on a DirectiveLiteral.
+ if (
+ rawContent.includes(preferred.quote) ||
+ rawContent.includes(alternate.quote)
+ ) {
+ const numPreferredQuotes = (rawContent.match(preferred.regex) || []).length;
+ const numAlternateQuotes = (rawContent.match(alternate.regex) || []).length;
+
+ shouldUseAlternateQuote = numPreferredQuotes > numAlternateQuotes;
+ } else {
+ canChangeDirectiveQuotes = true;
+ }
+
+ const enclosingQuote = shouldUseAlternateQuote
+ ? alternate.quote
+ : preferred.quote;
+
+ // Directives are exact code unit sequences, which means that you can't
+ // change the escape sequences they use.
+ // See https://github.com/prettier/prettier/issues/1555
+ // and https://tc39.github.io/ecma262/#directive-prologue
+ if (isDirectiveLiteral) {
+ if (canChangeDirectiveQuotes) {
+ return enclosingQuote + rawContent + enclosingQuote;
+ } else {
+ return raw;
+ }
+ }
+
+ // It might sound unnecessary to use `makeString` even if `node.raw` already
+ // is enclosed with `enclosingQuote`, but it isn't. `node.raw` could contain
+ // unnecessary escapes (such as in `"\'"`). Always using `makeString` makes
+ // sure that we consistently output the minimum amount of escaped quotes.
+ return makeString(rawContent, enclosingQuote);
+}
+
+function makeString(rawContent, enclosingQuote) {
+ const otherQuote = enclosingQuote === '"' ? "'" : '"';
+
+ // Matches _any_ escape and unescaped quotes (both single and double).
+ const regex = /\\([\s\S])|(['"])/g;
+
+ // Escape and unescape single and double quotes as needed to be able to
+ // enclose `rawContent` with `enclosingQuote`.
+ const newContent = rawContent.replace(regex, (match, escaped, quote) => {
+ // If we matched an escape, and the escaped character is a quote of the
+ // other type than we intend to enclose the string with, there's no need for
+ // it to be escaped, so return it _without_ the backslash.
+ if (escaped === otherQuote) {
+ return escaped;
+ }
+
+ // If we matched an unescaped quote and it is of the _same_ type as we
+ // intend to enclose the string with, it must be escaped, so return it with
+ // a backslash.
+ if (quote === enclosingQuote) {
+ return "\\" + quote;
+ }
+
+ if (quote) {
+ return quote;
+ }
+
+ // Unescape any unnecessarily escaped character.
+ // Adapted from https://github.com/eslint/eslint/blob/de0b4ad7bd820ade41b1f606008bea68683dc11a/lib/rules/no-useless-escape.js#L27
+ return /^[^\\nrvtbfux\r\n\u2028\u2029"'0-7]$/.test(escaped)
+ ? escaped
+ : "\\" + escaped;
+ });
+
+ return enclosingQuote + newContent + enclosingQuote;
+}
+
+function printRegex(node) {
+ const flags = node.flags.split("").sort().join("");
+ return `/${node.pattern}/${flags}`;
+}
+
+function printNumber(rawNumber) {
+ return (
+ rawNumber
+ .toLowerCase()
+ // Remove unnecessary plus and zeroes from scientific notation.
+ .replace(/^([\d.]+e)(?:\+|(-))?0*(\d)/, "$1$2$3")
+ // Remove unnecessary scientific notation (1e0).
+ .replace(/^([\d.]+)e[+-]?0+$/, "$1")
+ // Make sure numbers always start with a digit.
+ .replace(/^\./, "0.")
+ // Remove extraneous trailing decimal zeroes.
+ .replace(/(\.\d+?)0+(?=e|$)/, "$1")
+ // Remove trailing dot.
+ .replace(/\.(?=e|$)/, "")
+ );
+}
+
+function isLastStatement(path) {
+ const parent = path.getParentNode();
+ if (!parent) {
+ return true;
+ }
+ const node = path.getValue();
+ const body = parent.body.filter(stmt => stmt.type !== "EmptyStatement");
+ return body && body[body.length - 1] === node;
+}
+
+function hasLeadingComment(node) {
+ return node.comments && node.comments.some(comment => comment.leading);
+}
+
+function hasTrailingComment(node) {
+ return node.comments && node.comments.some(comment => comment.trailing);
+}
+
+function hasLeadingOwnLineComment(text, node) {
+ if (node.type === "JSXElement") {
+ return false;
+ }
+
+ const res =
+ node.comments &&
+ node.comments.some(
+ comment => comment.leading && util$4.hasNewline(text, util$4.locEnd(comment))
+ );
+ return res;
+}
+
+function hasNakedLeftSide(node) {
+ return (
+ node.type === "AssignmentExpression" ||
+ node.type === "BinaryExpression" ||
+ node.type === "LogicalExpression" ||
+ node.type === "ConditionalExpression" ||
+ node.type === "CallExpression" ||
+ node.type === "MemberExpression" ||
+ node.type === "SequenceExpression" ||
+ node.type === "TaggedTemplateExpression" ||
+ (node.type === "UpdateExpression" && !node.prefix)
+ );
+}
+
+function getLeftSide(node) {
+ if (node.expressions) {
+ return node.expressions[0];
+ }
+ return (
+ node.left ||
+ node.test ||
+ node.callee ||
+ node.object ||
+ node.tag ||
+ node.argument
+ );
+}
+
+function exprNeedsASIProtection(node) {
+ // HACK: node.needsParens is added in `genericPrint()` for the sole purpose
+ // of being used here. It'd be preferable to find a cleaner way to do this.
+ const maybeASIProblem =
+ node.needsParens ||
+ node.type === "ParenthesizedExpression" ||
+ node.type === "TypeCastExpression" ||
+ (node.type === "ArrowFunctionExpression" &&
+ !canPrintParamsWithoutParens(node)) ||
+ node.type === "ArrayExpression" ||
+ node.type === "ArrayPattern" ||
+ (node.type === "UnaryExpression" &&
+ node.prefix &&
+ (node.operator === "+" || node.operator === "-")) ||
+ node.type === "TemplateLiteral" ||
+ node.type === "TemplateElement" ||
+ node.type === "JSXElement" ||
+ node.type === "BindExpression" ||
+ node.type === "RegExpLiteral" ||
+ (node.type === "Literal" && node.pattern) ||
+ (node.type === "Literal" && node.regex);
+
+ if (maybeASIProblem) {
+ return true;
+ }
+
+ if (!hasNakedLeftSide(node)) {
+ return false;
+ }
+
+ return exprNeedsASIProtection(getLeftSide(node));
+}
+
+function stmtNeedsASIProtection(path) {
+ if (!path) {
+ return false;
+ }
+ const node = path.getNode();
+
+ if (node.type !== "ExpressionStatement") {
+ return false;
+ }
+
+ return exprNeedsASIProtection(node.expression);
+}
+
+function classPropMayCauseASIProblems(path) {
+ const node = path.getNode();
+
+ if (node.type !== "ClassProperty") {
+ return false;
+ }
+
+ const name = node.key && node.key.name;
+ if (!name) {
+ return false;
+ }
+
+ // this isn't actually possible yet with most parsers available today
+ // so isn't properly tested yet.
+ if (name === "static" || name === "get" || name === "set") {
+ return true;
+ }
+}
+
+function classChildNeedsASIProtection(node) {
+ if (!node) {
+ return;
+ }
+
+ switch (node.type) {
+ case "ClassProperty":
+ case "TSAbstractClassProperty":
+ return node.computed;
+ case "MethodDefinition": // Flow
+ case "TSAbstractMethodDefinition": // TypeScript
+ case "ClassMethod": {
+ // Babylon
+ const isAsync = node.value ? node.value.async : node.async;
+ const isGenerator = node.value ? node.value.generator : node.generator;
+ if (
+ isAsync ||
+ node.static ||
+ node.kind === "get" ||
+ node.kind === "set"
+ ) {
+ return false;
+ }
+ if (node.computed || isGenerator) {
+ return true;
+ }
+ return false;
+ }
+
+ default:
+ return false;
+ }
+}
+
+// This recurses the return argument, looking for the first token
+// (the leftmost leaf node) and, if it (or its parents) has any
+// leadingComments, returns true (so it can be wrapped in parens).
+function returnArgumentHasLeadingComment(options, argument) {
+ if (hasLeadingOwnLineComment(options.originalText, argument)) {
+ return true;
+ }
+
+ if (hasNakedLeftSide(argument)) {
+ let leftMost = argument;
+ let newLeftMost;
+ while ((newLeftMost = getLeftSide(leftMost))) {
+ leftMost = newLeftMost;
+
+ if (hasLeadingOwnLineComment(options.originalText, leftMost)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+function isMemberExpressionChain(node) {
+ if (node.type !== "MemberExpression") {
+ return false;
+ }
+ if (node.object.type === "Identifier") {
+ return true;
+ }
+ return isMemberExpressionChain(node.object);
+}
+
+// Hack to differentiate between the following two which have the same ast
+// type T = { method: () => void };
+// type T = { method(): void };
+function isObjectTypePropertyAFunction(node) {
+ return (
+ node.type === "ObjectTypeProperty" &&
+ node.value.type === "FunctionTypeAnnotation" &&
+ !node.static &&
+ !isFunctionNotation(node)
+ );
+}
+
+// TODO: This is a bad hack and we need a better way to distinguish between
+// arrow functions and otherwise
+function isFunctionNotation(node) {
+ return isGetterOrSetter(node) || sameLocStart(node, node.value);
+}
+
+function isGetterOrSetter(node) {
+ return node.kind === "get" || node.kind === "set";
+}
+
+function sameLocStart(nodeA, nodeB) {
+ return util$4.locStart(nodeA) === util$4.locStart(nodeB);
+}
+
+// Hack to differentiate between the following two which have the same ast
+// declare function f(a): void;
+// var f: (a) => void;
+function isTypeAnnotationAFunction(node) {
+ return (
+ node.type === "TypeAnnotation" &&
+ node.typeAnnotation.type === "FunctionTypeAnnotation" &&
+ !node.static &&
+ !sameLocStart(node, node.typeAnnotation)
+ );
+}
+
+function isNodeStartingWithDeclare(node, options) {
+ if (!(options.parser === "flow" || options.parser === "typescript")) {
+ return false;
+ }
+ return (
+ options.originalText.slice(0, util$4.locStart(node)).match(/declare\s*$/) ||
+ options.originalText
+ .slice(node.range[0], node.range[1])
+ .startsWith("declare ")
+ );
+}
+
+function shouldHugType(node) {
+ if (node.type === "ObjectTypeAnnotation") {
+ return true;
+ }
+
+ if (node.type === "UnionTypeAnnotation" || node.type === "TSUnionType") {
+ const count = node.types.filter(
+ n =>
+ n.type === "VoidTypeAnnotation" ||
+ n.type === "TSVoidKeyword" ||
+ n.type === "NullLiteralTypeAnnotation" ||
+ (n.type === "Literal" && n.value === null)
+ ).length;
+
+ if (node.types.length - 1 === count) {
+ return true;
+ }
+ }
+ return false;
+}
+
+function shouldHugArguments(fun) {
+ return (
+ fun &&
+ fun.params &&
+ fun.params.length === 1 &&
+ !fun.params[0].comments &&
+ (fun.params[0].type === "ObjectPattern" ||
+ (fun.params[0].type === "Identifier" &&
+ fun.params[0].typeAnnotation &&
+ fun.params[0].typeAnnotation.type === "TypeAnnotation" &&
+ shouldHugType(fun.params[0].typeAnnotation.typeAnnotation)) ||
+ (fun.params[0].type === "FunctionTypeParam" &&
+ shouldHugType(fun.params[0].typeAnnotation))) &&
+ !fun.rest
+ );
+}
+
+function templateLiteralHasNewLines(template) {
+ return template.quasis.some(quasi => quasi.value.raw.includes("\n"));
+}
+
+function isTemplateOnItsOwnLine(n, text) {
+ return (
+ ((n.type === "TemplateLiteral" && templateLiteralHasNewLines(n)) ||
+ (n.type === "TaggedTemplateExpression" &&
+ templateLiteralHasNewLines(n.quasi))) &&
+ !util$4.hasNewline(text, util$4.locStart(n), { backwards: true })
+ );
+}
+
+function printArrayItems(path, options, printPath, print) {
+ const printedElements = [];
+ let separatorParts = [];
+
+ path.each(childPath => {
+ printedElements.push(concat$2(separatorParts));
+ printedElements.push(group$1(print(childPath)));
+
+ separatorParts = [",", line$1];
+ if (
+ childPath.getValue() &&
+ util$4.isNextLineEmpty(options.originalText, childPath.getValue())
+ ) {
+ separatorParts.push(softline$1);
+ }
+ }, printPath);
+
+ return concat$2(printedElements);
+}
+
+function hasDanglingComments(node) {
+ return (
+ node.comments &&
+ node.comments.some(comment => !comment.leading && !comment.trailing)
+ );
+}
+
+function isLiteral(node) {
+ return (
+ node.type === "BooleanLiteral" ||
+ node.type === "DirectiveLiteral" ||
+ node.type === "Literal" ||
+ node.type === "NullLiteral" ||
+ node.type === "NumericLiteral" ||
+ node.type === "RegExpLiteral" ||
+ node.type === "StringLiteral" ||
+ node.type === "TemplateLiteral" ||
+ node.type === "TSTypeLiteral" ||
+ node.type === "JSXText"
+ );
+}
+
+function isStringLiteral(node) {
+ return (
+ node.type === "StringLiteral" ||
+ (node.type === "Literal" && typeof node.value === "string")
+ );
+}
+
+function removeLines(doc) {
+ // Force this doc into flat mode by statically converting all
+ // lines into spaces (or soft lines into nothing). Hard lines
+ // should still output because there's too great of a chance
+ // of breaking existing assumptions otherwise.
+ return docUtils.mapDoc(doc, d => {
+ if (d.type === "line" && !d.hard) {
+ return d.soft ? "" : " ";
+ } else if (d.type === "if-break") {
+ return d.flatContents || "";
+ }
+ return d;
+ });
+}
+
+function printAstToDoc$1(ast, options, addAlignmentSize) {
+ addAlignmentSize = addAlignmentSize || 0;
+
+ function printGenerically(path, args) {
+ const node = path.getValue();
+ const parent = path.getParentNode(0);
+ // We let JSXElement print its comments itself because it adds () around
+ // UnionTypeAnnotation has to align the child without the comments
+ if (
+ (node && node.type === "JSXElement") ||
+ (parent &&
+ (parent.type === "UnionTypeAnnotation" ||
+ parent.type === "TSUnionType"))
+ ) {
+ return genericPrint(path, options, printGenerically, args);
+ }
+
+ return comments$3.printComments(
+ path,
+ p => genericPrint(p, options, printGenerically, args),
+ options,
+ args && args.needsSemi
+ );
+ }
+
+ let doc = printGenerically(new FastPath(ast));
+ if (addAlignmentSize > 0) {
+ // Add a hardline to make the indents take effect
+ // It should be removed in index.js format()
+ doc = addAlignmentToDoc$1(
+ removeLines(concat$2([hardline$2, doc])),
+ addAlignmentSize,
+ options.tabWidth
+ );
+ }
+ docUtils.propagateBreaks(doc);
+ return doc;
+}
+
+var printer = { printAstToDoc: printAstToDoc$1 };
+
+const docBuilders$4 = docBuilders$1;
+const concat$3 = docBuilders$4.concat;
+const fill$2 = docBuilders$4.fill;
+
+const MODE_BREAK = 1;
+const MODE_FLAT = 2;
+
+function rootIndent() {
+ return {
+ indent: 0,
+ align: {
+ spaces: 0,
+ tabs: 0
+ }
+ };
+}
+
+function makeIndent(ind) {
+ return {
+ indent: ind.indent + 1,
+ align: ind.align
+ };
+}
+
+function makeAlign(ind, n) {
+ if (n === -Infinity) {
+ return {
+ indent: 0,
+ align: {
+ spaces: 0,
+ tabs: 0
+ }
+ };
+ }
+
+ return {
+ indent: ind.indent,
+ align: {
+ spaces: ind.align.spaces + n,
+ tabs: ind.align.tabs + (n ? 1 : 0)
+ }
+ };
+}
+
+function fits(next, restCommands, width, mustBeFlat) {
+ let restIdx = restCommands.length;
+ const cmds = [next];
+ while (width >= 0) {
+ if (cmds.length === 0) {
+ if (restIdx === 0) {
+ return true;
+ } else {
+ cmds.push(restCommands[restIdx - 1]);
+
+ restIdx--;
+
+ continue;
+ }
+ }
+
+ const x = cmds.pop();
+ const ind = x[0];
+ const mode = x[1];
+ const doc = x[2];
+
+ if (typeof doc === "string") {
+ width -= doc.length;
+ } else {
+ switch (doc.type) {
+ case "concat":
+ for (let i = doc.parts.length - 1; i >= 0; i--) {
+ cmds.push([ind, mode, doc.parts[i]]);
+ }
+
+ break;
+ case "indent":
+ cmds.push([makeIndent(ind), mode, doc.contents]);
+
+ break;
+ case "align":
+ cmds.push([makeAlign(ind, doc.n), mode, doc.contents]);
+
+ break;
+ case "group":
+ if (mustBeFlat && doc.break) {
+ return false;
+ }
+ cmds.push([ind, doc.break ? MODE_BREAK : mode, doc.contents]);
+
+ break;
+ case "fill":
+ for (let i = doc.parts.length - 1; i >= 0; i--) {
+ cmds.push([ind, mode, doc.parts[i]]);
+ }
+
+ break;
+ case "if-break":
+ if (mode === MODE_BREAK) {
+ if (doc.breakContents) {
+ cmds.push([ind, mode, doc.breakContents]);
+ }
+ }
+ if (mode === MODE_FLAT) {
+ if (doc.flatContents) {
+ cmds.push([ind, mode, doc.flatContents]);
+ }
+ }
+
+ break;
+ case "line":
+ switch (mode) {
+ // fallthrough
+ case MODE_FLAT:
+ if (!doc.hard) {
+ if (!doc.soft) {
+ width -= 1;
+ }
+
+ break;
+ }
+ return true;
+
+ case MODE_BREAK:
+ return true;
+ }
+ break;
+ }
+ }
+ }
+ return false;
+}
+
+function printDocToString$1(doc, options) {
+ const width = options.printWidth;
+ const newLine = options.newLine || "\n";
+ let pos = 0;
+ // cmds is basically a stack. We've turned a recursive call into a
+ // while loop which is much faster. The while loop below adds new
+ // cmds to the array instead of recursively calling `print`.
+ const cmds = [[rootIndent(), MODE_BREAK, doc]];
+ const out = [];
+ let shouldRemeasure = false;
+ let lineSuffix = [];
+
+ while (cmds.length !== 0) {
+ const x = cmds.pop();
+ const ind = x[0];
+ const mode = x[1];
+ const doc = x[2];
+
+ if (typeof doc === "string") {
+ out.push(doc);
+
+ pos += doc.length;
+ } else {
+ switch (doc.type) {
+ case "concat":
+ for (let i = doc.parts.length - 1; i >= 0; i--) {
+ cmds.push([ind, mode, doc.parts[i]]);
+ }
+
+ break;
+ case "indent":
+ cmds.push([makeIndent(ind), mode, doc.contents]);
+
+ break;
+ case "align":
+ cmds.push([makeAlign(ind, doc.n), mode, doc.contents]);
+
+ break;
+ case "group":
+ switch (mode) {
+ case MODE_FLAT:
+ if (!shouldRemeasure) {
+ cmds.push([
+ ind,
+ doc.break ? MODE_BREAK : MODE_FLAT,
+ doc.contents
+ ]);
+
+ break;
+ }
+ // fallthrough
+
+
+ case MODE_BREAK: {
+ shouldRemeasure = false;
+
+ const next = [ind, MODE_FLAT, doc.contents];
+ const rem = width - pos;
+
+ if (!doc.break && fits(next, cmds, rem)) {
+ cmds.push(next);
+ } else {
+ // Expanded states are a rare case where a document
+ // can manually provide multiple representations of
+ // itself. It provides an array of documents
+ // going from the least expanded (most flattened)
+ // representation first to the most expanded. If a
+ // group has these, we need to manually go through
+ // these states and find the first one that fits.
+ if (doc.expandedStates) {
+ const mostExpanded =
+ doc.expandedStates[doc.expandedStates.length - 1];
+
+ if (doc.break) {
+ cmds.push([ind, MODE_BREAK, mostExpanded]);
+
+ break;
+ } else {
+ for (let i = 1; i < doc.expandedStates.length + 1; i++) {
+ if (i >= doc.expandedStates.length) {
+ cmds.push([ind, MODE_BREAK, mostExpanded]);
+
+ break;
+ } else {
+ const state = doc.expandedStates[i];
+ const cmd = [ind, MODE_FLAT, state];
+
+ if (fits(cmd, cmds, rem)) {
+ cmds.push(cmd);
+
+ break;
+ }
+ }
+ }
+ }
+ } else {
+ cmds.push([ind, MODE_BREAK, doc.contents]);
+ }
+ }
+
+ break;
+ }
+ }
+ break;
+ // Fills each line with as much code as possible before moving to a new
+ // line with the same indentation.
+ //
+ // Expects doc.parts to be an array of alternating content and
+ // whitespace. The whitespace contains the linebreaks.
+ //
+ // For example:
+ // ["I", line, "love", line, "monkeys"]
+ // or
+ // [{ type: group, ... }, softline, { type: group, ... }]
+ //
+ // It uses this parts structure to handle three main layout cases:
+ // * The first two content items fit on the same line without
+ // breaking
+ // -> output the first content item and the whitespace "flat".
+ // * Only the first content item fits on the line without breaking
+ // -> output the first content item "flat" and the whitespace with
+ // "break".
+ // * Neither content item fits on the line without breaking
+ // -> output the first content item and the whitespace with "break".
+ case "fill": {
+ const rem = width - pos;
+
+ const parts = doc.parts;
+ if (parts.length === 0) {
+ break;
+ }
+
+ const content = parts[0];
+ const contentFlatCmd = [ind, MODE_FLAT, content];
+ const contentBreakCmd = [ind, MODE_BREAK, content];
+ const contentFits = fits(contentFlatCmd, [], width - rem, true);
+
+ if (parts.length === 1) {
+ if (contentFits) {
+ cmds.push(contentFlatCmd);
+ } else {
+ cmds.push(contentBreakCmd);
+ }
+ break;
+ }
+
+ const whitespace = parts[1];
+ const whitespaceFlatCmd = [ind, MODE_FLAT, whitespace];
+ const whitespaceBreakCmd = [ind, MODE_BREAK, whitespace];
+
+ if (parts.length === 2) {
+ if (contentFits) {
+ cmds.push(whitespaceFlatCmd);
+ cmds.push(contentFlatCmd);
+ } else {
+ cmds.push(whitespaceBreakCmd);
+ cmds.push(contentBreakCmd);
+ }
+ break;
+ }
+
+ const remaining = parts.slice(2);
+ const remainingCmd = [ind, mode, fill$2(remaining)];
+
+ const secondContent = parts[2];
+ const firstAndSecondContentFlatCmd = [
+ ind,
+ MODE_FLAT,
+ concat$3([content, whitespace, secondContent])
+ ];
+ const firstAndSecondContentFits = fits(
+ firstAndSecondContentFlatCmd,
+ [],
+ rem,
+ true
+ );
+
+ if (firstAndSecondContentFits) {
+ cmds.push(remainingCmd);
+ cmds.push(whitespaceFlatCmd);
+ cmds.push(contentFlatCmd);
+ } else if (contentFits) {
+ cmds.push(remainingCmd);
+ cmds.push(whitespaceBreakCmd);
+ cmds.push(contentFlatCmd);
+ } else {
+ cmds.push(remainingCmd);
+ cmds.push(whitespaceBreakCmd);
+ cmds.push(contentBreakCmd);
+ }
+ break;
+ }
+ case "if-break":
+ if (mode === MODE_BREAK) {
+ if (doc.breakContents) {
+ cmds.push([ind, mode, doc.breakContents]);
+ }
+ }
+ if (mode === MODE_FLAT) {
+ if (doc.flatContents) {
+ cmds.push([ind, mode, doc.flatContents]);
+ }
+ }
+
+ break;
+ case "line-suffix":
+ lineSuffix.push([ind, mode, doc.contents]);
+ break;
+ case "line-suffix-boundary":
+ if (lineSuffix.length > 0) {
+ cmds.push([ind, mode, { type: "line", hard: true }]);
+ }
+ break;
+ case "line":
+ switch (mode) {
+ case MODE_FLAT:
+ if (!doc.hard) {
+ if (!doc.soft) {
+ out.push(" ");
+
+ pos += 1;
+ }
+
+ break;
+ } else {
+ // This line was forced into the output even if we
+ // were in flattened mode, so we need to tell the next
+ // group that no matter what, it needs to remeasure
+ // because the previous measurement didn't accurately
+ // capture the entire expression (this is necessary
+ // for nested groups)
+ shouldRemeasure = true;
+ }
+ // fallthrough
+
+
+ case MODE_BREAK:
+ if (lineSuffix.length) {
+ cmds.push([ind, mode, doc]);
+ [].push.apply(cmds, lineSuffix.reverse());
+ lineSuffix = [];
+ break;
+ }
+
+ if (doc.literal) {
+ out.push(newLine);
+ pos = 0;
+ } else {
+ if (out.length > 0) {
+ // Trim whitespace at the end of line
+ while (
+ out.length > 0 &&
+ out[out.length - 1].match(/^[^\S\n]*$/)
+ ) {
+ out.pop();
+ }
+
+ if (out.length) {
+ out[out.length - 1] = out[out.length - 1].replace(
+ /[^\S\n]*$/,
+ ""
+ );
+ }
+ }
+
+ const length = ind.indent * options.tabWidth + ind.align.spaces;
+ const indentString = options.useTabs
+ ? "\t".repeat(ind.indent + ind.align.tabs)
+ : " ".repeat(length);
+ out.push(newLine + indentString);
+ pos = length;
+ }
+ break;
+ }
+ break;
+ default:
+ }
+ }
+ }
+ return out.join("");
+}
+
+var docPrinter = { printDocToString: printDocToString$1 };
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+
+var index$6 = function (str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+
+ return str.replace(matchOperatorsRe, '\\$&');
+};
+
+var index$8 = createCommonjsModule(function (module) {
+'use strict';
+
+function assembleStyles () {
+ var styles = {
+ modifiers: {
+ reset: [0, 0],
+ bold: [1, 22], // 21 isn't widely supported and 22 does the same thing
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ colors: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39]
+ },
+ bgColors: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49]
+ }
+ };
+
+ // fix humans
+ styles.colors.grey = styles.colors.gray;
+
+ Object.keys(styles).forEach(function (groupName) {
+ var group = styles[groupName];
+
+ Object.keys(group).forEach(function (styleName) {
+ var style = group[styleName];
+
+ styles[styleName] = group[styleName] = {
+ open: '\u001b[' + style[0] + 'm',
+ close: '\u001b[' + style[1] + 'm'
+ };
+ });
+
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
+ });
+
+ return styles;
+}
+
+Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+});
+});
+
+var index$12 = function () {
+ return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
+};
+
+var ansiRegex = index$12();
+
+var index$10 = function (str) {
+ return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
+};
+
+var ansiRegex$1 = index$12;
+var re = new RegExp(ansiRegex$1().source); // remove the `g` flag
+var index$14 = re.test.bind(re);
+
+var argv = process.argv;
+
+var terminator = argv.indexOf('--');
+var hasFlag = function (flag) {
+ flag = '--' + flag;
+ var pos = argv.indexOf(flag);
+ return pos !== -1 && (terminator !== -1 ? pos < terminator : true);
+};
+
+var index$16 = (function () {
+ if ('FORCE_COLOR' in process.env) {
+ return true;
+ }
+
+ if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ return false;
+ }
+
+ if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ return true;
+ }
+
+ if (process.stdout && !process.stdout.isTTY) {
+ return false;
+ }
+
+ if (process.platform === 'win32') {
+ return true;
+ }
+
+ if ('COLORTERM' in process.env) {
+ return true;
+ }
+
+ if (process.env.TERM === 'dumb') {
+ return false;
+ }
+
+ if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(process.env.TERM)) {
+ return true;
+ }
+
+ return false;
+})();
+
+var escapeStringRegexp = index$6;
+var ansiStyles = index$8;
+var stripAnsi = index$10;
+var hasAnsi = index$14;
+var supportsColor = index$16;
+var defineProps = Object.defineProperties;
+var isSimpleWindowsTerm = process.platform === 'win32' && !/^xterm/i.test(process.env.TERM);
+
+function Chalk(options) {
+ // detect mode if not set manually
+ this.enabled = !options || options.enabled === undefined ? supportsColor : options.enabled;
+}
+
+// use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+ ansiStyles.blue.open = '\u001b[94m';
+}
+
+var styles = (function () {
+ var ret = {};
+
+ Object.keys(ansiStyles).forEach(function (key) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+
+ ret[key] = {
+ get: function () {
+ return build.call(this, this._styles.concat(key));
+ }
+ };
+ });
+
+ return ret;
+})();
+
+var proto = defineProps(function chalk() {}, styles);
+
+function build(_styles) {
+ var builder = function () {
+ return applyStyle.apply(builder, arguments);
+ };
+
+ builder._styles = _styles;
+ builder.enabled = this.enabled;
+ // __proto__ is used because we must return a function, but there is
+ // no way to create a function with a different prototype.
+ /* eslint-disable no-proto */
+ builder.__proto__ = proto;
+
+ return builder;
+}
+
+function applyStyle() {
+ // support varags, but simply cast to string in case there's only one arg
+ var args = arguments;
+ var argsLen = args.length;
+ var str = argsLen !== 0 && String(arguments[0]);
+
+ if (argsLen > 1) {
+ // don't slice `arguments`, it prevents v8 optimizations
+ for (var a = 1; a < argsLen; a++) {
+ str += ' ' + args[a];
+ }
+ }
+
+ if (!this.enabled || !str) {
+ return str;
+ }
+
+ var nestedStyles = this._styles;
+ var i = nestedStyles.length;
+
+ // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
+ // see https://github.com/chalk/chalk/issues/58
+ // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
+ var originalDim = ansiStyles.dim.open;
+ if (isSimpleWindowsTerm && (nestedStyles.indexOf('gray') !== -1 || nestedStyles.indexOf('grey') !== -1)) {
+ ansiStyles.dim.open = '';
+ }
+
+ while (i--) {
+ var code = ansiStyles[nestedStyles[i]];
+
+ // Replace any instances already present with a re-opening code
+ // otherwise only the part of the string until said closing code
+ // will be colored, and the rest will simply be 'plain'.
+ str = code.open + str.replace(code.closeRe, code.open) + code.close;
+ }
+
+ // Reset the original 'dim' if we changed it to work around the Windows dimmed gray issue.
+ ansiStyles.dim.open = originalDim;
+
+ return str;
+}
+
+function init() {
+ var ret = {};
+
+ Object.keys(styles).forEach(function (name) {
+ ret[name] = {
+ get: function () {
+ return build.call(this, [name]);
+ }
+ };
+ });
+
+ return ret;
+}
+
+defineProps(Chalk.prototype, init());
+
+var index$4 = new Chalk();
+var styles_1 = ansiStyles;
+var hasColor = hasAnsi;
+var stripColor = stripAnsi;
+var supportsColor_1 = supportsColor;
+
+index$4.styles = styles_1;
+index$4.hasColor = hasColor;
+index$4.stripColor = stripColor;
+index$4.supportsColor = supportsColor_1;
+
+var index$24 = {
+ "aliceblue": [240, 248, 255],
+ "antiquewhite": [250, 235, 215],
+ "aqua": [0, 255, 255],
+ "aquamarine": [127, 255, 212],
+ "azure": [240, 255, 255],
+ "beige": [245, 245, 220],
+ "bisque": [255, 228, 196],
+ "black": [0, 0, 0],
+ "blanchedalmond": [255, 235, 205],
+ "blue": [0, 0, 255],
+ "blueviolet": [138, 43, 226],
+ "brown": [165, 42, 42],
+ "burlywood": [222, 184, 135],
+ "cadetblue": [95, 158, 160],
+ "chartreuse": [127, 255, 0],
+ "chocolate": [210, 105, 30],
+ "coral": [255, 127, 80],
+ "cornflowerblue": [100, 149, 237],
+ "cornsilk": [255, 248, 220],
+ "crimson": [220, 20, 60],
+ "cyan": [0, 255, 255],
+ "darkblue": [0, 0, 139],
+ "darkcyan": [0, 139, 139],
+ "darkgoldenrod": [184, 134, 11],
+ "darkgray": [169, 169, 169],
+ "darkgreen": [0, 100, 0],
+ "darkgrey": [169, 169, 169],
+ "darkkhaki": [189, 183, 107],
+ "darkmagenta": [139, 0, 139],
+ "darkolivegreen": [85, 107, 47],
+ "darkorange": [255, 140, 0],
+ "darkorchid": [153, 50, 204],
+ "darkred": [139, 0, 0],
+ "darksalmon": [233, 150, 122],
+ "darkseagreen": [143, 188, 143],
+ "darkslateblue": [72, 61, 139],
+ "darkslategray": [47, 79, 79],
+ "darkslategrey": [47, 79, 79],
+ "darkturquoise": [0, 206, 209],
+ "darkviolet": [148, 0, 211],
+ "deeppink": [255, 20, 147],
+ "deepskyblue": [0, 191, 255],
+ "dimgray": [105, 105, 105],
+ "dimgrey": [105, 105, 105],
+ "dodgerblue": [30, 144, 255],
+ "firebrick": [178, 34, 34],
+ "floralwhite": [255, 250, 240],
+ "forestgreen": [34, 139, 34],
+ "fuchsia": [255, 0, 255],
+ "gainsboro": [220, 220, 220],
+ "ghostwhite": [248, 248, 255],
+ "gold": [255, 215, 0],
+ "goldenrod": [218, 165, 32],
+ "gray": [128, 128, 128],
+ "green": [0, 128, 0],
+ "greenyellow": [173, 255, 47],
+ "grey": [128, 128, 128],
+ "honeydew": [240, 255, 240],
+ "hotpink": [255, 105, 180],
+ "indianred": [205, 92, 92],
+ "indigo": [75, 0, 130],
+ "ivory": [255, 255, 240],
+ "khaki": [240, 230, 140],
+ "lavender": [230, 230, 250],
+ "lavenderblush": [255, 240, 245],
+ "lawngreen": [124, 252, 0],
+ "lemonchiffon": [255, 250, 205],
+ "lightblue": [173, 216, 230],
+ "lightcoral": [240, 128, 128],
+ "lightcyan": [224, 255, 255],
+ "lightgoldenrodyellow": [250, 250, 210],
+ "lightgray": [211, 211, 211],
+ "lightgreen": [144, 238, 144],
+ "lightgrey": [211, 211, 211],
+ "lightpink": [255, 182, 193],
+ "lightsalmon": [255, 160, 122],
+ "lightseagreen": [32, 178, 170],
+ "lightskyblue": [135, 206, 250],
+ "lightslategray": [119, 136, 153],
+ "lightslategrey": [119, 136, 153],
+ "lightsteelblue": [176, 196, 222],
+ "lightyellow": [255, 255, 224],
+ "lime": [0, 255, 0],
+ "limegreen": [50, 205, 50],
+ "linen": [250, 240, 230],
+ "magenta": [255, 0, 255],
+ "maroon": [128, 0, 0],
+ "mediumaquamarine": [102, 205, 170],
+ "mediumblue": [0, 0, 205],
+ "mediumorchid": [186, 85, 211],
+ "mediumpurple": [147, 112, 219],
+ "mediumseagreen": [60, 179, 113],
+ "mediumslateblue": [123, 104, 238],
+ "mediumspringgreen": [0, 250, 154],
+ "mediumturquoise": [72, 209, 204],
+ "mediumvioletred": [199, 21, 133],
+ "midnightblue": [25, 25, 112],
+ "mintcream": [245, 255, 250],
+ "mistyrose": [255, 228, 225],
+ "moccasin": [255, 228, 181],
+ "navajowhite": [255, 222, 173],
+ "navy": [0, 0, 128],
+ "oldlace": [253, 245, 230],
+ "olive": [128, 128, 0],
+ "olivedrab": [107, 142, 35],
+ "orange": [255, 165, 0],
+ "orangered": [255, 69, 0],
+ "orchid": [218, 112, 214],
+ "palegoldenrod": [238, 232, 170],
+ "palegreen": [152, 251, 152],
+ "paleturquoise": [175, 238, 238],
+ "palevioletred": [219, 112, 147],
+ "papayawhip": [255, 239, 213],
+ "peachpuff": [255, 218, 185],
+ "peru": [205, 133, 63],
+ "pink": [255, 192, 203],
+ "plum": [221, 160, 221],
+ "powderblue": [176, 224, 230],
+ "purple": [128, 0, 128],
+ "rebeccapurple": [102, 51, 153],
+ "red": [255, 0, 0],
+ "rosybrown": [188, 143, 143],
+ "royalblue": [65, 105, 225],
+ "saddlebrown": [139, 69, 19],
+ "salmon": [250, 128, 114],
+ "sandybrown": [244, 164, 96],
+ "seagreen": [46, 139, 87],
+ "seashell": [255, 245, 238],
+ "sienna": [160, 82, 45],
+ "silver": [192, 192, 192],
+ "skyblue": [135, 206, 235],
+ "slateblue": [106, 90, 205],
+ "slategray": [112, 128, 144],
+ "slategrey": [112, 128, 144],
+ "snow": [255, 250, 250],
+ "springgreen": [0, 255, 127],
+ "steelblue": [70, 130, 180],
+ "tan": [210, 180, 140],
+ "teal": [0, 128, 128],
+ "thistle": [216, 191, 216],
+ "tomato": [255, 99, 71],
+ "turquoise": [64, 224, 208],
+ "violet": [238, 130, 238],
+ "wheat": [245, 222, 179],
+ "white": [255, 255, 255],
+ "whitesmoke": [245, 245, 245],
+ "yellow": [255, 255, 0],
+ "yellowgreen": [154, 205, 50]
+};
+
+var conversions$1 = createCommonjsModule(function (module) {
+/* MIT license */
+var cssKeywords = index$24;
+
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+// values that give correct `typeof` results).
+// do not use box values types (i.e. Number(), String(), etc.)
+
+var reverseKeywords = {};
+for (var key in cssKeywords) {
+ if (cssKeywords.hasOwnProperty(key)) {
+ reverseKeywords[cssKeywords[key]] = key;
+ }
+}
+
+var convert = module.exports = {
+ rgb: {channels: 3, labels: 'rgb'},
+ hsl: {channels: 3, labels: 'hsl'},
+ hsv: {channels: 3, labels: 'hsv'},
+ hwb: {channels: 3, labels: 'hwb'},
+ cmyk: {channels: 4, labels: 'cmyk'},
+ xyz: {channels: 3, labels: 'xyz'},
+ lab: {channels: 3, labels: 'lab'},
+ lch: {channels: 3, labels: 'lch'},
+ hex: {channels: 1, labels: ['hex']},
+ keyword: {channels: 1, labels: ['keyword']},
+ ansi16: {channels: 1, labels: ['ansi16']},
+ ansi256: {channels: 1, labels: ['ansi256']},
+ hcg: {channels: 3, labels: ['h', 'c', 'g']},
+ apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
+ gray: {channels: 1, labels: ['gray']}
+};
+
+// hide .channels and .labels properties
+for (var model in convert) {
+ if (convert.hasOwnProperty(model)) {
+ if (!('channels' in convert[model])) {
+ throw new Error('missing channels property: ' + model);
+ }
+
+ if (!('labels' in convert[model])) {
+ throw new Error('missing channel labels property: ' + model);
+ }
+
+ if (convert[model].labels.length !== convert[model].channels) {
+ throw new Error('channel and label counts mismatch: ' + model);
+ }
+
+ var channels = convert[model].channels;
+ var labels = convert[model].labels;
+ delete convert[model].channels;
+ delete convert[model].labels;
+ Object.defineProperty(convert[model], 'channels', {value: channels});
+ Object.defineProperty(convert[model], 'labels', {value: labels});
+ }
+}
+
+convert.rgb.hsl = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var min = Math.min(r, g, b);
+ var max = Math.max(r, g, b);
+ var delta = max - min;
+ var h;
+ var s;
+ var l;
+
+ if (max === min) {
+ h = 0;
+ } else if (r === max) {
+ h = (g - b) / delta;
+ } else if (g === max) {
+ h = 2 + (b - r) / delta;
+ } else if (b === max) {
+ h = 4 + (r - g) / delta;
+ }
+
+ h = Math.min(h * 60, 360);
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ l = (min + max) / 2;
+
+ if (max === min) {
+ s = 0;
+ } else if (l <= 0.5) {
+ s = delta / (max + min);
+ } else {
+ s = delta / (2 - max - min);
+ }
+
+ return [h, s * 100, l * 100];
+};
+
+convert.rgb.hsv = function (rgb) {
+ var r = rgb[0];
+ var g = rgb[1];
+ var b = rgb[2];
+ var min = Math.min(r, g, b);
+ var max = Math.max(r, g, b);
+ var delta = max - min;
+ var h;
+ var s;
+ var v;
+
+ if (max === 0) {
+ s = 0;
+ } else {
+ s = (delta / max * 1000) / 10;
+ }
+
+ if (max === min) {
+ h = 0;
+ } else if (r === max) {
+ h = (g - b) / delta;
+ } else if (g === max) {
+ h = 2 + (b - r) / delta;
+ } else if (b === max) {
+ h = 4 + (r - g) / delta;
+ }
+
+ h = Math.min(h * 60, 360);
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ v = ((max / 255) * 1000) / 10;
+
+ return [h, s, v];
+};
+
+convert.rgb.hwb = function (rgb) {
+ var r = rgb[0];
+ var g = rgb[1];
+ var b = rgb[2];
+ var h = convert.rgb.hsl(rgb)[0];
+ var w = 1 / 255 * Math.min(r, Math.min(g, b));
+
+ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+
+ return [h, w * 100, b * 100];
+};
+
+convert.rgb.cmyk = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var c;
+ var m;
+ var y;
+ var k;
+
+ k = Math.min(1 - r, 1 - g, 1 - b);
+ c = (1 - r - k) / (1 - k) || 0;
+ m = (1 - g - k) / (1 - k) || 0;
+ y = (1 - b - k) / (1 - k) || 0;
+
+ return [c * 100, m * 100, y * 100, k * 100];
+};
+
+/**
+ * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+ * */
+function comparativeDistance(x, y) {
+ return (
+ Math.pow(x[0] - y[0], 2) +
+ Math.pow(x[1] - y[1], 2) +
+ Math.pow(x[2] - y[2], 2)
+ );
+}
+
+convert.rgb.keyword = function (rgb) {
+ var reversed = reverseKeywords[rgb];
+ if (reversed) {
+ return reversed;
+ }
+
+ var currentClosestDistance = Infinity;
+ var currentClosestKeyword;
+
+ for (var keyword in cssKeywords) {
+ if (cssKeywords.hasOwnProperty(keyword)) {
+ var value = cssKeywords[keyword];
+
+ // Compute comparative distance
+ var distance = comparativeDistance(rgb, value);
+
+ // Check if its less, if so set as closest
+ if (distance < currentClosestDistance) {
+ currentClosestDistance = distance;
+ currentClosestKeyword = keyword;
+ }
+ }
+ }
+
+ return currentClosestKeyword;
+};
+
+convert.keyword.rgb = function (keyword) {
+ return cssKeywords[keyword];
+};
+
+convert.rgb.xyz = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+
+ // assume sRGB
+ r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
+ g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
+ b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
+
+ var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+ var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+ var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+
+ return [x * 100, y * 100, z * 100];
+};
+
+convert.rgb.lab = function (rgb) {
+ var xyz = convert.rgb.xyz(rgb);
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+
+ x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
+ y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
+ z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
+
+ l = (116 * y) - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
+
+ return [l, a, b];
+};
+
+convert.hsl.rgb = function (hsl) {
+ var h = hsl[0] / 360;
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var t1;
+ var t2;
+ var t3;
+ var rgb;
+ var val;
+
+ if (s === 0) {
+ val = l * 255;
+ return [val, val, val];
+ }
+
+ if (l < 0.5) {
+ t2 = l * (1 + s);
+ } else {
+ t2 = l + s - l * s;
+ }
+
+ t1 = 2 * l - t2;
+
+ rgb = [0, 0, 0];
+ for (var i = 0; i < 3; i++) {
+ t3 = h + 1 / 3 * -(i - 1);
+ if (t3 < 0) {
+ t3++;
+ }
+ if (t3 > 1) {
+ t3--;
+ }
+
+ if (6 * t3 < 1) {
+ val = t1 + (t2 - t1) * 6 * t3;
+ } else if (2 * t3 < 1) {
+ val = t2;
+ } else if (3 * t3 < 2) {
+ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+ } else {
+ val = t1;
+ }
+
+ rgb[i] = val * 255;
+ }
+
+ return rgb;
+};
+
+convert.hsl.hsv = function (hsl) {
+ var h = hsl[0];
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var smin = s;
+ var lmin = Math.max(l, 0.01);
+ var sv;
+ var v;
+
+ l *= 2;
+ s *= (l <= 1) ? l : 2 - l;
+ smin *= lmin <= 1 ? lmin : 2 - lmin;
+ v = (l + s) / 2;
+ sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
+
+ return [h, sv * 100, v * 100];
+};
+
+convert.hsv.rgb = function (hsv) {
+ var h = hsv[0] / 60;
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var hi = Math.floor(h) % 6;
+
+ var f = h - Math.floor(h);
+ var p = 255 * v * (1 - s);
+ var q = 255 * v * (1 - (s * f));
+ var t = 255 * v * (1 - (s * (1 - f)));
+ v *= 255;
+
+ switch (hi) {
+ case 0:
+ return [v, t, p];
+ case 1:
+ return [q, v, p];
+ case 2:
+ return [p, v, t];
+ case 3:
+ return [p, q, v];
+ case 4:
+ return [t, p, v];
+ case 5:
+ return [v, p, q];
+ }
+};
+
+convert.hsv.hsl = function (hsv) {
+ var h = hsv[0];
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var vmin = Math.max(v, 0.01);
+ var lmin;
+ var sl;
+ var l;
+
+ l = (2 - s) * v;
+ lmin = (2 - s) * vmin;
+ sl = s * vmin;
+ sl /= (lmin <= 1) ? lmin : 2 - lmin;
+ sl = sl || 0;
+ l /= 2;
+
+ return [h, sl * 100, l * 100];
+};
+
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert.hwb.rgb = function (hwb) {
+ var h = hwb[0] / 360;
+ var wh = hwb[1] / 100;
+ var bl = hwb[2] / 100;
+ var ratio = wh + bl;
+ var i;
+ var v;
+ var f;
+ var n;
+
+ // wh + bl cant be > 1
+ if (ratio > 1) {
+ wh /= ratio;
+ bl /= ratio;
+ }
+
+ i = Math.floor(6 * h);
+ v = 1 - bl;
+ f = 6 * h - i;
+
+ if ((i & 0x01) !== 0) {
+ f = 1 - f;
+ }
+
+ n = wh + f * (v - wh); // linear interpolation
+
+ var r;
+ var g;
+ var b;
+ switch (i) {
+ default:
+ case 6:
+ case 0: r = v; g = n; b = wh; break;
+ case 1: r = n; g = v; b = wh; break;
+ case 2: r = wh; g = v; b = n; break;
+ case 3: r = wh; g = n; b = v; break;
+ case 4: r = n; g = wh; b = v; break;
+ case 5: r = v; g = wh; b = n; break;
+ }
+
+ return [r * 255, g * 255, b * 255];
+};
+
+convert.cmyk.rgb = function (cmyk) {
+ var c = cmyk[0] / 100;
+ var m = cmyk[1] / 100;
+ var y = cmyk[2] / 100;
+ var k = cmyk[3] / 100;
+ var r;
+ var g;
+ var b;
+
+ r = 1 - Math.min(1, c * (1 - k) + k);
+ g = 1 - Math.min(1, m * (1 - k) + k);
+ b = 1 - Math.min(1, y * (1 - k) + k);
+
+ return [r * 255, g * 255, b * 255];
+};
+
+convert.xyz.rgb = function (xyz) {
+ var x = xyz[0] / 100;
+ var y = xyz[1] / 100;
+ var z = xyz[2] / 100;
+ var r;
+ var g;
+ var b;
+
+ r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+ g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+ b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+
+ // assume sRGB
+ r = r > 0.0031308
+ ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
+ : r * 12.92;
+
+ g = g > 0.0031308
+ ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
+ : g * 12.92;
+
+ b = b > 0.0031308
+ ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
+ : b * 12.92;
+
+ r = Math.min(Math.max(0, r), 1);
+ g = Math.min(Math.max(0, g), 1);
+ b = Math.min(Math.max(0, b), 1);
+
+ return [r * 255, g * 255, b * 255];
+};
+
+convert.xyz.lab = function (xyz) {
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+
+ x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
+ y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
+ z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
+
+ l = (116 * y) - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
+
+ return [l, a, b];
+};
+
+convert.lab.xyz = function (lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var x;
+ var y;
+ var z;
+
+ y = (l + 16) / 116;
+ x = a / 500 + y;
+ z = y - b / 200;
+
+ var y2 = Math.pow(y, 3);
+ var x2 = Math.pow(x, 3);
+ var z2 = Math.pow(z, 3);
+ y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+ x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+ z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+
+ x *= 95.047;
+ y *= 100;
+ z *= 108.883;
+
+ return [x, y, z];
+};
+
+convert.lab.lch = function (lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var hr;
+ var h;
+ var c;
+
+ hr = Math.atan2(b, a);
+ h = hr * 360 / 2 / Math.PI;
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ c = Math.sqrt(a * a + b * b);
+
+ return [l, c, h];
+};
+
+convert.lch.lab = function (lch) {
+ var l = lch[0];
+ var c = lch[1];
+ var h = lch[2];
+ var a;
+ var b;
+ var hr;
+
+ hr = h / 360 * 2 * Math.PI;
+ a = c * Math.cos(hr);
+ b = c * Math.sin(hr);
+
+ return [l, a, b];
+};
+
+convert.rgb.ansi16 = function (args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
+ var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
+
+ value = Math.round(value / 50);
+
+ if (value === 0) {
+ return 30;
+ }
+
+ var ansi = 30
+ + ((Math.round(b / 255) << 2)
+ | (Math.round(g / 255) << 1)
+ | Math.round(r / 255));
+
+ if (value === 2) {
+ ansi += 60;
+ }
+
+ return ansi;
+};
+
+convert.hsv.ansi16 = function (args) {
+ // optimization here; we already know the value and don't need to get
+ // it converted for us.
+ return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+};
+
+convert.rgb.ansi256 = function (args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
+
+ // we use the extended greyscale palette here, with the exception of
+ // black and white. normal palette only has 4 greyscale shades.
+ if (r === g && g === b) {
+ if (r < 8) {
+ return 16;
+ }
+
+ if (r > 248) {
+ return 231;
+ }
+
+ return Math.round(((r - 8) / 247) * 24) + 232;
+ }
+
+ var ansi = 16
+ + (36 * Math.round(r / 255 * 5))
+ + (6 * Math.round(g / 255 * 5))
+ + Math.round(b / 255 * 5);
+
+ return ansi;
+};
+
+convert.ansi16.rgb = function (args) {
+ var color = args % 10;
+
+ // handle greyscale
+ if (color === 0 || color === 7) {
+ if (args > 50) {
+ color += 3.5;
+ }
+
+ color = color / 10.5 * 255;
+
+ return [color, color, color];
+ }
+
+ var mult = (~~(args > 50) + 1) * 0.5;
+ var r = ((color & 1) * mult) * 255;
+ var g = (((color >> 1) & 1) * mult) * 255;
+ var b = (((color >> 2) & 1) * mult) * 255;
+
+ return [r, g, b];
+};
+
+convert.ansi256.rgb = function (args) {
+ // handle greyscale
+ if (args >= 232) {
+ var c = (args - 232) * 10 + 8;
+ return [c, c, c];
+ }
+
+ args -= 16;
+
+ var rem;
+ var r = Math.floor(args / 36) / 5 * 255;
+ var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+ var b = (rem % 6) / 5 * 255;
+
+ return [r, g, b];
+};
+
+convert.rgb.hex = function (args) {
+ var integer = ((Math.round(args[0]) & 0xFF) << 16)
+ + ((Math.round(args[1]) & 0xFF) << 8)
+ + (Math.round(args[2]) & 0xFF);
+
+ var string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+};
+
+convert.hex.rgb = function (args) {
+ var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+ if (!match) {
+ return [0, 0, 0];
+ }
+
+ var colorString = match[0];
+
+ if (match[0].length === 3) {
+ colorString = colorString.split('').map(function (char) {
+ return char + char;
+ }).join('');
+ }
+
+ var integer = parseInt(colorString, 16);
+ var r = (integer >> 16) & 0xFF;
+ var g = (integer >> 8) & 0xFF;
+ var b = integer & 0xFF;
+
+ return [r, g, b];
+};
+
+convert.rgb.hcg = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var max = Math.max(Math.max(r, g), b);
+ var min = Math.min(Math.min(r, g), b);
+ var chroma = (max - min);
+ var grayscale;
+ var hue;
+
+ if (chroma < 1) {
+ grayscale = min / (1 - chroma);
+ } else {
+ grayscale = 0;
+ }
+
+ if (chroma <= 0) {
+ hue = 0;
+ } else
+ if (max === r) {
+ hue = ((g - b) / chroma) % 6;
+ } else
+ if (max === g) {
+ hue = 2 + (b - r) / chroma;
+ } else {
+ hue = 4 + (r - g) / chroma + 4;
+ }
+
+ hue /= 6;
+ hue %= 1;
+
+ return [hue * 360, chroma * 100, grayscale * 100];
+};
+
+convert.hsl.hcg = function (hsl) {
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var c = 1;
+ var f = 0;
+
+ if (l < 0.5) {
+ c = 2.0 * s * l;
+ } else {
+ c = 2.0 * s * (1.0 - l);
+ }
+
+ if (c < 1.0) {
+ f = (l - 0.5 * c) / (1.0 - c);
+ }
+
+ return [hsl[0], c * 100, f * 100];
+};
+
+convert.hsv.hcg = function (hsv) {
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+
+ var c = s * v;
+ var f = 0;
+
+ if (c < 1.0) {
+ f = (v - c) / (1 - c);
+ }
+
+ return [hsv[0], c * 100, f * 100];
+};
+
+convert.hcg.rgb = function (hcg) {
+ var h = hcg[0] / 360;
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+
+ if (c === 0.0) {
+ return [g * 255, g * 255, g * 255];
+ }
+
+ var pure = [0, 0, 0];
+ var hi = (h % 1) * 6;
+ var v = hi % 1;
+ var w = 1 - v;
+ var mg = 0;
+
+ switch (Math.floor(hi)) {
+ case 0:
+ pure[0] = 1; pure[1] = v; pure[2] = 0; break;
+ case 1:
+ pure[0] = w; pure[1] = 1; pure[2] = 0; break;
+ case 2:
+ pure[0] = 0; pure[1] = 1; pure[2] = v; break;
+ case 3:
+ pure[0] = 0; pure[1] = w; pure[2] = 1; break;
+ case 4:
+ pure[0] = v; pure[1] = 0; pure[2] = 1; break;
+ default:
+ pure[0] = 1; pure[1] = 0; pure[2] = w;
+ }
+
+ mg = (1.0 - c) * g;
+
+ return [
+ (c * pure[0] + mg) * 255,
+ (c * pure[1] + mg) * 255,
+ (c * pure[2] + mg) * 255
+ ];
+};
+
+convert.hcg.hsv = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+
+ var v = c + g * (1.0 - c);
+ var f = 0;
+
+ if (v > 0.0) {
+ f = c / v;
+ }
+
+ return [hcg[0], f * 100, v * 100];
+};
+
+convert.hcg.hsl = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+
+ var l = g * (1.0 - c) + 0.5 * c;
+ var s = 0;
+
+ if (l > 0.0 && l < 0.5) {
+ s = c / (2 * l);
+ } else
+ if (l >= 0.5 && l < 1.0) {
+ s = c / (2 * (1 - l));
+ }
+
+ return [hcg[0], s * 100, l * 100];
+};
+
+convert.hcg.hwb = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var v = c + g * (1.0 - c);
+ return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
+
+convert.hwb.hcg = function (hwb) {
+ var w = hwb[1] / 100;
+ var b = hwb[2] / 100;
+ var v = 1 - b;
+ var c = v - w;
+ var g = 0;
+
+ if (c < 1) {
+ g = (v - c) / (1 - c);
+ }
+
+ return [hwb[0], c * 100, g * 100];
+};
+
+convert.apple.rgb = function (apple) {
+ return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
+};
+
+convert.rgb.apple = function (rgb) {
+ return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
+};
+
+convert.gray.rgb = function (args) {
+ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+};
+
+convert.gray.hsl = convert.gray.hsv = function (args) {
+ return [0, 0, args[0]];
+};
+
+convert.gray.hwb = function (gray) {
+ return [0, 100, gray[0]];
+};
+
+convert.gray.cmyk = function (gray) {
+ return [0, 0, 0, gray[0]];
+};
+
+convert.gray.lab = function (gray) {
+ return [gray[0], 0, 0];
+};
+
+convert.gray.hex = function (gray) {
+ var val = Math.round(gray[0] / 100 * 255) & 0xFF;
+ var integer = (val << 16) + (val << 8) + val;
+
+ var string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+};
+
+convert.rgb.gray = function (rgb) {
+ var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+ return [val / 255 * 100];
+};
+});
+
+var conversions$3 = conversions$1;
+
+/*
+ this function routes a model to all other models.
+
+ all functions that are routed have a property `.conversion` attached
+ to the returned synthetic function. This property is an array
+ of strings, each with the steps in between the 'from' and 'to'
+ color models (inclusive).
+
+ conversions that are not possible simply are not included.
+*/
+
+// https://jsperf.com/object-keys-vs-for-in-with-closure/3
+var models$1 = Object.keys(conversions$3);
+
+function buildGraph() {
+ var graph = {};
+
+ for (var len = models$1.length, i = 0; i < len; i++) {
+ graph[models$1[i]] = {
+ // http://jsperf.com/1-vs-infinity
+ // micro-opt, but this is simple.
+ distance: -1,
+ parent: null
+ };
+ }
+
+ return graph;
+}
+
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS(fromModel) {
+ var graph = buildGraph();
+ var queue = [fromModel]; // unshift -> queue -> pop
+
+ graph[fromModel].distance = 0;
+
+ while (queue.length) {
+ var current = queue.pop();
+ var adjacents = Object.keys(conversions$3[current]);
+
+ for (var len = adjacents.length, i = 0; i < len; i++) {
+ var adjacent = adjacents[i];
+ var node = graph[adjacent];
+
+ if (node.distance === -1) {
+ node.distance = graph[current].distance + 1;
+ node.parent = current;
+ queue.unshift(adjacent);
+ }
+ }
+ }
+
+ return graph;
+}
+
+function link(from, to) {
+ return function (args) {
+ return to(from(args));
+ };
+}
+
+function wrapConversion(toModel, graph) {
+ var path = [graph[toModel].parent, toModel];
+ var fn = conversions$3[graph[toModel].parent][toModel];
+
+ var cur = graph[toModel].parent;
+ while (graph[cur].parent) {
+ path.unshift(graph[cur].parent);
+ fn = link(conversions$3[graph[cur].parent][cur], fn);
+ cur = graph[cur].parent;
+ }
+
+ fn.conversion = path;
+ return fn;
+}
+
+var route$1 = function (fromModel) {
+ var graph = deriveBFS(fromModel);
+ var conversion = {};
+
+ var models = Object.keys(graph);
+ for (var len = models.length, i = 0; i < len; i++) {
+ var toModel = models[i];
+ var node = graph[toModel];
+
+ if (node.parent === null) {
+ // no possible conversion, or this node is the source model.
+ continue;
+ }
+
+ conversion[toModel] = wrapConversion(toModel, graph);
+ }
+
+ return conversion;
+};
+
+var conversions = conversions$1;
+var route = route$1;
+
+var convert = {};
+
+var models = Object.keys(conversions);
+
+function wrapRaw(fn) {
+ var wrappedFn = function (args) {
+ if (args === undefined || args === null) {
+ return args;
+ }
+
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
+
+ return fn(args);
+ };
+
+ // preserve .conversion property if there is one
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+
+ return wrappedFn;
+}
+
+function wrapRounded(fn) {
+ var wrappedFn = function (args) {
+ if (args === undefined || args === null) {
+ return args;
+ }
+
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
+
+ var result = fn(args);
+
+ // we're assuming the result is an array here.
+ // see notice in conversions.js; don't use box types
+ // in conversion functions.
+ if (typeof result === 'object') {
+ for (var len = result.length, i = 0; i < len; i++) {
+ result[i] = Math.round(result[i]);
+ }
+ }
+
+ return result;
+ };
+
+ // preserve .conversion property if there is one
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+
+ return wrappedFn;
+}
+
+models.forEach(function (fromModel) {
+ convert[fromModel] = {};
+
+ Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
+ Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
+
+ var routes = route(fromModel);
+ var routeModels = Object.keys(routes);
+
+ routeModels.forEach(function (toModel) {
+ var fn = routes[toModel];
+
+ convert[fromModel][toModel] = wrapRounded(fn);
+ convert[fromModel][toModel].raw = wrapRaw(fn);
+ });
+});
+
+var index$22 = convert;
+
+var index$20 = createCommonjsModule(function (module) {
+'use strict';
+const colorConvert = index$22;
+
+const wrapAnsi16 = (fn, offset) => function () {
+ const code = fn.apply(colorConvert, arguments);
+ return `\u001B[${code + offset}m`;
+};
+
+const wrapAnsi256 = (fn, offset) => function () {
+ const code = fn.apply(colorConvert, arguments);
+ return `\u001B[${38 + offset};5;${code}m`;
+};
+
+const wrapAnsi16m = (fn, offset) => function () {
+ const rgb = fn.apply(colorConvert, arguments);
+ return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
+
+function assembleStyles() {
+ const styles = {
+ modifier: {
+ reset: [0, 0],
+ // 21 isn't widely supported and 22 does the same thing
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ color: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39]
+ },
+ bgColor: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49]
+ }
+ };
+
+ // fix humans
+ styles.color.grey = styles.color.gray;
+
+ Object.keys(styles).forEach(groupName => {
+ const group = styles[groupName];
+
+ Object.keys(group).forEach(styleName => {
+ const style = group[styleName];
+
+ styles[styleName] = group[styleName] = {
+ open: `\u001B[${style[0]}m`,
+ close: `\u001B[${style[1]}m`
+ };
+ });
+
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
+ });
+
+ const rgb2rgb = (r, g, b) => [r, g, b];
+
+ styles.color.close = '\u001B[39m';
+ styles.bgColor.close = '\u001B[49m';
+
+ styles.color.ansi = {};
+ styles.color.ansi256 = {};
+ styles.color.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 0)
+ };
+
+ styles.bgColor.ansi = {};
+ styles.bgColor.ansi256 = {};
+ styles.bgColor.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 10)
+ };
+
+ for (const key of Object.keys(colorConvert)) {
+ if (typeof colorConvert[key] !== 'object') {
+ continue;
+ }
+
+ const suite = colorConvert[key];
+
+ if ('ansi16' in suite) {
+ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+ }
+
+ if ('ansi256' in suite) {
+ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+ }
+
+ if ('rgb' in suite) {
+ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+ }
+ }
+
+ return styles;
+}
+
+Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+});
+});
+
+const asymmetricMatcher = Symbol.for('jest.asymmetricMatcher'); /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const SPACE = ' ';class ArrayContaining extends Array {}class ObjectContaining extends Object {}const print$1 = (val, print,
+indent,
+opts,
+colors) =>
+{
+ const stringedValue = val.toString();
+
+ if (stringedValue === 'ArrayContaining') {
+ const array = ArrayContaining.from(val.sample);
+ return opts.spacing === SPACE ?
+ stringedValue + SPACE + print(array) :
+ print(array);
+ }
+
+ if (stringedValue === 'ObjectContaining') {
+ const object = Object.assign(new ObjectContaining(), val.sample);
+ return opts.spacing === SPACE ?
+ stringedValue + SPACE + print(object) :
+ print(object);
+ }
+
+ if (stringedValue === 'StringMatching') {
+ return stringedValue + SPACE + print(val.sample);
+ }
+
+ if (stringedValue === 'StringContaining') {
+ return stringedValue + SPACE + print(val.sample);
+ }
+
+ return val.toAsymmetricMatcher();
+};
+
+const test = object => object && object.$$typeof === asymmetricMatcher;
+
+var AsymmetricMatcher = { print: print$1, test };
+
+const ansiRegex$2 = index$12; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const toHumanReadableAnsi = text => {const style = index$20;return text.replace(ansiRegex$2(), (match, offset, string) => {switch (match) {case style.red.close:case style.green.close:case style.reset.open:
+ case style.reset.close:
+ return '';
+ case style.red.open:
+ return '';
+ case style.green.open:
+ return '';
+ case style.dim.open:
+ return '';
+ case style.bold.open:
+ return '';
+ default:
+ return '';}
+
+ });
+};
+
+const test$1 = value =>
+typeof value === 'string' && value.match(ansiRegex$2());
+
+const print$2 = (
+val,
+print,
+indent,
+opts,
+colors) =>
+print(toHumanReadableAnsi(val));
+
+var ConvertAnsi = { print: print$2, test: test$1 };
+
+function escapeHTML$1(str) {
+ return str.replace(//g, '>');
+}
+
+var escapeHTML_1 = escapeHTML$1;
+
+const escapeHTML = escapeHTML_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const HTML_ELEMENT_REGEXP = /(HTML\w*?Element)|Text|Comment/;
+const test$2 = isHTMLElement;
+
+function isHTMLElement(value) {
+ return (
+ value !== undefined &&
+ value !== null && (
+ value.nodeType === 1 || value.nodeType === 3 || value.nodeType === 8) &&
+ value.constructor !== undefined &&
+ value.constructor.name !== undefined &&
+ HTML_ELEMENT_REGEXP.test(value.constructor.name));
+
+}
+
+function printChildren(flatChildren, print, indent, colors, opts) {
+ return flatChildren.
+ map(node => {
+ if (typeof node === 'object') {
+ return print(node, print, indent, colors, opts);
+ } else if (typeof node === 'string') {
+ return colors.content.open + escapeHTML(node) + colors.content.close;
+ } else {
+ return print(node);
+ }
+ }).
+ filter(value => value.trim().length).
+ join(opts.edgeSpacing);
+}
+
+function printAttributes(attributes, indent, colors, opts) {
+ return attributes.
+ sort().
+ map(attribute => {
+ return (
+ opts.spacing +
+ indent(colors.prop.open + attribute.name + colors.prop.close + '=') +
+ colors.value.open +
+ `"${attribute.value}"` +
+ colors.value.close);
+
+ }).
+ join('');
+}
+
+const print$3 = (
+element,
+print,
+indent,
+opts,
+colors) =>
+{
+ if (element.nodeType === 3) {
+ return element.data.
+ split('\n').
+ map(text => text.trimLeft()).
+ filter(text => text.length).
+ join(' ');
+ } else if (element.nodeType === 8) {
+ return (
+ colors.comment.open +
+ '' +
+ colors.comment.close);
+
+ }
+
+ let result = colors.tag.open + '<';
+ const elementName = element.tagName.toLowerCase();
+ result += elementName + colors.tag.close;
+
+ const hasAttributes = element.attributes && element.attributes.length;
+ if (hasAttributes) {
+ const attributes = Array.prototype.slice.call(element.attributes);
+ result += printAttributes(attributes, indent, colors, opts);
+ }
+
+ const flatChildren = Array.prototype.slice.call(element.childNodes);
+ if (!flatChildren.length && element.textContent) {
+ flatChildren.push(element.textContent);
+ }
+
+ const closeInNewLine = hasAttributes && !opts.min;
+ if (flatChildren.length) {
+ const children = printChildren(flatChildren, print, indent, colors, opts);
+ result +=
+ colors.tag.open + (
+ closeInNewLine ? '\n' : '') +
+ '>' +
+ colors.tag.close +
+ opts.edgeSpacing +
+ indent(children) +
+ opts.edgeSpacing +
+ colors.tag.open +
+ '' +
+ colors.tag.close;
+ } else {
+ result +=
+ colors.tag.open + (closeInNewLine ? '\n' : ' ') + '/>' + colors.tag.close;
+ }
+
+ return result;
+};
+
+var HTMLElement = { print: print$3, test: test$2 };
+
+var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();
+
+
+
+
+
+
+
+
+
+
+
+const IMMUTABLE_NAMESPACE = 'Immutable.'; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const SPACE$1 = ' ';const addKey = (isMap, key) => isMap ? key + ': ' : '';const addFinalEdgeSpacing = (length, edgeSpacing) => length > 0 ? edgeSpacing : '';const printImmutable$1 = (
+val,
+print,
+indent,
+opts,
+colors,
+immutableDataStructureName,
+isMap) =>
+{var _ref =
+ isMap ? ['{', '}'] : ['[', ']'],_ref2 = _slicedToArray(_ref, 2);const openTag = _ref2[0],closeTag = _ref2[1];
+ let result =
+ IMMUTABLE_NAMESPACE +
+ immutableDataStructureName +
+ SPACE$1 +
+ openTag +
+ opts.edgeSpacing;
+
+ const immutableArray = [];
+ val.forEach((item, key) =>
+ immutableArray.push(
+ indent(addKey(isMap, key) + print(item, print, indent, opts, colors))));
+
+
+
+ result += immutableArray.join(',' + opts.spacing);
+ if (!opts.min && immutableArray.length > 0) {
+ result += ',';
+ }
+
+ return (
+ result +
+ addFinalEdgeSpacing(immutableArray.length, opts.edgeSpacing) +
+ closeTag);
+
+};
+
+var printImmutable_1 = printImmutable$1;
+
+const printImmutable = printImmutable_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const IS_LIST = '@@__IMMUTABLE_LIST__@@';const test$3 = maybeList => !!(maybeList && maybeList[IS_LIST]);const print$4 = (val, print, indent,
+opts,
+colors) =>
+printImmutable(val, print, indent, opts, colors, 'List', false);
+
+var ImmutableList = { print: print$4, test: test$3 };
+
+const printImmutable$2 = printImmutable_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const IS_SET = '@@__IMMUTABLE_SET__@@';const IS_ORDERED = '@@__IMMUTABLE_ORDERED__@@';const test$4 = maybeSet => !!(maybeSet && maybeSet[IS_SET] && !maybeSet[IS_ORDERED]);const print$5 = (val,
+print,
+indent,
+opts,
+colors) =>
+printImmutable$2(val, print, indent, opts, colors, 'Set', false);
+
+var ImmutableSet = { print: print$5, test: test$4 };
+
+const printImmutable$3 = printImmutable_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const IS_MAP = '@@__IMMUTABLE_MAP__@@';const IS_ORDERED$1 = '@@__IMMUTABLE_ORDERED__@@';const test$5 = maybeMap => !!(maybeMap && maybeMap[IS_MAP] && !maybeMap[IS_ORDERED$1]);const print$6 = (val,
+print,
+indent,
+opts,
+colors) =>
+printImmutable$3(val, print, indent, opts, colors, 'Map', true);
+
+var ImmutableMap = { print: print$6, test: test$5 };
+
+const printImmutable$4 = printImmutable_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const IS_STACK = '@@__IMMUTABLE_STACK__@@';const test$6 = maybeStack => !!(maybeStack && maybeStack[IS_STACK]);const print$7 = (val, print, indent,
+opts,
+colors) =>
+printImmutable$4(val, print, indent, opts, colors, 'Stack', false);
+
+var ImmutableStack = { print: print$7, test: test$6 };
+
+const printImmutable$5 = printImmutable_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const IS_SET$1 = '@@__IMMUTABLE_SET__@@';const IS_ORDERED$2 = '@@__IMMUTABLE_ORDERED__@@';const test$7 = maybeOrderedSet => maybeOrderedSet && maybeOrderedSet[IS_SET$1] && maybeOrderedSet[IS_ORDERED$2];const print$8 = (val,
+print,
+indent,
+opts,
+colors) =>
+printImmutable$5(val, print, indent, opts, colors, 'OrderedSet', false);
+
+var ImmutableOrderedSet = { print: print$8, test: test$7 };
+
+const printImmutable$6 = printImmutable_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const IS_MAP$1 = '@@__IMMUTABLE_MAP__@@';const IS_ORDERED$3 = '@@__IMMUTABLE_ORDERED__@@';const test$8 = maybeOrderedMap => maybeOrderedMap && maybeOrderedMap[IS_MAP$1] && maybeOrderedMap[IS_ORDERED$3];const print$9 = (val,
+print,
+indent,
+opts,
+colors) =>
+printImmutable$6(val, print, indent, opts, colors, 'OrderedMap', true);
+
+var ImmutableOrderedMap = { print: print$9, test: test$8 };
+
+var ImmutablePlugins = [
+ImmutableList,
+ImmutableSet,
+ImmutableMap,
+ImmutableStack,
+ImmutableOrderedSet,
+ImmutableOrderedMap];
+
+const escapeHTML$2 = escapeHTML_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const reactElement = Symbol.for('react.element');function traverseChildren(opaqueChildren, cb) {if (Array.isArray(opaqueChildren)) {opaqueChildren.forEach(child => traverseChildren(child, cb));} else if (opaqueChildren != null && opaqueChildren !== false) {cb(opaqueChildren);
+ }
+}
+
+function printChildren$1(flatChildren, print, indent, colors, opts) {
+ return flatChildren.
+ map(node => {
+ if (typeof node === 'object') {
+ return print(node, print, indent, colors, opts);
+ } else if (typeof node === 'string') {
+ return colors.content.open + escapeHTML$2(node) + colors.content.close;
+ } else {
+ return print(node);
+ }
+ }).
+ join(opts.edgeSpacing);
+}
+
+function printProps(props, print, indent, colors, opts) {
+ return Object.keys(props).
+ sort().
+ map(name => {
+ if (name === 'children') {
+ return '';
+ }
+
+ const prop = props[name];
+ let printed = print(prop);
+
+ if (typeof prop !== 'string') {
+ if (printed.indexOf('\n') !== -1) {
+ printed =
+ '{' +
+ opts.edgeSpacing +
+ indent(indent(printed) + opts.edgeSpacing + '}');
+ } else {
+ printed = '{' + printed + '}';
+ }
+ }
+
+ return (
+ opts.spacing +
+ indent(colors.prop.open + name + colors.prop.close + '=') +
+ colors.value.open +
+ printed +
+ colors.value.close);
+
+ }).
+ join('');
+}
+
+const print$10 = (
+element,
+print,
+indent,
+opts,
+colors) =>
+{
+ let result = colors.tag.open + '<';
+ let elementName;
+ if (typeof element.type === 'string') {
+ elementName = element.type;
+ } else if (typeof element.type === 'function') {
+ elementName = element.type.displayName || element.type.name || 'Unknown';
+ } else {
+ elementName = 'Unknown';
+ }
+ result += elementName + colors.tag.close;
+ result += printProps(element.props, print, indent, colors, opts);
+
+ const opaqueChildren = element.props.children;
+ const hasProps = !!Object.keys(element.props).filter(
+ propName => propName !== 'children').
+ length;
+ const closeInNewLine = hasProps && !opts.min;
+
+ if (opaqueChildren) {
+ const flatChildren = [];
+ traverseChildren(opaqueChildren, child => {
+ flatChildren.push(child);
+ });
+ const children = printChildren$1(flatChildren, print, indent, colors, opts);
+ result +=
+ colors.tag.open + (
+ closeInNewLine ? '\n' : '') +
+ '>' +
+ colors.tag.close +
+ opts.edgeSpacing +
+ indent(children) +
+ opts.edgeSpacing +
+ colors.tag.open +
+ '' +
+ colors.tag.close;
+ } else {
+ result +=
+ colors.tag.open + (closeInNewLine ? '\n' : ' ') + '/>' + colors.tag.close;
+ }
+
+ return result;
+};
+
+const test$9 = object => object && object.$$typeof === reactElement;
+
+var ReactElement = { print: print$10, test: test$9 };
+
+const escapeHTML$3 = escapeHTML_1; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */const reactTestInstance = Symbol.for('react.test.json');function printChildren$2(children, print, indent, colors,
+opts)
+{
+ return children.
+ map(child => printInstance(child, print, indent, colors, opts)).
+ join(opts.edgeSpacing);
+}
+
+function printProps$1(props, print, indent, colors, opts) {
+ return Object.keys(props).
+ sort().
+ map(name => {
+ const prop = props[name];
+ let printed = print(prop);
+
+ if (typeof prop !== 'string') {
+ if (printed.indexOf('\n') !== -1) {
+ printed =
+ '{' +
+ opts.edgeSpacing +
+ indent(indent(printed) + opts.edgeSpacing + '}');
+ } else {
+ printed = '{' + printed + '}';
+ }
+ }
+
+ return (
+ opts.spacing +
+ indent(colors.prop.open + name + colors.prop.close + '=') +
+ colors.value.open +
+ printed +
+ colors.value.close);
+
+ }).
+ join('');
+}
+
+function printInstance(instance, print, indent, colors, opts) {
+ if (typeof instance == 'number') {
+ return print(instance);
+ } else if (typeof instance === 'string') {
+ return colors.content.open + escapeHTML$3(instance) + colors.content.close;
+ }
+
+ let closeInNewLine = false;
+ let result = colors.tag.open + '<' + instance.type + colors.tag.close;
+
+ if (instance.props) {
+ closeInNewLine = !!Object.keys(instance.props).length && !opts.min;
+ result += printProps$1(instance.props, print, indent, colors, opts);
+ }
+
+ if (instance.children) {
+ const children = printChildren$2(
+ instance.children,
+ print,
+ indent,
+ colors,
+ opts);
+
+ result +=
+ colors.tag.open + (
+ closeInNewLine ? '\n' : '') +
+ '>' +
+ colors.tag.close +
+ opts.edgeSpacing +
+ indent(children) +
+ opts.edgeSpacing +
+ colors.tag.open +
+ '' +
+ colors.tag.close;
+ } else {
+ result +=
+ colors.tag.open + (closeInNewLine ? '\n' : ' ') + '/>' + colors.tag.close;
+ }
+
+ return result;
+}
+
+const print$11 = (
+val,
+print,
+indent,
+opts,
+colors) =>
+printInstance(val, print, indent, colors, opts);
+
+const test$10 = object =>
+object && object.$$typeof === reactTestInstance;
+
+var ReactTestComponent = { print: print$11, test: test$10 };
+
+const style = index$20; /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const toString = Object.prototype.toString;
+const toISOString = Date.prototype.toISOString;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+const symbolToString = Symbol.prototype.toString;
+
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+const NEWLINE_REGEXP = /\n/gi;
+
+const getSymbols = Object.getOwnPropertySymbols || (obj => []);
+
+function isToStringedArrayType(toStringed) {
+ return (
+ toStringed === '[object Array]' ||
+ toStringed === '[object ArrayBuffer]' ||
+ toStringed === '[object DataView]' ||
+ toStringed === '[object Float32Array]' ||
+ toStringed === '[object Float64Array]' ||
+ toStringed === '[object Int8Array]' ||
+ toStringed === '[object Int16Array]' ||
+ toStringed === '[object Int32Array]' ||
+ toStringed === '[object Uint8Array]' ||
+ toStringed === '[object Uint8ClampedArray]' ||
+ toStringed === '[object Uint16Array]' ||
+ toStringed === '[object Uint32Array]');
+
+}
+
+function printNumber$1(val) {
+ if (val != +val) {
+ return 'NaN';
+ }
+ const isNegativeZero = val === 0 && 1 / val < 0;
+ return isNegativeZero ? '-0' : '' + val;
+}
+
+function printFunction(val, printFunctionName) {
+ if (!printFunctionName) {
+ return '[Function]';
+ } else if (val.name === '') {
+ return '[Function anonymous]';
+ } else {
+ return '[Function ' + val.name + ']';
+ }
+}
+
+function printSymbol(val) {
+ return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+}
+
+function printError(val) {
+ return '[' + errorToString.call(val) + ']';
+}
+
+function printBasicValue(
+val,
+printFunctionName,
+escapeRegex)
+{
+ if (val === true || val === false) {
+ return '' + val;
+ }
+ if (val === undefined) {
+ return 'undefined';
+ }
+ if (val === null) {
+ return 'null';
+ }
+
+ const typeOf = typeof val;
+
+ if (typeOf === 'number') {
+ return printNumber$1(val);
+ }
+ if (typeOf === 'string') {
+ return '"' + val.replace(/"|\\/g, '\\$&') + '"';
+ }
+ if (typeOf === 'function') {
+ return printFunction(val, printFunctionName);
+ }
+ if (typeOf === 'symbol') {
+ return printSymbol(val);
+ }
+
+ const toStringed = toString.call(val);
+
+ if (toStringed === '[object WeakMap]') {
+ return 'WeakMap {}';
+ }
+ if (toStringed === '[object WeakSet]') {
+ return 'WeakSet {}';
+ }
+ if (
+ toStringed === '[object Function]' ||
+ toStringed === '[object GeneratorFunction]')
+ {
+ return printFunction(val, printFunctionName);
+ }
+ if (toStringed === '[object Symbol]') {
+ return printSymbol(val);
+ }
+ if (toStringed === '[object Date]') {
+ return toISOString.call(val);
+ }
+ if (toStringed === '[object Error]') {
+ return printError(val);
+ }
+ if (toStringed === '[object RegExp]') {
+ if (escapeRegex) {
+ // https://github.com/benjamingr/RegExp.escape/blob/master/polyfill.js
+ return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+ }
+ return regExpToString.call(val);
+ }
+ if (toStringed === '[object Arguments]' && val.length === 0) {
+ return 'Arguments []';
+ }
+ if (isToStringedArrayType(toStringed) && val.length === 0) {
+ return val.constructor.name + ' []';
+ }
+
+ if (val instanceof Error) {
+ return printError(val);
+ }
+
+ return null;
+}
+
+function printList(
+list,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ let body = '';
+
+ if (list.length) {
+ body += edgeSpacing;
+
+ const innerIndent = prevIndent + indent;
+
+ for (let i = 0; i < list.length; i++) {
+ body +=
+ innerIndent +
+ print(
+ list[i],
+ indent,
+ innerIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+
+ if (i < list.length - 1) {
+ body += ',' + spacing;
+ }
+ }
+
+ body += (min ? '' : ',') + edgeSpacing + prevIndent;
+ }
+
+ return '[' + body + ']';
+}
+
+function printArguments(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ return (
+ (min ? '' : 'Arguments ') +
+ printList(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors));
+
+
+}
+
+function printArray(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ return (
+ (min ? '' : val.constructor.name + ' ') +
+ printList(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors));
+
+
+}
+
+function printMap(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ let result = 'Map {';
+ const iterator = val.entries();
+ let current = iterator.next();
+
+ if (!current.done) {
+ result += edgeSpacing;
+
+ const innerIndent = prevIndent + indent;
+
+ while (!current.done) {
+ const key = print(
+ current.value[0],
+ indent,
+ innerIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ const value = print(
+ current.value[1],
+ indent,
+ innerIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+
+ result += innerIndent + key + ' => ' + value;
+
+ current = iterator.next();
+
+ if (!current.done) {
+ result += ',' + spacing;
+ }
+ }
+
+ result += (min ? '' : ',') + edgeSpacing + prevIndent;
+ }
+
+ return result + '}';
+}
+
+function printObject(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ const constructor = min ?
+ '' :
+ val.constructor ? val.constructor.name + ' ' : 'Object ';
+ let result = constructor + '{';
+ let keys = Object.keys(val).sort();
+ const symbols = getSymbols(val);
+
+ if (symbols.length) {
+ keys = keys.
+ filter(
+ key =>
+ // $FlowFixMe string literal `symbol`. This value is not a valid `typeof` return value
+ !(typeof key === 'symbol' ||
+ toString.call(key) === '[object Symbol]')).
+
+ concat(symbols);
+ }
+
+ if (keys.length) {
+ result += edgeSpacing;
+
+ const innerIndent = prevIndent + indent;
+
+ for (let i = 0; i < keys.length; i++) {
+ const key = keys[i];
+ const name = print(
+ key,
+ indent,
+ innerIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ const value = print(
+ val[key],
+ indent,
+ innerIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+
+ result += innerIndent + name + ': ' + value;
+
+ if (i < keys.length - 1) {
+ result += ',' + spacing;
+ }
+ }
+
+ result += (min ? '' : ',') + edgeSpacing + prevIndent;
+ }
+
+ return result + '}';
+}
+
+function printSet(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ let result = 'Set {';
+ const iterator = val.entries();
+ let current = iterator.next();
+
+ if (!current.done) {
+ result += edgeSpacing;
+
+ const innerIndent = prevIndent + indent;
+
+ while (!current.done) {
+ result +=
+ innerIndent +
+ print(
+ current.value[1],
+ indent,
+ innerIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+
+ current = iterator.next();
+
+ if (!current.done) {
+ result += ',' + spacing;
+ }
+ }
+
+ result += (min ? '' : ',') + edgeSpacing + prevIndent;
+ }
+
+ return result + '}';
+}
+
+function printComplexValue(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ refs = refs.slice();
+ if (refs.indexOf(val) > -1) {
+ return '[Circular]';
+ } else {
+ refs.push(val);
+ }
+
+ currentDepth++;
+
+ const hitMaxDepth = currentDepth > maxDepth;
+
+ if (
+ callToJSON &&
+ !hitMaxDepth &&
+ val.toJSON &&
+ typeof val.toJSON === 'function')
+ {
+ return print(
+ val.toJSON(),
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ }
+
+ const toStringed = toString.call(val);
+ if (toStringed === '[object Arguments]') {
+ return hitMaxDepth ?
+ '[Arguments]' :
+ printArguments(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ } else if (isToStringedArrayType(toStringed)) {
+ return hitMaxDepth ?
+ '[Array]' :
+ printArray(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ } else if (toStringed === '[object Map]') {
+ return hitMaxDepth ?
+ '[Map]' :
+ printMap(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ } else if (toStringed === '[object Set]') {
+ return hitMaxDepth ?
+ '[Set]' :
+ printSet(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ }
+
+ return hitMaxDepth ?
+ '[Object]' :
+ printObject(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+}
+
+function printPlugin(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ let plugin;
+
+ for (let p = 0; p < plugins.length; p++) {
+ if (plugins[p].test(val)) {
+ plugin = plugins[p];
+ break;
+ }
+ }
+
+ if (!plugin) {
+ return null;
+ }
+
+ function boundPrint(val) {
+ return print(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ }
+
+ function boundIndent(str) {
+ const indentation = prevIndent + indent;
+ return indentation + str.replace(NEWLINE_REGEXP, '\n' + indentation);
+ }
+
+ const opts = {
+ edgeSpacing,
+ min,
+ spacing };
+
+ return plugin.print(val, boundPrint, boundIndent, opts, colors);
+}
+
+function print(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+ const pluginsResult = printPlugin(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+ if (typeof pluginsResult === 'string') {
+ return pluginsResult;
+ }
+
+ const basicResult = printBasicValue(val, printFunctionName, escapeRegex);
+ if (basicResult !== null) {
+ return basicResult;
+ }
+
+ return printComplexValue(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ maxDepth,
+ currentDepth,
+ plugins,
+ min,
+ callToJSON,
+ printFunctionName,
+ escapeRegex,
+ colors);
+
+}
+
+const DEFAULTS = {
+ callToJSON: true,
+ edgeSpacing: '\n',
+ escapeRegex: false,
+ highlight: false,
+ indent: 2,
+ maxDepth: Infinity,
+ min: false,
+ plugins: [],
+ printFunctionName: true,
+ spacing: '\n',
+ theme: {
+ comment: 'gray',
+ content: 'reset',
+ prop: 'yellow',
+ tag: 'cyan',
+ value: 'green' } };
+
+
+
+function validateOptions(opts) {
+ Object.keys(opts).forEach(key => {
+ if (!DEFAULTS.hasOwnProperty(key)) {
+ throw new Error(`pretty-format: Unknown option "${key}".`);
+ }
+ });
+
+ if (opts.min && opts.indent !== undefined && opts.indent !== 0) {
+ throw new Error(
+ 'pretty-format: Options "min" and "indent" cannot be used together.');
+
+ }
+}
+
+function normalizeOptions$1(opts) {
+ const result = {};
+
+ Object.keys(DEFAULTS).forEach(
+ key =>
+ result[key] = opts.hasOwnProperty(key) ?
+ key === 'theme' ? normalizeTheme(opts.theme) : opts[key] :
+ DEFAULTS[key]);
+
+
+ if (result.min) {
+ result.indent = 0;
+ }
+
+ // $FlowFixMe the type cast below means YOU are responsible to verify the code above.
+ return result;
+}
+
+function normalizeTheme(themeOption) {
+ if (!themeOption) {
+ throw new Error(`pretty-format: Option "theme" must not be null.`);
+ }
+
+ if (typeof themeOption !== 'object') {
+ throw new Error(
+ `pretty-format: Option "theme" must be of type "object" but instead received "${typeof themeOption}".`);
+
+ }
+
+ // Silently ignore any keys in `theme` that are not in defaults.
+ const themeRefined = themeOption;
+ const themeDefaults = DEFAULTS.theme;
+ return Object.keys(themeDefaults).reduce((theme, key) => {
+ theme[key] = Object.prototype.hasOwnProperty.call(themeOption, key) ?
+ themeRefined[key] :
+ themeDefaults[key];
+ return theme;
+ }, {});
+}
+
+function createIndent(indent) {
+ return new Array(indent + 1).join(' ');
+}
+
+function prettyFormat(val, initialOptions) {
+ let opts;
+ if (!initialOptions) {
+ opts = DEFAULTS;
+ } else {
+ validateOptions(initialOptions);
+ opts = normalizeOptions$1(initialOptions);
+ }
+
+ const colors = {
+ comment: { close: '', open: '' },
+ content: { close: '', open: '' },
+ prop: { close: '', open: '' },
+ tag: { close: '', open: '' },
+ value: { close: '', open: '' } };
+
+ Object.keys(opts.theme).forEach(key => {
+ if (opts.highlight) {
+ const color = colors[key] = style[opts.theme[key]];
+ if (
+ !color ||
+ typeof color.close !== 'string' ||
+ typeof color.open !== 'string')
+ {
+ throw new Error(
+ `pretty-format: Option "theme" has a key "${key}" whose value "${opts.theme[key]}" is undefined in ansi-styles.`);
+
+ }
+ }
+ });
+
+ let indent;
+ let refs;
+ const prevIndent = '';
+ const currentDepth = 0;
+ const spacing = opts.min ? ' ' : '\n';
+ const edgeSpacing = opts.min ? '' : '\n';
+
+ if (opts && opts.plugins.length) {
+ indent = createIndent(opts.indent);
+ refs = [];
+ const pluginsResult = printPlugin(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ opts.maxDepth,
+ currentDepth,
+ opts.plugins,
+ opts.min,
+ opts.callToJSON,
+ opts.printFunctionName,
+ opts.escapeRegex,
+ colors);
+
+ if (typeof pluginsResult === 'string') {
+ return pluginsResult;
+ }
+ }
+
+ const basicResult = printBasicValue(
+ val,
+ opts.printFunctionName,
+ opts.escapeRegex);
+
+ if (basicResult !== null) {
+ return basicResult;
+ }
+
+ if (!indent) {
+ indent = createIndent(opts.indent);
+ }
+ if (!refs) {
+ refs = [];
+ }
+ return printComplexValue(
+ val,
+ indent,
+ prevIndent,
+ spacing,
+ edgeSpacing,
+ refs,
+ opts.maxDepth,
+ currentDepth,
+ opts.plugins,
+ opts.min,
+ opts.callToJSON,
+ opts.printFunctionName,
+ opts.escapeRegex,
+ colors);
+
+}
+
+prettyFormat.plugins = {
+ AsymmetricMatcher: AsymmetricMatcher,
+ ConvertAnsi: ConvertAnsi,
+ HTMLElement: HTMLElement,
+ Immutable: ImmutablePlugins,
+ ReactElement: ReactElement,
+ ReactTestComponent: ReactTestComponent };
+
+
+var index$18 = prettyFormat;
+
+/* eslint-disable no-nested-ternary */
+var arr = [];
+var charCodeCache = [];
+
+var index$26 = function (a, b) {
+ if (a === b) {
+ return 0;
+ }
+
+ var swap = a;
+
+ // Swapping the strings if `a` is longer than `b` so we know which one is the
+ // shortest & which one is the longest
+ if (a.length > b.length) {
+ a = b;
+ b = swap;
+ }
+
+ var aLen = a.length;
+ var bLen = b.length;
+
+ if (aLen === 0) {
+ return bLen;
+ }
+
+ if (bLen === 0) {
+ return aLen;
+ }
+
+ // Performing suffix trimming:
+ // We can linearly drop suffix common to both strings since they
+ // don't increase distance at all
+ // Note: `~-` is the bitwise way to perform a `- 1` operation
+ while (aLen > 0 && (a.charCodeAt(~-aLen) === b.charCodeAt(~-bLen))) {
+ aLen--;
+ bLen--;
+ }
+
+ if (aLen === 0) {
+ return bLen;
+ }
+
+ // Performing prefix trimming
+ // We can linearly drop prefix common to both strings since they
+ // don't increase distance at all
+ var start = 0;
+
+ while (start < aLen && (a.charCodeAt(start) === b.charCodeAt(start))) {
+ start++;
+ }
+
+ aLen -= start;
+ bLen -= start;
+
+ if (aLen === 0) {
+ return bLen;
+ }
+
+ var bCharCode;
+ var ret;
+ var tmp;
+ var tmp2;
+ var i = 0;
+ var j = 0;
+
+ while (i < aLen) {
+ charCodeCache[start + i] = a.charCodeAt(start + i);
+ arr[i] = ++i;
+ }
+
+ while (j < bLen) {
+ bCharCode = b.charCodeAt(start + j);
+ tmp = j++;
+ ret = j;
+
+ for (i = 0; i < aLen; i++) {
+ tmp2 = bCharCode === charCodeCache[start + i] ? tmp : tmp + 1;
+ tmp = arr[i];
+ ret = arr[i] = tmp > ret ? tmp2 > ret ? ret + 1 : tmp2 : tmp2 > tmp ? tmp + 1 : tmp2;
+ }
+ }
+
+ return ret;
+};
+
+const chalk$1 = index$4;
+const BULLET = chalk$1.bold('\u25cf');
+const DEPRECATION = `${BULLET} Deprecation Warning`;
+const ERROR$1 = `${BULLET} Validation Error`;
+const WARNING = `${BULLET} Validation Warning`;
+
+const format$2 = value =>
+typeof value === 'function' ?
+value.toString() :
+index$18(value, { min: true });
+
+class ValidationError$1 extends Error {
+
+
+
+ constructor(name, message, comment) {
+ super();
+ comment = comment ? '\n\n' + comment : '\n';
+ this.name = '';
+ this.message = chalk$1.red(chalk$1.bold(name) + ':\n\n' + message + comment);
+ Error.captureStackTrace(this, () => {});
+ }}
+
+
+const logValidationWarning = (
+name,
+message,
+comment) =>
+{
+ comment = comment ? '\n\n' + comment : '\n';
+ console.warn(chalk$1.yellow(chalk$1.bold(name) + ':\n\n' + message + comment));
+};
+
+const createDidYouMeanMessage = (
+unrecognized,
+allowedOptions) =>
+{
+ const leven = index$26;
+ const suggestion = allowedOptions.find(option => {
+ const steps = leven(option, unrecognized);
+ return steps < 3;
+ });
+
+ return suggestion ? `Did you mean ${chalk$1.bold(format$2(suggestion))}?` : '';
+};
+
+var utils$2 = {
+ DEPRECATION,
+ ERROR: ERROR$1,
+ ValidationError: ValidationError$1,
+ WARNING,
+ createDidYouMeanMessage,
+ format: format$2,
+ logValidationWarning };
+
+const chalk$2 = index$4;
+const prettyFormat$1 = index$18;var _require$plugins =
+
+
+
+
+
+index$18.plugins;const AsymmetricMatcher$2 = _require$plugins.AsymmetricMatcher; const ReactElement$2 = _require$plugins.ReactElement; const HTMLElement$2 = _require$plugins.HTMLElement; const Immutable = _require$plugins.Immutable;
+
+const PLUGINS = [AsymmetricMatcher$2, ReactElement$2, HTMLElement$2].concat(
+Immutable);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const EXPECTED_COLOR = chalk$2.green;
+const EXPECTED_BG = chalk$2.bgGreen;
+const RECEIVED_COLOR = chalk$2.red;
+const RECEIVED_BG = chalk$2.bgRed;
+
+const NUMBERS = [
+'zero',
+'one',
+'two',
+'three',
+'four',
+'five',
+'six',
+'seven',
+'eight',
+'nine',
+'ten',
+'eleven',
+'twelve',
+'thirteen'];
+
+
+// get the type of a value with handling the edge cases like `typeof []`
+// and `typeof null`
+const getType$1 = value => {
+ if (typeof value === 'undefined') {
+ return 'undefined';
+ } else if (value === null) {
+ return 'null';
+ } else if (Array.isArray(value)) {
+ return 'array';
+ } else if (typeof value === 'boolean') {
+ return 'boolean';
+ } else if (typeof value === 'function') {
+ return 'function';
+ } else if (typeof value === 'number') {
+ return 'number';
+ } else if (typeof value === 'string') {
+ return 'string';
+ } else if (typeof value === 'object') {
+ if (value.constructor === RegExp) {
+ return 'regexp';
+ } else if (value.constructor === Map) {
+ return 'map';
+ } else if (value.constructor === Set) {
+ return 'set';
+ }
+ return 'object';
+ // $FlowFixMe https://github.com/facebook/flow/issues/1015
+ } else if (typeof value === 'symbol') {
+ return 'symbol';
+ }
+
+ throw new Error(`value of unknown type: ${value}`);
+};
+
+const stringify = function (object) {let maxDepth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+ const MAX_LENGTH = 10000;
+ let result;
+
+ try {
+ result = prettyFormat$1(object, {
+ maxDepth,
+ min: true,
+ plugins: PLUGINS });
+
+ } catch (e) {
+ result = prettyFormat$1(object, {
+ callToJSON: false,
+ maxDepth,
+ min: true,
+ plugins: PLUGINS });
+
+ }
+
+ return result.length >= MAX_LENGTH && maxDepth > 1 ?
+ stringify(object, Math.floor(maxDepth / 2)) :
+ result;
+};
+
+const highlightTrailingWhitespace = (text, bgColor) =>
+text.replace(/\s+$/gm, bgColor('$&'));
+
+const printReceived = object =>
+highlightTrailingWhitespace(RECEIVED_COLOR(stringify(object)), RECEIVED_BG);
+const printExpected = value =>
+highlightTrailingWhitespace(EXPECTED_COLOR(stringify(value)), EXPECTED_BG);
+
+const printWithType = (
+name,
+received,
+print) =>
+{
+ const type = getType$1(received);
+ return (
+ name +
+ ':' + (
+ type !== 'null' && type !== 'undefined' ? '\n ' + type + ': ' : ' ') +
+ print(received));
+
+};
+
+const ensureNoExpected = (expected, matcherName) => {
+ matcherName || (matcherName = 'This');
+ if (typeof expected !== 'undefined') {
+ throw new Error(
+ matcherHint('[.not]' + matcherName, undefined, '') +
+ '\n\n' +
+ 'Matcher does not accept any arguments.\n' +
+ printWithType('Got', expected, printExpected));
+
+ }
+};
+
+const ensureActualIsNumber = (actual, matcherName) => {
+ matcherName || (matcherName = 'This matcher');
+ if (typeof actual !== 'number') {
+ throw new Error(
+ matcherHint('[.not]' + matcherName) +
+ '\n\n' +
+ `Received value must be a number.\n` +
+ printWithType('Received', actual, printReceived));
+
+ }
+};
+
+const ensureExpectedIsNumber = (expected, matcherName) => {
+ matcherName || (matcherName = 'This matcher');
+ if (typeof expected !== 'number') {
+ throw new Error(
+ matcherHint('[.not]' + matcherName) +
+ '\n\n' +
+ `Expected value must be a number.\n` +
+ printWithType('Got', expected, printExpected));
+
+ }
+};
+
+const ensureNumbers = (actual, expected, matcherName) => {
+ ensureActualIsNumber(actual, matcherName);
+ ensureExpectedIsNumber(expected, matcherName);
+};
+
+const pluralize = (word, count) =>
+(NUMBERS[count] || count) + ' ' + word + (count === 1 ? '' : 's');
+
+const matcherHint = function (
+matcherName)
+
+
+
+
+
+
+{let received = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'received';let expected = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'expected';let options = arguments[3];
+ const secondArgument = options && options.secondArgument;
+ const isDirectExpectCall = options && options.isDirectExpectCall;
+ return (
+ chalk$2.dim('expect' + (isDirectExpectCall ? '' : '(')) +
+ RECEIVED_COLOR(received) +
+ chalk$2.dim((isDirectExpectCall ? '' : ')') + matcherName + '(') +
+ EXPECTED_COLOR(expected) + (
+ secondArgument ? `, ${EXPECTED_COLOR(secondArgument)}` : '') +
+ chalk$2.dim(')'));
+
+};
+
+var index$28 = {
+ EXPECTED_BG,
+ EXPECTED_COLOR,
+ RECEIVED_BG,
+ RECEIVED_COLOR,
+ ensureActualIsNumber,
+ ensureExpectedIsNumber,
+ ensureNoExpected,
+ ensureNumbers,
+ getType: getType$1,
+ highlightTrailingWhitespace,
+ matcherHint,
+ pluralize,
+ printExpected,
+ printReceived,
+ printWithType,
+ stringify };
+
+const chalk = index$4;var _require =
+utils$2;const format$1 = _require.format; const ValidationError = _require.ValidationError; const ERROR = _require.ERROR;var _require2 =
+index$28;const getType = _require2.getType;
+
+const errorMessage = (
+option,
+received,
+defaultValue,
+options) =>
+{
+ const message = ` Option ${chalk.bold(`"${option}"`)} must be of type:
+ ${chalk.bold.green(getType(defaultValue))}
+ but instead received:
+ ${chalk.bold.red(getType(received))}
+
+ Example:
+ {
+ ${chalk.bold(`"${option}"`)}: ${chalk.bold(format$1(defaultValue))}
+ }`;
+
+ const comment = options.comment;
+ const name = options.title && options.title.error || ERROR;
+
+ throw new ValidationError(name, message, comment);
+};
+
+var errors = {
+ ValidationError,
+ errorMessage };
+
+var _require$2 =
+
+
+
+utils$2;const logValidationWarning$1 = _require$2.logValidationWarning; const DEPRECATION$2 = _require$2.DEPRECATION;
+
+const deprecationMessage = (message, options) => {
+ const comment = options.comment;
+ const name = options.title && options.title.deprecation || DEPRECATION$2;
+
+ logValidationWarning$1(name, message, comment);
+};
+
+const deprecationWarning$1 = (
+config,
+option,
+deprecatedOptions,
+options) =>
+{
+ if (option in deprecatedOptions) {
+ deprecationMessage(deprecatedOptions[option](config), options);
+
+ return true;
+ }
+
+ return false;
+};
+
+var deprecated = {
+ deprecationWarning: deprecationWarning$1 };
+
+const chalk$3 = index$4;var _require$3 =
+
+
+
+
+
+utils$2;const format$3 = _require$3.format; const logValidationWarning$2 = _require$3.logValidationWarning; const createDidYouMeanMessage$1 = _require$3.createDidYouMeanMessage; const WARNING$2 = _require$3.WARNING;
+
+const unknownOptionWarning$1 = (
+config,
+exampleConfig,
+option,
+options) =>
+{
+ const didYouMean = createDidYouMeanMessage$1(
+ option,
+ Object.keys(exampleConfig));
+
+ /* eslint-disable max-len */
+ const message =
+ ` Unknown option ${chalk$3.bold(`"${option}"`)} with value ${chalk$3.bold(format$3(config[option]))} was found.` + (
+ didYouMean && ` ${didYouMean}`) +
+ `\n This is probably a typing mistake. Fixing it will remove this message.`;
+ /* eslint-enable max-len */
+
+ const comment = options.comment;
+ const name = options.title && options.title.warning || WARNING$2;
+
+ logValidationWarning$2(name, message, comment);
+};
+
+var warnings = {
+ unknownOptionWarning: unknownOptionWarning$1 };
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */
+
+const config = {
+ comment: ' A comment',
+ condition: (option, validOption) => true,
+ deprecate: (config, option, deprecatedOptions, options) => false,
+ deprecatedConfig: {
+ key: config => {} },
+
+ error: (option, received, defaultValue, options) => {},
+ exampleConfig: { key: 'value', test: 'case' },
+ title: {
+ deprecation: 'Deprecation Warning',
+ error: 'Validation Error',
+ warning: 'Validation Warning' },
+
+ unknown: (config, option, options) => {} };
+
+
+var exampleConfig$2 = config;
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */
+
+const toString$1 = Object.prototype.toString;
+
+const validationCondition$1 = (option, validOption) => {
+ return (
+ option === null ||
+ option === undefined ||
+ toString$1.call(option) === toString$1.call(validOption));
+
+};
+
+var condition = validationCondition$1;
+
+var _require$1 =
+
+
+
+deprecated;const deprecationWarning = _require$1.deprecationWarning;var _require2$1 =
+warnings;const unknownOptionWarning = _require2$1.unknownOptionWarning;var _require3 =
+errors;const errorMessage$1 = _require3.errorMessage;
+const exampleConfig$1 = exampleConfig$2;
+const validationCondition = condition;var _require4 =
+utils$2;const ERROR$2 = _require4.ERROR; const DEPRECATION$1 = _require4.DEPRECATION; const WARNING$1 = _require4.WARNING;
+
+var defaultConfig$1 = {
+ comment: '',
+ condition: validationCondition,
+ deprecate: deprecationWarning,
+ deprecatedConfig: {},
+ error: errorMessage$1,
+ exampleConfig: exampleConfig$1,
+ title: {
+ deprecation: DEPRECATION$1,
+ error: ERROR$2,
+ warning: WARNING$1 },
+
+ unknown: unknownOptionWarning };
+
+const defaultConfig = defaultConfig$1;
+
+const _validate = (config, options) => {
+ let hasDeprecationWarnings = false;
+
+ for (const key in config) {
+ if (
+ options.deprecatedConfig &&
+ key in options.deprecatedConfig &&
+ typeof options.deprecate === 'function')
+ {
+ const isDeprecatedKey = options.deprecate(
+ config,
+ key,
+ options.deprecatedConfig,
+ options);
+
+
+ hasDeprecationWarnings = hasDeprecationWarnings || isDeprecatedKey;
+ } else if (hasOwnProperty.call(options.exampleConfig, key)) {
+ if (
+ typeof options.condition === 'function' &&
+ typeof options.error === 'function' &&
+ !options.condition(config[key], options.exampleConfig[key]))
+ {
+ options.error(key, config[key], options.exampleConfig[key], options);
+ }
+ } else {
+ options.unknown &&
+ options.unknown(config, options.exampleConfig, key, options);
+ }
+ }
+
+ return { hasDeprecationWarnings };
+};
+
+const validate$1 = (config, options) => {
+ _validate(options, defaultConfig); // validate against jest-validate config
+
+ const defaultedOptions = Object.assign(
+ {},
+ defaultConfig,
+ options,
+ { title: Object.assign({}, defaultConfig.title, options.title) });var _validate2 =
+
+
+ _validate(config, defaultedOptions);const hasDeprecationWarnings = _validate2.hasDeprecationWarnings;
+
+ return {
+ hasDeprecationWarnings,
+ isValid: true };
+
+};
+
+var validate_1 = validate$1;
+
+var index$2 = {
+ ValidationError: errors.ValidationError,
+ createDidYouMeanMessage: utils$2.createDidYouMeanMessage,
+ format: utils$2.format,
+ logValidationWarning: utils$2.logValidationWarning,
+ validate: validate_1 };
+
+const deprecated$2 = {
+ useFlowParser: config =>
+ ` The ${'"useFlowParser"'} option is deprecated. Use ${'"parser"'} instead.
+
+ Prettier now treats your configuration as:
+ {
+ ${'"parser"'}: ${config.useFlowParser ? '"flow"' : '"babylon"'}
+ }`
+};
+
+var deprecated_1 = deprecated$2;
+
+const validate = index$2.validate;
+const deprecatedConfig = deprecated_1;
+
+const defaults = {
+ rangeStart: 0,
+ rangeEnd: Infinity,
+ useTabs: false,
+ tabWidth: 2,
+ printWidth: 80,
+ singleQuote: false,
+ trailingComma: "none",
+ bracketSpacing: true,
+ jsxBracketSameLine: false,
+ parser: "babylon",
+ semi: true
+};
+
+const exampleConfig = Object.assign({}, defaults, {
+ filepath: "path/to/Filename",
+ printWidth: 80,
+ originalText: "text"
+});
+
+// Copy options and fill in default values.
+function normalize(options) {
+ const normalized = Object.assign({}, options || {});
+ const filepath = normalized.filepath;
+
+ if (/\.(css|less|scss)$/.test(filepath)) {
+ normalized.parser = "postcss";
+ } else if (/\.(ts|tsx)$/.test(filepath)) {
+ normalized.parser = "typescript";
+ }
+
+ if (typeof normalized.trailingComma === "boolean") {
+ // Support a deprecated boolean type for the trailing comma config
+ // for a few versions. This code can be removed later.
+ normalized.trailingComma = "es5";
+
+ console.warn(
+ "Warning: `trailingComma` without any argument is deprecated. " +
+ 'Specify "none", "es5", or "all".'
+ );
+ }
+
+ validate(normalized, { exampleConfig, deprecatedConfig });
+
+ // For backward compatibility. Deprecated in 0.0.10
+ if ("useFlowParser" in normalized) {
+ normalized.parser = normalized.useFlowParser ? "flow" : "babylon";
+ delete normalized.useFlowParser;
+ }
+
+ Object.keys(defaults).forEach(k => {
+ if (normalized[k] == null) {
+ normalized[k] = defaults[k];
+ }
+ });
+
+ return normalized;
+}
+
+var options = { normalize };
+
+var index$32 = createCommonjsModule(function (module, exports) {
+// Copyright 2014, 2015, 2016, 2017 Simon Lydell
+// License: MIT. (See LICENSE.)
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+// This regex comes from regex.coffee, and is inserted here by generate-index.js
+// (run `npm run build`).
+exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyu]{1,5}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g;
+
+exports.matchToToken = function(match) {
+ var token = {type: "invalid", value: match[0]};
+ if (match[ 1]) token.type = "string" , token.closed = !!(match[3] || match[4]);
+ else if (match[ 5]) token.type = "comment";
+ else if (match[ 6]) token.type = "comment", token.closed = !!match[7];
+ else if (match[ 8]) token.type = "regex";
+ else if (match[ 9]) token.type = "number";
+ else if (match[10]) token.type = "name";
+ else if (match[11]) token.type = "punctuator";
+ else if (match[12]) token.type = "whitespace";
+ return token
+};
+});
+
+var index$30 = createCommonjsModule(function (module, exports) {
+"use strict";
+
+exports.__esModule = true;
+
+exports.default = function (rawLines, lineNumber, colNumber) {
+ var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+ colNumber = Math.max(colNumber, 0);
+
+ var highlighted = opts.highlightCode && _chalk2.default.supportsColor || opts.forceColor;
+ var chalk = _chalk2.default;
+ if (opts.forceColor) {
+ chalk = new _chalk2.default.constructor({ enabled: true });
+ }
+ var maybeHighlight = function maybeHighlight(chalkFn, string) {
+ return highlighted ? chalkFn(string) : string;
+ };
+ var defs = getDefs(chalk);
+ if (highlighted) rawLines = highlight(defs, rawLines);
+
+ var linesAbove = opts.linesAbove || 2;
+ var linesBelow = opts.linesBelow || 3;
+
+ var lines = rawLines.split(NEWLINE);
+ var start = Math.max(lineNumber - (linesAbove + 1), 0);
+ var end = Math.min(lines.length, lineNumber + linesBelow);
+
+ if (!lineNumber && !colNumber) {
+ start = 0;
+ end = lines.length;
+ }
+
+ var numberMaxWidth = String(end).length;
+
+ var frame = lines.slice(start, end).map(function (line, index) {
+ var number = start + 1 + index;
+ var paddedNumber = (" " + number).slice(-numberMaxWidth);
+ var gutter = " " + paddedNumber + " | ";
+ if (number === lineNumber) {
+ var markerLine = "";
+ if (colNumber) {
+ var markerSpacing = line.slice(0, colNumber - 1).replace(/[^\t]/g, " ");
+ markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^")].join("");
+ }
+ return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
+ } else {
+ return " " + maybeHighlight(defs.gutter, gutter) + line;
+ }
+ }).join("\n");
+
+ if (highlighted) {
+ return chalk.reset(frame);
+ } else {
+ return frame;
+ }
+};
+
+var _jsTokens = index$32;
+
+var _jsTokens2 = _interopRequireDefault(_jsTokens);
+
+var _esutils = utils;
+
+var _esutils2 = _interopRequireDefault(_esutils);
+
+var _chalk = index$4;
+
+var _chalk2 = _interopRequireDefault(_chalk);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getDefs(chalk) {
+ return {
+ keyword: chalk.cyan,
+ capitalized: chalk.yellow,
+ jsx_tag: chalk.yellow,
+ punctuator: chalk.yellow,
+
+ number: chalk.magenta,
+ string: chalk.green,
+ regex: chalk.magenta,
+ comment: chalk.grey,
+ invalid: chalk.white.bgRed.bold,
+ gutter: chalk.grey,
+ marker: chalk.red.bold
+ };
+}
+
+var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+
+var JSX_TAG = /^[a-z][\w-]*$/i;
+
+var BRACKET = /^[()\[\]{}]$/;
+
+function getTokenType(match) {
+ var _match$slice = match.slice(-2),
+ offset = _match$slice[0],
+ text = _match$slice[1];
+
+ var token = (0, _jsTokens.matchToToken)(match);
+
+ if (token.type === "name") {
+ if (_esutils2.default.keyword.isReservedWordES6(token.value)) {
+ return "keyword";
+ }
+
+ if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == "= 0 && text.charAt(index - 1) === "\r") {
+ return "\r\n";
+ }
+ return "\n";
+}
+
+function attachComments(text, ast, opts) {
+ const astComments = ast.comments;
+ if (astComments) {
+ delete ast.comments;
+ comments.attach(astComments, ast, text, opts);
+ }
+ ast.tokens = [];
+ opts.originalText = text.trimRight();
+ return astComments;
+}
+
+function ensureAllCommentsPrinted(astComments) {
+ if (!astComments) {
+ return;
+ }
+
+ for (let i = 0; i < astComments.length; ++i) {
+ if (astComments[i].value.trim() === "prettier-ignore") {
+ // If there's a prettier-ignore, we're not printing that sub-tree so we
+ // don't know if the comments was printed or not.
+ return;
+ }
+ }
+
+ astComments.forEach(comment => {
+ if (!comment.printed) {
+ throw new Error(
+ 'Comment "' +
+ comment.value.trim() +
+ '" was not printed. Please report this error!'
+ );
+ }
+ delete comment.printed;
+ });
+}
+
+function format(text, opts, addAlignmentSize) {
+ addAlignmentSize = addAlignmentSize || 0;
+
+ const ast = parser.parse(text, opts);
+
+ const formattedRangeOnly = formatRange(text, opts, ast);
+ if (formattedRangeOnly) {
+ return formattedRangeOnly;
+ }
+
+ const astComments = attachComments(text, ast, opts);
+ const doc = printAstToDoc(ast, opts, addAlignmentSize);
+ opts.newLine = guessLineEnding(text);
+ const str = printDocToString(doc, opts);
+ ensureAllCommentsPrinted(astComments);
+ // Remove extra leading indentation as well as the added indentation after last newline
+ if (addAlignmentSize > 0) {
+ return str.trim() + opts.newLine;
+ }
+ return str;
+}
+
+function findSiblingAncestors(startNodeAndParents, endNodeAndParents) {
+ let resultStartNode = startNodeAndParents.node;
+ let resultEndNode = endNodeAndParents.node;
+
+ for (const endParent of endNodeAndParents.parentNodes) {
+ if (util.locStart(endParent) >= util.locStart(startNodeAndParents.node)) {
+ resultEndNode = endParent;
+ } else {
+ break;
+ }
+ }
+
+ for (const startParent of startNodeAndParents.parentNodes) {
+ if (util.locEnd(startParent) <= util.locEnd(endNodeAndParents.node)) {
+ resultStartNode = startParent;
+ } else {
+ break;
+ }
+ }
+
+ return {
+ startNode: resultStartNode,
+ endNode: resultEndNode
+ };
+}
+
+function findNodeAtOffset(node, offset, parentNodes) {
+ parentNodes = parentNodes || [];
+ const start = util.locStart(node);
+ const end = util.locEnd(node);
+ if (start <= offset && offset <= end) {
+ for (const childNode of comments.getSortedChildNodes(node)) {
+ const childResult = findNodeAtOffset(
+ childNode,
+ offset,
+ [node].concat(parentNodes)
+ );
+ if (childResult) {
+ return childResult;
+ }
+ }
+
+ if (isSourceElement(node)) {
+ return {
+ node: node,
+ parentNodes: parentNodes
+ };
+ }
+ }
+}
+
+// See https://www.ecma-international.org/ecma-262/5.1/#sec-A.5
+function isSourceElement(node) {
+ if (node == null) {
+ return false;
+ }
+ switch (node.type) {
+ case "FunctionDeclaration":
+ case "BlockStatement":
+ case "BreakStatement":
+ case "ContinueStatement":
+ case "DebuggerStatement":
+ case "DoWhileStatement":
+ case "EmptyStatement":
+ case "ExpressionStatement":
+ case "ForInStatement":
+ case "ForStatement":
+ case "IfStatement":
+ case "LabeledStatement":
+ case "ReturnStatement":
+ case "SwitchStatement":
+ case "ThrowStatement":
+ case "TryStatement":
+ case "VariableDeclaration":
+ case "WhileStatement":
+ case "WithStatement":
+ return true;
+ }
+ return false;
+}
+
+function calculateRange(text, opts, ast) {
+ // Contract the range so that it has non-whitespace characters at its endpoints.
+ // This ensures we can format a range that doesn't end on a node.
+ const rangeStringOrig = text.slice(opts.rangeStart, opts.rangeEnd);
+ const startNonWhitespace = Math.max(
+ opts.rangeStart + rangeStringOrig.search(/\S/),
+ opts.rangeStart
+ );
+ let endNonWhitespace;
+ for (
+ endNonWhitespace = opts.rangeEnd;
+ endNonWhitespace > opts.rangeStart;
+ --endNonWhitespace
+ ) {
+ if (text[endNonWhitespace - 1].match(/\S/)) {
+ break;
+ }
+ }
+
+ const startNodeAndParents = findNodeAtOffset(ast, startNonWhitespace);
+ const endNodeAndParents = findNodeAtOffset(ast, endNonWhitespace);
+ const siblingAncestors = findSiblingAncestors(
+ startNodeAndParents,
+ endNodeAndParents
+ );
+ const startNode = siblingAncestors.startNode;
+ const endNode = siblingAncestors.endNode;
+ const rangeStart = Math.min(util.locStart(startNode), util.locStart(endNode));
+ const rangeEnd = Math.max(util.locEnd(startNode), util.locEnd(endNode));
+
+ return {
+ rangeStart: rangeStart,
+ rangeEnd: rangeEnd
+ };
+}
+
+function formatRange(text, opts, ast) {
+ if (0 < opts.rangeStart || opts.rangeEnd < text.length) {
+ const range = calculateRange(text, opts, ast);
+ const rangeStart = range.rangeStart;
+ const rangeEnd = range.rangeEnd;
+ const rangeString = text.slice(rangeStart, rangeEnd);
+
+ // Try to extend the range backwards to the beginning of the line.
+ // This is so we can detect indentation correctly and restore it.
+ // Use `Math.min` since `lastIndexOf` returns 0 when `rangeStart` is 0
+ const rangeStart2 = Math.min(
+ rangeStart,
+ text.lastIndexOf("\n", rangeStart) + 1
+ );
+ const indentString = text.slice(rangeStart2, rangeStart);
+
+ const alignmentSize = util.getAlignmentSize(indentString, opts.tabWidth);
+
+ const rangeFormatted = format(
+ rangeString,
+ Object.assign({}, opts, {
+ rangeStart: 0,
+ rangeEnd: Infinity,
+ printWidth: opts.printWidth - alignmentSize
+ }),
+ alignmentSize
+ );
+
+ // Since the range contracts to avoid trailing whitespace,
+ // we need to remove the newline that was inserted by the `format` call.
+ const rangeTrimmed = rangeFormatted.trimRight();
+
+ return text.slice(0, rangeStart) + rangeTrimmed + text.slice(rangeEnd);
+ }
+}
+
+function formatWithShebang(text, opts) {
+ if (!text.startsWith("#!")) {
+ return format(text, opts);
+ }
+
+ const index = text.indexOf("\n");
+ const shebang = text.slice(0, index + 1);
+ const nextChar = text.charAt(index + 1);
+ const newLine = nextChar === "\n" ? "\n" : nextChar === "\r" ? "\r\n" : "";
+
+ return shebang + newLine + format(text, opts);
+}
+
+var index = {
+ format: function(text, opts) {
+ return formatWithShebang(text, normalizeOptions(opts));
+ },
+ check: function(text, opts) {
+ try {
+ const formatted = formatWithShebang(text, normalizeOptions(opts));
+ return formatted === text;
+ } catch (e) {
+ return false;
+ }
+ },
+ version: version,
+ __debug: {
+ parse: function(text, opts) {
+ return parser.parse(text, opts);
+ },
+ formatAST: function(ast, opts) {
+ opts = normalizeOptions(opts);
+ const doc = printAstToDoc(ast, opts);
+ const str = printDocToString(doc, opts);
+ return str;
+ },
+ // Doesn't handle shebang for now
+ formatDoc: function(doc, opts) {
+ opts = normalizeOptions(opts);
+ const debug = printDocToDebug(doc);
+ const str = format(debug, opts);
+ return str;
+ },
+ printToDoc: function(text, opts) {
+ opts = normalizeOptions(opts);
+ const ast = parser.parse(text, opts);
+ attachComments(text, ast, opts);
+ const doc = printAstToDoc(ast, opts);
+ return doc;
+ },
+ printDocToString: function(doc, opts) {
+ opts = normalizeOptions(opts);
+ const str = printDocToString(doc, opts);
+ return str;
+ }
+ }
+};
+
+module.exports = index;
diff --git a/docs/parser-babylon.js b/docs/parser-babylon.js
new file mode 100644
index 00000000..931acb2d
--- /dev/null
+++ b/docs/parser-babylon.js
@@ -0,0 +1,18 @@
+var babylon = (function () {
+function unwrapExports (x) {
+ return x && x.__esModule ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, module) {
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var parserBabylon_1 = createCommonjsModule(function (module) {
+"use strict";function createCommonjsModule$$1(t,e){return e={exports:{}},t(e,e.exports),e.exports}function parse(t){const e=index,s={sourceType:"module",allowImportExportEverywhere:!1,allowReturnOutsideFunction:!0,plugins:["jsx","flow","doExpressions","objectRestSpread","decorators","classProperties","exportExtensions","asyncGenerators","functionBind","functionSent","dynamicImport"]};let i;try{i=e.parse(t,s);}catch(i){try{return e.parse(t,Object.assign({},s,{strictMode:!1}))}catch(t){throw i}}return delete i.tokens,i}var index=createCommonjsModule$$1(function(t,e){function s(t){var e={};for(var s in b)e[s]=t&&s in t?t[s]:b[s];return e}function i(t){var e=t.split(" ");return function(t){return e.indexOf(t)>=0}}function r(t,e){for(var s=65536,i=0;it)return!1;if((s+=e[i+1])>=t)return!0}return!1}function a(t){return t<65?36===t:t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&j.test(String.fromCharCode(t)):r(t,D)))}function n(t){return t<48?36===t:t<58||!(t<65)&&(t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&R.test(String.fromCharCode(t)):r(t,D)||r(t,O))))}function o(t){return 10===t||13===t||8232===t||8233===t}function h(t,e){for(var s=1,i=0;;){F.lastIndex=i;var r=F.exec(t);if(!(r&&r.index>10),56320+(t-65536&1023))}function l(t){for(var e={},s=t,i=Array.isArray(s),r=0,s=i?s:s[Symbol.iterator]();;){var a;if(i){if(r>=s.length)break;a=s[r++];}else{if((r=s.next()).done)break;a=r.value;}e[a]=!0;}return e}function u(t){return null!=t&&"Property"===t.type&&"init"===t.kind&&!1===t.method}function d(t){return"DeclareExportAllDeclaration"===t.type||"DeclareExportDeclaration"===t.type&&(!t.declaration||"TypeAlias"!==t.declaration.type&&"InterfaceDeclaration"!==t.declaration.type)}function f(t){if("JSXIdentifier"===t.type)return t.name;if("JSXNamespacedName"===t.type)return t.namespace.name+":"+t.name.name;if("JSXMemberExpression"===t.type)return f(t.object)+"."+f(t.property);throw new Error("Node had unexpected type: "+t.type)}function m(t,e){return x(e,t).parse()}function y(t,e){var s=x(e,t);return s.options.strictMode&&(s.state.strict=!0),s.getExpression()}function x(t,e){return new(t&&t.plugins?v(t.plugins):tt)(t,e)}function v(t){var e=t.filter(function(t){return"estree"===t||"flow"===t||"jsx"===t});e.indexOf("flow")>=0&&(e=e.filter(function(t){return"flow"!==t})).push("flow"),e.indexOf("estree")>=0&&(e=e.filter(function(t){return"estree"!==t})).unshift("estree");var s=e.join("/"),i=pt[s];if(!i){i=tt;for(var r=e,a=Array.isArray(r),n=0,r=a?r:r[Symbol.iterator]();;){var o;if(a){if(n>=r.length)break;o=r[n++];}else{if((n=r.next()).done)break;o=n.value;}i=Z[o](i);}pt[s]=i;}return i}Object.defineProperty(e,"__esModule",{value:!0});var b={sourceType:"script",sourceFilename:void 0,startLine:1,allowReturnOutsideFunction:!1,allowImportExportEverywhere:!1,allowSuperOutsideMethod:!1,plugins:[],strictMode:null,ranges:!1},g=function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")},w=function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e);},P=function(t,e){if(!t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?t:e},A=!0,k=function t(e){var s=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};g(this,t),this.label=e,this.keyword=s.keyword,this.beforeExpr=!!s.beforeExpr,this.startsExpr=!!s.startsExpr,this.rightAssociative=!!s.rightAssociative,this.isLoop=!!s.isLoop,this.isAssign=!!s.isAssign,this.prefix=!!s.prefix,this.postfix=!!s.postfix,this.binop=s.binop||null,this.updateContext=null;},E=function(t){function e(s){var i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return g(this,e),i.keyword=s,P(this,t.call(this,s,i))}return w(e,t),e}(k),T=function(t){function e(s,i){return g(this,e),P(this,t.call(this,s,{beforeExpr:A,binop:i}))}return w(e,t),e}(k),C={num:new k("num",{startsExpr:!0}),regexp:new k("regexp",{startsExpr:!0}),string:new k("string",{startsExpr:!0}),name:new k("name",{startsExpr:!0}),eof:new k("eof"),bracketL:new k("[",{beforeExpr:A,startsExpr:!0}),bracketR:new k("]"),braceL:new k("{",{beforeExpr:A,startsExpr:!0}),braceBarL:new k("{|",{beforeExpr:A,startsExpr:!0}),braceR:new k("}"),braceBarR:new k("|}"),parenL:new k("(",{beforeExpr:A,startsExpr:!0}),parenR:new k(")"),comma:new k(",",{beforeExpr:A}),semi:new k(";",{beforeExpr:A}),colon:new k(":",{beforeExpr:A}),doubleColon:new k("::",{beforeExpr:A}),dot:new k("."),question:new k("?",{beforeExpr:A}),arrow:new k("=>",{beforeExpr:A}),template:new k("template"),ellipsis:new k("...",{beforeExpr:A}),backQuote:new k("`",{startsExpr:!0}),dollarBraceL:new k("${",{beforeExpr:A,startsExpr:!0}),at:new k("@"),hash:new k("#"),eq:new k("=",{beforeExpr:A,isAssign:!0}),assign:new k("_=",{beforeExpr:A,isAssign:!0}),incDec:new k("++/--",{prefix:!0,postfix:!0,startsExpr:!0}),prefix:new k("prefix",{beforeExpr:A,prefix:!0,startsExpr:!0}),logicalOR:new T("||",1),logicalAND:new T("&&",2),bitwiseOR:new T("|",3),bitwiseXOR:new T("^",4),bitwiseAND:new T("&",5),equality:new T("==/!=",6),relational:new T("",7),bitShift:new T("<>",8),plusMin:new k("+/-",{beforeExpr:A,binop:9,prefix:!0,startsExpr:!0}),modulo:new T("%",10),star:new T("*",10),slash:new T("/",10),exponent:new k("**",{beforeExpr:A,binop:11,rightAssociative:!0})},N={break:new E("break"),case:new E("case",{beforeExpr:A}),catch:new E("catch"),continue:new E("continue"),debugger:new E("debugger"),default:new E("default",{beforeExpr:A}),do:new E("do",{isLoop:!0,beforeExpr:A}),else:new E("else",{beforeExpr:A}),finally:new E("finally"),for:new E("for",{isLoop:!0}),function:new E("function",{startsExpr:!0}),if:new E("if"),return:new E("return",{beforeExpr:A}),switch:new E("switch"),throw:new E("throw",{beforeExpr:A}),try:new E("try"),var:new E("var"),let:new E("let"),const:new E("const"),while:new E("while",{isLoop:!0}),with:new E("with"),new:new E("new",{beforeExpr:A,startsExpr:!0}),this:new E("this",{startsExpr:!0}),super:new E("super",{startsExpr:!0}),class:new E("class"),extends:new E("extends",{beforeExpr:A}),export:new E("export"),import:new E("import",{startsExpr:!0}),yield:new E("yield",{beforeExpr:A,startsExpr:!0}),null:new E("null",{startsExpr:!0}),true:new E("true",{startsExpr:!0}),false:new E("false",{startsExpr:!0}),in:new E("in",{beforeExpr:A,binop:7}),instanceof:new E("instanceof",{beforeExpr:A,binop:7}),typeof:new E("typeof",{beforeExpr:A,prefix:!0,startsExpr:!0}),void:new E("void",{beforeExpr:A,prefix:!0,startsExpr:!0}),delete:new E("delete",{beforeExpr:A,prefix:!0,startsExpr:!0})};Object.keys(N).forEach(function(t){C["_"+t]=N[t];});var S={6:i("enum await"),strict:i("implements interface let package private protected public static yield"),strictBind:i("eval arguments")},L=i("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this let const class extends export import yield super"),I="ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠ-ࢴࢶ-ࢽऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲈᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞮꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ",_="·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࣔ-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఃా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ഁ-ഃാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ංඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ູົຼ່-ໍ໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠐-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭ᳲ-᳴᳸᳹᷀-᷵᷻-᷿‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱꤀-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿",j=new RegExp("["+I+"]"),R=new RegExp("["+I+_+"]");I=_=null;var D=[0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,17,26,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,26,45,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,785,52,76,44,33,24,27,35,42,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,25,391,63,32,0,449,56,264,8,2,36,18,0,50,29,881,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,881,68,12,0,67,12,65,0,32,6124,20,754,9486,1,3071,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,10591,541],O=[509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,1306,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,52,0,13,2,49,13,10,2,4,9,83,11,7,0,161,11,6,9,7,3,57,0,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,87,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,423,9,838,7,2,7,17,9,57,21,2,13,19882,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239],M=/\r\n?|\n|\u2028|\u2029/,F=new RegExp(M.source,"g"),B=/[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/,q=function t(e,s,i,r){g(this,t),this.token=e,this.isExpr=!!s,this.preserveSpace=!!i,this.override=r;},V={braceStatement:new q("{",!1),braceExpression:new q("{",!0),templateQuasi:new q("${",!0),parenStatement:new q("(",!1),parenExpression:new q("(",!0),template:new q("`",!0,!0,function(t){return t.readTmplToken()}),functionExpression:new q("function",!0)};C.parenR.updateContext=C.braceR.updateContext=function(){if(1!==this.state.context.length){var t=this.state.context.pop();t===V.braceStatement&&this.curContext()===V.functionExpression?(this.state.context.pop(),this.state.exprAllowed=!1):t===V.templateQuasi?this.state.exprAllowed=!0:this.state.exprAllowed=!t.isExpr;}else this.state.exprAllowed=!0;},C.name.updateContext=function(t){this.state.exprAllowed=!1,t!==C._let&&t!==C._const&&t!==C._var||M.test(this.input.slice(this.state.end))&&(this.state.exprAllowed=!0);},C.braceL.updateContext=function(t){this.state.context.push(this.braceIsBlock(t)?V.braceStatement:V.braceExpression),this.state.exprAllowed=!0;},C.dollarBraceL.updateContext=function(){this.state.context.push(V.templateQuasi),this.state.exprAllowed=!0;},C.parenL.updateContext=function(t){var e=t===C._if||t===C._for||t===C._with||t===C._while;this.state.context.push(e?V.parenStatement:V.parenExpression),this.state.exprAllowed=!0;},C.incDec.updateContext=function(){},C._function.updateContext=function(){this.curContext()!==V.braceStatement&&this.state.context.push(V.functionExpression),this.state.exprAllowed=!1;},C.backQuote.updateContext=function(){this.curContext()===V.template?this.state.context.pop():this.state.context.push(V.template),this.state.exprAllowed=!1;};var U=function t(e,s){g(this,t),this.line=e,this.column=s;},X=function t(e,s){g(this,t),this.start=e,this.end=s;},J=function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.raise=function(t,e){var s=h(this.input,t);e+=" ("+s.line+":"+s.column+")";var i=new SyntaxError(e);throw i.pos=t,i.loc=s,i},e}(function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.addComment=function(t){this.filename&&(t.loc.filename=this.filename),this.state.trailingComments.push(t),this.state.leadingComments.push(t);},e.prototype.processComment=function(t){if(!("Program"===t.type&&t.body.length>0)){var e=this.state.commentStack,s=void 0,i=void 0,r=void 0,a=void 0,n=void 0;if(this.state.trailingComments.length>0)this.state.trailingComments[0].start>=t.end?(r=this.state.trailingComments,this.state.trailingComments=[]):this.state.trailingComments.length=0;else{var o=p(e);e.length>0&&o.trailingComments&&o.trailingComments[0].start>=t.end&&(r=o.trailingComments,o.trailingComments=null);}for(e.length>0&&p(e).start>=t.start&&(s=e.pop());e.length>0&&p(e).start>=t.start;)i=e.pop();if(!i&&s&&(i=s),s&&("ObjectProperty"===s.type||"CallExpression"===t.type)&&this.state.leadingComments.length>0&&p(this.state.leadingComments).start>=t.start&&this.state.commentPreviousNode){for(n=0;n0&&(s.trailingComments=this.state.leadingComments,this.state.leadingComments=[]);}if(i){if(i.leadingComments)if(i!==t&&p(i.leadingComments).end<=t.start)t.leadingComments=i.leadingComments,i.leadingComments=null;else for(a=i.leadingComments.length-2;a>=0;--a)if(i.leadingComments[a].end<=t.start){t.leadingComments=i.leadingComments.splice(0,a+1);break}}else if(this.state.leadingComments.length>0)if(p(this.state.leadingComments).end<=t.start){if(this.state.commentPreviousNode)for(n=0;n0&&(t.leadingComments=this.state.leadingComments,this.state.leadingComments=[]);}else{for(a=0;at.start);a++);var h=this.state.leadingComments.slice(0,a);t.leadingComments=0===h.length?null:h,0===(r=this.state.leadingComments.slice(a)).length&&(r=null);}this.state.commentPreviousNode=t,r&&(r.length&&r[0].start>=t.start&&p(r).end<=t.end?t.innerComments=r:t.trailingComments=r),e.push(t);}},e}(function(){function t(){g(this,t);}return t.prototype.isReservedWord=function(t){return"await"===t?this.inModule:S[6](t)},t.prototype.hasPlugin=function(t){return!!this.plugins[t]},t}())),W=function(){function t(){g(this,t);}return t.prototype.init=function(t,e){this.strict=!1!==t.strictMode&&"module"===t.sourceType,this.input=e,this.potentialArrowAt=-1,this.inMethod=this.inFunction=this.inGenerator=this.inAsync=this.inPropertyName=this.inType=this.inClass=this.inClassProperty=this.noAnonFunctionType=!1,this.labels=[],this.decorators=[],this.tokens=[],this.comments=[],this.trailingComments=[],this.leadingComments=[],this.commentStack=[],this.pos=this.lineStart=0,this.curLine=t.startLine,this.type=C.eof,this.value=null,this.start=this.end=this.pos,this.startLoc=this.endLoc=this.curPosition(),this.lastTokEndLoc=this.lastTokStartLoc=null,this.lastTokStart=this.lastTokEnd=this.pos,this.context=[V.braceStatement],this.exprAllowed=!0,this.containsEsc=this.containsOctal=!1,this.octalPosition=null,this.invalidTemplateEscapePosition=null,this.exportedIdentifiers=[];},t.prototype.curPosition=function(){return new U(this.curLine,this.pos-this.lineStart)},t.prototype.clone=function(e){var s=new t;for(var i in this){var r=this[i];e&&"context"!==i||!Array.isArray(r)||(r=r.slice()),s[i]=r;}return s},t}(),G=function t(e){g(this,t),this.type=e.type,this.value=e.value,this.start=e.start,this.end=e.end,this.loc=new X(e.startLoc,e.endLoc);},K=function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.addExtra=function(t,e,s){t&&((t.extra=t.extra||{})[e]=s);},e.prototype.isRelational=function(t){return this.match(C.relational)&&this.state.value===t},e.prototype.expectRelational=function(t){this.isRelational(t)?this.next():this.unexpected(null,C.relational);},e.prototype.isContextual=function(t){return this.match(C.name)&&this.state.value===t},e.prototype.eatContextual=function(t){return this.state.value===t&&this.eat(C.name)},e.prototype.expectContextual=function(t,e){this.eatContextual(t)||this.unexpected(null,e);},e.prototype.canInsertSemicolon=function(){return this.match(C.eof)||this.match(C.braceR)||M.test(this.input.slice(this.state.lastTokEnd,this.state.start))},e.prototype.isLineTerminator=function(){return this.eat(C.semi)||this.canInsertSemicolon()},e.prototype.semicolon=function(){this.isLineTerminator()||this.unexpected(null,C.semi);},e.prototype.expect=function(t,e){this.eat(t)||this.unexpected(e,t);},e.prototype.unexpected=function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"Unexpected token";throw"string"!=typeof e&&(e="Unexpected token, expected "+e.label),this.raise(null!=t?t:this.state.start,e)},e}(function(t){function e(s,i){g(this,e);var r=P(this,t.call(this));return r.state=new W,r.state.init(s,i),r}return w(e,t),e.prototype.next=function(){this.isLookahead||this.state.tokens.push(new G(this.state)),this.state.lastTokEnd=this.state.end,this.state.lastTokStart=this.state.start,this.state.lastTokEndLoc=this.state.endLoc,this.state.lastTokStartLoc=this.state.startLoc,this.nextToken();},e.prototype.eat=function(t){return!!this.match(t)&&(this.next(),!0)},e.prototype.match=function(t){return this.state.type===t},e.prototype.isKeyword=function(t){return L(t)},e.prototype.lookahead=function(){var t=this.state;this.state=t.clone(!0),this.isLookahead=!0,this.next(),this.isLookahead=!1;var e=this.state.clone(!0);return this.state=t,e},e.prototype.setStrict=function(t){if(this.state.strict=t,this.match(C.num)||this.match(C.string)){for(this.state.pos=this.state.start;this.state.pos=this.input.length?this.finishToken(C.eof):t.override?t.override(this):this.readToken(this.fullCharCodeAtPos())},e.prototype.readToken=function(t){return a(t)||92===t?this.readWord():this.getTokenFromCode(t)},e.prototype.fullCharCodeAtPos=function(){var t=this.input.charCodeAt(this.state.pos);return t<=55295||t>=57344?t:(t<<10)+this.input.charCodeAt(this.state.pos+1)-56613888},e.prototype.pushComment=function(t,e,s,i,r,a){var n={type:t?"CommentBlock":"CommentLine",value:e,start:s,end:i,loc:new X(r,a)};this.isLookahead||(this.state.tokens.push(n),this.state.comments.push(n),this.addComment(n));},e.prototype.skipBlockComment=function(){var t=this.state.curPosition(),e=this.state.pos,s=this.input.indexOf("*/",this.state.pos+=2);-1===s&&this.raise(this.state.pos-2,"Unterminated comment"),this.state.pos=s+2,F.lastIndex=e;for(var i=void 0;(i=F.exec(this.input))&&i.index8&&t<14||t>=5760&&B.test(String.fromCharCode(t))))break t;++this.state.pos;}}},e.prototype.finishToken=function(t,e){this.state.end=this.state.pos,this.state.endLoc=this.state.curPosition();var s=this.state.type;this.state.type=t,this.state.value=e,this.updateContext(s);},e.prototype.readToken_dot=function(){var t=this.input.charCodeAt(this.state.pos+1);if(t>=48&&t<=57)return this.readNumber(!0);var e=this.input.charCodeAt(this.state.pos+2);return 46===t&&46===e?(this.state.pos+=3,this.finishToken(C.ellipsis)):(++this.state.pos,this.finishToken(C.dot))},e.prototype.readToken_slash=function(){return this.state.exprAllowed?(++this.state.pos,this.readRegexp()):61===this.input.charCodeAt(this.state.pos+1)?this.finishOp(C.assign,2):this.finishOp(C.slash,1)},e.prototype.readToken_mult_modulo=function(t){var e=42===t?C.star:C.modulo,s=1,i=this.input.charCodeAt(this.state.pos+1);return 42===i&&(s++,i=this.input.charCodeAt(this.state.pos+2),e=C.exponent),61===i&&(s++,e=C.assign),this.finishOp(e,s)},e.prototype.readToken_pipe_amp=function(t){var e=this.input.charCodeAt(this.state.pos+1);return e===t?this.finishOp(124===t?C.logicalOR:C.logicalAND,2):61===e?this.finishOp(C.assign,2):124===t&&125===e&&this.hasPlugin("flow")?this.finishOp(C.braceBarR,2):this.finishOp(124===t?C.bitwiseOR:C.bitwiseAND,1)},e.prototype.readToken_caret=function(){return 61===this.input.charCodeAt(this.state.pos+1)?this.finishOp(C.assign,2):this.finishOp(C.bitwiseXOR,1)},e.prototype.readToken_plus_min=function(t){var e=this.input.charCodeAt(this.state.pos+1);return e===t?45===e&&62===this.input.charCodeAt(this.state.pos+2)&&M.test(this.input.slice(this.state.lastTokEnd,this.state.pos))?(this.skipLineComment(3),this.skipSpace(),this.nextToken()):this.finishOp(C.incDec,2):61===e?this.finishOp(C.assign,2):this.finishOp(C.plusMin,1)},e.prototype.readToken_lt_gt=function(t){var e=this.input.charCodeAt(this.state.pos+1),s=1;return e===t?(s=62===t&&62===this.input.charCodeAt(this.state.pos+2)?3:2,61===this.input.charCodeAt(this.state.pos+s)?this.finishOp(C.assign,s+1):this.finishOp(C.bitShift,s)):33===e&&60===t&&45===this.input.charCodeAt(this.state.pos+2)&&45===this.input.charCodeAt(this.state.pos+3)?(this.inModule&&this.unexpected(),this.skipLineComment(4),this.skipSpace(),this.nextToken()):(61===e&&(s=2),this.finishOp(C.relational,s))},e.prototype.readToken_eq_excl=function(t){var e=this.input.charCodeAt(this.state.pos+1);return 61===e?this.finishOp(C.equality,61===this.input.charCodeAt(this.state.pos+2)?3:2):61===t&&62===e?(this.state.pos+=2,this.finishToken(C.arrow)):this.finishOp(61===t?C.eq:C.prefix,1)},e.prototype.getTokenFromCode=function(t){switch(t){case 35:if(this.hasPlugin("classPrivateProperties")&&this.state.inClass)return++this.state.pos,this.finishToken(C.hash);this.raise(this.state.pos,"Unexpected character '"+c(t)+"'");case 46:return this.readToken_dot();case 40:return++this.state.pos,this.finishToken(C.parenL);case 41:return++this.state.pos,this.finishToken(C.parenR);case 59:return++this.state.pos,this.finishToken(C.semi);case 44:return++this.state.pos,this.finishToken(C.comma);case 91:return++this.state.pos,this.finishToken(C.bracketL);case 93:return++this.state.pos,this.finishToken(C.bracketR);case 123:return this.hasPlugin("flow")&&124===this.input.charCodeAt(this.state.pos+1)?this.finishOp(C.braceBarL,2):(++this.state.pos,this.finishToken(C.braceL));case 125:return++this.state.pos,this.finishToken(C.braceR);case 58:return this.hasPlugin("functionBind")&&58===this.input.charCodeAt(this.state.pos+1)?this.finishOp(C.doubleColon,2):(++this.state.pos,this.finishToken(C.colon));case 63:return++this.state.pos,this.finishToken(C.question);case 64:return++this.state.pos,this.finishToken(C.at);case 96:return++this.state.pos,this.finishToken(C.backQuote);case 48:var e=this.input.charCodeAt(this.state.pos+1);if(120===e||88===e)return this.readRadixNumber(16);if(111===e||79===e)return this.readRadixNumber(8);if(98===e||66===e)return this.readRadixNumber(2);case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:return this.readNumber(!1);case 34:case 39:return this.readString(t);case 47:return this.readToken_slash();case 37:case 42:return this.readToken_mult_modulo(t);case 124:case 38:return this.readToken_pipe_amp(t);case 94:return this.readToken_caret();case 43:case 45:return this.readToken_plus_min(t);case 60:case 62:return this.readToken_lt_gt(t);case 61:case 33:return this.readToken_eq_excl(t);case 126:return this.finishOp(C.prefix,1)}this.raise(this.state.pos,"Unexpected character '"+c(t)+"'");},e.prototype.finishOp=function(t,e){var s=this.input.slice(this.state.pos,this.state.pos+e);return this.state.pos+=e,this.finishToken(t,s)},e.prototype.readRegexp=function(){for(var t=this.state.pos,e=void 0,s=void 0;;){this.state.pos>=this.input.length&&this.raise(t,"Unterminated regular expression");var i=this.input.charAt(this.state.pos);if(M.test(i)&&this.raise(t,"Unterminated regular expression"),e)e=!1;else{if("["===i)s=!0;else if("]"===i&&s)s=!1;else if("/"===i&&!s)break;e="\\"===i;}++this.state.pos;}var r=this.input.slice(t,this.state.pos);++this.state.pos;var a=this.readWord1();return a&&(/^[gmsiyu]*$/.test(a)||this.raise(t,"Invalid regular expression flag")),this.finishToken(C.regexp,{pattern:r,flags:a})},e.prototype.readInt=function(t,e){for(var s=this.state.pos,i=0,r=0,a=null==e?1/0:e;r=97?n-97+10:n>=65?n-65+10:n>=48&&n<=57?n-48:1/0)>=t)break;++this.state.pos,i=i*t+o;}return this.state.pos===s||null!=e&&this.state.pos-s!==e?null:i},e.prototype.readRadixNumber=function(t){this.state.pos+=2;var e=this.readInt(t);return null==e&&this.raise(this.state.start+2,"Expected number in radix "+t),a(this.fullCharCodeAtPos())&&this.raise(this.state.pos,"Identifier directly after number"),this.finishToken(C.num,e)},e.prototype.readNumber=function(t){var e=this.state.pos,s=48===this.input.charCodeAt(e),i=!1;t||null!==this.readInt(10)||this.raise(e,"Invalid number"),s&&this.state.pos==e+1&&(s=!1);var r=this.input.charCodeAt(this.state.pos);46!==r||s||(++this.state.pos,this.readInt(10),i=!0,r=this.input.charCodeAt(this.state.pos)),69!==r&&101!==r||s||(43!==(r=this.input.charCodeAt(++this.state.pos))&&45!==r||++this.state.pos,null===this.readInt(10)&&this.raise(e,"Invalid number"),i=!0),a(this.fullCharCodeAtPos())&&this.raise(this.state.pos,"Identifier directly after number");var n=this.input.slice(e,this.state.pos),o=void 0;return i?o=parseFloat(n):s&&1!==n.length?this.state.strict?this.raise(e,"Invalid number"):o=/[89]/.test(n)?parseInt(n,10):parseInt(n,8):o=parseInt(n,10),this.finishToken(C.num,o)},e.prototype.readCodePoint=function(t){var e=void 0;if(123===this.input.charCodeAt(this.state.pos)){var s=++this.state.pos;if(e=this.readHexChar(this.input.indexOf("}",this.state.pos)-this.state.pos,t),++this.state.pos,null===e)--this.state.invalidTemplateEscapePosition;else if(e>1114111){if(!t)return this.state.invalidTemplateEscapePosition=s-2,null;this.raise(s,"Code point out of bounds");}}else e=this.readHexChar(4,t);return e},e.prototype.readString=function(t){for(var e="",s=++this.state.pos;;){this.state.pos>=this.input.length&&this.raise(this.state.start,"Unterminated string constant");var i=this.input.charCodeAt(this.state.pos);if(i===t)break;92===i?(e+=this.input.slice(s,this.state.pos),e+=this.readEscapedChar(!1),s=this.state.pos):(o(i)&&this.raise(this.state.start,"Unterminated string constant"),++this.state.pos);}return e+=this.input.slice(s,this.state.pos++),this.finishToken(C.string,e)},e.prototype.readTmplToken=function(){for(var t="",e=this.state.pos,s=!1;;){this.state.pos>=this.input.length&&this.raise(this.state.start,"Unterminated template");var i=this.input.charCodeAt(this.state.pos);if(96===i||36===i&&123===this.input.charCodeAt(this.state.pos+1))return this.state.pos===this.state.start&&this.match(C.template)?36===i?(this.state.pos+=2,this.finishToken(C.dollarBraceL)):(++this.state.pos,this.finishToken(C.backQuote)):(t+=this.input.slice(e,this.state.pos),this.finishToken(C.template,s?null:t));if(92===i){t+=this.input.slice(e,this.state.pos);var r=this.readEscapedChar(!0);null===r?s=!0:t+=r,e=this.state.pos;}else if(o(i)){switch(t+=this.input.slice(e,this.state.pos),++this.state.pos,i){case 13:10===this.input.charCodeAt(this.state.pos)&&++this.state.pos;case 10:t+="\n";break;default:t+=String.fromCharCode(i);}++this.state.curLine,this.state.lineStart=this.state.pos,e=this.state.pos;}else++this.state.pos;}},e.prototype.readEscapedChar=function(t){var e=!t,s=this.input.charCodeAt(++this.state.pos);switch(++this.state.pos,s){case 110:return"\n";case 114:return"\r";case 120:var i=this.readHexChar(2,e);return null===i?null:String.fromCharCode(i);case 117:var r=this.readCodePoint(e);return null===r?null:c(r);case 116:return"\t";case 98:return"\b";case 118:return"\v";case 102:return"\f";case 13:10===this.input.charCodeAt(this.state.pos)&&++this.state.pos;case 10:return this.state.lineStart=this.state.pos,++this.state.curLine,"";default:if(s>=48&&s<=55){var a=this.state.pos-1,n=this.input.substr(this.state.pos-1,3).match(/^[0-7]+/)[0],o=parseInt(n,8);if(o>255&&(n=n.slice(0,-1),o=parseInt(n,8)),o>0){if(t)return this.state.invalidTemplateEscapePosition=a,null;this.state.strict?this.raise(a,"Octal literal in strict mode"):this.state.containsOctal||(this.state.containsOctal=!0,this.state.octalPosition=a);}return this.state.pos+=n.length-1,String.fromCharCode(o)}return String.fromCharCode(s)}},e.prototype.readHexChar=function(t,e){var s=this.state.pos,i=this.readInt(16,t);return null===i&&(e?this.raise(s,"Bad character escape sequence"):(this.state.pos=s-1,this.state.invalidTemplateEscapePosition=s-1)),i},e.prototype.readWord1=function(){this.state.containsEsc=!1;for(var t="",e=!0,s=this.state.pos;this.state.pos=i.length)break;n=i[a++];}else{if((a=i.next()).done)break;n=a.value;}n.name===e&&this.raise(s.start,"Label '"+e+"' is already declared");}for(var o=this.state.type.isLoop?"loop":this.match(C._switch)?"switch":null,h=this.state.labels.length-1;h>=0;h--){var p=this.state.labels[h];if(p.statementStart!==t.start)break;p.statementStart=this.state.start,p.kind=o;}return this.state.labels.push({name:e,kind:o,statementStart:this.state.start}),t.body=this.parseStatement(!0),this.state.labels.pop(),t.label=s,this.finishNode(t,"LabeledStatement")},e.prototype.parseExpressionStatement=function(t,e){return t.expression=e,this.semicolon(),this.finishNode(t,"ExpressionStatement")},e.prototype.parseBlock=function(t){var e=this.startNode();return this.expect(C.braceL),this.parseBlockBody(e,t,!1,C.braceR),this.finishNode(e,"BlockStatement")},e.prototype.isValidDirective=function(t){return"ExpressionStatement"===t.type&&"StringLiteral"===t.expression.type&&!t.expression.extra.parenthesized},e.prototype.parseBlockBody=function(t,e,s,i){for(var r=t.body=[],a=t.directives=[],n=!1,o=void 0,h=void 0;!this.eat(i);){n||!this.state.containsOctal||h||(h=this.state.octalPosition);var p=this.parseStatement(!0,s);if(e&&!n&&this.isValidDirective(p)){var c=this.stmtToDirective(p);a.push(c),void 0===o&&"use strict"===c.value.value&&(o=this.state.strict,this.setStrict(!0),h&&this.raise(h,"Octal literal in strict mode"));}else n=!0,r.push(p);}!1===o&&this.setStrict(!1);},e.prototype.parseFor=function(t,e){return t.init=e,this.expect(C.semi),t.test=this.match(C.semi)?null:this.parseExpression(),this.expect(C.semi),t.update=this.match(C.parenR)?null:this.parseExpression(),this.expect(C.parenR),t.body=this.parseStatement(!1),this.state.labels.pop(),this.finishNode(t,"ForStatement")},e.prototype.parseForIn=function(t,e,s){var i=this.match(C._in)?"ForInStatement":"ForOfStatement";return s?this.eatContextual("of"):this.next(),"ForOfStatement"===i&&(t.await=!!s),t.left=e,t.right=this.parseExpression(),this.expect(C.parenR),t.body=this.parseStatement(!1),this.state.labels.pop(),this.finishNode(t,i)},e.prototype.parseVar=function(t,e,s){var i=t.declarations=[];for(t.kind=s.keyword;;){var r=this.startNode();if(this.parseVarHead(r),this.eat(C.eq)?r.init=this.parseMaybeAssign(e):s!==C._const||this.match(C._in)||this.isContextual("of")?"Identifier"===r.id.type||e&&(this.match(C._in)||this.isContextual("of"))?r.init=null:this.raise(this.state.lastTokEnd,"Complex binding patterns require an initialization value"):this.unexpected(),i.push(this.finishNode(r,"VariableDeclarator")),!this.eat(C.comma))break}return t},e.prototype.parseVarHead=function(t){t.id=this.parseBindingAtom(),this.checkLVal(t.id,!0,void 0,"variable declaration");},e.prototype.parseFunction=function(t,e,s,i,r){var a=this.state.inMethod;return this.state.inMethod=!1,this.initFunction(t,i),this.match(C.star)&&(t.async&&!this.hasPlugin("asyncGenerators")?this.unexpected():(t.generator=!0,this.next())),!e||r||this.match(C.name)||this.match(C._yield)||this.unexpected(),(this.match(C.name)||this.match(C._yield))&&(t.id=this.parseBindingIdentifier()),this.parseFunctionParams(t),this.parseFunctionBody(t,s),this.state.inMethod=a,this.finishNode(t,e?"FunctionDeclaration":"FunctionExpression")},e.prototype.parseFunctionParams=function(t){this.expect(C.parenL),t.params=this.parseBindingList(C.parenR);},e.prototype.parseClass=function(t,e,s){return this.next(),this.takeDecorators(t),this.parseClassId(t,e,s),this.parseClassSuper(t),this.parseClassBody(t),this.finishNode(t,e?"ClassDeclaration":"ClassExpression")},e.prototype.isClassProperty=function(){return this.match(C.eq)||this.match(C.semi)||this.match(C.braceR)},e.prototype.isClassMethod=function(){return this.match(C.parenL)},e.prototype.isNonstaticConstructor=function(t){return!(t.computed||t.static||"constructor"!==t.key.name&&"constructor"!==t.key.value)},e.prototype.parseClassBody=function(t){var e=this.state.strict;this.state.strict=!0,this.state.inClass=!0;var s=!1,i=[],r=this.startNode();for(r.body=[],this.expect(C.braceL);!this.eat(C.braceR);)if(this.eat(C.semi))i.length>0&&this.raise(this.state.lastTokEnd,"Decorators must not be followed by a semicolon");else if(this.match(C.at))i.push(this.parseDecorator());else{var a=this.startNode();if(i.length&&(a.decorators=i,i=[]),this.hasPlugin("classPrivateProperties")&&this.match(C.hash))this.next(),this.parsePropertyName(a),r.body.push(this.parsePrivateClassProperty(a));else{if(a.static=!1,this.match(C.name)&&"static"===this.state.value){var n=this.parseIdentifier(!0);if(this.isClassMethod()){a.kind="method",a.computed=!1,a.key=n,this.parseClassMethod(r,a,!1,!1);continue}if(this.isClassProperty()){a.computed=!1,a.key=n,r.body.push(this.parseClassProperty(a));continue}a.static=!0;}if(this.eat(C.star))a.kind="method",this.parsePropertyName(a),this.isNonstaticConstructor(a)&&this.raise(a.key.start,"Constructor can't be a generator"),a.computed||!a.static||"prototype"!==a.key.name&&"prototype"!==a.key.value||this.raise(a.key.start,"Classes may not have static property named prototype"),this.parseClassMethod(r,a,!0,!1);else{var o=this.match(C.name),h=this.parsePropertyName(a);if(a.computed||!a.static||"prototype"!==a.key.name&&"prototype"!==a.key.value||this.raise(a.key.start,"Classes may not have static property named prototype"),this.isClassMethod())this.isNonstaticConstructor(a)?(s?this.raise(h.start,"Duplicate constructor in the same class"):a.decorators&&this.raise(a.start,"You can't attach decorators to a class constructor"),s=!0,a.kind="constructor"):a.kind="method",this.parseClassMethod(r,a,!1,!1);else if(this.isClassProperty())this.isNonstaticConstructor(a)&&this.raise(a.key.start,"Classes may not have a non-static field named 'constructor'"),r.body.push(this.parseClassProperty(a));else if(o&&"async"===h.name&&!this.isLineTerminator()){var p=this.hasPlugin("asyncGenerators")&&this.eat(C.star);a.kind="method",this.parsePropertyName(a),this.isNonstaticConstructor(a)&&this.raise(a.key.start,"Constructor can't be an async function"),this.parseClassMethod(r,a,p,!0);}else!o||"get"!==h.name&&"set"!==h.name||this.isLineTerminator()&&this.match(C.star)?this.isLineTerminator()?(this.isNonstaticConstructor(a)&&this.raise(a.key.start,"Classes may not have a non-static field named 'constructor'"),r.body.push(this.parseClassProperty(a))):this.unexpected():(a.kind=h.name,this.parsePropertyName(a),this.isNonstaticConstructor(a)&&this.raise(a.key.start,"Constructor can't have get/set modifier"),this.parseClassMethod(r,a,!1,!1),this.checkGetterSetterParamCount(a));}}}i.length&&this.raise(this.state.start,"You have trailing decorators with no method"),t.body=this.finishNode(r,"ClassBody"),this.state.inClass=!1,this.state.strict=e;},e.prototype.parsePrivateClassProperty=function(t){return this.state.inClassProperty=!0,this.match(C.eq)?(this.next(),t.value=this.parseMaybeAssign()):t.value=null,this.semicolon(),this.state.inClassProperty=!1,this.finishNode(t,"ClassPrivateProperty")},e.prototype.parseClassProperty=function(t){var e=this.hasPlugin("classProperties"),s="You can only use Class Properties when the 'classProperties' plugin is enabled.";return t.typeAnnotation||e||this.raise(t.start,s),this.state.inClassProperty=!0,this.match(C.eq)?(e||this.raise(this.state.start,s),this.next(),t.value=this.parseMaybeAssign()):t.value=null,this.semicolon(),this.state.inClassProperty=!1,this.finishNode(t,"ClassProperty")},e.prototype.parseClassMethod=function(t,e,s,i){this.parseMethod(e,s,i),t.body.push(this.finishNode(e,"ClassMethod"));},e.prototype.parseClassId=function(t,e,s){this.match(C.name)?t.id=this.parseIdentifier():s||!e?t.id=null:this.unexpected(null,"A class name is required");},e.prototype.parseClassSuper=function(t){t.superClass=this.eat(C._extends)?this.parseExprSubscripts():null;},e.prototype.parseExport=function(t){if(this.eat(C._export),this.match(C.star)){var e=this.startNode();if(this.next(),!this.hasPlugin("exportExtensions")||!this.eatContextual("as"))return this.parseExportFrom(t,!0),this.finishNode(t,"ExportAllDeclaration");e.exported=this.parseIdentifier(!0),t.specifiers=[this.finishNode(e,"ExportNamespaceSpecifier")],this.parseExportSpecifiersMaybe(t),this.parseExportFrom(t,!0);}else if(this.hasPlugin("exportExtensions")&&this.isExportDefaultSpecifier()){var s=this.startNode();s.exported=this.parseIdentifier(!0);var i=[this.finishNode(s,"ExportDefaultSpecifier")];if(t.specifiers=i,this.match(C.comma)&&this.lookahead().type===C.star){this.expect(C.comma);var r=this.startNode();this.expect(C.star),this.expectContextual("as"),r.exported=this.parseIdentifier(),i.push(this.finishNode(r,"ExportNamespaceSpecifier"));}else this.parseExportSpecifiersMaybe(t);this.parseExportFrom(t,!0);}else{if(this.eat(C._default)){var a=this.startNode(),n=!1;return this.eat(C._function)?a=this.parseFunction(a,!0,!1,!1,!0):this.isContextual("async")&&this.lookahead().type===C._function?(this.eatContextual("async"),this.eat(C._function),a=this.parseFunction(a,!0,!1,!0,!0)):this.match(C._class)?a=this.parseClass(a,!0,!0):(n=!0,a=this.parseMaybeAssign()),t.declaration=a,n&&this.semicolon(),this.checkExport(t,!0,!0),this.finishNode(t,"ExportDefaultDeclaration")}this.shouldParseExportDeclaration()?(t.specifiers=[],t.source=null,t.declaration=this.parseExportDeclaration(t)):(t.declaration=null,t.specifiers=this.parseExportSpecifiers(),this.parseExportFrom(t));}return this.checkExport(t,!0),this.finishNode(t,"ExportNamedDeclaration")},e.prototype.parseExportDeclaration=function(t){return this.parseStatement(!0)},e.prototype.isExportDefaultSpecifier=function(){if(this.match(C.name))return"async"!==this.state.value;if(!this.match(C._default))return!1;var t=this.lookahead();return t.type===C.comma||t.type===C.name&&"from"===t.value},e.prototype.parseExportSpecifiersMaybe=function(t){this.eat(C.comma)&&(t.specifiers=t.specifiers.concat(this.parseExportSpecifiers()));},e.prototype.parseExportFrom=function(t,e){this.eatContextual("from")?(t.source=this.match(C.string)?this.parseExprAtom():this.unexpected(),this.checkExport(t)):e?this.unexpected():t.source=null,this.semicolon();},e.prototype.shouldParseExportDeclaration=function(){return"var"===this.state.type.keyword||"const"===this.state.type.keyword||"let"===this.state.type.keyword||"function"===this.state.type.keyword||"class"===this.state.type.keyword||this.isContextual("async")},e.prototype.checkExport=function(t,e,s){if(e)if(s)this.checkDuplicateExports(t,"default");else if(t.specifiers&&t.specifiers.length)for(var i=t.specifiers,r=Array.isArray(i),a=0,i=r?i:i[Symbol.iterator]();;){var n;if(r){if(a>=i.length)break;n=i[a++];}else{if((a=i.next()).done)break;n=a.value;}var o=n;this.checkDuplicateExports(o,o.exported.name);}else if(t.declaration)if("FunctionDeclaration"===t.declaration.type||"ClassDeclaration"===t.declaration.type)this.checkDuplicateExports(t,t.declaration.id.name);else if("VariableDeclaration"===t.declaration.type)for(var h=t.declaration.declarations,p=Array.isArray(h),c=0,h=p?h:h[Symbol.iterator]();;){var l;if(p){if(c>=h.length)break;l=h[c++];}else{if((c=h.next()).done)break;l=c.value;}var u=l;this.checkDeclaration(u.id);}if(this.state.decorators.length){var d=t.declaration&&("ClassDeclaration"===t.declaration.type||"ClassExpression"===t.declaration.type);if(!t.declaration||!d)throw this.raise(t.start,"You can only use decorators on an export when exporting a class");this.takeDecorators(t.declaration);}},e.prototype.checkDeclaration=function(t){if("ObjectPattern"===t.type)for(var e=t.properties,s=Array.isArray(e),i=0,e=s?e:e[Symbol.iterator]();;){var r;if(s){if(i>=e.length)break;r=e[i++];}else{if((i=e.next()).done)break;r=i.value;}var a=r;this.checkDeclaration(a);}else if("ArrayPattern"===t.type)for(var n=t.elements,o=Array.isArray(n),h=0,n=o?n:n[Symbol.iterator]();;){var p;if(o){if(h>=n.length)break;p=n[h++];}else{if((h=n.next()).done)break;p=h.value;}var c=p;c&&this.checkDeclaration(c);}else"ObjectProperty"===t.type?this.checkDeclaration(t.value):"RestElement"===t.type?this.checkDeclaration(t.argument):"Identifier"===t.type&&this.checkDuplicateExports(t,t.name);},e.prototype.checkDuplicateExports=function(t,e){this.state.exportedIdentifiers.indexOf(e)>-1&&this.raiseDuplicateExportError(t,e),this.state.exportedIdentifiers.push(e);},e.prototype.raiseDuplicateExportError=function(t,e){throw this.raise(t.start,"default"===e?"Only one default export allowed per module.":"`"+e+"` has already been exported. Exported identifiers must be unique.")},e.prototype.parseExportSpecifiers=function(){var t=[],e=!0,s=void 0;for(this.expect(C.braceL);!this.eat(C.braceR);){if(e)e=!1;else if(this.expect(C.comma),this.eat(C.braceR))break;var i=this.match(C._default);i&&!s&&(s=!0);var r=this.startNode();r.local=this.parseIdentifier(i),r.exported=this.eatContextual("as")?this.parseIdentifier(!0):r.local.__clone(),t.push(this.finishNode(r,"ExportSpecifier"));}return s&&!this.isContextual("from")&&this.unexpected(),t},e.prototype.parseImport=function(t){return this.eat(C._import),this.match(C.string)?(t.specifiers=[],t.source=this.parseExprAtom()):(t.specifiers=[],this.parseImportSpecifiers(t),this.expectContextual("from"),t.source=this.match(C.string)?this.parseExprAtom():this.unexpected()),this.semicolon(),this.finishNode(t,"ImportDeclaration")},e.prototype.parseImportSpecifiers=function(t){var e=!0;if(this.match(C.name)){var s=this.state.start,i=this.state.startLoc;if(t.specifiers.push(this.parseImportSpecifierDefault(this.parseIdentifier(),s,i)),!this.eat(C.comma))return}if(this.match(C.star)){var r=this.startNode();return this.next(),this.expectContextual("as"),r.local=this.parseIdentifier(),this.checkLVal(r.local,!0,void 0,"import namespace specifier"),void t.specifiers.push(this.finishNode(r,"ImportNamespaceSpecifier"))}for(this.expect(C.braceL);!this.eat(C.braceR);){if(e)e=!1;else if(this.eat(C.colon)&&this.unexpected(null,"ES2015 named imports do not destructure. Use another statement for destructuring after the import."),this.expect(C.comma),this.eat(C.braceR))break;this.parseImportSpecifier(t);}},e.prototype.parseImportSpecifier=function(t){var e=this.startNode();e.imported=this.parseIdentifier(!0),this.eatContextual("as")?e.local=this.parseIdentifier():(this.checkReservedWord(e.imported.name,e.start,!0,!0),e.local=e.imported.__clone()),this.checkLVal(e.local,!0,void 0,"import specifier"),t.specifiers.push(this.finishNode(e,"ImportSpecifier"));},e.prototype.parseImportSpecifierDefault=function(t,e,s){var i=this.startNodeAt(e,s);return i.local=t,this.checkLVal(i.local,!0,void 0,"default import specifier"),this.finishNode(i,"ImportDefaultSpecifier")},e}(function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.checkPropClash=function(t,e){if(!t.computed&&!t.kind){var s=t.key;"__proto__"===("Identifier"===s.type?s.name:String(s.value))&&(e.proto&&this.raise(s.start,"Redefinition of __proto__ property"),e.proto=!0);}},e.prototype.getExpression=function(){this.nextToken();var t=this.parseExpression();return this.match(C.eof)||this.unexpected(),t},e.prototype.parseExpression=function(t,e){var s=this.state.start,i=this.state.startLoc,r=this.parseMaybeAssign(t,e);if(this.match(C.comma)){var a=this.startNodeAt(s,i);for(a.expressions=[r];this.eat(C.comma);)a.expressions.push(this.parseMaybeAssign(t,e));return this.toReferencedList(a.expressions),this.finishNode(a,"SequenceExpression")}return r},e.prototype.parseMaybeAssign=function(t,e,s,i){var r=this.state.start,a=this.state.startLoc;if(this.match(C._yield)&&this.state.inGenerator){var n=this.parseYield();return s&&(n=s.call(this,n,r,a)),n}var o=void 0;e?o=!1:(e={start:0},o=!0),(this.match(C.parenL)||this.match(C.name))&&(this.state.potentialArrowAt=this.state.start);var h=this.parseMaybeConditional(t,e,i);if(s&&(h=s.call(this,h,r,a)),this.state.type.isAssign){var p=this.startNodeAt(r,a);if(p.operator=this.state.value,p.left=this.match(C.eq)?this.toAssignable(h,void 0,"assignment expression"):h,e.start=0,this.checkLVal(h,void 0,void 0,"assignment expression"),h.extra&&h.extra.parenthesized){var c=void 0;"ObjectPattern"===h.type?c="`({a}) = 0` use `({a} = 0)`":"ArrayPattern"===h.type&&(c="`([a]) = 0` use `([a] = 0)`"),c&&this.raise(h.start,"You're trying to assign to a parenthesized expression, eg. instead of "+c);}return this.next(),p.right=this.parseMaybeAssign(t),this.finishNode(p,"AssignmentExpression")}return o&&e.start&&this.unexpected(e.start),h},e.prototype.parseMaybeConditional=function(t,e,s){var i=this.state.start,r=this.state.startLoc,a=this.parseExprOps(t,e);return e&&e.start?a:this.parseConditional(a,t,i,r,s)},e.prototype.parseConditional=function(t,e,s,i){if(this.eat(C.question)){var r=this.startNodeAt(s,i);return r.test=t,r.consequent=this.parseMaybeAssign(),this.expect(C.colon),r.alternate=this.parseMaybeAssign(e),this.finishNode(r,"ConditionalExpression")}return t},e.prototype.parseExprOps=function(t,e){var s=this.state.start,i=this.state.startLoc,r=this.parseMaybeUnary(e);return e&&e.start?r:this.parseExprOp(r,s,i,-1,t)},e.prototype.parseExprOp=function(t,e,s,i,r){var a=this.state.type.binop;if(!(null==a||r&&this.match(C._in))&&a>i){var n=this.startNodeAt(e,s);n.left=t,n.operator=this.state.value,"**"!==n.operator||"UnaryExpression"!==t.type||!t.extra||t.extra.parenthesizedArgument||t.extra.parenthesized||this.raise(t.argument.start,"Illegal expression. Wrap left hand side or entire exponentiation in parentheses.");var o=this.state.type;this.next();var h=this.state.start,p=this.state.startLoc;return n.right=this.parseExprOp(this.parseMaybeUnary(),h,p,o.rightAssociative?a-1:a,r),this.finishNode(n,o===C.logicalOR||o===C.logicalAND?"LogicalExpression":"BinaryExpression"),this.parseExprOp(n,e,s,i,r)}return t},e.prototype.parseMaybeUnary=function(t){if(this.state.type.prefix){var e=this.startNode(),s=this.match(C.incDec);e.operator=this.state.value,e.prefix=!0,this.next();var i=this.state.type;return e.argument=this.parseMaybeUnary(),this.addExtra(e,"parenthesizedArgument",!(i!==C.parenL||e.argument.extra&&e.argument.extra.parenthesized)),t&&t.start&&this.unexpected(t.start),s?this.checkLVal(e.argument,void 0,void 0,"prefix operation"):this.state.strict&&"delete"===e.operator&&"Identifier"===e.argument.type&&this.raise(e.start,"Deleting local variable in strict mode"),this.finishNode(e,s?"UpdateExpression":"UnaryExpression")}var r=this.state.start,a=this.state.startLoc,n=this.parseExprSubscripts(t);if(t&&t.start)return n;for(;this.state.type.postfix&&!this.canInsertSemicolon();){var o=this.startNodeAt(r,a);o.operator=this.state.value,o.prefix=!1,o.argument=n,this.checkLVal(n,void 0,void 0,"postfix operation"),this.next(),n=this.finishNode(o,"UpdateExpression");}return n},e.prototype.parseExprSubscripts=function(t){var e=this.state.start,s=this.state.startLoc,i=this.state.potentialArrowAt,r=this.parseExprAtom(t);return"ArrowFunctionExpression"===r.type&&r.start===i?r:t&&t.start?r:this.parseSubscripts(r,e,s)},e.prototype.parseSubscripts=function(t,e,s,i){for(;;){if(!i&&this.eat(C.doubleColon)){var r=this.startNodeAt(e,s);return r.object=t,r.callee=this.parseNoCallExpr(),this.parseSubscripts(this.finishNode(r,"BindExpression"),e,s,i)}if(this.eat(C.dot)){var a=this.startNodeAt(e,s);a.object=t,a.property=this.hasPlugin("classPrivateProperties")?this.parseMaybePrivateName():this.parseIdentifier(!0),a.computed=!1,t=this.finishNode(a,"MemberExpression");}else if(this.eat(C.bracketL)){var n=this.startNodeAt(e,s);n.object=t,n.property=this.parseExpression(),n.computed=!0,this.expect(C.bracketR),t=this.finishNode(n,"MemberExpression");}else if(!i&&this.match(C.parenL)){var o=this.state.potentialArrowAt===t.start&&"Identifier"===t.type&&"async"===t.name&&!this.canInsertSemicolon();this.next();var h=this.startNodeAt(e,s);if(h.callee=t,h.arguments=this.parseCallExpressionArguments(C.parenR,o),"Import"===h.callee.type){1!==h.arguments.length&&this.raise(h.start,"import() requires exactly one argument");var p=h.arguments[0];p&&"SpreadElement"===p.type&&this.raise(p.start,"... is not allowed in import()");}if(t=this.finishNode(h,"CallExpression"),o&&this.shouldParseAsyncArrow())return this.parseAsyncArrowFromCallExpression(this.startNodeAt(e,s),h);this.toReferencedList(h.arguments);}else{if(!this.match(C.backQuote))return t;var c=this.startNodeAt(e,s);c.tag=t,c.quasi=this.parseTemplate(!0),t=this.finishNode(c,"TaggedTemplateExpression");}}throw new Error("Unreachable")},e.prototype.parseCallExpressionArguments=function(t,e){for(var s=[],i=void 0,r=!0;!this.eat(t);){if(r)r=!1;else if(this.expect(C.comma),this.eat(t))break;this.match(C.parenL)&&!i&&(i=this.state.start),s.push(this.parseExprListItem(!1,e?{start:0}:void 0,e?{start:0}:void 0));}return e&&i&&this.shouldParseAsyncArrow()&&this.unexpected(),s},e.prototype.shouldParseAsyncArrow=function(){return this.match(C.arrow)},e.prototype.parseAsyncArrowFromCallExpression=function(t,e){return this.expect(C.arrow),this.parseArrowExpression(t,e.arguments,!0)},e.prototype.parseNoCallExpr=function(){var t=this.state.start,e=this.state.startLoc;return this.parseSubscripts(this.parseExprAtom(),t,e,!0)},e.prototype.parseExprAtom=function(t){var e=this.state.potentialArrowAt===this.state.start,s=void 0;switch(this.state.type){case C._super:return this.state.inMethod||this.state.inClassProperty||this.options.allowSuperOutsideMethod||this.raise(this.state.start,"'super' outside of function or class"),s=this.startNode(),this.next(),this.match(C.parenL)||this.match(C.bracketL)||this.match(C.dot)||this.unexpected(),this.match(C.parenL)&&"constructor"!==this.state.inMethod&&!this.options.allowSuperOutsideMethod&&this.raise(s.start,"super() is only valid inside a class constructor. Make sure the method name is spelled exactly as 'constructor'."),this.finishNode(s,"Super");case C._import:return this.hasPlugin("dynamicImport")||this.unexpected(),s=this.startNode(),this.next(),this.match(C.parenL)||this.unexpected(null,C.parenL),this.finishNode(s,"Import");case C._this:return s=this.startNode(),this.next(),this.finishNode(s,"ThisExpression");case C._yield:this.state.inGenerator&&this.unexpected();case C.name:s=this.startNode();var i="await"===this.state.value&&this.state.inAsync,r=this.shouldAllowYieldIdentifier(),a=this.parseIdentifier(i||r);if("await"===a.name){if(this.state.inAsync||this.inModule)return this.parseAwait(s)}else{if("async"===a.name&&this.match(C._function)&&!this.canInsertSemicolon())return this.next(),this.parseFunction(s,!1,!1,!0);if(e&&"async"===a.name&&this.match(C.name)){var n=[this.parseIdentifier()];return this.expect(C.arrow),this.parseArrowExpression(s,n,!0)}}return e&&!this.canInsertSemicolon()&&this.eat(C.arrow)?this.parseArrowExpression(s,[a]):a;case C._do:if(this.hasPlugin("doExpressions")){var o=this.startNode();this.next();var h=this.state.inFunction,p=this.state.labels;return this.state.labels=[],this.state.inFunction=!1,o.body=this.parseBlock(!1,!0),this.state.inFunction=h,this.state.labels=p,this.finishNode(o,"DoExpression")}case C.regexp:var c=this.state.value;return s=this.parseLiteral(c.value,"RegExpLiteral"),s.pattern=c.pattern,s.flags=c.flags,s;case C.num:return this.parseLiteral(this.state.value,"NumericLiteral");case C.string:return this.parseLiteral(this.state.value,"StringLiteral");case C._null:return s=this.startNode(),this.next(),this.finishNode(s,"NullLiteral");case C._true:case C._false:return s=this.startNode(),s.value=this.match(C._true),this.next(),this.finishNode(s,"BooleanLiteral");case C.parenL:return this.parseParenAndDistinguishExpression(e);case C.bracketL:return s=this.startNode(),this.next(),s.elements=this.parseExprList(C.bracketR,!0,t),this.toReferencedList(s.elements),this.finishNode(s,"ArrayExpression");case C.braceL:return this.parseObj(!1,t);case C._function:return this.parseFunctionExpression();case C.at:this.parseDecorators();case C._class:return s=this.startNode(),this.takeDecorators(s),this.parseClass(s,!1);case C.hash:if(this.hasPlugin("classPrivateProperties"))return this.parseMaybePrivateName();this.unexpected();case C._new:return this.parseNew();case C.backQuote:return this.parseTemplate(!1);case C.doubleColon:s=this.startNode(),this.next(),s.object=null;var l=s.callee=this.parseNoCallExpr();if("MemberExpression"===l.type)return this.finishNode(s,"BindExpression");throw this.raise(l.start,"Binding should be performed on object property.");default:throw this.unexpected()}},e.prototype.parseMaybePrivateName=function(){if(this.eat(C.hash)){var t=this.startNode();return t.name=this.parseIdentifier(!0),this.finishNode(t,"PrivateName")}return this.parseIdentifier(!0)},e.prototype.parseFunctionExpression=function(){var t=this.startNode(),e=this.parseIdentifier(!0);return this.state.inGenerator&&this.eat(C.dot)&&this.hasPlugin("functionSent")?this.parseMetaProperty(t,e,"sent"):this.parseFunction(t,!1)},e.prototype.parseMetaProperty=function(t,e,s){return t.meta=e,t.property=this.parseIdentifier(!0),t.property.name!==s&&this.raise(t.property.start,"The only valid meta property for new is "+e.name+"."+s),this.finishNode(t,"MetaProperty")},e.prototype.parseLiteral=function(t,e,s,i){s=s||this.state.start,i=i||this.state.startLoc;var r=this.startNodeAt(s,i);return this.addExtra(r,"rawValue",t),this.addExtra(r,"raw",this.input.slice(s,this.state.end)),r.value=t,this.next(),this.finishNode(r,e)},e.prototype.parseParenExpression=function(){this.expect(C.parenL);var t=this.parseExpression();return this.expect(C.parenR),t},e.prototype.parseParenAndDistinguishExpression=function(t){var e=this.state.start,s=this.state.startLoc,i=void 0;this.expect(C.parenL);for(var r=this.state.start,a=this.state.startLoc,n=[],o={start:0},h={start:0},p=!0,c=void 0,l=void 0;!this.match(C.parenR);){if(p)p=!1;else if(this.expect(C.comma,h.start||null),this.match(C.parenR)){l=this.state.start;break}if(this.match(C.ellipsis)){var u=this.state.start,d=this.state.startLoc;c=this.state.start,n.push(this.parseParenItem(this.parseRest(),u,d));break}n.push(this.parseMaybeAssign(!1,o,this.parseParenItem,h));}var f=this.state.start,m=this.state.startLoc;this.expect(C.parenR);var y=this.startNodeAt(e,s);if(t&&this.shouldParseArrow()&&(y=this.parseArrow(y))){for(var x=n,v=Array.isArray(x),b=0,x=v?x:x[Symbol.iterator]();;){var g;if(v){if(b>=x.length)break;g=x[b++];}else{if((b=x.next()).done)break;g=b.value;}var w=g;w.extra&&w.extra.parenthesized&&this.unexpected(w.extra.parenStart);}return this.parseArrowExpression(y,n)}return n.length||this.unexpected(this.state.lastTokStart),l&&this.unexpected(l),c&&this.unexpected(c),o.start&&this.unexpected(o.start),h.start&&this.unexpected(h.start),n.length>1?((i=this.startNodeAt(r,a)).expressions=n,this.toReferencedList(i.expressions),this.finishNodeAt(i,"SequenceExpression",f,m)):i=n[0],this.addExtra(i,"parenthesized",!0),this.addExtra(i,"parenStart",e),i},e.prototype.shouldParseArrow=function(){return!this.canInsertSemicolon()},e.prototype.parseArrow=function(t){if(this.eat(C.arrow))return t},e.prototype.parseParenItem=function(t,e,s){return t},e.prototype.parseNew=function(){var t=this.startNode(),e=this.parseIdentifier(!0);if(this.eat(C.dot)){var s=this.parseMetaProperty(t,e,"target");return this.state.inFunction||this.raise(s.property.start,"new.target can only be used in functions"),s}return t.callee=this.parseNoCallExpr(),this.eat(C.parenL)?(t.arguments=this.parseExprList(C.parenR),this.toReferencedList(t.arguments)):t.arguments=[],this.finishNode(t,"NewExpression")},e.prototype.parseTemplateElement=function(t){var e=this.startNode();return null===this.state.value&&(t?this.state.invalidTemplateEscapePosition=null:this.raise(this.state.invalidTemplateEscapePosition,"Invalid escape sequence in template")),e.value={raw:this.input.slice(this.state.start,this.state.end).replace(/\r\n?/g,"\n"),cooked:this.state.value},this.next(),e.tail=this.match(C.backQuote),this.finishNode(e,"TemplateElement")},e.prototype.parseTemplate=function(t){var e=this.startNode();this.next(),e.expressions=[];var s=this.parseTemplateElement(t);for(e.quasis=[s];!s.tail;)this.expect(C.dollarBraceL),e.expressions.push(this.parseExpression()),this.expect(C.braceR),e.quasis.push(s=this.parseTemplateElement(t));return this.next(),this.finishNode(e,"TemplateLiteral")},e.prototype.parseObj=function(t,e){var s=[],i=Object.create(null),r=!0,a=this.startNode();a.properties=[],this.next();for(var n=null;!this.eat(C.braceR);){if(r)r=!1;else if(this.expect(C.comma),this.eat(C.braceR))break;for(;this.match(C.at);)s.push(this.parseDecorator());var o=this.startNode(),h=!1,p=!1,c=void 0,l=void 0;if(s.length&&(o.decorators=s,s=[]),this.hasPlugin("objectRestSpread")&&this.match(C.ellipsis)){if(o=this.parseSpread(t?{start:0}:void 0),o.type=t?"RestElement":"SpreadElement",t&&this.toAssignable(o.argument,!0,"object pattern"),a.properties.push(o),!t)continue;var u=this.state.start;if(null!==n)this.unexpected(n,"Cannot have multiple rest elements when destructuring");else{if(this.eat(C.braceR))break;if(!this.match(C.comma)||this.lookahead().type!==C.braceR){n=u;continue}this.unexpected(u,"A trailing comma is not permitted after the rest element");}}if(o.method=!1,(t||e)&&(c=this.state.start,l=this.state.startLoc),t||(h=this.eat(C.star)),!t&&this.isContextual("async")){h&&this.unexpected();var d=this.parseIdentifier();this.match(C.colon)||this.match(C.parenL)||this.match(C.braceR)||this.match(C.eq)||this.match(C.comma)?(o.key=d,o.computed=!1):(p=!0,this.hasPlugin("asyncGenerators")&&(h=this.eat(C.star)),this.parsePropertyName(o));}else this.parsePropertyName(o);this.parseObjPropValue(o,c,l,h,p,t,e),this.checkPropClash(o,i),o.shorthand&&this.addExtra(o,"shorthand",!0),a.properties.push(o);}return null!==n&&this.unexpected(n,"The rest element has to be the last element when destructuring"),s.length&&this.raise(this.state.start,"You have trailing decorators with no property"),this.finishNode(a,t?"ObjectPattern":"ObjectExpression")},e.prototype.isGetterOrSetterMethod=function(t,e){return!e&&!t.computed&&"Identifier"===t.key.type&&("get"===t.key.name||"set"===t.key.name)&&(this.match(C.string)||this.match(C.num)||this.match(C.bracketL)||this.match(C.name)||!!this.state.type.keyword)},e.prototype.checkGetterSetterParamCount=function(t){var e="get"===t.kind?0:1;if(t.params.length!==e){var s=t.start;"get"===t.kind?this.raise(s,"getter should have no params"):this.raise(s,"setter should have exactly one param");}},e.prototype.parseObjectMethod=function(t,e,s,i){return s||e||this.match(C.parenL)?(i&&this.unexpected(),t.kind="method",t.method=!0,this.parseMethod(t,e,s),this.finishNode(t,"ObjectMethod")):this.isGetterOrSetterMethod(t,i)?((e||s)&&this.unexpected(),t.kind=t.key.name,this.parsePropertyName(t),this.parseMethod(t),this.checkGetterSetterParamCount(t),this.finishNode(t,"ObjectMethod")):void 0},e.prototype.parseObjectProperty=function(t,e,s,i,r){return t.shorthand=!1,this.eat(C.colon)?(t.value=i?this.parseMaybeDefault(this.state.start,this.state.startLoc):this.parseMaybeAssign(!1,r),this.finishNode(t,"ObjectProperty")):t.computed||"Identifier"!==t.key.type?void 0:(this.checkReservedWord(t.key.name,t.key.start,!0,!0),i?t.value=this.parseMaybeDefault(e,s,t.key.__clone()):this.match(C.eq)&&r?(r.start||(r.start=this.state.start),t.value=this.parseMaybeDefault(e,s,t.key.__clone())):t.value=t.key.__clone(),t.shorthand=!0,this.finishNode(t,"ObjectProperty"))},e.prototype.parseObjPropValue=function(t,e,s,i,r,a,n){this.parseObjectMethod(t,i,r,a)||this.parseObjectProperty(t,e,s,a,n)||this.unexpected();},e.prototype.parsePropertyName=function(t){if(this.eat(C.bracketL))t.computed=!0,t.key=this.parseMaybeAssign(),this.expect(C.bracketR);else{t.computed=!1;var e=this.state.inPropertyName;this.state.inPropertyName=!0,t.key=this.match(C.num)||this.match(C.string)?this.parseExprAtom():this.parseIdentifier(!0),this.state.inPropertyName=e;}return t.key},e.prototype.initFunction=function(t,e){t.id=null,t.generator=!1,t.expression=!1,t.async=!!e;},e.prototype.parseMethod=function(t,e,s){var i=this.state.inMethod;return this.state.inMethod=t.kind||!0,this.initFunction(t,s),this.expect(C.parenL),t.params=this.parseBindingList(C.parenR),t.generator=!!e,this.parseFunctionBody(t),this.state.inMethod=i,t},e.prototype.parseArrowExpression=function(t,e,s){return this.initFunction(t,s),t.params=this.toAssignableList(e,!0,"arrow function parameters"),this.parseFunctionBody(t,!0),this.finishNode(t,"ArrowFunctionExpression")},e.prototype.isStrictBody=function(t,e){if(!e&&t.body.directives.length)for(var s=t.body.directives,i=Array.isArray(s),r=0,s=i?s:s[Symbol.iterator]();;){var a;if(i){if(r>=s.length)break;a=s[r++];}else{if((r=s.next()).done)break;a=r.value;}if("use strict"===a.value.value)return!0}return!1},e.prototype.parseFunctionBody=function(t,e){var s=e&&!this.match(C.braceL),i=this.state.inAsync;if(this.state.inAsync=t.async,s)t.body=this.parseMaybeAssign(),t.expression=!0;else{var r=this.state.inFunction,a=this.state.inGenerator,n=this.state.labels;this.state.inFunction=!0,this.state.inGenerator=t.generator,this.state.labels=[],t.body=this.parseBlock(!0),t.expression=!1,this.state.inFunction=r,this.state.inGenerator=a,this.state.labels=n;}this.state.inAsync=i;var o=this.isStrictBody(t,s),h=this.state.strict||e||o;if(o&&t.id&&"Identifier"===t.id.type&&"yield"===t.id.name&&this.raise(t.id.start,"Binding yield in strict mode"),h){var p=Object.create(null),c=this.state.strict;o&&(this.state.strict=!0),t.id&&this.checkLVal(t.id,!0,void 0,"function name");for(var l=t.params,u=Array.isArray(l),d=0,l=u?l:l[Symbol.iterator]();;){var f;if(u){if(d>=l.length)break;f=l[d++];}else{if((d=l.next()).done)break;f=d.value;}var m=f;o&&"Identifier"!==m.type&&this.raise(m.start,"Non-simple parameter in strict mode"),this.checkLVal(m,!0,p,"function parameter list");}this.state.strict=c;}},e.prototype.parseExprList=function(t,e,s){for(var i=[],r=!0;!this.eat(t);){if(r)r=!1;else if(this.expect(C.comma),this.eat(t))break;i.push(this.parseExprListItem(e,s));}return i},e.prototype.parseExprListItem=function(t,e,s){return t&&this.match(C.comma)?null:this.match(C.ellipsis)?this.parseSpread(e):this.parseMaybeAssign(!1,e,this.parseParenItem,s)},e.prototype.parseIdentifier=function(t){var e=this.startNode();return t||this.checkReservedWord(this.state.value,this.state.start,!!this.state.type.keyword,!1),this.match(C.name)?e.name=this.state.value:this.state.type.keyword?e.name=this.state.type.keyword:this.unexpected(),!t&&"await"===e.name&&this.state.inAsync&&this.raise(e.start,"invalid use of await inside of an async function"),e.loc.identifierName=e.name,this.next(),this.finishNode(e,"Identifier")},e.prototype.checkReservedWord=function(t,e,s,i){(this.isReservedWord(t)||s&&this.isKeyword(t))&&this.raise(e,t+" is a reserved word"),this.state.strict&&(S.strict(t)||i&&S.strictBind(t))&&this.raise(e,t+" is a reserved word in strict mode");},e.prototype.parseAwait=function(t){return this.state.inAsync||this.unexpected(),this.match(C.star)&&this.raise(t.start,"await* has been removed from the async functions proposal. Use Promise.all() instead."),t.argument=this.parseMaybeUnary(),this.finishNode(t,"AwaitExpression")},e.prototype.parseYield=function(){var t=this.startNode();return this.next(),this.match(C.semi)||this.canInsertSemicolon()||!this.match(C.star)&&!this.state.type.startsExpr?(t.delegate=!1,t.argument=null):(t.delegate=this.eat(C.star),t.argument=this.parseMaybeAssign()),this.finishNode(t,"YieldExpression")},e}(function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.toAssignable=function(t,e,s){if(t)switch(t.type){case"Identifier":case"PrivateName":case"ObjectPattern":case"ArrayPattern":case"AssignmentPattern":break;case"ObjectExpression":t.type="ObjectPattern";for(var i=t.properties,r=Array.isArray(i),a=0,i=r?i:i[Symbol.iterator]();;){var n;if(r){if(a>=i.length)break;n=i[a++];}else{if((a=i.next()).done)break;n=a.value;}var o=n;"ObjectMethod"===o.type?"get"===o.kind||"set"===o.kind?this.raise(o.key.start,"Object pattern can't contain getter or setter"):this.raise(o.key.start,"Object pattern can't contain methods"):this.toAssignable(o,e,"object destructuring pattern");}break;case"ObjectProperty":this.toAssignable(t.value,e,s);break;case"SpreadElement":t.type="RestElement";var h=t.argument;this.toAssignable(h,e,s);break;case"ArrayExpression":t.type="ArrayPattern",this.toAssignableList(t.elements,e,s);break;case"AssignmentExpression":"="===t.operator?(t.type="AssignmentPattern",delete t.operator):this.raise(t.left.end,"Only '=' operator can be used for specifying default value.");break;case"MemberExpression":if(!e)break;default:var p="Invalid left-hand side"+(s?" in "+s:"expression");this.raise(t.start,p);}return t},e.prototype.toAssignableList=function(t,e,s){var i=t.length;if(i){var r=t[i-1];if(r&&"RestElement"===r.type)--i;else if(r&&"SpreadElement"===r.type){r.type="RestElement";var a=r.argument;this.toAssignable(a,e,s),"Identifier"!==a.type&&"MemberExpression"!==a.type&&"ArrayPattern"!==a.type&&this.unexpected(a.start),--i;}}for(var n=0;n=a.length)break;h=a[o++];}else{if((o=a.next()).done)break;h=o.value;}var p=h;"ObjectProperty"===p.type&&(p=p.value),this.checkLVal(p,e,s,"object destructuring pattern");}break;case"ArrayPattern":for(var c=t.elements,l=Array.isArray(c),u=0,c=l?c:c[Symbol.iterator]();;){var d;if(l){if(u>=c.length)break;d=c[u++];}else{if((u=c.next()).done)break;d=u.value;}var f=d;f&&this.checkLVal(f,e,s,"array destructuring pattern");}break;case"AssignmentPattern":this.checkLVal(t.left,e,s,"assignment pattern");break;case"RestElement":this.checkLVal(t.argument,e,s,"rest element");break;default:var m=(e?"Binding invalid":"Invalid")+" left-hand side"+(i?" in "+i:"expression");this.raise(t.start,m);}},e}(function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.startNode=function(){return new Q(this,this.state.start,this.state.startLoc)},e.prototype.startNodeAt=function(t,e){return new Q(this,t,e)},e.prototype.finishNode=function(t,e){return this.finishNodeAt(t,e,this.state.lastTokEnd,this.state.lastTokEndLoc)},e.prototype.finishNodeAt=function(t,e,s,i){return t.type=e,t.end=s,t.loc.end=i,this.options.ranges&&(t.range[1]=s),this.processComment(t),t},e.prototype.resetStartLocationFromNode=function(t,e){t.start=e.start,t.loc.start=e.loc.start,this.options.ranges&&(t.range[0]=e.range[0]);},e}(K))))),et=function(t){return function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.estreeParseRegExpLiteral=function(t){var e=t.pattern,s=t.flags,i=null;try{i=new RegExp(e,s);}catch(t){}var r=this.estreeParseLiteral(i);return r.regex={pattern:e,flags:s},r},e.prototype.estreeParseLiteral=function(t){return this.parseLiteral(t,"Literal")},e.prototype.directiveToStmt=function(t){var e=t.value,s=this.startNodeAt(t.start,t.loc.start),i=this.startNodeAt(e.start,e.loc.start);return i.value=e.value,i.raw=e.extra.raw,s.expression=this.finishNodeAt(i,"Literal",e.end,e.loc.end),s.directive=e.extra.raw.slice(1,-1),this.finishNodeAt(s,"ExpressionStatement",t.end,t.loc.end)},e.prototype.checkDeclaration=function(e){u(e)?this.checkDeclaration(e.value):t.prototype.checkDeclaration.call(this,e);},e.prototype.checkGetterSetterParamCount=function(t){var e="get"===t.kind?0:1;if(t.value.params.length!==e){var s=t.start;"get"===t.kind?this.raise(s,"getter should have no params"):this.raise(s,"setter should have exactly one param");}},e.prototype.checkLVal=function(e,s,i){var r,a=this;switch(e.type){case"ObjectPattern":e.properties.forEach(function(t){a.checkLVal("Property"===t.type?t.value:t,s,i,"object destructuring pattern");});break;default:for(var n=arguments.length,o=Array(n>3?n-3:0),h=3;h0)for(var s=t.body.body,i=Array.isArray(s),r=0,s=i?s:s[Symbol.iterator]();;){var a;if(i){if(r>=s.length)break;a=s[r++];}else{if((r=s.next()).done)break;a=r.value;}var n=a;if("ExpressionStatement"!==n.type||"Literal"!==n.expression.type)break;if("use strict"===n.expression.value)return!0}return!1},e.prototype.isValidDirective=function(t){return!("ExpressionStatement"!==t.type||"Literal"!==t.expression.type||"string"!=typeof t.expression.value||t.expression.extra&&t.expression.extra.parenthesized)},e.prototype.parseBlockBody=function(e){for(var s,i=this,r=arguments.length,a=Array(r>1?r-1:0),n=1;n1?i-1:0),a=1;a1?r-1:0),n=1;n2?r-2:0),n=2;n=o.length)break;c=o[p++];}else{if((p=o.next()).done)break;c=p.value;}var l=c;"get"===l.kind||"set"===l.kind?this.raise(l.key.start,"Object pattern can't contain getter or setter"):l.method?this.raise(l.key.start,"Object pattern can't contain methods"):this.toAssignable(l,s,"object destructuring pattern");}return e}return(i=t.prototype.toAssignable).call.apply(i,[this,e,s].concat(a))},e}(t)},st=["any","mixed","empty","bool","boolean","number","string","void","null"],it={const:"declare export var",let:"declare export var",type:"export type",interface:"export interface"},rt=function(t){return function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.flowParseTypeInitialiser=function(t){var e=this.state.inType;this.state.inType=!0,this.expect(t||C.colon);var s=this.flowParseType();return this.state.inType=e,s},e.prototype.flowParsePredicate=function(){var t=this.startNode(),e=this.state.startLoc,s=this.state.start;this.expect(C.modulo);var i=this.state.startLoc;return this.expectContextual("checks"),e.line===i.line&&e.column===i.column-1||this.raise(s,"Spaces between ´%´ and ´checks´ are not allowed here."),this.eat(C.parenL)?(t.value=this.parseExpression(),this.expect(C.parenR),this.finishNode(t,"DeclaredPredicate")):this.finishNode(t,"InferredPredicate")},e.prototype.flowParseTypeAndPredicateInitialiser=function(){var t=this.state.inType;this.state.inType=!0,this.expect(C.colon);var e=null,s=null;return this.match(C.modulo)?(this.state.inType=t,s=this.flowParsePredicate()):(e=this.flowParseType(),this.state.inType=t,this.match(C.modulo)&&(s=this.flowParsePredicate())),[e,s]},e.prototype.flowParseDeclareClass=function(t){return this.next(),this.flowParseInterfaceish(t),this.finishNode(t,"DeclareClass")},e.prototype.flowParseDeclareFunction=function(t){this.next();var e=t.id=this.parseIdentifier(),s=this.startNode(),i=this.startNode();this.isRelational("<")?s.typeParameters=this.flowParseTypeParameterDeclaration():s.typeParameters=null,this.expect(C.parenL);var r=this.flowParseFunctionTypeParams();s.params=r.params,s.rest=r.rest,this.expect(C.parenR);var a=this.flowParseTypeAndPredicateInitialiser();return s.returnType=a[0],t.predicate=a[1],i.typeAnnotation=this.finishNode(s,"FunctionTypeAnnotation"),e.typeAnnotation=this.finishNode(i,"TypeAnnotation"),this.finishNode(e,e.type),this.semicolon(),this.finishNode(t,"DeclareFunction")},e.prototype.flowParseDeclare=function(t,e){if(this.match(C._class))return this.flowParseDeclareClass(t);if(this.match(C._function))return this.flowParseDeclareFunction(t);if(this.match(C._var))return this.flowParseDeclareVariable(t);if(this.isContextual("module"))return this.lookahead().type===C.dot?this.flowParseDeclareModuleExports(t):(e&&this.unexpected(null,"`declare module` cannot be used inside another `declare module`"),this.flowParseDeclareModule(t));if(this.isContextual("type"))return this.flowParseDeclareTypeAlias(t);if(this.isContextual("interface"))return this.flowParseDeclareInterface(t);if(this.match(C._export))return this.flowParseDeclareExportDeclaration(t,e);throw this.unexpected()},e.prototype.flowParseDeclareVariable=function(t){return this.next(),t.id=this.flowParseTypeAnnotatableIdentifier(),this.semicolon(),this.finishNode(t,"DeclareVariable")},e.prototype.flowParseDeclareModule=function(t){var e=this;this.next(),this.match(C.string)?t.id=this.parseExprAtom():t.id=this.parseIdentifier();var s=t.body=this.startNode(),i=s.body=[];for(this.expect(C.braceL);!this.match(C.braceR);){var r=this.startNode();if(this.match(C._import)){var a=this.lookahead();"type"!==a.value&&"typeof"!==a.value&&this.unexpected(null,"Imports within a `declare module` body must always be `import type` or `import typeof`"),this.parseImport(r);}else this.expectContextual("declare","Only declares and type imports are allowed inside declare module"),r=this.flowParseDeclare(r,!0);i.push(r);}this.expect(C.braceR),this.finishNode(s,"BlockStatement");var n=null,o=!1,h="Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module";return i.forEach(function(t){d(t)?("CommonJS"===n&&e.unexpected(t.start,h),n="ES"):"DeclareModuleExports"===t.type&&(o&&e.unexpected(t.start,"Duplicate `declare module.exports` statement"),"ES"===n&&e.unexpected(t.start,h),n="CommonJS",o=!0);}),t.kind=n||"CommonJS",this.finishNode(t,"DeclareModule")},e.prototype.flowParseDeclareExportDeclaration=function(t,e){if(this.expect(C._export),this.eat(C._default))return this.match(C._function)||this.match(C._class)?t.declaration=this.flowParseDeclare(this.startNode()):(t.declaration=this.flowParseType(),this.semicolon()),t.default=!0,this.finishNode(t,"DeclareExportDeclaration");if(this.match(C._const)||this.match(C._let)||(this.isContextual("type")||this.isContextual("interface"))&&!e){var s=this.state.value,i=it[s];this.unexpected(this.state.start,"`declare export "+s+"` is not supported. Use `"+i+"` instead");}if(this.match(C._var)||this.match(C._function)||this.match(C._class))return t.declaration=this.flowParseDeclare(this.startNode()),t.default=!1,this.finishNode(t,"DeclareExportDeclaration");if(this.match(C.star)||this.match(C.braceL)||this.isContextual("interface")||this.isContextual("type"))return"ExportNamedDeclaration"===(t=this.parseExport(t)).type&&(t.type="ExportDeclaration",t.default=!1,delete t.exportKind),t.type="Declare"+t.type,t;throw this.unexpected()},e.prototype.flowParseDeclareModuleExports=function(t){return this.expectContextual("module"),this.expect(C.dot),this.expectContextual("exports"),t.typeAnnotation=this.flowParseTypeAnnotation(),this.semicolon(),this.finishNode(t,"DeclareModuleExports")},e.prototype.flowParseDeclareTypeAlias=function(t){return this.next(),this.flowParseTypeAlias(t),this.finishNode(t,"DeclareTypeAlias")},e.prototype.flowParseDeclareInterface=function(t){return this.next(),this.flowParseInterfaceish(t),this.finishNode(t,"DeclareInterface")},e.prototype.flowParseInterfaceish=function(t){if(t.id=this.parseIdentifier(),this.isRelational("<")?t.typeParameters=this.flowParseTypeParameterDeclaration():t.typeParameters=null,t.extends=[],t.mixins=[],this.eat(C._extends))do{t.extends.push(this.flowParseInterfaceExtends());}while(this.eat(C.comma));if(this.isContextual("mixins")){this.next();do{t.mixins.push(this.flowParseInterfaceExtends());}while(this.eat(C.comma))}t.body=this.flowParseObjectType(!0,!1,!1);},e.prototype.flowParseInterfaceExtends=function(){var t=this.startNode();return t.id=this.flowParseQualifiedTypeIdentifier(),this.isRelational("<")?t.typeParameters=this.flowParseTypeParameterInstantiation():t.typeParameters=null,this.finishNode(t,"InterfaceExtends")},e.prototype.flowParseInterface=function(t){return this.flowParseInterfaceish(t),this.finishNode(t,"InterfaceDeclaration")},e.prototype.flowParseRestrictedIdentifier=function(t){return st.indexOf(this.state.value)>-1&&this.raise(this.state.start,"Cannot overwrite primitive type "+this.state.value),this.parseIdentifier(t)},e.prototype.flowParseTypeAlias=function(t){return t.id=this.flowParseRestrictedIdentifier(),this.isRelational("<")?t.typeParameters=this.flowParseTypeParameterDeclaration():t.typeParameters=null,t.right=this.flowParseTypeInitialiser(C.eq),this.semicolon(),this.finishNode(t,"TypeAlias")},e.prototype.flowParseTypeParameter=function(){var t=this.startNode(),e=this.flowParseVariance(),s=this.flowParseTypeAnnotatableIdentifier();return t.name=s.name,t.variance=e,t.bound=s.typeAnnotation,this.match(C.eq)&&(this.eat(C.eq),t.default=this.flowParseType()),this.finishNode(t,"TypeParameter")},e.prototype.flowParseTypeParameterDeclaration=function(){var t=this.state.inType,e=this.startNode();e.params=[],this.state.inType=!0,this.isRelational("<")||this.match(C.jsxTagStart)?this.next():this.unexpected();do{e.params.push(this.flowParseTypeParameter()),this.isRelational(">")||this.expect(C.comma);}while(!this.isRelational(">"));return this.expectRelational(">"),this.state.inType=t,this.finishNode(e,"TypeParameterDeclaration")},e.prototype.flowParseTypeParameterInstantiation=function(){var t=this.startNode(),e=this.state.inType;for(t.params=[],this.state.inType=!0,this.expectRelational("<");!this.isRelational(">");)t.params.push(this.flowParseType()),this.isRelational(">")||this.expect(C.comma);return this.expectRelational(">"),this.state.inType=e,this.finishNode(t,"TypeParameterInstantiation")},e.prototype.flowParseObjectPropertyKey=function(){return this.match(C.num)||this.match(C.string)?this.parseExprAtom():this.parseIdentifier(!0)},e.prototype.flowParseObjectTypeIndexer=function(t,e,s){return t.static=e,this.expect(C.bracketL),this.lookahead().type===C.colon?(t.id=this.flowParseObjectPropertyKey(),t.key=this.flowParseTypeInitialiser()):(t.id=null,t.key=this.flowParseType()),this.expect(C.bracketR),t.value=this.flowParseTypeInitialiser(),t.variance=s,this.finishNode(t,"ObjectTypeIndexer")},e.prototype.flowParseObjectTypeMethodish=function(t){for(t.params=[],t.rest=null,t.typeParameters=null,this.isRelational("<")&&(t.typeParameters=this.flowParseTypeParameterDeclaration()),this.expect(C.parenL);!this.match(C.parenR)&&!this.match(C.ellipsis);)t.params.push(this.flowParseFunctionTypeParam()),this.match(C.parenR)||this.expect(C.comma);return this.eat(C.ellipsis)&&(t.rest=this.flowParseFunctionTypeParam()),this.expect(C.parenR),t.returnType=this.flowParseTypeInitialiser(),this.finishNode(t,"FunctionTypeAnnotation")},e.prototype.flowParseObjectTypeCallProperty=function(t,e){var s=this.startNode();return t.static=e,t.value=this.flowParseObjectTypeMethodish(s),this.finishNode(t,"ObjectTypeCallProperty")},e.prototype.flowParseObjectType=function(t,e,s){var i=this.state.inType;this.state.inType=!0;var r=this.startNode();r.callProperties=[],r.properties=[],r.indexers=[];var a=void 0,n=void 0;for(e&&this.match(C.braceBarL)?(this.expect(C.braceBarL),a=C.braceBarR,n=!0):(this.expect(C.braceL),a=C.braceR,n=!1),r.exact=n;!this.match(a);){var o=!1,h=this.startNode();t&&this.isContextual("static")&&this.lookahead().type!==C.colon&&(this.next(),o=!0);var p=this.flowParseVariance();if(this.match(C.bracketL))r.indexers.push(this.flowParseObjectTypeIndexer(h,o,p));else if(this.match(C.parenL)||this.isRelational("<"))p&&this.unexpected(p.start),r.callProperties.push(this.flowParseObjectTypeCallProperty(h,o));else{var c="init";if(this.isContextual("get")||this.isContextual("set")){var l=this.lookahead();l.type!==C.name&&l.type!==C.string&&l.type!==C.num||(c=this.state.value,this.next());}r.properties.push(this.flowParseObjectTypeProperty(h,o,p,c,s));}this.flowObjectTypeSemicolon();}this.expect(a);var u=this.finishNode(r,"ObjectTypeAnnotation");return this.state.inType=i,u},e.prototype.flowParseObjectTypeProperty=function(t,e,s,i,r){if(this.match(C.ellipsis))return r||this.unexpected(null,"Spread operator cannot appear in class or interface definitions"),s&&this.unexpected(s.start,"Spread properties cannot have variance"),this.expect(C.ellipsis),t.argument=this.flowParseType(),this.finishNode(t,"ObjectTypeSpreadProperty");t.key=this.flowParseObjectPropertyKey(),t.static=e,t.kind=i;var a=!1;return this.isRelational("<")||this.match(C.parenL)?(s&&this.unexpected(s.start),t.value=this.flowParseObjectTypeMethodish(this.startNodeAt(t.start,t.loc.start)),"get"!==i&&"set"!==i||this.flowCheckGetterSetterParamCount(t)):("init"!==i&&this.unexpected(),this.eat(C.question)&&(a=!0),t.value=this.flowParseTypeInitialiser(),t.variance=s),t.optional=a,this.finishNode(t,"ObjectTypeProperty")},e.prototype.flowCheckGetterSetterParamCount=function(t){var e="get"===t.kind?0:1;if(t.value.params.length!==e){var s=t.start;"get"===t.kind?this.raise(s,"getter should have no params"):this.raise(s,"setter should have exactly one param");}},e.prototype.flowObjectTypeSemicolon=function(){this.eat(C.semi)||this.eat(C.comma)||this.match(C.braceR)||this.match(C.braceBarR)||this.unexpected();},e.prototype.flowParseQualifiedTypeIdentifier=function(t,e,s){t=t||this.state.start,e=e||this.state.startLoc;for(var i=s||this.parseIdentifier();this.eat(C.dot);){var r=this.startNodeAt(t,e);r.qualification=i,r.id=this.parseIdentifier(),i=this.finishNode(r,"QualifiedTypeIdentifier");}return i},e.prototype.flowParseGenericType=function(t,e,s){var i=this.startNodeAt(t,e);return i.typeParameters=null,i.id=this.flowParseQualifiedTypeIdentifier(t,e,s),this.isRelational("<")&&(i.typeParameters=this.flowParseTypeParameterInstantiation()),this.finishNode(i,"GenericTypeAnnotation")},e.prototype.flowParseTypeofType=function(){var t=this.startNode();return this.expect(C._typeof),t.argument=this.flowParsePrimaryType(),this.finishNode(t,"TypeofTypeAnnotation")},e.prototype.flowParseTupleType=function(){var t=this.startNode();for(t.types=[],this.expect(C.bracketL);this.state.pos0&&void 0!==arguments[0]?arguments[0]:[],e=null;!this.match(C.parenR)&&!this.match(C.ellipsis);)t.push(this.flowParseFunctionTypeParam()),this.match(C.parenR)||this.expect(C.comma);return this.eat(C.ellipsis)&&(e=this.flowParseFunctionTypeParam()),{params:t,rest:e}},e.prototype.flowIdentToTypeAnnotation=function(t,e,s,i){switch(i.name){case"any":return this.finishNode(s,"AnyTypeAnnotation");case"void":return this.finishNode(s,"VoidTypeAnnotation");case"bool":case"boolean":return this.finishNode(s,"BooleanTypeAnnotation");case"mixed":return this.finishNode(s,"MixedTypeAnnotation");case"empty":return this.finishNode(s,"EmptyTypeAnnotation");case"number":return this.finishNode(s,"NumberTypeAnnotation");case"string":return this.finishNode(s,"StringTypeAnnotation");default:return this.flowParseGenericType(t,e,i)}},e.prototype.flowParsePrimaryType=function(){var t=this.state.start,e=this.state.startLoc,s=this.startNode(),i=void 0,r=void 0,a=!1,n=this.state.noAnonFunctionType;switch(this.state.type){case C.name:return this.flowIdentToTypeAnnotation(t,e,s,this.parseIdentifier());case C.braceL:return this.flowParseObjectType(!1,!1,!0);case C.braceBarL:return this.flowParseObjectType(!1,!0,!0);case C.bracketL:return this.flowParseTupleType();case C.relational:if("<"===this.state.value)return s.typeParameters=this.flowParseTypeParameterDeclaration(),this.expect(C.parenL),i=this.flowParseFunctionTypeParams(),s.params=i.params,s.rest=i.rest,this.expect(C.parenR),this.expect(C.arrow),s.returnType=this.flowParseType(),this.finishNode(s,"FunctionTypeAnnotation");break;case C.parenL:if(this.next(),!this.match(C.parenR)&&!this.match(C.ellipsis))if(this.match(C.name)){var o=this.lookahead().type;a=o!==C.question&&o!==C.colon;}else a=!0;if(a){if(this.state.noAnonFunctionType=!1,r=this.flowParseType(),this.state.noAnonFunctionType=n,this.state.noAnonFunctionType||!(this.match(C.comma)||this.match(C.parenR)&&this.lookahead().type===C.arrow))return this.expect(C.parenR),r;this.eat(C.comma);}return i=r?this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(r)]):this.flowParseFunctionTypeParams(),s.params=i.params,s.rest=i.rest,this.expect(C.parenR),this.expect(C.arrow),s.returnType=this.flowParseType(),s.typeParameters=null,this.finishNode(s,"FunctionTypeAnnotation");case C.string:return this.parseLiteral(this.state.value,"StringLiteralTypeAnnotation");case C._true:case C._false:return s.value=this.match(C._true),this.next(),this.finishNode(s,"BooleanLiteralTypeAnnotation");case C.plusMin:if("-"===this.state.value)return this.next(),this.match(C.num)||this.unexpected(null,"Unexpected token, expected number"),this.parseLiteral(-this.state.value,"NumberLiteralTypeAnnotation",s.start,s.loc.start);this.unexpected();case C.num:return this.parseLiteral(this.state.value,"NumberLiteralTypeAnnotation");case C._null:return s.value=this.match(C._null),this.next(),this.finishNode(s,"NullLiteralTypeAnnotation");case C._this:return s.value=this.match(C._this),this.next(),this.finishNode(s,"ThisTypeAnnotation");case C.star:return this.next(),this.finishNode(s,"ExistsTypeAnnotation");default:if("typeof"===this.state.type.keyword)return this.flowParseTypeofType()}throw this.unexpected()},e.prototype.flowParsePostfixType=function(){for(var t=this.state.start,e=this.state.startLoc,s=this.flowParsePrimaryType();!this.canInsertSemicolon()&&this.match(C.bracketL);){var i=this.startNodeAt(t,e);i.elementType=s,this.expect(C.bracketL),this.expect(C.bracketR),s=this.finishNode(i,"ArrayTypeAnnotation");}return s},e.prototype.flowParsePrefixType=function(){var t=this.startNode();return this.eat(C.question)?(t.typeAnnotation=this.flowParsePrefixType(),this.finishNode(t,"NullableTypeAnnotation")):this.flowParsePostfixType()},e.prototype.flowParseAnonFunctionWithoutParens=function(){var t=this.flowParsePrefixType();if(!this.state.noAnonFunctionType&&this.eat(C.arrow)){var e=this.startNodeAt(t.start,t.loc);return e.params=[this.reinterpretTypeAsFunctionTypeParam(t)],e.rest=null,e.returnType=this.flowParseType(),e.typeParameters=null,this.finishNode(e,"FunctionTypeAnnotation")}return t},e.prototype.flowParseIntersectionType=function(){var t=this.startNode();this.eat(C.bitwiseAND);var e=this.flowParseAnonFunctionWithoutParens();for(t.types=[e];this.eat(C.bitwiseAND);)t.types.push(this.flowParseAnonFunctionWithoutParens());return 1===t.types.length?e:this.finishNode(t,"IntersectionTypeAnnotation")},e.prototype.flowParseUnionType=function(){var t=this.startNode();this.eat(C.bitwiseOR);var e=this.flowParseIntersectionType();for(t.types=[e];this.eat(C.bitwiseOR);)t.types.push(this.flowParseIntersectionType());return 1===t.types.length?e:this.finishNode(t,"UnionTypeAnnotation")},e.prototype.flowParseType=function(){var t=this.state.inType;this.state.inType=!0;var e=this.flowParseUnionType();return this.state.inType=t,e},e.prototype.flowParseTypeAnnotation=function(){var t=this.startNode();return t.typeAnnotation=this.flowParseTypeInitialiser(),this.finishNode(t,"TypeAnnotation")},e.prototype.flowParseTypeAnnotatableIdentifier=function(){var t=this.flowParseRestrictedIdentifier();return this.match(C.colon)&&(t.typeAnnotation=this.flowParseTypeAnnotation(),this.finishNode(t,t.type)),t},e.prototype.typeCastToParameter=function(t){return t.expression.typeAnnotation=t.typeAnnotation,this.finishNodeAt(t.expression,t.expression.type,t.typeAnnotation.end,t.typeAnnotation.loc.end)},e.prototype.flowParseVariance=function(){var t=null;return this.match(C.plusMin)&&(t=this.startNode(),"+"===this.state.value?t.kind="plus":t.kind="minus",this.next(),this.finishNode(t,"Variance")),t},e.prototype.parseFunctionBody=function(e,s){if(this.match(C.colon)&&!s){var i=this.startNode(),r=this.flowParseTypeAndPredicateInitialiser();i.typeAnnotation=r[0],e.predicate=r[1],e.returnType=i.typeAnnotation?this.finishNode(i,"TypeAnnotation"):null;}return t.prototype.parseFunctionBody.call(this,e,s)},e.prototype.parseStatement=function(e,s){if(this.state.strict&&this.match(C.name)&&"interface"===this.state.value){var i=this.startNode();return this.next(),this.flowParseInterface(i)}return t.prototype.parseStatement.call(this,e,s)},e.prototype.parseExpressionStatement=function(e,s){if("Identifier"===s.type)if("declare"===s.name){if(this.match(C._class)||this.match(C.name)||this.match(C._function)||this.match(C._var)||this.match(C._export))return this.flowParseDeclare(e)}else if(this.match(C.name)){if("interface"===s.name)return this.flowParseInterface(e);if("type"===s.name)return this.flowParseTypeAlias(e)}return t.prototype.parseExpressionStatement.call(this,e,s)},e.prototype.shouldParseExportDeclaration=function(){return this.isContextual("type")||this.isContextual("interface")||t.prototype.shouldParseExportDeclaration.call(this)},e.prototype.isExportDefaultSpecifier=function(){return(!this.match(C.name)||"type"!==this.state.value&&"interface"!==this.state.value)&&t.prototype.isExportDefaultSpecifier.call(this)},e.prototype.parseConditional=function(e,s,i,r,a){if(a&&this.match(C.question)){var n=this.state.clone();try{return t.prototype.parseConditional.call(this,e,s,i,r)}catch(t){if(t instanceof SyntaxError)return this.state=n,a.start=t.pos||this.state.start,e;throw t}}return t.prototype.parseConditional.call(this,e,s,i,r)},e.prototype.parseParenItem=function(e,s,i){if(e=t.prototype.parseParenItem.call(this,e,s,i),this.eat(C.question)&&(e.optional=!0),this.match(C.colon)){var r=this.startNodeAt(s,i);return r.expression=e,r.typeAnnotation=this.flowParseTypeAnnotation(),this.finishNode(r,"TypeCastExpression")}return e},e.prototype.parseExport=function(e){return"ExportNamedDeclaration"===(e=t.prototype.parseExport.call(this,e)).type&&(e.exportKind=e.exportKind||"value"),e},e.prototype.parseExportDeclaration=function(e){if(this.isContextual("type")){e.exportKind="type";var s=this.startNode();return this.next(),this.match(C.braceL)?(e.specifiers=this.parseExportSpecifiers(),this.parseExportFrom(e),null):this.flowParseTypeAlias(s)}if(this.isContextual("interface")){e.exportKind="type";var i=this.startNode();return this.next(),this.flowParseInterface(i)}return t.prototype.parseExportDeclaration.call(this,e)},e.prototype.parseClassId=function(e){for(var s,i=arguments.length,r=Array(i>1?i-1:0),a=1;a1?i-1:0),a=1;a2?r-2:0),n=2;n1?r-1:0),n=1;n",nbsp:" ",iexcl:"¡",cent:"¢",pound:"£",curren:"¤",yen:"¥",brvbar:"¦",sect:"§",uml:"¨",copy:"©",ordf:"ª",laquo:"«",not:"¬",shy:"",reg:"®",macr:"¯",deg:"°",plusmn:"±",sup2:"²",sup3:"³",acute:"´",micro:"µ",para:"¶",middot:"·",cedil:"¸",sup1:"¹",ordm:"º",raquo:"»",frac14:"¼",frac12:"½",frac34:"¾",iquest:"¿",Agrave:"À",Aacute:"Á",Acirc:"Â",Atilde:"Ã",Auml:"Ä",Aring:"Å",AElig:"Æ",Ccedil:"Ç",Egrave:"È",Eacute:"É",Ecirc:"Ê",Euml:"Ë",Igrave:"Ì",Iacute:"Í",Icirc:"Î",Iuml:"Ï",ETH:"Ð",Ntilde:"Ñ",Ograve:"Ò",Oacute:"Ó",Ocirc:"Ô",Otilde:"Õ",Ouml:"Ö",times:"×",Oslash:"Ø",Ugrave:"Ù",Uacute:"Ú",Ucirc:"Û",Uuml:"Ü",Yacute:"Ý",THORN:"Þ",szlig:"ß",agrave:"à",aacute:"á",acirc:"â",atilde:"ã",auml:"ä",aring:"å",aelig:"æ",ccedil:"ç",egrave:"è",eacute:"é",ecirc:"ê",euml:"ë",igrave:"ì",iacute:"í",icirc:"î",iuml:"ï",eth:"ð",ntilde:"ñ",ograve:"ò",oacute:"ó",ocirc:"ô",otilde:"õ",ouml:"ö",divide:"÷",oslash:"ø",ugrave:"ù",uacute:"ú",ucirc:"û",uuml:"ü",yacute:"ý",thorn:"þ",yuml:"ÿ",OElig:"Œ",oelig:"œ",Scaron:"Š",scaron:"š",Yuml:"Ÿ",fnof:"ƒ",circ:"ˆ",tilde:"˜",Alpha:"Α",Beta:"Β",Gamma:"Γ",Delta:"Δ",Epsilon:"Ε",Zeta:"Ζ",Eta:"Η",Theta:"Θ",Iota:"Ι",Kappa:"Κ",Lambda:"Λ",Mu:"Μ",Nu:"Ν",Xi:"Ξ",Omicron:"Ο",Pi:"Π",Rho:"Ρ",Sigma:"Σ",Tau:"Τ",Upsilon:"Υ",Phi:"Φ",Chi:"Χ",Psi:"Ψ",Omega:"Ω",alpha:"α",beta:"β",gamma:"γ",delta:"δ",epsilon:"ε",zeta:"ζ",eta:"η",theta:"θ",iota:"ι",kappa:"κ",lambda:"λ",mu:"μ",nu:"ν",xi:"ξ",omicron:"ο",pi:"π",rho:"ρ",sigmaf:"ς",sigma:"σ",tau:"τ",upsilon:"υ",phi:"φ",chi:"χ",psi:"ψ",omega:"ω",thetasym:"ϑ",upsih:"ϒ",piv:"ϖ",ensp:" ",emsp:" ",thinsp:" ",zwnj:"",zwj:"",lrm:"",rlm:"",ndash:"–",mdash:"—",lsquo:"‘",rsquo:"’",sbquo:"‚",ldquo:"“",rdquo:"”",bdquo:"„",dagger:"†",Dagger:"‡",bull:"•",hellip:"…",permil:"‰",prime:"′",Prime:"″",lsaquo:"‹",rsaquo:"›",oline:"‾",frasl:"⁄",euro:"€",image:"ℑ",weierp:"℘",real:"ℜ",trade:"™",alefsym:"ℵ",larr:"←",uarr:"↑",rarr:"→",darr:"↓",harr:"↔",crarr:"↵",lArr:"⇐",uArr:"⇑",rArr:"⇒",dArr:"⇓",hArr:"⇔",forall:"∀",part:"∂",exist:"∃",empty:"∅",nabla:"∇",isin:"∈",notin:"∉",ni:"∋",prod:"∏",sum:"∑",minus:"−",lowast:"∗",radic:"√",prop:"∝",infin:"∞",ang:"∠",and:"∧",or:"∨",cap:"∩",cup:"∪",int:"∫",there4:"∴",sim:"∼",cong:"≅",asymp:"≈",ne:"≠",equiv:"≡",le:"≤",ge:"≥",sub:"⊂",sup:"⊃",nsub:"⊄",sube:"⊆",supe:"⊇",oplus:"⊕",otimes:"⊗",perp:"⊥",sdot:"⋅",lceil:"⌈",rceil:"⌉",lfloor:"⌊",rfloor:"⌋",lang:"〈",rang:"〉",loz:"◊",spades:"♠",clubs:"♣",hearts:"♥",diams:"♦"},nt=/^[\da-fA-F]+$/,ot=/^\d+$/;V.j_oTag=new q("...",!0,!0),C.jsxName=new k("jsxName"),C.jsxText=new k("jsxText",{beforeExpr:!0}),C.jsxTagStart=new k("jsxTagStart",{startsExpr:!0}),C.jsxTagEnd=new k("jsxTagEnd"),C.jsxTagStart.updateContext=function(){this.state.context.push(V.j_expr),this.state.context.push(V.j_oTag),this.state.exprAllowed=!1;},C.jsxTagEnd.updateContext=function(t){var e=this.state.context.pop();e===V.j_oTag&&t===C.slash||e===V.j_cTag?(this.state.context.pop(),this.state.exprAllowed=this.curContext()===V.j_expr):this.state.exprAllowed=!0;};var ht=function(t){return function(t){function e(){return g(this,e),P(this,t.apply(this,arguments))}return w(e,t),e.prototype.jsxReadToken=function(){for(var t="",e=this.state.pos;;){this.state.pos>=this.input.length&&this.raise(this.state.start,"Unterminated JSX contents");var s=this.input.charCodeAt(this.state.pos);switch(s){case 60:case 123:return this.state.pos===this.state.start?60===s&&this.state.exprAllowed?(++this.state.pos,this.finishToken(C.jsxTagStart)):this.getTokenFromCode(s):(t+=this.input.slice(e,this.state.pos),this.finishToken(C.jsxText,t));case 38:t+=this.input.slice(e,this.state.pos),t+=this.jsxReadEntity(),e=this.state.pos;break;default:o(s)?(t+=this.input.slice(e,this.state.pos),t+=this.jsxReadNewLine(!0),e=this.state.pos):++this.state.pos;}}},e.prototype.jsxReadNewLine=function(t){var e=this.input.charCodeAt(this.state.pos),s=void 0;return++this.state.pos,13===e&&10===this.input.charCodeAt(this.state.pos)?(++this.state.pos,s=t?"\n":"\r\n"):s=String.fromCharCode(e),++this.state.curLine,this.state.lineStart=this.state.pos,s},e.prototype.jsxReadString=function(t){for(var e="",s=++this.state.pos;;){this.state.pos>=this.input.length&&this.raise(this.state.start,"Unterminated string constant");var i=this.input.charCodeAt(this.state.pos);if(i===t)break;38===i?(e+=this.input.slice(s,this.state.pos),e+=this.jsxReadEntity(),s=this.state.pos):o(i)?(e+=this.input.slice(s,this.state.pos),e+=this.jsxReadNewLine(!1),s=this.state.pos):++this.state.pos;}return e+=this.input.slice(s,this.state.pos++),this.finishToken(C.string,e)},e.prototype.jsxReadEntity=function(){for(var t="",e=0,s=void 0,i=this.input[this.state.pos],r=++this.state.pos;this.state.pos");}return s.openingElement=r,s.closingElement=a,s.children=i,this.match(C.relational)&&"<"===this.state.value&&this.raise(this.state.start,"Adjacent JSX elements must be wrapped in an enclosing tag"),this.finishNode(s,"JSXElement")},e.prototype.jsxParseElement=function(){var t=this.state.start,e=this.state.startLoc;return this.next(),this.jsxParseElementAt(t,e)},e.prototype.parseExprAtom=function(e){return this.match(C.jsxText)?this.parseLiteral(this.state.value,"JSXText"):this.match(C.jsxTagStart)?this.jsxParseElement():t.prototype.parseExprAtom.call(this,e)},e.prototype.readToken=function(e){if(this.state.inPropertyName)return t.prototype.readToken.call(this,e);var s=this.curContext();if(s===V.j_expr)return this.jsxReadToken();if(s===V.j_oTag||s===V.j_cTag){if(a(e))return this.jsxReadWord();if(62===e)return++this.state.pos,this.finishToken(C.jsxTagEnd);if((34===e||39===e)&&s===V.j_oTag)return this.jsxReadString(e)}return 60===e&&this.state.exprAllowed?(++this.state.pos,this.finishToken(C.jsxTagStart)):t.prototype.readToken.call(this,e)},e.prototype.updateContext=function(e){if(this.match(C.braceL)){var s=this.curContext();s===V.j_oTag?this.state.context.push(V.braceExpression):s===V.j_expr?this.state.context.push(V.templateQuasi):t.prototype.updateContext.call(this,e),this.state.exprAllowed=!0;}else{if(!this.match(C.slash)||e!==C.jsxTagStart)return t.prototype.updateContext.call(this,e);this.state.context.length-=2,this.state.context.push(V.j_cTag),this.state.exprAllowed=!1;}},e}(t)};Z.estree=et,Z.flow=rt,Z.jsx=ht;var pt={};e.parse=m,e.parseExpression=y,e.tokTypes=C;}),parserBabylon=parse;module.exports=parserBabylon;
+});
+
+var parserBabylon = unwrapExports(parserBabylon_1);
+
+return parserBabylon;
+
+}());
diff --git a/docs/parser-flow.js b/docs/parser-flow.js
new file mode 100644
index 00000000..9f28cc6b
--- /dev/null
+++ b/docs/parser-flow.js
@@ -0,0 +1,6 @@
+var flow = (function () {
+function createError$1(t,r,e){const n=new SyntaxError(t+" ("+r+":"+e+")");return n.loc={line:r,column:e},n}function createCommonjsModule(t,r){return r={exports:{}},t(r,r.exports),r.exports}function parse(t){const r=flow_parser.parse(t,{esproposal_class_instance_fields:!0,esproposal_class_static_fields:!0,esproposal_export_star_as:!0});if(r.errors.length>0)throw createError(r.errors[0].message,r.errors[0].loc.start.line,r.errors[0].loc.start.column);return r}var parserCreateError=createError$1; var flow_parser=createCommonjsModule(function(t,r){!function(t){"use strict";function e(t,r){throw[0,t,r]}function n(t,r){function n(r){e(Gd.Undefined_recursive_module,t);}function a(t,r,e){if("number"==typeof t)switch(t){case 0:r[e]={fun:n};break;case 1:r[e]=[ls,n];break;default:r[e]=[];}else switch(t[0]){case 0:r[e]=[0];for(var u=1;u=1;u--)e[n+u]=t[r+u];return 0}function c(t,r,e){var n=new Array(e+1);n[0]=0;for(var a=1,u=r+1;a<=e;a++,u++)n[a]=t[u];return n}function s(t,r,e){for(var n=new Array(e),a=0;a=e.l||2==e.t&&a>=e.c.length))e.c=4==t.t?o(t.c,r,a):0==r&&t.c.length==a?t.c:t.c.substr(r,a),e.t=e.c.length==e.l?0:2;else if(2==e.t&&n==e.c.length)e.c+=4==t.t?o(t.c,r,a):0==r&&t.c.length==a?t.c:t.c.substr(r,a),e.t=e.c.length==e.l?0:2;else{4!=e.t&&v(e);var u=t.c,i=e.c;if(4==t.t)if(n<=r)for(c=0;c=0;c--)i[n+c]=u[r+c];else{for(var f=Math.min(a,u.length-r),c=0;c>=1))return e;r+=r,9==++n&&r.slice(0,1);}}function k(t){2==t.t?t.c+=b(t.l-t.c.length,"\0"):t.c=o(t.c,0,t.c.length),t.t=0;}function p(t){if(t.length<24){for(var r=0;rKb)return!1;return!0}return!/[^\x00-\x7f]/.test(t)}function h(t){for(var r,e,n,a,u=mb,i=mb,f=0,c=t.length;fHn?(i.substr(0,1),u+=i,i=mb,u+=t.slice(f,s)):i+=t.slice(f,s),s==c)break;f=s;}a=1,++f=55295&&anl)&&(a=3))))),a<4?(f-=a,i+="�"):i+=a>ki?String.fromCharCode(55232+(a>>10),Ji+(a&va)):String.fromCharCode(a),i.length>Nu&&(i.substr(0,1),u+=i,i=mb);}return u+i}function d(t){switch(t.t){case 9:return t.c;default:k(t);case 0:if(p(t.c))return t.t=9,t.c;t.t=8;case 8:return h(t.c)}}function m(t,r,e){this.t=t,this.c=r,this.l=e;}function y(t){return new m(0,t,t.length)}function w(t,r){e(t,y(r));}function g(t){w(Gd.Invalid_argument,t);}function T(){g(pu);}function _(t,r,e){if(e&=lh,4!=t.t){if(r==t.c.length)return t.c+=String.fromCharCode(e),r+1==t.l&&(t.t=0),0;v(t);}return t.c[r]=e,0}function S(t,r,e){return r>>>0>=t.l&&T(),_(t,r,e)}function A(t,r){for(var e=t.length,n=new Array(e+1),a=0;a>>0>=t.length-1&&x(),t}function C(t){return isFinite(t)?Math.abs(t)>=2.2250738585072014e-308?0:0!=t?1:2:isNaN(t)?4:3}function N(t,r){var e=t[3]<<16,n=r[3]<<16;return e>n?1:er[2]?1:t[2]r[1]?1:t[1]r.c?1:0}function P(t,r,e){for(var n=[];;){if(!e||t!==r)if(t instanceof m){if(!(r instanceof m))return 1;if(t!==r&&0!=(i=L(t,r)))return i}else if(t instanceof Array&&t[0]===(0|t[0])){var a=t[0];if(a===Cn&&(a=0),a===Ql){t=t[1];continue}if(!(r instanceof Array&&r[0]===(0|r[0])))return 1;var u=r[0];if(u===Cn&&(u=0),u===Ql){r=r[1];continue}if(a!=u)return a1&&n.push(t,r,1);}}else{if(r instanceof m||r instanceof Array&&r[0]===(0|r[0]))return-1;if("number"!=typeof t&&t&&t.compare)return t.compare(r,e);if(typeof t==Pk)g("equal: functional value");else{if(tr)return 1;if(t!=r){if(!e)return NaN;if(t==t)return 1;if(r==r)return-1}}}if(0==n.length)return 0;var f=n.pop();r=n.pop(),f+1<(t=n.pop()).length&&n.push(t,r,f+1),t=t[f],r=r[f];}}function O(t,r){return P(t,r,!0)}function U(t){return t<0&&g("Bytes.create"),new m(t?2:9,mb,t)}function D(t,r){return+(0==P(t,r,!1))}function M(t,r,e,n){if(e>0)if(0==r&&(e>=t.l||2==t.t&&e>=t.c.length))0==n?(t.c=mb,t.t=2):(t.c=b(e,String.fromCharCode(n)),t.t=e==t.l?0:2);else for(4!=t.t&&v(t),e+=r;r0&&r===r)return r;if(t=t.replace(/_/g,mb),r=+t,t.length>0&&r===r||/^[+-]?nan$/i.test(t))return r;var e=/^ *([+-]?)0x([0-9a-f]+)\.?([0-9a-f]*)p([+-]?[0-9]+)/i.exec(t);if(e){var n=e[3].replace(/0+$/,mb),a=parseInt(e[1]+e[2]+n,16),u=(0|e[4])-4*n.length;return r=a*Math.pow(2,u)}return/^\+?inf(inity)?$/i.test(t)?1/0:/^-inf(inity)?$/i.test(t)?-1/0:void F("float_of_string")}function j(t){var r=(t=X(t)).length;r>31&&g("format_int: format too long");for(var e={justify:Mb,signstyle:xl,filler:hd,alternate:!1,base:0,signedconv:!1,width:0,uppercase:!1,sign:1,prec:-1,conv:"f"},n=0;n=0&&a<=9;)e.width=10*e.width+a,n++;n--;break;case".":for(e.prec=0,n++;(a=t.charCodeAt(n)-48)>=0&&a<=9;)e.prec=10*e.prec+a,n++;n--;case"d":case"i":e.signedconv=!0;case"u":e.base=10;break;case"x":e.base=16;break;case"X":e.base=16,e.uppercase=!0;break;case"o":e.base=8;break;case"e":case"f":case"g":e.signedconv=!0,e.conv=a;break;case"E":case"F":case"G":e.signedconv=!0,e.uppercase=!0,e.conv=a.toLowerCase();}}return e}function G(t,r){t.uppercase&&(r=r.toUpperCase());var e=r.length;t.signedconv&&(t.sign<0||t.signstyle!=xl)&&e++,t.alternate&&(8==t.base&&(e+=1),16==t.base&&(e+=2));var n=mb;if(t.justify==Mb&&t.filler==hd)for(a=e;a=1e21||r.toFixed(0).length>a){for(c=u-1;e.charAt(c)==Nv;)c--;e.charAt(c)==bi&&c--,c=(e=e.slice(0,c+1)+e.slice(u)).length,e.charAt(c-3)==za&&(e=e.slice(0,c-1)+Nv+e.slice(c-1));break}var f=a;if(i<0)f-=i+1,e=r.toFixed(f);else for(;(e=r.toFixed(f)).length>a+1;)f--;if(f){for(var c=e.length-1;e.charAt(c)==Nv;)c--;e.charAt(c)==bi&&c--,e=e.slice(0,c+1);}}else e="inf",n.filler=hd;return G(n,e)}function Y(t,r){if(X(t)==hc)return y(mb+r);var e=j(t);r<0&&(e.signedconv?(e.sign=-1,r=-r):r>>>=0);var n=r.toString(e.base);if(e.prec>=0){e.filler=hd;var a=e.prec-n.length;a>0&&(n=b(a,Nv)+n);}return G(e,n)}function J(){return Jd++}function H(t,r){return+(P(t,r,!1)>=0)}function W(t,r){return r=Hd(r,-862048943),r=r<<15|r>>>17,r=Hd(r,461845907),t^=r,((t=t<<13|t>>>19)+(t<<2)|0)-430675100|0}function z(t,r){var e=r[1]|r[2]<<24;return t=W(t,(r[2]>>>8|r[3]<<16)^e)}function V(t){if(Wd)return Math.floor(Math.log2(t));var r=0;if(0==t)return-1/0;if(t>=1)for(;t>=2;)t/=2,r++;else for(;t<1;)t*=2,r--;return r}function K(t){if(!isFinite(t))return isNaN(t)?[lh,1,0,jo]:t>0?[lh,0,0,jo]:[lh,0,0,65520];var r=0==t&&1/t==-1/0?oh:t>=0?0:oh;r&&(t=-t);var e=V(t)+va;e<=0?(e=0,t/=Math.pow(2,-1026)):((t/=Math.pow(2,e-1027))<16&&(t*=2,e-=1),0==e&&(t/=2));var n=Math.pow(2,24),a=0|t,u=0|(t=(t-a)*n);return a=15&a|r|e<<4,[lh,0|(t=(t-u)*n),u,a]}function $(t,r){var e=K(r),n=e[1]|e[2]<<24,a=e[2]>>>8|e[3]<<16;return t=W(t,n),t=W(t,a)}function Q(t,r){var e,n,a=r.length;for(e=0;e+4<=a;e+=4)t=W(t,n=r[e]|r[e+1]<<8|r[e+2]<<16|r[e+3]<<24);switch(n=0,3&a){case 3:n=r[e+2]<<16;case 2:n|=r[e+1]<<8;case 1:t=W(t,n|=r[e]);}return t^=a}function Z(t,r){var e,n,a=r.length;for(e=0;e+4<=a;e+=4)t=W(t,n=r.charCodeAt(e)|r.charCodeAt(e+1)<<8|r.charCodeAt(e+2)<<16|r.charCodeAt(e+3)<<24);switch(n=0,3&a){case 3:n=r.charCodeAt(e+2)<<16;case 2:n|=r.charCodeAt(e+1)<<8;case 1:t=W(t,n|=r.charCodeAt(e));}return t^=a}function tt(t,r){switch(6&r.t){default:k(r);case 0:t=Z(t,r.c);break;case 2:t=Q(t,r.c);}return t}function rt(t){return t^=t>>>16,t=Hd(t,-2048144789),t^=t>>>13,t=Hd(t,-1028477387),t^=t>>>16}function et(t,r,e,n){var a,u,i,f,c,s,o,v,l;for(((f=r)<0||f>zd)&&(f=zd),c=t,s=e,a=[n],u=0,i=1;u0;)if((o=a[u++])instanceof Array&&o[0]===(0|o[0]))switch(o[0]){case 248:s=W(s,o[2]),c--;break;case 250:a[--u]=o[1];break;case 255:s=z(s,o),c--;break;default:for(s=W(s,o.length-1<<10|o[0]),v=1,l=o.length;v=f);v++)a[i++]=o[v];}else o instanceof m?(s=tt(s,o),c--):o===(0|o)?(s=W(s,o+o+1),c--):o===+o&&(s=$(s,o),c--);return(s=rt(s))&wp}function nt(t){return[t[3]>>8,t[3]&lh,t[2]>>16,t[2]>>8&lh,t[2]&lh,t[1]>>16,t[1]>>8&lh,t[1]&lh]}function at(t,r,e){function n(e){if(r--,!(t<0||r<0))if(e instanceof Array&&e[0]===(0|e[0]))switch(e[0]){case 248:t--,a=a*bv+e[2]|0;break;case 250:r++,n(e);break;case 255:t--,a=a*bv+e[1]+(e[2]<<24)|0;break;default:t--,a=19*a+e[0]|0;for(f=e.length-1;f>0;f--)n(e[f]);}else if(e instanceof m)switch(t--,6&e.t){default:k(e);case 0:for(var u=e.c,i=e.l,f=0;f=0;f--)a=19*a+s[f]|0;}}var a=0;return n(e),a&wp}function ut(t){for(var r,e,n=mb,a=n,u=0,i=t.length;uHn?(a.substr(0,1),n+=a,a=mb,n+=t.slice(u,f)):a+=t.slice(u,f),f==i)break;u=f;}r>6),a+=String.fromCharCode(Zn|63&r)):r=yc?a+=String.fromCharCode(Jl|r>>12,Zn|r>>6&63,Zn|63&r):r>=56319||u+1==i||(e=t.charCodeAt(u+1))yc?a+="�":(u++,r=(r<<10)+e-56613888,a+=String.fromCharCode($p|r>>18,Zn|r>>12&63,Zn|r>>6&63,Zn|63&r)),a.length>Nu&&(a.substr(0,1),n+=a,a=mb);}return n+a}function it(t){var r=9;return p(t)||(r=8,t=ut(t)),new m(r,t,t.length)}function ft(t,r,e){if(!isFinite(t))return it(isNaN(t)?ak:t>0?Bu:"-infinity");var n=0==t&&1/t==-1/0?1:t>=0?0:1;n&&(t=-t);var a=0;if(0==t);else if(t<1)for(;t<1&&a>-1022;)t*=2,a--;else for(;t>=2;)t/=2,a++;var u=a<0?mb:Mb,i=mb;if(n)i=xl;else switch(e){case 43:i=Mb;break;case 32:i=hd;}if(r>=0&&r<13){var f=Math.pow(2,4*r);t=Math.round(t*f)/f;}var c=t.toString(16);if(r>=0){var s=c.indexOf(bi);if(s<0)c+=bi+b(r,Nv);else{var o=s+1+r;c.length>24&On,t>>31&ki]}function ot(t){for(var r=t.length,e=new Array(r),n=0;n>24),a=t[3]-r[3]+(n>>24);return[lh,e&On,n&On,a&ki]}function lt(t,r){return t[3]>r[3]?1:t[3]r[2]?1:t[2]r[1]?1:t[1]>23,t[2]=(t[2]<<1|t[1]>>23)&On,t[1]=t[1]<<1&On;}function kt(t){t[1]=(t[1]>>>1|t[2]<<23)&On,t[2]=(t[2]>>>1|t[3]<<23)&On,t[3]=t[3]>>>1;}function pt(t,r){for(var e=0,n=ot(t),a=ot(r),u=[lh,0,0,0];lt(n,a)>0;)e++,bt(a);for(;e>=0;)e--,bt(u),lt(n,a)>=0&&(u[1]++,n=vt(n,a)),kt(a);return[0,u,n]}function ht(t){return t[1]|t[2]<<24}function dt(t){return t[3]<<16<0}function mt(t){var r=-t[1],e=-t[2]+(r>>24),n=-t[3]+(e>>24);return[lh,r&On,e&On,n&ki]}function yt(t,r){var e=j(t);e.signedconv&&dt(r)&&(e.sign=-1,r=mt(r));var n=mb,a=st(e.base);do{var u=pt(r,a);r=u[1],n="0123456789abcdef".charAt(ht(u[2]))+n;}while(!ct(r));if(e.prec>=0){e.filler=hd;var i=e.prec-n.length;i>0&&(n=b(i,Nv)+n);}return G(e,n)}function wt(t){return t.l}function gt(t,r){switch(6&t.t){default:if(r>=t.c.length)return 0;case 0:return t.c.charCodeAt(r);case 4:return t.c[r]}}function Tt(t,r){var e=t[1]+r[1],n=t[2]+r[2]+(e>>24),a=t[3]+r[3]+(n>>24);return[lh,e&On,n&On,a&ki]}function _t(t,r){var e=t[1]*r[1],n=(e*Vd|0)+t[2]*r[1]+t[1]*r[2],a=(n*Vd|0)+t[3]*r[1]+t[2]*r[2]+t[1]*r[3];return[lh,e&On,n&On,a&ki]}function St(t,r){return lt(t,r)<0}function At(t){var r=0,e=wt(t),n=10,a=e>0&&45==gt(t,0)?(r++,-1):1;if(r+1=48&&t<=57?t-48:t>=65&&t<=90?t-55:t>=97&&t<=xs?t-87:-1}function xt(t){var r=At(t),e=r[0],n=r[1],a=r[2],u=st(a),i=pt([lh,On,268435455,ki],u)[1],f=gt(t,e),c=Et(f);(c<0||c>=a)&&F(Ap);for(var s=st(c);;)if(e++,95!=(f=gt(t,e))){if((c=Et(f))<0||c>=a)break;St(i,s)&&F(Ap),c=st(c),St(s=Tt(_t(u,s),c),c)&&F(Ap);}return e!=wt(t)&&F(Ap),10==r[2]&&St([lh,0,0,oh],s)&&F(Ap),n<0&&(s=mt(s)),s}function It(t){return(t[3]<<16)*Math.pow(2,32)+t[2]*Math.pow(2,24)+t[1]}function Ct(t){var r=At(t),e=r[0],n=r[1],a=r[2],u=wt(t),i=e=a)&&F(Ap);var c=f;for(e++;e=a)break;(c=a*c+f)>-1>>>0&&F(Ap);}return e!=u&&F(Ap),c*=n,10==a&&(0|c)!=c&&F(Ap),0|c}function Nt(t){return s(t,1,t.length-1)}function Rt(t){return t.toString()}function Lt(t){for(var r={},e=1;e=0;e--)r=[0,t[e],r];return r}function Dt(t,r){var t=t+1|0,e=new Array(t);e[0]=0;for(var n=1;n=a){var i=jt(u+n);l(t.file.data,0,i,0,a),l(e,0,i,u,n),t.file.data=i;}return t.offset+=n,t.file.modified(),0}function Kt(t){var r;switch(t){case 1:r=zt;break;case 2:r=Wt;break;default:r=Vt;}var e=Gd.fds[t];e.flags.rdonly&&Xt(ca+t+" is readonly");var n={file:e.file,offset:e.offset,fd:t,opened:!0,buffer:mb,output:r};return Qd[n.fd]=n,n}function $t(){for(var t=0,r=0;r>>0>=t.l&&T(),gt(t,r)}function sr(t,r){return 1-fr(t,r)}function or(t,r,e){if(e&=lh,4!=t.t){if(r==t.c.length)return t.c+=String.fromCharCode(e),r+1==t.l&&(t.t=0),0;v(t);}return t.c[r]=e,0}function vr(){Zt(Gd.Not_found);}function lr(r){var e=t,n=r.toString();if(e.process&&e.process.env&&void 0!=e.process.env[n])return it(e.process.env[n]);vr();}function br(){return[0,new Date^4294967295*Math.random()]}function kr(t){for(var r=1;t&&t.joo_tramp;)t=t.joo_tramp.apply(null,t.joo_args),r++;return t}function pr(t,r){return{joo_tramp:t,joo_args:r}}function hr(t){return t}function dr(t){return Zd[t]}function mr(r){return r instanceof Array?r:t.RangeError&&r instanceof t.RangeError&&r.message&&r.message.match(/maximum call stack/i)?hr(Gd.Stack_overflow):t.InternalError&&r instanceof t.InternalError&&r.message&&r.message.match(/too much recursion/i)?hr(Gd.Stack_overflow):r instanceof t.Error?[0,dr(Mk),r]:[0,Gd.Failure,it(String(r))]}function yr(t,r){return 1==t.length?t(r):E(t,[r])}function wr(t,r,e){return 2==t.length?t(r,e):E(t,[r,e])}function gr(t,r,e,n){return 3==t.length?t(r,e,n):E(t,[r,e,n])}function Tr(t,r,e,n,a){return 4==t.length?t(r,e,n,a):E(t,[r,e,n,a])}function _r(t,r,e,n,a,u){return 5==t.length?t(r,e,n,a,u):E(t,[r,e,n,a,u])}function Sr(t){if("number"==typeof t)return 0;switch(t[0]){case 0:return[0,Sr(t[1])];case 1:return[1,Sr(t[1])];case 2:return[2,Sr(t[1])];case 3:return[3,Sr(t[1])];case 4:return[4,Sr(t[1])];case 5:return[5,Sr(t[1])];case 6:return[6,Sr(t[1])];case 7:return[7,Sr(t[1])];case 8:return[8,t[1],Sr(t[2])];case 9:var r=t[1];return[9,r,r,Sr(t[3])];case 10:return[10,Sr(t[1])];case 11:return[11,Sr(t[1])];case 12:return[12,Sr(t[1])];case 13:return[13,Sr(t[1])];default:return[14,Sr(t[1])]}}function Ar(t,r){if("number"==typeof t)return r;switch(t[0]){case 0:return[0,Ar(t[1],r)];case 1:return[1,Ar(t[1],r)];case 2:return[2,Ar(t[1],r)];case 3:return[3,Ar(t[1],r)];case 4:return[4,Ar(t[1],r)];case 5:return[5,Ar(t[1],r)];case 6:return[6,Ar(t[1],r)];case 7:return[7,Ar(t[1],r)];case 8:return[8,t[1],Ar(t[2],r)];case 9:var e=t[2];return[9,t[1],e,Ar(t[3],r)];case 10:return[10,Ar(t[1],r)];case 11:return[11,Ar(t[1],r)];case 12:return[12,Ar(t[1],r)];case 13:return[13,Ar(t[1],r)];default:return[14,Ar(t[1],r)]}}function Er(t,r){if("number"==typeof t)return r;switch(t[0]){case 0:return[0,Er(t[1],r)];case 1:return[1,Er(t[1],r)];case 2:return[2,t[1],Er(t[2],r)];case 3:return[3,t[1],Er(t[2],r)];case 4:var e=t[3],n=t[2];return[4,t[1],n,e,Er(t[4],r)];case 5:var a=t[3],u=t[2];return[5,t[1],u,a,Er(t[4],r)];case 6:var i=t[3],f=t[2];return[6,t[1],f,i,Er(t[4],r)];case 7:var c=t[3],s=t[2];return[7,t[1],s,c,Er(t[4],r)];case 8:var o=t[3],v=t[2];return[8,t[1],v,o,Er(t[4],r)];case 9:return[9,Er(t[1],r)];case 10:return[10,Er(t[1],r)];case 11:return[11,t[1],Er(t[2],r)];case 12:return[12,t[1],Er(t[2],r)];case 13:var l=t[2];return[13,t[1],l,Er(t[3],r)];case 14:var b=t[2];return[14,t[1],b,Er(t[3],r)];case 15:return[15,Er(t[1],r)];case 16:return[16,Er(t[1],r)];case 17:return[17,t[1],Er(t[2],r)];case 18:return[18,t[1],Er(t[2],r)];case 19:return[19,Er(t[1],r)];case 20:var k=t[2];return[20,t[1],k,Er(t[3],r)];case 21:return[21,t[1],Er(t[2],r)];case 22:return[22,Er(t[1],r)];case 23:return[23,t[1],Er(t[2],r)];default:var p=t[2];return[24,t[1],p,Er(t[3],r)]}}function xr(t){throw[0,rm,t]}function Ir(t){throw[0,em,t]}function Cr(t,r){return H(t,r)?t:r}function Nr(t){return 0<=t?t:0|-t}function Rr(t,r){var e=wt(t),n=wt(r),a=U(e+n|0);return l(t,0,a,0,e),l(r,0,a,e,n),a}function Lr(t,r){return t?[0,t[1],Lr(t[2],r)]:r}function Pr(t){for(var r=0,e=t;;){if(!e)return r;var r=r+1|0,e=e[2];}}function Or(t){return t?t[1]:xr(_m)}function Ur(t,r){for(var e=t,n=r;;){if(!e)return n;var a=[0,e[1],n],e=e[2],n=a;}}function Dr(t){return Ur(t,0)}function Mr(t,r){if(r){var e=r[2];return[0,yr(t,r[1]),Mr(t,e)]}return 0}function Fr(t,r){for(n=r;;){if(!n)return 0;var e=n[2];yr(t,n[1]);var n=e;}}function Xr(t,r,e){for(var n=r,a=e;;){if(!a)return n;var u=a[2],n=wr(t,n,a[1]),a=u;}}function Br(t,r){for(var e=t,n=r;;){if(0===e)return n;if(!n)throw[0,im,Tm];var e=e-1|0,n=n[2];}}function jr(t){return 0<=t&&!(lh>1,w=Br(y,r),g=p(y,r),T=p(t-y|0,w),_=0;;){if(g){if(T){var S=T[2],A=T[1],E=g[2],x=g[1],I=wr(b,x,A);if(0===I){var g=E,T=S,_=[0,x,_];continue}if(0>1,w=Br(y,r),g=k(y,r),T=k(t-y|0,w),_=0;;){if(g){if(T){var S=T[2],A=T[1],E=g[2],x=g[1],I=wr(b,x,A);if(0===I){var g=E,T=S,_=[0,x,_];continue}if(0<=I){var T=S,_=[0,A,_];continue}var g=E,_=[0,x,_];continue}return Ur(g,_)}return Ur(T,_)}},h=Pr(r),d=2<=h?k(h,r):r,m=function(t,r){if(!(3>>0))switch(t){case 0:return[0,0,r];case 1:if(r)return[0,[0,0,r[1],0,1],r[2]];break;case 2:if(r){var n=r[2];if(n)return[0,[0,[0,0,r[1],0,1],n[1],0,2],n[2]]}break;default:if(r){var a=r[2];if(a){var u=a[2];if(u)return[0,[0,[0,0,r[1],0,1],a[1],[0,0,u[1],0,1],2],u[2]]}}}var i=t/2|0,f=m(i,r),c=f[2],s=f[1];if(c){var o=c[1],v=m((t-i|0)-1|0,c[2]),l=v[2];return[0,e(s,o,v[1]),l]}throw[0,im,Bm]};return m(Pr(d),d)[1]}return a(v[1],a(l,a(o,a(c,u(i)))))}return a(l,a(o,a(c,u(i))))}return a(o,a(c,u(i)))}return a(c,u(i))}return u(i)}return 0}]}function ne(t){throw YK}function ae(t){var r=t[1];t[1]=ne;try{var e=yr(r,0);return t[1]=e,nr(t,Ql),e}catch(r){throw r=mr(r),t[1]=function(t){throw r},r}}function ue(t){var r=1<=t?t:1,e=qK>>0?1:0:65<=a?0:1;else{if(32===a)f=1;else if(43<=a)switch(a+na|0){case 5:if(n<(e+2|0)&&1>>0)if(93<=e)n=0;else n=1;else if(56<(e-1|0)>>>0)n=0;else var n=1;if(n){var a=a+1|0;continue}}else;var u=1;}if(u){var i=[0,0],f=Ft(t)-1|0;if(!(f<0))for(p=0;;){var c=gt(t,p);if(32<=c){var s=c+kp|0;if(58>>0)if(93<=s)var o=0,v=0;else v=1;else if(56<(s-1|0)>>>0)var o=1,v=0;else v=1;if(v)var b=1,o=2;}else o=11<=c?13===c?1:0:8<=c?1:0;switch(o){case 0:b=4;break;case 1:b=2;}i[1]=i[1]+b|0;var k=p+1|0;if(f===p)break;var p=k;}if(i[1]===Ft(t)){var h=Ft(t),d=U(h);qd(t,0,d,0,h);S=d;}else{var m=U(i[1]);i[1]=0;var y=Ft(t)-1|0;if(!(y<0))for(_=0;;){var w=gt(t,_);if(35<=w)g=92===w?1:Kb<=w?0:2;else if(32<=w)g=34<=w?1:2;else if(14<=w)g=0;else switch(w){case 8:or(m,i[1],92),or(m,++i[1],98);g=3;break;case 9:or(m,i[1],92),or(m,++i[1],Ad);g=3;break;case 10:or(m,i[1],92),or(m,++i[1],ol);g=3;break;case 13:or(m,i[1],92),or(m,++i[1],rf);g=3;break;default:var g=0;}switch(g){case 0:or(m,i[1],92),or(m,++i[1],48+(w/Tb|0)|0),or(m,++i[1],48+((w/10|0)%10|0)|0),or(m,++i[1],48+(w%10|0)|0);break;case 1:or(m,i[1],92),or(m,++i[1],w);break;case 2:or(m,i[1],w);}i[1]++;var T=_+1|0;if(y===_)break;var _=T;}S=m;}}else var S=t;var A=wt(S),E=qr(A+2|0,34);return l(S,0,E,1,A),E}}function xe(t,r){switch(t){case 0:e=Ew;break;case 1:e=xw;break;case 2:e=Iw;break;case 3:e=Cw;break;case 4:e=Nw;break;case 5:e=Rw;break;case 6:e=Lw;break;case 7:e=Pw;break;case 8:e=Ow;break;case 9:e=Uw;break;case 10:e=Dw;break;case 11:e=Mw;break;default:var e=Fw;}return Y(e,r)}function Ie(t,r){switch(t){case 0:e=tw;break;case 1:e=rw;break;case 2:e=ew;break;case 3:e=nw;break;case 4:e=aw;break;case 5:e=uw;break;case 6:e=iw;break;case 7:e=fw;break;case 8:e=cw;break;case 9:e=sw;break;case 10:e=ow;break;case 11:e=vw;break;default:var e=lw;}return Y(e,r)}function Ce(t,r){switch(t){case 0:e=jy;break;case 1:e=Gy;break;case 2:e=qy;break;case 3:e=Yy;break;case 4:e=Jy;break;case 5:e=Hy;break;case 6:e=Wy;break;case 7:e=zy;break;case 8:e=Vy;break;case 9:e=Ky;break;case 10:e=$y;break;case 11:e=Qy;break;default:var e=Zy;}return Y(e,r)}function Ne(t,r){switch(t){case 0:e=bw;break;case 1:e=kw;break;case 2:e=pw;break;case 3:e=hw;break;case 4:e=dw;break;case 5:e=mw;break;case 6:e=yw;break;case 7:e=ww;break;case 8:e=gw;break;case 9:e=Tw;break;case 10:e=_w;break;case 11:e=Sw;break;default:var e=Aw;}return yt(e,r)}function Re(t,r,e){if(16<=t){if(17<=t)switch(t+xb|0){case 2:a=0;break;case 0:case 3:var n=43,a=1;break;default:var n=32,a=1;}else a=0;if(!a)n=45;var u=ft(e,r,n);if(19<=t){var i=Ft(u);if(0===i)return u;var f=U(i),c=i-1|0;if(!(c<0))for(b=0;;){var s=gt(u,b);if(97<=s)if(xs>>0?55===T?1:0:21<(T-1|0)>>>0?1:0)){var _=_+1|0;continue}var S=1;}return S?m:Rr(m,My)}}return m}function Le(t,r,e,n,a,u,i,f){if("number"==typeof a){if("number"==typeof u)return 0===u?function(a){return Fe(t,r,[4,e,wr(i,f,a)],n)}:function(a,u){return Fe(t,r,[4,e,Ae(a,wr(i,f,u))],n)};var c=u[1];return function(a){return Fe(t,r,[4,e,Ae(c,wr(i,f,a))],n)}}if(0===a[0]){var s=a[2],o=a[1];if("number"==typeof u)return 0===u?function(a){return Fe(t,r,[4,e,Se(o,s,wr(i,f,a))],n)}:function(a,u){return Fe(t,r,[4,e,Se(o,s,Ae(a,wr(i,f,u)))],n)};var v=u[1];return function(a){return Fe(t,r,[4,e,Se(o,s,Ae(v,wr(i,f,a)))],n)}}var l=a[1];if("number"==typeof u)return 0===u?function(a,u){return Fe(t,r,[4,e,Se(l,a,wr(i,f,u))],n)}:function(a,u,c){return Fe(t,r,[4,e,Se(l,a,Ae(u,wr(i,f,c)))],n)};var b=u[1];return function(a,u){return Fe(t,r,[4,e,Se(l,a,Ae(b,wr(i,f,u)))],n)}}function Pe(t,r,e,n,a,u){if("number"==typeof a)return function(a){return Fe(t,r,[4,e,yr(u,a)],n)};if(0===a[0]){var i=a[2],f=a[1];return function(a){return Fe(t,r,[4,e,Se(f,i,yr(u,a))],n)}}var c=a[1];return function(a,i){return Fe(t,r,[4,e,Se(c,a,yr(u,i))],n)}}function Oe(t,r,e,n,a){for(var u=r,i=n,f=a;;){if("number"==typeof f)return wr(u,e,i);switch(f[0]){case 0:var c=f[1];return function(t){return Fe(u,e,[5,i,t],c)};case 1:var s=f[1];return function(t){var r=Gr(t),n=wt(r),a=qr(n+2|0,39);return l(r,0,a,1,n),Fe(u,e,[4,i,a],s)};case 2:var o=f[2],v=f[1];return Pe(u,e,i,o,v,function(t){return t});case 3:return Pe(u,e,i,f[2],f[1],Ee);case 4:return Le(u,e,i,f[4],f[2],f[3],xe,f[1]);case 5:return Le(u,e,i,f[4],f[2],f[3],Ie,f[1]);case 6:return Le(u,e,i,f[4],f[2],f[3],Ce,f[1]);case 7:return Le(u,e,i,f[4],f[2],f[3],Ne,f[1]);case 8:var b=f[4],k=f[3],p=f[2],h=f[1];if("number"==typeof p){if("number"==typeof k)return 0===k?function(t){return Fe(u,e,[4,i,Re(h,JK,t)],b)}:function(t,r){return Fe(u,e,[4,i,Re(h,t,r)],b)};var d=k[1];return function(t){return Fe(u,e,[4,i,Re(h,d,t)],b)}}if(0===p[0]){var m=p[2],y=p[1];if("number"==typeof k)return 0===k?function(t){return Fe(u,e,[4,i,Se(y,m,Re(h,JK,t))],b)}:function(t,r){return Fe(u,e,[4,i,Se(y,m,Re(h,t,r))],b)};var w=k[1];return function(t){return Fe(u,e,[4,i,Se(y,m,Re(h,w,t))],b)}}var g=p[1];if("number"==typeof k)return 0===k?function(t,r){return Fe(u,e,[4,i,Se(g,t,Re(h,JK,r))],b)}:function(t,r,n){return Fe(u,e,[4,i,Se(g,t,Re(h,r,n))],b)};var T=k[1];return function(t,r){return Fe(u,e,[4,i,Se(g,t,Re(h,T,r))],b)};case 9:var _=f[1];return function(t){return Fe(u,e,[4,i,t?wm:gm],_)};case 10:var i=[7,i],f=f[1];continue;case 11:var i=[2,i,f[1]],f=f[2];continue;case 12:var i=[3,i,f[1]],f=f[2];continue;case 13:var S=f[3],A=f[2],E=oe(16);pe(E,A);var x=ke(E);return function(t){return Fe(u,e,[4,i,x],S)};case 14:var I=f[3],C=f[2];return function(t){var r=Te(t[1],Sr(he(C)));if("number"==typeof r[2])return Fe(u,e,i,Er(r[1],I));throw HK};case 15:var N=f[1];return function(t,r){return Fe(u,e,[6,i,function(e){return wr(t,e,r)}],N)};case 16:var R=f[1];return function(t){return Fe(u,e,[6,i,t],R)};case 17:var i=[0,i,f[1]],f=f[2];continue;case 18:var L=f[1];if(0===L[0]){var P=f[2],O=L[1][1],u=function(t,r,e){return function(n,a){return Fe(r,n,[1,t,[0,a]],e)}}(i,u,P),i=0,f=O;continue}var U=f[2],D=L[1][1],u=function(t,r,e){return function(n,a){return Fe(r,n,[1,t,[1,a]],e)}}(i,u,U),i=0,f=D;continue;case 19:throw[0,im,Iy];case 20:var M=f[3],F=[8,i,Cy];return function(t){return Fe(u,e,F,M)};case 21:var X=f[2];return function(t){return Fe(u,e,[4,i,Y(xy,t)],X)};case 22:var B=f[1];return function(t){return Fe(u,e,[5,i,t],B)};case 23:var j=f[2],G=f[1];if("number"==typeof G)switch(G){case 0:case 1:case 2:return t<50?De(t+1|0,u,e,i,j):pr(De,[0,u,e,i,j]);case 3:throw[0,im,Ny];default:return t<50?De(t+1|0,u,e,i,j):pr(De,[0,u,e,i,j])}else switch(G[0]){case 0:case 1:case 2:case 3:case 4:case 5:case 6:case 7:return t<50?De(t+1|0,u,e,i,j):pr(De,[0,u,e,i,j]);case 8:var q=G[2];return t<50?Ue(t+1|0,u,e,i,q,j):pr(Ue,[0,u,e,i,q,j]);case 9:default:return t<50?De(t+1|0,u,e,i,j):pr(De,[0,u,e,i,j])}default:var J=f[3],H=f[1],W=yr(f[2],0);return t<50?Me(t+1|0,u,e,i,J,H,W):pr(Me,[0,u,e,i,J,H,W])}}}function Ue(t,r,e,n,a,u){if("number"==typeof a)return t<50?De(t+1|0,r,e,n,u):pr(De,[0,r,e,n,u]);switch(a[0]){case 0:var i=a[1];return function(t){return Xe(r,e,n,i,u)};case 1:var f=a[1];return function(t){return Xe(r,e,n,f,u)};case 2:var c=a[1];return function(t){return Xe(r,e,n,c,u)};case 3:var s=a[1];return function(t){return Xe(r,e,n,s,u)};case 4:var o=a[1];return function(t){return Xe(r,e,n,o,u)};case 5:var v=a[1];return function(t){return Xe(r,e,n,v,u)};case 6:var l=a[1];return function(t){return Xe(r,e,n,l,u)};case 7:var b=a[1];return function(t){return Xe(r,e,n,b,u)};case 8:var k=a[2];return function(t){return Xe(r,e,n,k,u)};case 9:var p=a[3],h=a[2],d=me(he(a[1]),h);return function(t){return Xe(r,e,n,Ar(d,p),u)};case 10:var m=a[1];return function(t,a){return Xe(r,e,n,m,u)};case 11:var y=a[1];return function(t){return Xe(r,e,n,y,u)};case 12:var w=a[1];return function(t){return Xe(r,e,n,w,u)};case 13:throw[0,im,Ry];default:throw[0,im,Ly]}}function De(t,r,e,n,a){var u=[8,n,Py];return t<50?Oe(t+1|0,r,e,u,a):pr(Oe,[0,r,e,u,a])}function Me(t,r,e,n,a,u,i){if(u){var f=u[1];return function(t){return Be(r,e,n,a,f,yr(i,t))}}var c=[4,n,i];return t<50?Oe(t+1|0,r,e,c,a):pr(Oe,[0,r,e,c,a])}function Fe(t,r,e,n){return kr(Oe(0,t,r,e,n))}function Xe(t,r,e,n,a){return kr(Ue(0,t,r,e,n,a))}function Be(t,r,e,n,a,u){return kr(Me(0,t,r,e,n,a,u))}function je(t,r){for(o=r;;){if("number"==typeof o)return 0;switch(o[0]){case 0:var e=o[2],n=o[1];if("number"==typeof e)switch(e){case 0:a=Xw;break;case 1:a=Bw;break;case 2:a=jw;break;case 3:a=Gw;break;case 4:a=qw;break;case 5:a=Yw;break;default:a=Jw;}else switch(e[0]){case 0:case 1:a=e[1];break;default:var a=Rr(Hw,zr(1,e[1]));}return je(t,n),se(t,a);case 1:var u=o[2],i=o[1];if(0===u[0]){var f=u[1];je(t,i),se(t,Oy);o=f;continue}var c=u[1];je(t,i),se(t,Uy);o=c;continue;case 6:var s=o[2];return je(t,o[1]),se(t,yr(s,0));case 7:var o=o[1];continue;case 8:var v=o[2];return je(t,o[1]),Ir(v);case 2:case 4:var l=o[2];return je(t,o[1]),se(t,l);default:var b=o[2];return je(t,o[1]),ce(t,b)}}}function Ge(t){return Fe(function(t,r){var e=ue(64);return je(e,r),ie(e)},0,0,t[1])}function qe(t,r){var e=t[r+1];if(1-("number"==typeof e)){if(ar(e)===bd)return yr(Ge(ig),e);if(ar(e)===Sl)for(var n=q(mm,e),a=0,u=wt(n);;){if(u<=a)return Rr(n,ym);var i=cr(n,a);if(!(48<=i?58<=i?0:1:45===i?1:0))return n;a=a+1|0;}return fg}return yr(Ge(ug),e)}function Ye(t,r){if(t.length-1<=r)return zw;var e=Ye(t,r+1|0),n=qe(t,r);return wr(Ge(Vw),n,e)}function Je(t){var r=t.length-1;if(2>>0){var e=Ye(t,2),n=qe(t,1);return wr(Ge(rg),n,e)}switch(r){case 0:return eg;case 1:return ng;default:var a=qe(t,1);return yr(Ge(ag),a)}}function He(t){return WK[1]=[0,t,WK[1]],0}function We(t,r){for(var e=t?t[1]:KK,n=16;;){if(r<=n||GK<(2*n|0)){if(e){var a=ar($K),u=Ql===a?$K[1]:ls===a?ae($K):$K;u[2]=(u[2]+1|0)%55|0;var i=u[2],f=I(u[1],i)[i+1],c=(u[2]+24|0)%55|0,s=(I(u[1],c)[c+1]+(f^31&(f>>>25|0))|0)&wp,o=u[2];I(u[1],o)[o+1]=s;v=s;}else var v=0;return[0,0,Dt(n,0),v,n]}n=2*n|0;}}function ze(t,r){return 3<=t.length-1?et(10,Tb,t[3],r)&(t[2].length-1-1|0):rr(at(10,Tb,r),t[2].length-1)}function Ve(t,r,e){var n=ze(t,r),a=[0,r,e,I(t[2],n)[n+1]];I(t[2],n)[n+1]=a,t[1]=t[1]+1|0;var u=t[2].length-1<<1>16)*r<<16)+(t&ki)*r|0});var Hd=Math.imul,Wd=Math.log2&&1020==Math.log2(1.1235582092889474e307),zd=256,Vd=Math.pow(2,-24),Kd=function(){function t(t,r){return t+r|0}function r(r,e,n,a,u,i){return e=t(t(e,r),t(a,i)),t(e<>>32-u,n)}function e(t,e,n,a,u,i,f){return r(e&n|~e&a,t,e,u,i,f)}function n(t,e,n,a,u,i,f){return r(e&a|n&~a,t,e,u,i,f)}function a(t,e,n,a,u,i,f){return r(e^n^a,t,e,u,i,f)}function u(t,e,n,a,u,i,f){return r(n^(e|~a),t,e,u,i,f)}function i(r,i){for(r[(b=i)>>2]|=Zn<<8*(3&b),b=8+(-4&b);(63&b)<60;b+=4)r[(b>>2)-1]=0;r[(b>>2)-1]=i<<3,r[b>>2]=i>>29&536870911;var f=[1732584193,4023233417,2562383102,271733878];for(b=0;b>8*k&lh;return l}return function(t,r,e){var n=[];switch(6&t.t){default:k(t);case 0:for(var a=t.c,u=0;u>2]=a.charCodeAt(c)|a.charCodeAt(c+1)<<8|a.charCodeAt(c+2)<<16|a.charCodeAt(c+3)<<24;}for(;u>2]|=a.charCodeAt(u+r)<<8*(3&u);break;case 4:for(var f=t.c,u=0;u>2]=f[c]|f[c+1]<<8|f[c+2]<<16|f[c+3]<<24;}for(;u>2]|=f[u+r]<<8*(3&u);}return Mt(i(n,e))}}(),$d=0;Yt.prototype={truncate:function(){this.data=jt(0),this.modified();},modified:function(){var t=qt();this.atime=t,this.mtime=t;}};Jt.prototype={exists:function(t){return this.content[t]?1:0},mk:function(t,r){this.content[t]=r;},get:function(t){return this.content[t]},list:function(){var t=[];for(var r in this.content)t.push(r);return t},remove:function(t){delete this.content[t];}},(new Jt).mk(mb,new Jt),Ht(0,new Yt(jt(0))),Ht(1,new Yt(jt(0))),Ht(2,new Yt(jt(0)));var Qd=new Array,Zd={},tm=[Ov,y(fu),-1],rm=[Ov,y(Kk),-3],em=[Ov,y(av),-4],nm=[Ov,y(Gs),-7],am=[Ov,y(Rb),-8],um=[Ov,y(Rs),-9],im=[Ov,y(Qi),-11],fm=[Ov,y(yd),-12],cm=[0,[11,y('File "'),[2,0,[11,y('", line '),[4,0,0,0,[11,y(", characters "),[4,0,0,0,[12,45,[4,0,0,0,[11,y(": "),[2,0,0]]]]]]]]]],y('File "%s", line %d, characters %d-%d: %s')],sm=[0,0,[0,0,0,0],[0,0,0,0]],om=[0,0,0],vm=y(""),lm=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),bm=[0,0,0,0,0,1,0],km=[0,0,0],pm=[0,1],hm=[0,0];ur(11,fm,yd),ur(10,im,Qi),ur(9,[Ov,y(Fv),-10],Fv),ur(8,um,Rs),ur(7,am,Rb),ur(6,nm,Gs),ur(5,[Ov,y(ec),-6],ec),ur(4,[Ov,y(Hk),-5],Hk),ur(3,em,av),ur(2,rm,Kk),ur(1,[Ov,y(pp),-2],pp),ur(0,tm,fu);var dm=y("output_substring"),mm=y("%.12g"),ym=y(bi),wm=y($o),gm=y(ko),Tm=[0,y("list.ml"),227,11],_m=y("hd"),Sm=y("\\\\"),Am=y("\\'"),Em=y("\\b"),xm=y("\\t"),Im=y("\\n"),Cm=y("\\r"),Nm=y("Char.chr"),Rm=y("String.blit / Bytes.blit_string"),Lm=y("Bytes.blit"),Pm=y("String.sub / Bytes.sub"),Om=y("String.contains_from / Bytes.contains_from"),Um=(y(mb),y("String.concat"),y("Array.blit")),Dm=y("Array.init"),Mm=y("Set.remove_min_elt"),Fm=[0,0,0,0],Xm=[0,0,0],Bm=[0,y("set.ml"),405,18],jm=y(Od),Gm=y(Od),qm=y(Od),Ym=y(Od),Jm=y("CamlinternalLazy.Undefined"),Hm=y("Buffer.add_substring/add_subbytes"),Wm=y("Buffer.add: cannot grow buffer"),zm=y("%c"),Vm=y("%s"),Km=y("%i"),$m=y("%li"),Qm=y("%ni"),Zm=y("%Li"),ty=y("%f"),ry=y("%B"),ey=y("%{"),ny=y("%}"),ay=y("%("),uy=y("%)"),iy=y("%a"),fy=y("%t"),cy=y("%?"),sy=y("%r"),oy=y("%_r"),vy=[0,y(vp),845,23],ly=[0,y(vp),809,21],by=[0,y(vp),810,21],ky=[0,y(vp),813,21],py=[0,y(vp),814,21],hy=[0,y(vp),817,19],dy=[0,y(vp),818,19],my=[0,y(vp),821,22],yy=[0,y(vp),822,22],wy=[0,y(vp),826,30],gy=[0,y(vp),827,30],Ty=[0,y(vp),831,26],_y=[0,y(vp),832,26],Sy=[0,y(vp),841,28],Ay=[0,y(vp),842,28],Ey=[0,y(vp),846,23],xy=y("%u"),Iy=[0,y(vp),1520,4],Cy=y("Printf: bad conversion %["),Ny=[0,y(vp),1588,39],Ry=[0,y(vp),1611,31],Ly=[0,y(vp),1612,31],Py=y("Printf: bad conversion %_"),Oy=y("@{"),Uy=y("@["),Dy=y(ak),My=y(bi),Fy=y("neg_infinity"),Xy=y(Bu),By=y("%.12g"),jy=y("%nd"),Gy=y("%+nd"),qy=y("% nd"),Yy=y("%ni"),Jy=y("%+ni"),Hy=y("% ni"),Wy=y("%nx"),zy=y("%#nx"),Vy=y("%nX"),Ky=y("%#nX"),$y=y("%no"),Qy=y("%#no"),Zy=y("%nu"),tw=y("%ld"),rw=y("%+ld"),ew=y("% ld"),nw=y("%li"),aw=y("%+li"),uw=y("% li"),iw=y("%lx"),fw=y("%#lx"),cw=y("%lX"),sw=y("%#lX"),ow=y("%lo"),vw=y("%#lo"),lw=y("%lu"),bw=y("%Ld"),kw=y("%+Ld"),pw=y("% Ld"),hw=y("%Li"),dw=y("%+Li"),mw=y("% Li"),yw=y("%Lx"),ww=y("%#Lx"),gw=y("%LX"),Tw=y("%#LX"),_w=y("%Lo"),Sw=y("%#Lo"),Aw=y("%Lu"),Ew=y(hc),xw=y("%+d"),Iw=y("% d"),Cw=y("%i"),Nw=y("%+i"),Rw=y("% i"),Lw=y("%x"),Pw=y("%#x"),Ow=y("%X"),Uw=y("%#X"),Dw=y("%o"),Mw=y("%#o"),Fw=y("%u"),Xw=y("@]"),Bw=y("@}"),jw=y("@?"),Gw=y("@\n"),qw=y("@."),Yw=y("@@"),Jw=y("@%"),Hw=y("@"),Ww=y("CamlinternalFormat.Type_mismatch"),zw=y(mb),Vw=[0,[11,y(", "),[2,0,[2,0,0]]],y(", %s%s")],Kw=y("Out of memory"),$w=y("Stack overflow"),Qw=y("Pattern matching failed"),Zw=y("Assertion failed"),tg=y("Undefined recursive module"),rg=[0,[12,40,[2,0,[2,0,[12,41,0]]]],y("(%s%s)")],eg=y(mb),ng=y(mb),ag=[0,[12,40,[2,0,[12,41,0]]],y("(%s)")],ug=[0,[4,0,0,0,0],y(hc)],ig=[0,[3,0,0],y("%S")],fg=y("_"),cg=y("x"),sg=y("OCAMLRUNPARAM"),og=y("CAMLRUNPARAM"),vg=y(mb),lg=[3,0,3],bg=y(bi),kg=y(">"),pg=y(""),dg=y("<"),mg=y("\n"),yg=y("Format.Empty_queue"),wg=[0,y(mb)],gg=y("TMPDIR"),Tg=y("TEMP"),_g=y("Cygwin"),Sg=y("Win32"),Ag=[0,y("sedlexing.ml"),51,25],Eg=y("Sedlexing.MalFormed"),xg=y("Js.Error"),Ig=y(Mk),Cg=y(xf),Ng=[0,[0]],Rg=[0,y(Ib),18,6],Lg=[0,[0,[0,[0]]]],Pg=[0,y(Ib),39,6],Og=[0,[0]],Ug=[0,y(Ib),44,6],Dg=[0,[0,[0,[0,[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]]]],Mg=[0,y(Ib),218,6],Fg=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],Xg=[0,y(Ib),516,6],Bg=[0,[0,[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0,[0,[0]],[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]]]],jg=[0,y(Ib),782,6],Gg=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],qg=[0,y(Ib),885,6],Yg=[0,[0,[0,[0,[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]]]],Jg=[0,y(Ib),950,6],Hg=[0,[0]],Wg=[0,y(Ib),957,6],zg=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],Vg=[0,y(Ib),1010,6],Kg=[0,[0,[0,[0]]]],$g=[0,y(Ib),1033,6],Qg=[0,[0]],Zg=[0,[0,[0,[0]]]],tT=[0,[0]],rT=[0,[0,[0,[0,[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]]]],eT=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],nT=[0,[0,[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0,[0,[0]],[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]]]],aT=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],uT=[0,[0,[0,[0,[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]]]],iT=[0,[0]],fT=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],cT=[0,[0,[0,[0]]]],sT=y("Unexpected number"),oT=y("Unexpected string"),vT=y("Unexpected identifier"),lT=y("Unexpected reserved word"),bT=y("Unexpected end of input"),kT=y("Unexpected variance sigil"),pT=y("Type aliases are not allowed in untyped mode"),hT=y("Type annotations are not allowed in untyped mode"),dT=y("Type declarations are not allowed in untyped mode"),mT=y("Type imports are not allowed in untyped mode"),yT=y("Type exports are not allowed in untyped mode"),wT=y("Interfaces are not allowed in untyped mode"),gT=y("Illegal newline after throw"),TT=y("Invalid regular expression"),_T=y("Invalid regular expression: missing /"),ST=y("Invalid left-hand side in assignment"),AT=y("Invalid left-hand side in exponentiation expression"),ET=y("Invalid left-hand side in for-in"),xT=y("Invalid left-hand side in for-of"),IT=y("found an expression instead"),CT=y("Expected an object pattern, array pattern, or an identifier but "),NT=y("More than one default clause in switch statement"),RT=y("Missing catch or finally after try"),LT=y("Illegal continue statement"),PT=y("Illegal break statement"),OT=y("Illegal return statement"),UT=y("Illegal yield expression"),DT=y("Strict mode code may not include a with statement"),MT=y("Catch variable may not be eval or arguments in strict mode"),FT=y("Variable name may not be eval or arguments in strict mode"),XT=y("Parameter name eval or arguments is not allowed in strict mode"),BT=y("Strict mode function may not have duplicate parameter names"),jT=y("Function name may not be eval or arguments in strict mode"),GT=y("Octal literals are not allowed in strict mode."),qT=y("Delete of an unqualified identifier in strict mode."),YT=y("Duplicate data property in object literal not allowed in strict mode"),JT=y("Object literal may not have data and accessor property with the same name"),HT=y("Object literal may not have multiple get/set accessors with the same name"),WT=y("Assignment to eval or arguments is not allowed in strict mode"),zT=y("Postfix increment/decrement may not have eval or arguments operand in strict mode"),VT=y("Prefix increment/decrement may not have eval or arguments operand in strict mode"),KT=y("Use of future reserved word in strict mode"),$T=y("JSX attributes must only be assigned a non-empty expression"),QT=y("JSX value should be either an expression or a quoted JSX text"),ZT=y("Const must be initialized"),t_=y("Destructuring assignment must be initialized"),r_=y("Illegal newline before arrow"),e_=y(" declared at top level or immediately within another function."),n_=y("In strict mode code, functions can only be"),a_=y("elements must be wrapped in an enclosing parent tag"),u_=y("Unexpected token <. Remember, adjacent JSX "),i_=y("Rest parameter must be final parameter of an argument list"),f_=y("async is an implementation detail and isn't necessary for your declare function statement. It is sufficient for your declare function to just have a Promise return type."),c_=y("`declare export let` is not supported. Use `declare export var` instead."),s_=y("`declare export const` is not supported. Use `declare export var` instead."),o_=y("`declare export type` is not supported. Use `export type` instead."),v_=y("`declare export interface` is not supported. Use `export interface` instead."),l_=y("`export * as` is an early-stage proposal and is not enabled by default. To enable support in the parser, use the `esproposal_export_star_as` option"),b_=y("When exporting a class as a named export, you must specify a class name. Did you mean `export default class ...`?"),k_=y("When exporting a function as a named export, you must specify a function name. Did you mean `export default function ...`?"),p_=y("Found a decorator in an unsupported position."),h_=y("Type parameter declaration needs a default, since a preceding type parameter declaration has a default."),d_=y("The Windows version of OCaml has a bug in how it parses hexidecimal numbers. It is fixed in OCaml 4.03.0. Until we can switch to 4.03.0, please avoid either hexidecimal notation or Windows."),m_=y("Duplicate `declare module.exports` statement!"),y_=y("Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module xor they are a CommonJS module."),w_=y("Getter should have zero parameters"),g_=y("Setter should have exactly one parameter"),T_=y("`import type` or `import typeof`!"),__=y("Imports within a `declare module` body must always be "),S_=y("The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements"),A_=y("Missing comma between import specifiers"),E_=y("Malformed unicode"),x_=y("Unexpected parser state: "),I_=y("Unexpected token "),C_=[0,[11,y("Unexpected token `"),[2,0,[11,y("`. Did you mean `"),[2,0,[11,y("`?"),0]]]]],y("Unexpected token `%s`. Did you mean `%s`?")],N_=y("'"),R_=y("Invalid flags supplied to RegExp constructor '"),L_=y("'"),P_=y("Undefined label '"),O_=y("' has already been declared"),U_=y(" '"),D_=y("Expected corresponding JSX closing tag for "),M_=[0,[11,y("Duplicate export for `"),[2,0,[12,96,0]]],y("Duplicate export for `%s`")],F_=y("Parse_error.Error"),X_=y("comments"),B_=y(Gc),j_=y("Program"),G_=y("DebuggerStatement"),q_=y("EmptyStatement"),Y_=y(yv),J_=y("BreakStatement"),H_=y(yv),W_=y("ContinueStatement"),z_=y(gh),V_=y("DeclareExportAllDeclaration"),K_=y(gh),$_=y(Pd),Q_=y(hs),Z_=y(hb),tS=y("DeclareExportDeclaration"),rS=y(hi),eS=y(Gc),nS=y(Vo),aS=y("DeclareModule"),uS=y(Id),iS=y("DeclareModuleExports"),fS=y(yo),cS=y(Gc),sS=y("DoWhileStatement"),oS=y(yb),vS=y(hs),lS=y("ExportDefaultDeclaration"),bS=y(yb),kS=y(gh),pS=y("ExportAllDeclaration"),hS=y(yb),dS=y(gh),mS=y(Pd),yS=y(hs),wS=y("ExportNamedDeclaration"),gS=y("directive"),TS=y(ji),_S=y("ExpressionStatement"),SS=y(Gc),AS=y("update"),ES=y(yo),xS=y(Ts),IS=y("ForStatement"),CS=y("each"),NS=y(Gc),RS=y(Xc),LS=y(Ll),PS=y("ForInStatement"),OS=y("ForAwaitStatement"),US=y("ForOfStatement"),DS=y(Gc),MS=y(Xc),FS=y(Ll),XS=y(ci),BS=y(Jn),jS=y(yo),GS=y("IfStatement"),qS=y(Su),YS=y(jl),JS=y(qi),HS=y(Bd),WS=y(gh),zS=y(Pd),VS=y("ImportDeclaration"),KS=y(Gc),$S=y(yv),QS=y("LabeledStatement"),ZS=y(_b),tA=y("ReturnStatement"),rA=y("cases"),eA=y("discriminant"),nA=y("SwitchStatement"),aA=y(_b),uA=y("ThrowStatement"),iA=y("finalizer"),fA=y("handler"),cA=y("block"),sA=y("TryStatement"),oA=y(Gc),vA=y(yo),lA=y("WhileStatement"),bA=y(Gc),kA=y(sl),pA=y("WithStatement"),hA=y("Super"),dA=y("ThisExpression"),mA=y(lp),yA=y("ArrayExpression"),wA=y(lo),gA=y(Al),TA=y(ji),_A=y(Jp),SA=y(Ch),AA=y(Cl),EA=y(Gc),xA=y(Qn),IA=y(Vo),CA=y("ArrowFunctionExpression"),NA=y("="),RA=y("+="),LA=y("-="),PA=y("*="),OA=y("**="),UA=y("/="),DA=y("%="),MA=y("<<="),FA=y(">>="),XA=y(">>>="),BA=y("|="),jA=y("^="),GA=y("&="),qA=y(Xc),YA=y(Ll),JA=y(Cp),HA=y("AssignmentExpression"),WA=y("=="),zA=y("!="),VA=y("==="),KA=y("!=="),$A=y("<"),QA=y("<="),ZA=y(">"),tE=y(">="),rE=y("<<"),eE=y(">>"),nE=y(">>>"),aE=y(Mb),uE=y(xl),iE=y("*"),fE=y("**"),cE=y("/"),sE=y("%"),oE=y("|"),vE=y("^"),lE=y("&"),bE=y("in"),kE=y(wb),pE=y(Xc),hE=y(Ll),dE=y(Cp),mE=y("BinaryExpression"),yE=y(fs),wE=y(Dp),gE=y(Vs),TE=y("filter"),_E=y("blocks"),SE=y("ComprehensionExpression"),AE=y(ci),EE=y(Jn),xE=y(yo),IE=y("ConditionalExpression"),CE=y("filter"),NE=y("blocks"),RE=y("GeneratorExpression"),LE=y(fs),PE=y("Import"),OE=y(Dp),UE=y(Vs),DE=y("&&"),ME=y("||"),FE=y(Xc),XE=y(Ll),BE=y(Cp),jE=y("LogicalExpression"),GE=y(qo),qE=y(mk),YE=y(sl),JE=y("MemberExpression"),HE=y(mk),WE=y("meta"),zE=y("MetaProperty"),VE=y(fs),KE=y(Dp),$E=y("NewExpression"),QE=y(es),ZE=y("ObjectExpression"),tx=y(of),rx=y("SequenceExpression"),ex=y(Id),nx=y(ji),ax=y("TypeCastExpression"),ux=y(_b),ix=y("AwaitExpression"),fx=y(xl),cx=y(Mb),sx=y("!"),ox=y("~"),vx=y(jl),lx=y(tk),bx=y("delete"),kx=y("matched above"),px=y(_b),hx=y("prefix"),dx=y(Cp),mx=y("UnaryExpression"),yx=y("--"),wx=y("++"),gx=y("prefix"),Tx=y(_b),_x=y(Cp),Sx=y("UpdateExpression"),Ax=y("delegate"),Ex=y(_b),xx=y("YieldExpression"),Ix=y(lo),Cx=y(Al),Nx=y(ji),Rx=y(Jp),Lx=y(Ch),Px=y(Cl),Ox=y(Gc),Ux=y(Qn),Dx=y(Vo),Mx=y("FunctionDeclaration"),Fx=y(lo),Xx=y(Al),Bx=y(ji),jx=y(Jp),Gx=y(Ch),qx=y(Cl),Yx=y(Gc),Jx=y(Qn),Hx=y(Vo),Wx=y("FunctionExpression"),zx=y(ah),Vx=y(Id),Kx=y(Np),$x=y(Pn),Qx=y(ah),Zx=y(Id),tI=y(Np),rI=y(Pn),eI=y(Jn),nI=y(yo),aI=y("SwitchCase"),uI=y(Gc),iI=y("param"),fI=y("CatchClause"),cI=y(Gc),sI=y("BlockStatement"),oI=y(Vo),vI=y("DeclareVariable"),lI=y(Jp),bI=y(Vo),kI=y("DeclareFunction"),pI=y(Xd),hI=y(Gc),dI=y(lo),mI=y(Vo),yI=y("DeclareClass"),wI=y(qi),gI=y(Su),TI=y(kf),_I=y("ExportNamespaceSpecifier"),SI=y(Xc),AI=y(lo),EI=y(Vo),xI=y("TypeAlias"),II=y(Ta),CI=y(ti),NI=y(Bv),RI=y(lo),LI=y(co),PI=y(Gc),OI=y(Vo),UI=y("ClassDeclaration"),DI=y(Ta),MI=y(ti),FI=y(Bv),XI=y(lo),BI=y(co),jI=y(Gc),GI=y(Vo),qI=y("ClassExpression"),YI=y(lo),JI=y(Vo),HI=y("ClassImplements"),WI=y(Gc),zI=y("ClassBody"),VI=y(ua),KI=y(Oa),$I=y(lf),QI=y(Uc),ZI=y(Ta),tC=y(qo),rC=y(ps),eC=y(hi),nC=y(qi),aC=y(pd),uC=y("MethodDefinition"),iC=y(Fn),fC=y(ps),cC=y(qo),sC=y(Id),oC=y(qi),vC=y(pd),lC=y("ClassProperty"),bC=y(Xd),kC=y(Gc),pC=y(lo),hC=y(Vo),dC=y("InterfaceDeclaration"),mC=y(lo),yC=y(Vo),wC=y("InterfaceExtends"),gC=y(Id),TC=y(es),_C=y("ObjectPattern"),SC=y(Id),AC=y(lp),EC=y("ArrayPattern"),xC=y(Xc),IC=y(Ll),CC=y("AssignmentPattern"),NC=y(_b),RC=y(md),LC=y(_b),PC=y(md),OC=y(Ts),UC=y(lf),DC=y(Uc),MC=y(qo),FC=y(Av),XC=y(Oa),BC=y(hi),jC=y(qi),GC=y(pd),qC=y($u),YC=y(_b),JC=y("SpreadProperty"),HC=y(qo),WC=y(Av),zC=y(Oa),VC=y(hi),KC=y(qi),$C=y(pd),QC=y($u),ZC=y(_b),tN=y("RestProperty"),rN=y(_b),eN=y("SpreadElement"),nN=y("each"),aN=y(Xc),uN=y(Ll),iN=y("ComprehensionBlock"),fN=y("regex"),cN=y(ui),sN=y(qi),oN=y(ui),vN=y(qi),lN=y("Literal"),bN=y(of),kN=y("quasis"),pN=y("TemplateLiteral"),hN=y("tail"),dN=y(qi),mN=y("TemplateElement"),yN=y("quasi"),wN=y("tag"),gN=y("TaggedTemplateExpression"),TN=y("var"),_N=y("let"),SN=y("const"),AN=y(hi),EN=y("declarations"),xN=y("VariableDeclaration"),IN=y(Ts),CN=y(Vo),NN=y("VariableDeclarator"),RN=y("AnyTypeAnnotation"),LN=y("MixedTypeAnnotation"),PN=y("EmptyTypeAnnotation"),ON=y("VoidTypeAnnotation"),UN=y("NullLiteralTypeAnnotation"),DN=y("NumberTypeAnnotation"),MN=y("StringTypeAnnotation"),FN=y("BooleanTypeAnnotation"),XN=y(Id),BN=y("NullableTypeAnnotation"),jN=y(lo),GN=y("rest"),qN=y(Al),YN=y(Qn),JN=y("FunctionTypeAnnotation"),HN=y(ah),WN=y(Id),zN=y(Np),VN=y("FunctionTypeParam"),KN=[0,0,0,0],$N=y("callProperties"),QN=y("indexers"),ZN=y(es),tR=y("exact"),rR=y("ObjectTypeAnnotation"),eR=y("There should not be computed object type property keys"),nR=y(Ts),aR=y(lf),uR=y(Uc),iR=y(hi),fR=y(Fn),cR=y(ps),sR=y(ah),oR=y(qi),vR=y(pd),lR=y("ObjectTypeProperty"),bR=y(_b),kR=y("ObjectTypeSpreadProperty"),pR=y(Fn),hR=y(ps),dR=y(qi),mR=y(pd),yR=y(Vo),wR=y("ObjectTypeIndexer"),gR=y(ps),TR=y(qi),_R=y("ObjectTypeCallProperty"),SR=y("elementType"),AR=y("ArrayTypeAnnotation"),ER=y(Vo),xR=y("qualification"),IR=y("QualifiedTypeIdentifier"),CR=y(lo),NR=y(Vo),RR=y("GenericTypeAnnotation"),LR=y(Wp),PR=y("UnionTypeAnnotation"),OR=y(Wp),UR=y("IntersectionTypeAnnotation"),DR=y(_b),MR=y("TypeofTypeAnnotation"),FR=y(Wp),XR=y("TupleTypeAnnotation"),BR=y(ui),jR=y(qi),GR=y("StringLiteralTypeAnnotation"),qR=y(ui),YR=y(qi),JR=y("NumberLiteralTypeAnnotation"),HR=y(ui),WR=y(qi),zR=y("BooleanLiteralTypeAnnotation"),VR=y("ExistsTypeAnnotation"),KR=y(Id),$R=y("TypeAnnotation"),QR=y(Qn),ZR=y("TypeParameterDeclaration"),tL=y(hb),rL=y(Fn),eL=y("bound"),nL=y(Np),aL=y("TypeParameter"),uL=y(Qn),iL=y("TypeParameterInstantiation"),fL=y("children"),cL=y("closingElement"),sL=y("openingElement"),oL=y("JSXElement"),vL=y("selfClosing"),lL=y("attributes"),bL=y(Np),kL=y("JSXOpeningElement"),pL=y(Np),hL=y("JSXClosingElement"),dL=y(qi),mL=y(Np),yL=y("JSXAttribute"),wL=y(_b),gL=y("JSXSpreadAttribute"),TL=y("JSXEmptyExpression"),_L=y(ji),SL=y("JSXExpressionContainer"),AL=y(ui),EL=y(qi),xL=y("JSXText"),IL=y(mk),CL=y(sl),NL=y("JSXMemberExpression"),RL=y(Np),LL=y("namespace"),PL=y("JSXNamespacedName"),OL=y(Np),UL=y("JSXIdentifier"),DL=y(kf),ML=y(Qk),FL=y("ExportSpecifier"),XL=y(Qk),BL=y("ImportDefaultSpecifier"),jL=y(Qk),GL=y("ImportNamespaceSpecifier"),qL=y(Bd),YL=y(Qk),JL=y("imported"),HL=y("ImportSpecifier"),WL=y("Block"),zL=y("Line"),VL=y(qi),KL=y(qi),$L=y("DeclaredPredicate"),QL=y("InferredPredicate"),ZL=y("range"),tP=y("loc"),rP=y(Su),eP=[0,1,0],nP=y("T_IDENTIFIER"),aP=y("T_LCURLY"),uP=y("T_RCURLY"),iP=y("T_LCURLYBAR"),fP=y("T_RCURLYBAR"),cP=y("T_LPAREN"),sP=y("T_RPAREN"),oP=y("T_LBRACKET"),vP=y("T_RBRACKET"),lP=y("T_SEMICOLON"),bP=y("T_COMMA"),kP=y("T_PERIOD"),pP=y("T_ARROW"),hP=y("T_ELLIPSIS"),dP=y("T_AT"),mP=y("T_FUNCTION"),yP=y("T_IF"),wP=y("T_IN"),gP=y("T_INSTANCEOF"),TP=y("T_RETURN"),_P=y("T_SWITCH"),SP=y("T_THIS"),AP=y("T_THROW"),EP=y("T_TRY"),xP=y("T_VAR"),IP=y("T_WHILE"),CP=y("T_WITH"),NP=y("T_CONST"),RP=y("T_LET"),LP=y("T_NULL"),PP=y("T_FALSE"),OP=y("T_TRUE"),UP=y("T_BREAK"),DP=y("T_CASE"),MP=y("T_CATCH"),FP=y("T_CONTINUE"),XP=y("T_DEFAULT"),BP=y("T_DO"),jP=y("T_FINALLY"),GP=y("T_FOR"),qP=y("T_CLASS"),YP=y("T_EXTENDS"),JP=y("T_STATIC"),HP=y("T_ELSE"),WP=y("T_NEW"),zP=y("T_DELETE"),VP=y("T_TYPEOF"),KP=y("T_VOID"),$P=y("T_ENUM"),QP=y("T_EXPORT"),ZP=y("T_IMPORT"),tO=y("T_SUPER"),rO=y("T_IMPLEMENTS"),eO=y("T_INTERFACE"),nO=y("T_PACKAGE"),aO=y("T_PRIVATE"),uO=y("T_PROTECTED"),iO=y("T_PUBLIC"),fO=y("T_YIELD"),cO=y("T_DEBUGGER"),sO=y("T_DECLARE"),oO=y("T_TYPE"),vO=y("T_OF"),lO=y("T_ASYNC"),bO=y("T_AWAIT"),kO=y("T_CHECKS"),pO=y("T_RSHIFT3_ASSIGN"),hO=y("T_RSHIFT_ASSIGN"),dO=y("T_LSHIFT_ASSIGN"),mO=y("T_BIT_XOR_ASSIGN"),yO=y("T_BIT_OR_ASSIGN"),wO=y("T_BIT_AND_ASSIGN"),gO=y("T_MOD_ASSIGN"),TO=y("T_DIV_ASSIGN"),_O=y("T_MULT_ASSIGN"),SO=y("T_EXP_ASSIGN"),AO=y("T_MINUS_ASSIGN"),EO=y("T_PLUS_ASSIGN"),xO=y("T_ASSIGN"),IO=y("T_PLING"),CO=y("T_COLON"),NO=y("T_OR"),RO=y("T_AND"),LO=y("T_BIT_OR"),PO=y("T_BIT_XOR"),OO=y("T_BIT_AND"),UO=y("T_EQUAL"),DO=y("T_NOT_EQUAL"),MO=y("T_STRICT_EQUAL"),FO=y("T_STRICT_NOT_EQUAL"),XO=y("T_LESS_THAN_EQUAL"),BO=y("T_GREATER_THAN_EQUAL"),jO=y("T_LESS_THAN"),GO=y("T_GREATER_THAN"),qO=y("T_LSHIFT"),YO=y("T_RSHIFT"),JO=y("T_RSHIFT3"),HO=y("T_PLUS"),WO=y("T_MINUS"),zO=y("T_DIV"),VO=y("T_MULT"),KO=y("T_EXP"),$O=y("T_MOD"),QO=y("T_NOT"),ZO=y("T_BIT_NOT"),tU=y("T_INCR"),rU=y("T_DECR"),eU=y("T_ERROR"),nU=y("T_EOF"),aU=y("T_JSX_IDENTIFIER"),uU=y("T_ANY_TYPE"),iU=y("T_MIXED_TYPE"),fU=y("T_EMPTY_TYPE"),cU=y("T_BOOLEAN_TYPE"),sU=y("T_NUMBER_TYPE"),oU=y("T_STRING_TYPE"),vU=y("T_VOID_TYPE"),lU=y("T_NUMBER"),bU=y("T_STRING"),kU=y("T_TEMPLATE_PART"),pU=y("T_REGEXP"),hU=y("T_JSX_TEXT"),dU=y("T_NUMBER_SINGLETON_TYPE"),mU=y(Yk),yU=[0,3],wU=y(Yk),gU=[0,3],TU=y(Yk),_U=[0,3],SU=y(Yk),AU=[0,1],EU=y(Yk),xU=[0,2],IU=y(Yk),CU=[0,0],NU=y(Yk),RU=y(":"),LU=y(":"),PU=y(Pi),OU=[0,0],UU=[0,2],DU=[0,1],MU=[0,3],FU=[0,3],XU=[0,3],BU=y(Yk),jU=y(Yk),GU=y(Yk),qU=y(Yk),YU=y(Yk),JU=y(Yk),HU=y(Yk),WU=y(":"),zU=y(":"),VU=y(Pi),KU=y(Yk),$U=y("\\"),QU=y(Yk),ZU=y("\\"),tD=y(Nv),rD=y(ha),eD=y(ha),nD=y(ha),aD=y(eh),uD=y(eh),iD=y("*-/"),fD=y("*/"),cD=y("*-/"),sD=y(Yk),oD=y(Yk),vD=y(Yk),lD=y(mb),bD=y(mb),kD=y(mb),pD=y(mb),hD=y(Yk),dD=y("\\\\"),mD=y(Yk),yD=y("'"),wD=y(Yk),gD=y(Yk),TD=y("'"),_D=y('"'),SD=y("<"),AD=y("{"),ED=y(eh),xD=y("iexcl"),ID=y("aelig"),CD=y("Nu"),ND=y("Eacute"),RD=y("Atilde"),LD=y("'int'"),PD=y("AElig"),OD=y("Aacute"),UD=y("Acirc"),DD=y("Agrave"),MD=y("Alpha"),FD=y("Aring"),XD=[0,197],BD=[0,913],jD=[0,Io],GD=[0,194],qD=[0,193],YD=[0,198],JD=[0,8747],HD=y("Auml"),WD=y("Beta"),zD=y("Ccedil"),VD=y("Chi"),KD=y("Dagger"),$D=y("Delta"),QD=y("ETH"),ZD=[0,208],tM=[0,916],rM=[0,8225],eM=[0,935],nM=[0,199],aM=[0,914],uM=[0,196],iM=[0,195],fM=y("Icirc"),cM=y("Ecirc"),sM=y("Egrave"),oM=y("Epsilon"),vM=y("Eta"),lM=y("Euml"),bM=y("Gamma"),kM=y("Iacute"),pM=[0,205],hM=[0,915],dM=[0,203],mM=[0,919],yM=[0,917],wM=[0,200],gM=[0,202],TM=y("Igrave"),_M=y("Iota"),SM=y("Iuml"),AM=y("Kappa"),EM=y("Lambda"),xM=y("Mu"),IM=y("Ntilde"),CM=[0,209],NM=[0,924],RM=[0,923],LM=[0,922],PM=[0,207],OM=[0,921],UM=[0,204],DM=[0,206],MM=[0,201],FM=y("Sigma"),XM=y("Otilde"),BM=y("OElig"),jM=y("Oacute"),GM=y("Ocirc"),qM=y("Ograve"),YM=y("Omega"),JM=y("Omicron"),HM=y("Oslash"),WM=[0,216],zM=[0,927],VM=[0,937],KM=[0,210],$M=[0,212],QM=[0,211],ZM=[0,338],tF=y("Ouml"),rF=y("Phi"),eF=y("Pi"),nF=y("Prime"),aF=y("Psi"),uF=y("Rho"),iF=y("Scaron"),fF=[0,352],cF=[0,929],sF=[0,936],oF=[0,8243],vF=[0,928],lF=[0,934],bF=[0,214],kF=[0,213],pF=y("Uuml"),hF=y("THORN"),dF=y("Tau"),mF=y("Theta"),yF=y("Uacute"),wF=y("Ucirc"),gF=y("Ugrave"),TF=y("Upsilon"),_F=[0,933],SF=[0,217],AF=[0,219],EF=[0,218],xF=[0,920],IF=[0,932],CF=[0,222],NF=y("Xi"),RF=y("Yacute"),LF=y("Yuml"),PF=y("Zeta"),OF=y("aacute"),UF=y("acirc"),DF=y("acute"),MF=[0,180],FF=[0,226],XF=[0,225],BF=[0,918],jF=[0,376],GF=[0,221],qF=[0,926],YF=[0,220],JF=[0,931],HF=[0,925],WF=y("delta"),zF=y("cap"),VF=y("aring"),KF=y("agrave"),$F=y("alefsym"),QF=y("alpha"),ZF=y("amp"),tX=y("and"),rX=y("ang"),eX=y("apos"),nX=[0,39],aX=[0,8736],uX=[0,8743],iX=[0,38],fX=[0,945],cX=[0,8501],sX=[0,Jl],oX=y("asymp"),vX=y("atilde"),lX=y("auml"),bX=y("bdquo"),kX=y("beta"),pX=y("brvbar"),hX=y("bull"),dX=[0,8226],mX=[0,166],yX=[0,946],wX=[0,8222],gX=[0,228],TX=[0,227],_X=[0,8776],SX=[0,229],AX=y("copy"),EX=y("ccedil"),xX=y("cedil"),IX=y("cent"),CX=y("chi"),NX=y("circ"),RX=y("clubs"),LX=y("cong"),PX=[0,8773],OX=[0,9827],UX=[0,710],DX=[0,967],MX=[0,162],FX=[0,184],XX=[0,231],BX=y("crarr"),jX=y("cup"),GX=y("curren"),qX=y("dArr"),YX=y("dagger"),JX=y("darr"),HX=y("deg"),WX=[0,176],zX=[0,8595],VX=[0,8224],KX=[0,8659],$X=[0,164],QX=[0,8746],ZX=[0,8629],tB=[0,169],rB=[0,8745],eB=y("fnof"),nB=y("ensp"),aB=y("diams"),uB=y("divide"),iB=y("eacute"),fB=y("ecirc"),cB=y("egrave"),sB=y("empty"),oB=y("emsp"),vB=[0,8195],lB=[0,8709],bB=[0,232],kB=[0,234],pB=[0,233],hB=[0,247],dB=[0,9830],mB=y("epsilon"),yB=y("equiv"),wB=y("eta"),gB=y("eth"),TB=y("euml"),_B=y("euro"),SB=y("exist"),AB=[0,8707],EB=[0,8364],xB=[0,235],IB=[0,$p],CB=[0,951],NB=[0,8801],RB=[0,949],LB=[0,8194],PB=y("gt"),OB=y("forall"),UB=y("frac12"),DB=y("frac14"),MB=y("frac34"),FB=y("frasl"),XB=y("gamma"),BB=y("ge"),jB=[0,8805],GB=[0,947],qB=[0,8260],YB=[0,190],JB=[0,188],HB=[0,189],WB=[0,8704],zB=y("hArr"),VB=y("harr"),KB=y("hearts"),$B=y("hellip"),QB=y("iacute"),ZB=y("icirc"),tj=[0,238],rj=[0,237],ej=[0,8230],nj=[0,9829],aj=[0,8596],uj=[0,8660],ij=[0,62],fj=[0,402],cj=[0,948],sj=[0,230],oj=y("prime"),vj=y("ndash"),lj=y("le"),bj=y("kappa"),kj=y("igrave"),pj=y("image"),hj=y("infin"),dj=y("iota"),mj=y("iquest"),yj=y("isin"),wj=y("iuml"),gj=[0,239],Tj=[0,8712],_j=[0,191],Sj=[0,953],Aj=[0,8734],Ej=[0,8465],xj=[0,236],Ij=y("lArr"),Cj=y("lambda"),Nj=y("lang"),Rj=y("laquo"),Lj=y("larr"),Pj=y("lceil"),Oj=y("ldquo"),Uj=[0,8220],Dj=[0,8968],Mj=[0,8592],Fj=[0,171],Xj=[0,10216],Bj=[0,955],jj=[0,8656],Gj=[0,954],qj=y("macr"),Yj=y("lfloor"),Jj=y("lowast"),Hj=y("loz"),Wj=y("lrm"),zj=y("lsaquo"),Vj=y("lsquo"),Kj=y("lt"),$j=[0,60],Qj=[0,8216],Zj=[0,8249],tG=[0,8206],rG=[0,9674],eG=[0,8727],nG=[0,8970],aG=y("mdash"),uG=y("micro"),iG=y("middot"),fG=y(Uo),cG=y("mu"),sG=y("nabla"),oG=y("nbsp"),vG=[0,160],lG=[0,8711],bG=[0,956],kG=[0,8722],pG=[0,183],hG=[0,181],dG=[0,8212],mG=[0,175],yG=[0,8804],wG=y("or"),gG=y("oacute"),TG=y("ne"),_G=y("ni"),SG=y("not"),AG=y("notin"),EG=y("nsub"),xG=y("ntilde"),IG=y("nu"),CG=[0,957],NG=[0,241],RG=[0,8836],LG=[0,8713],PG=[0,172],OG=[0,8715],UG=[0,8800],DG=y("ocirc"),MG=y("oelig"),FG=y("ograve"),XG=y("oline"),BG=y("omega"),jG=y("omicron"),GG=y("oplus"),qG=[0,8853],YG=[0,959],JG=[0,969],HG=[0,Wu],WG=[0,242],zG=[0,339],VG=[0,244],KG=[0,243],$G=y("part"),QG=y("ordf"),ZG=y("ordm"),tq=y("oslash"),rq=y("otilde"),eq=y("otimes"),nq=y("ouml"),aq=y("para"),uq=[0,182],iq=[0,ls],fq=[0,8855],cq=[0,Mo],sq=[0,Ov],oq=[0,186],vq=[0,170],lq=y("permil"),bq=y("perp"),kq=y("phi"),pq=y("pi"),hq=y("piv"),dq=y("plusmn"),mq=y("pound"),yq=[0,163],wq=[0,177],gq=[0,982],Tq=[0,960],_q=[0,966],Sq=[0,8869],Aq=[0,8240],Eq=[0,8706],xq=[0,8744],Iq=[0,8211],Cq=y("sup1"),Nq=y("rlm"),Rq=y("raquo"),Lq=y("prod"),Pq=y("prop"),Oq=y("psi"),Uq=y("quot"),Dq=y("rArr"),Mq=y("radic"),Fq=y("rang"),Xq=[0,10217],Bq=[0,8730],jq=[0,8658],Gq=[0,34],qq=[0,968],Yq=[0,8733],Jq=[0,8719],Hq=y("rarr"),Wq=y("rceil"),zq=y("rdquo"),Vq=y("real"),Kq=y("reg"),$q=y("rfloor"),Qq=y("rho"),Zq=[0,961],tY=[0,8971],rY=[0,174],eY=[0,8476],nY=[0,8221],aY=[0,8969],uY=[0,8594],iY=[0,187],fY=y("sigma"),cY=y("rsaquo"),sY=y("rsquo"),oY=y("sbquo"),vY=y("scaron"),lY=y("sdot"),bY=y("sect"),kY=y("shy"),pY=[0,173],hY=[0,167],dY=[0,8901],mY=[0,353],yY=[0,8218],wY=[0,8217],gY=[0,8250],TY=y("sigmaf"),_Y=y("sim"),SY=y("spades"),AY=y("sub"),EY=y("sube"),xY=y("sum"),IY=y("sup"),CY=[0,8835],NY=[0,8721],RY=[0,8838],LY=[0,8834],PY=[0,9824],OY=[0,8764],UY=[0,962],DY=[0,963],MY=[0,8207],FY=y("uarr"),XY=y("thetasym"),BY=y("sup2"),jY=y("sup3"),GY=y("supe"),qY=y("szlig"),YY=y("tau"),JY=y("there4"),HY=y("theta"),WY=[0,952],zY=[0,8756],VY=[0,964],KY=[0,223],$Y=[0,8839],QY=[0,179],ZY=[0,178],tJ=y("thinsp"),rJ=y("thorn"),eJ=y("tilde"),nJ=y("times"),aJ=y("trade"),uJ=y("uArr"),iJ=y("uacute"),fJ=[0,Ql],cJ=[0,8657],sJ=[0,8482],oJ=[0,215],vJ=[0,732],lJ=[0,Cn],bJ=[0,8201],kJ=[0,977],pJ=y("xi"),hJ=y("ucirc"),dJ=y("ugrave"),mJ=y("uml"),yJ=y("upsih"),wJ=y("upsilon"),gJ=y("uuml"),TJ=y("weierp"),_J=[0,8472],SJ=[0,bd],AJ=[0,965],EJ=[0,978],xJ=[0,168],IJ=[0,249],CJ=[0,251],NJ=y("yacute"),RJ=y("yen"),LJ=y("yuml"),PJ=y("zeta"),OJ=y("zwj"),UJ=y("zwnj"),DJ=[0,8204],MJ=[0,Il],FJ=[0,950],XJ=[0,lh],BJ=[0,165],jJ=[0,Sl],GJ=[0,958],qJ=[0,8593],YJ=[0,185],JJ=[0,8242],HJ=[0,161],WJ=y(";"),zJ=y("&"),VJ=y(Yk),KJ=y("}"),$J=[0,y(mb),y(mb),y(mb)],QJ=y(Yk),ZJ=y("${"),tH=y("\r\n"),rH=y("\r\n"),eH=y("\n"),nH=y(ha),aH=y(Xl),uH=y(Hc),iH=y(au),fH=(y("src/parser/lexer.ml"),y(mb),[1,y("ILLEGAL")]),cH=y("/"),sH=y("/"),oH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),vH=y(""),lH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),bH=y(""),kH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),pH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),hH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),dH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),mH=y("\b\t\n\v\f\r"),yH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),wH=y(""),gH=y("\0"),TH=y("\0"),_H=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),SH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),AH=y(""),EH=y(""),xH=y(""),IH=y(""),CH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),NH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),RH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),LH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),PH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),OH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),UH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),DH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),MH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\b\0\0\0\0\0\b"),FH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),XH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),BH=y("\0\0\0"),jH=y('\b\t\n\v\f\r \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t \t!\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"#$%\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'),GH=y("\b\t\n\v\f\r"),qH=y("\0\0\0\0"),YH=y(""),JH=y("\b\t\n\v\f\r "),HH=y(""),WH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),zH=y("\0\0"),VH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),KH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),$H=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),QH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),ZH=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),tW=y("\0"),rW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),eW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),nW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),aW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),uW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),iW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),fW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),cW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),sW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),oW=y(""),vW=y(""),lW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),bW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),kW=y("\0"),pW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),hW=y("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),dW=y("Lexer.FloatOfString.No_good"),mW=Ut([[0,y(Pk),15],[0,y("if"),16],[0,y("in"),17],[0,y(wb),18],[0,y("return"),19],[0,y("switch"),20],[0,y("this"),21],[0,y("throw"),22],[0,y("try"),23],[0,y("var"),24],[0,y("while"),25],[0,y("with"),26],[0,y("const"),27],[0,y("let"),28],[0,y(ff),29],[0,y(ko),30],[0,y($o),31],[0,y("break"),32],[0,y("case"),33],[0,y("catch"),34],[0,y("continue"),35],[0,y(hb),36],[0,y("do"),37],[0,y("finally"),38],[0,y("for"),39],[0,y("class"),40],[0,y(Xd),41],[0,y(ps),42],[0,y("else"),43],[0,y("new"),44],[0,y("delete"),45],[0,y(jl),46],[0,y(tk),47],[0,y("enum"),48],[0,y("export"),49],[0,y("import"),50],[0,y("super"),51],[0,y(ti),52],[0,y(ab),53],[0,y(hu),54],[0,y(Gu),55],[0,y(rl),56],[0,y("public"),57],[0,y("yield"),58],[0,y("debugger"),59],[0,y("declare"),60],[0,y(Su),61],[0,y("of"),62],[0,y(Cl),63],[0,y("await"),64]]),yW=Ut([[0,y(ps),42],[0,y(jl),46],[0,y("any"),ol],[0,y("mixed"),111],[0,y("empty"),112],[0,y("bool"),113],[0,y("boolean"),113],[0,y($o),31],[0,y(ko),30],[0,y("number"),rf],[0,y("string"),115],[0,y(tk),Ad],[0,y(ff),29]]),wW=y(Ga),gW=y(Ga),TW=y(fs),_W=y("eval"),SW=y(ti),AW=y(ab),EW=y(hu),xW=y(Gu),IW=y(rl),CW=y("public"),NW=y(ps),RW=y("yield"),LW=y("enum"),PW=[0,y("src/parser/parser_env.ml"),289,2],OW=y(mb),UW=[0,0,0],DW=y($c),MW=y($c),FW=y("Parser_env.Try.Rollback"),XW=[0,y("did not consume any tokens")],BW=[0,1],jW=[0,0,0],GW=[0,y(ni),494,6],qW=y(ps),YW=y(lf),JW=y(Uc),HW=y(lf),WW=[0,1],zW=[0,[0,0,0]],VW=[0,1],KW=[0,1],$W=[0,1],QW=[0,0],ZW=[0,1],tz=[0,2],rz=[0,7],ez=[0,5],nz=[0,6],az=[0,3],uz=[0,4],iz=[0,y(ni),106,17],fz=[0,y(ni),85,17],cz=[0,y(ni),63,11],sz=[0,y(ni),67,11],oz=[0,y(ni),45,14],vz=[0,31],lz=[0,31],bz=[0,1],kz=[0,29],pz=[0,y(Ef),826,13],hz=[0,y(Ef),728,17],dz=[0,[0,y(mb),y(mb)],1],mz=y(ff),yz=y(ha),wz=y(Xl),gz=y(Hc),Tz=y(au),_z=[0,31],Sz=y("new"),Az=y("target"),Ez=[0,1],xz=[0,0],Iz=[0,1],Cz=[0,0],Nz=[0,1],Rz=[0,0],Lz=[0,2],Pz=[0,3],Oz=[0,7],Uz=[0,6],Dz=[0,4],Mz=[0,5],Fz=[0,[0,17,[0,2]]],Xz=[0,[0,18,[0,3]]],Bz=[0,[0,19,[0,4]]],jz=[0,[0,0,[0,5]]],Gz=[0,[0,1,[0,5]]],qz=[0,[0,2,[0,5]]],Yz=[0,[0,3,[0,5]]],Jz=[0,[0,5,[0,6]]],Hz=[0,[0,7,[0,6]]],Wz=[0,[0,4,[0,6]]],zz=[0,[0,6,[0,6]]],Vz=[0,[0,8,[0,7]]],Kz=[0,[0,9,[0,7]]],$z=[0,[0,10,[0,7]]],Qz=[0,[0,11,[0,8]]],Zz=[0,[0,12,[0,8]]],tV=[0,[0,15,[0,9]]],rV=[0,[0,13,[0,9]]],eV=[0,[0,14,[1,10]]],nV=[0,[0,16,[0,9]]],aV=[0,[0,21,[0,6]]],uV=[0,[0,20,[0,6]]],iV=[0,9],fV=[0,8],cV=[0,7],sV=[0,11],oV=[0,10],vV=[0,12],lV=[0,6],bV=[0,5],kV=[0,3],pV=[0,4],hV=[0,2],dV=[0,1],mV=[0,0],yV=[0,6],wV=y(Cl),gV=y(":"),TV=y(bi),_V=y(mb),SV=[0,y(mb)],AV=y(ua),EV=y(ua),xV=[0,1],IV=[0,1],CV=[0,1],NV=[0,1],RV=y(lf),LV=y(Uc),PV=y(lf),OV=y(Uc),UV=y(Su),DV=[0,0],MV=y(jl),FV=[0,1],XV=y(Ko),BV=y(Ko),jV=y(Ko),GV=y(Nc),qV=y(Ko),YV=y(Nc),JV=y(Ko),HV=y(Ko),WV=y(Nc),zV=[0,y(Va),1141,15],VV=y("other than an interface declaration!"),KV=y("Internal Flow Error! Parsed `export interface` into something "),$V=[0,1],QV=[0,1],ZV=y("other than a type alias!"),tK=y("Internal Flow Error! Parsed `export type` into something "),rK=y(Ko),eK=y(Ko),nK=y(hb),aK=y(Nc),uK=y("Internal Flow Error! Unexpected export statement declaration!"),iK=y(Ko),fK=y(Ko),cK=y(Nc),sK=[0,1],oK=y("module"),vK=[0,1],lK=y("module"),bK=y("exports"),kK=[0,1],pK=[0,1],hK=y("mixins"),dK=y("mixins"),mK=[0,1],yK=[0,1],wK=y("Label"),gK=[0,27],TK=[0,0,0],_K=[0,y(Va),197,20],SK=[0,y(Va),214,20],AK=y("Parser error: No such thing as an expression pattern!"),EK=[0,1],xK=[0,1],IK=y("use strict"),CK=[0,0,0],NK=y("\n"),RK=y("Nooo: "),LK=[0,[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]],PK=[0,y("src/parser/parser_flow.ml"),37,28],OK=[0,[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]],UK=y("Internal error: ");J();var DK=Qc;!function(t){var r=Gd.fds[t];r.flags.wronly&&Xt(ca+t+" is writeonly"),r.file,r.offset;}(0);var MK=Kt(1),FK=Kt(2),XK=[0,function(t){return function(t){for(n=t;;){if(!n)return 0;var r=n[2],e=n[1];try{Bt(e);}catch(n){}var n=r;}}($t())}],BK=L,jK=function(){return[0,y("Unix"),32,0]}()[1],GK=function(){return Qc/4|0}(),qK=(4*GK|0)-1|0;J(),J(),J();var YK=[Ov,Jm,J()];J(),J();var JK=-6,HK=[Ov,Ww,J()],WK=[0,0];try{VK=lr(sg);}catch(y){if((y=mr(y))!==nm)throw y;try{zK=lr(og);}catch(y){if((y=mr(y))!==nm)throw y;var zK=vg;}var VK=zK;}var KK=function(t,r){return Qr(t,0,r)}(VK,82),$K=[ls,function(t){for(var r=br(),e=[0,Dt(55,0),0],n=0==r.length-1?[0,0]:r,a=n.length-1,u=0;;){I(e[1],u)[u+1]=u;var i=u+1|0;if(54===u){var f=[0,cg],c=54+Cr(55,a)|0;if(!(c<0))for(g=0;;){var s=g%55|0,o=rr(g,a),v=I(n,o)[o+1],l=Rr(f[1],y(mb+v));f[1]=Kd(l,0,wt(l));var b=f[1],k=cr(b,3)<<24,p=cr(b,2)<<16,h=cr(b,1)<<8,d=((cr(b,0)+h|0)+p|0)+k|0,m=(I(e[1],s)[s+1]^d)℘I(e[1],s)[s+1]=m;var w=g+1|0;if(c===g)break;var g=w;}return e[2]=0,e}u=i;}}],QK=[Ov,yg,J()],ZK=1000000010,t$=[0,[0,-1,[0,-1,wg,0]],0],r$=zr(80,32),e$=Hn,n$=function(t){return ue(e$)}(),a$=yn(MK);yn(FK),function(t){function r(t){return 0}mn(function(r,e,n){var a=e<0?1:0;if(a)i=a;else var u=n<0?1:0,i=u||((wt(r)-n|0)>>6|0)?1:0;if(l)k=l;else var b=2!=(o>>>6|0)?1:0,k=b||(2!=(v>>>6|0)?1:0);if(k)throw f$;var p=(7&c)<<18|(63&s)<<12|(63&o)<<6|63&v,h=1;}else if(Jl<=c){var d=cr(t,u+1|0),m=cr(t,u+2|0);if((2!=(d>>>6|0)?1:0)||(2!=(m>>>6|0)?1:0))throw f$;var y=(15&c)<<12|(63&d)<<6|63&m,w=Zu<=y?1:0;if(w?y<=57088?1:0:w)throw f$;var p=y,h=1;}else{var g=cr(t,u+1|0);if(2!=(g>>>6|0))throw f$;var p=(31&c)<<6|63&g,h=1;}else if(Zn<=c)h=0;else var p=c,h=1;if(h){I(a,i)[i+1]=p;var T=cr(t,u),u=u+I(o$,T)[T+1]|0,i=i+1|0,f=f-1|0;continue}throw f$}var _=a.length-1;return[0,wn,Zr(_,function(t){return I(a,t)[t+1]}),_,0,0,0,0,0,1]}throw f$}var S=cr(t,n),A=I(o$,S)[S+1];if(!(0>>18|0)),ce(u,jr(Zn|63&(c>>>12|0))),ce(u,jr(Zn|63&(c>>>6|0))),ce(u,jr(Zn|63&c));}else{var s=Zu<=c?1:0;if(s?c>>12|0)),ce(u,jr(Zn|63&(c>>>6|0))),ce(u,jr(Zn|63&c));}else ce(u,jr(Io|c>>>6|0)),ce(u,jr(Zn|63&c));else ce(u,jr(c));var i=i+1|0,f=f-1|0;}},m$=function(t){return d$(t,0,t[5]-t[6]|0)},y$=t,w$=null,g$=function(t){return void 0!==t?1:0},T$=y$.Array,_$=[Ov,xg,J()],S$=y$.Error;!function(t,r){ir(t,ar(r)===Ov?r:r[1]);}(Ig,[0,_$,{}]);var A$=function(t){throw t};He(function(t){return t[1]===_$?[0,it(t[2].toString())]:0}),He(function(t){return t instanceof T$?0:[0,it(t.toString())]});var E$=function(t,r){return[0,t[1],t[2],r[3]]},x$=function(t){return"number"==typeof t?Cg:t[1]},I$=function(t){if("number"==typeof t)return 1;switch(t[0]){case 0:return 2;case 1:case 2:return 3;default:return 4}},C$=function(t,r){var e=t[1]-r[1]|0;return 0===e?t[2]-r[2]|0:e},N$=wr(i$,Rg,Ng),R$=wr(i$,Pg,Lg),L$=wr(i$,Ug,Og),P$=wr(i$,Mg,Dg),O$=wr(i$,Xg,Fg),U$=wr(i$,jg,Bg),D$=wr(i$,qg,Gg),M$=wr(i$,Jg,Yg),F$=wr(i$,Wg,Hg),X$=wr(i$,Vg,zg),B$=wr(i$,$g,Kg);gr(u$,Qg,N$,N$),gr(u$,Zg,R$,R$),gr(u$,tT,L$,L$),gr(u$,rT,P$,P$),gr(u$,eT,O$,O$),gr(u$,nT,U$,U$),gr(u$,aT,D$,D$),gr(u$,uT,M$,M$),gr(u$,iT,F$,F$),gr(u$,fT,X$,X$),gr(u$,cT,B$,B$);var j$=[Ov,F_,J()],G$=function(t,r,e){return[0,t,r,eP,0,e,om]},q$=function(t,r){return[0,r[1],t,r[3],r[4],r[5],r[6]]},Y$=function(t){return t[3][1]},J$=function(t){return t[3][2]},H$=function(t,r){return t!==r[4]?[0,r[1],r[2],r[3],t,r[5],r[6]]:r},W$=function(t){return 35>>6|0)),r],n=[0,jr(Zn|63&(t>>>12|0)),e];return[0,jr($p|t>>>18|0),n]}if(Mc<=t){var a=[0,jr(Zn|63&t),0],u=[0,jr(Zn|63&(t>>>6|0)),a];return[0,jr(Jl|t>>>12|0),u]}if(Zn<=t){var i=[0,jr(Zn|63&t),0];return[0,jr(Io|t>>>6|0),i]}return[0,jr(t),0]},tZ=function(t,r){if(45===cr(r,0))var e=1,n=Vr(r,1,wt(r)-1|0);else var e=0,n=r;if(0===t)c=0;else{switch(t-1|0){case 0:var a=1;try{var u=It(xt(Rr(nH,n)));}catch(r){if(a=0,(r=mr(r))[1]!==rm)throw r;var i=xr(Rr(aH,n)),f=1;}if(a)var i=u,f=1;break;case 1:var c=0,f=0;break;default:var s=1;try{var o=$Q(n);}catch(r){if(s=0,(r=mr(r))[1]!==rm)throw r;var i=xr(Rr(uH,n)),f=1;}if(s)var i=o,f=1;}if(f)var v=i,c=1;}if(!c)try{v=It(xt(n));}catch(f){if((f=mr(f))[1]!==rm)throw f;v=xr(Rr(iH,n));}return[5,t,e?-v:v]},rZ=function(t,r,e){var n=VQ(t,JQ(t,r));return An(r),wr(e,n,r)},eZ=We(0,53),nZ=We(0,53);Fr(function(t){return Ve(eZ,t[1],t[2])},mW),Fr(function(t){return Ve(nZ,t[1],t[2])},yW);var aZ=function(t,r){for(p=t;;){var e=function(t){for(;;)if(_n(t,20),0!==hQ(gn(t)))return Sn(t)},n=function(t){if(0===uQ(gn(t)))for(;;){_n(t,19);var r=z$(gn(t));if(0===r)for(;;)if(_n(t,18),0!==hQ(gn(t)))return Sn(t);if(1!==r)return Sn(t)}return Sn(t)},a=function(t,r){return function(e){_n(e,20);var n=qQ(gn(e));if(2>>0)return Sn(e);switch(n){case 0:return t(e);case 1:return r(e);default:for(;;){_n(e,19);var a=z$(gn(e));if(0===a)for(;;)if(_n(e,18),0!==hQ(gn(e)))return Sn(e);if(1!==a)return Sn(e)}}}}(e,n),u=function(t,r){return function(e){for(;;){_n(e,21);var n=W$(gn(e));if(2>>0)return Sn(e);switch(n){case 0:return t(e);case 1:continue;default:return r(e)}}}}(e,a),i=function(t,r){return function(e){_n(e,21);var n=z$(gn(e));return 0===n?r(e):1===n?t(e):Sn(e)}}(u,e),f=function(t,r,e){return function(n){for(;;){_n(n,21);var a=Q$(gn(n));if(3>>0)return Sn(n);switch(a){case 0:return t(n);case 1:return e(n);case 2:continue;default:return r(n)}}}}(e,a,i),c=function(t){for(;;)if(_n(t,14),0!==hQ(gn(t)))return Sn(t)},s=function(t,r,e,n,a,u,i,f,c,s){return function(o){var v=gn(o),l=Fo>>0)return Sn(o);switch(l){case 0:return 76;case 1:return 77;case 2:if(_n(o,2),0===tQ(gn(o)))for(;;)if(_n(o,2),0!==tQ(gn(o)))return Sn(o);return Sn(o);case 3:return 0;case 4:return _n(o,0),0===kQ(gn(o))?0:Sn(o);case 5:return _n(o,69),0===SQ(gn(o))?(_n(o,42),0===SQ(gn(o))?38:Sn(o)):Sn(o);case 6:return 8;case 7:_n(o,77);var b=gn(o);return 0===(32>>0)return Sn(o);switch(h){case 0:return _n(o,64),0===SQ(gn(o))?54:Sn(o);case 1:return 5;default:return 53}case 14:_n(o,61);var d=gn(o),m=42>>0)return Sn(o);switch(T){case 0:_n(o,3);var _=gQ(gn(o));if(2<_>>>0)return Sn(o);switch(_){case 0:for(;;){var S=gQ(gn(o));if(2>>0)return Sn(o);switch(S){case 0:continue;case 1:return a(o);default:return u(o)}}case 1:return a(o);default:return u(o)}case 1:return 6;default:return 73}case 19:_n(o,21);var A=mQ(gn(o));if(7>>0)return Sn(o);switch(A){case 0:return e(o);case 1:return i(o);case 2:for(;;){_n(o,15);var E=XQ(gn(o));if(4>>0)return Sn(o);switch(E){case 0:return f(o);case 1:return i(o);case 2:continue;case 3:for(;;){_n(o,14);var x=Q$(gn(o));if(3>>0)return Sn(o);switch(x){case 0:return f(o);case 1:return i(o);case 2:continue;default:return c(o)}}default:return c(o)}}case 3:return s(o);case 4:_n(o,20);var I=MQ(gn(o));if(0===I)return e(o);if(1===I)for(;;){_n(o,11);var C=MQ(gn(o));if(0===C)for(;;)if(_n(o,10),0!==hQ(gn(o)))return Sn(o);if(1!==C)return Sn(o)}return Sn(o);case 5:return n(o);case 6:_n(o,20);var N=K$(gn(o));if(0===N)return e(o);if(1===N)for(;;){_n(o,13);var R=K$(gn(o));if(0===R)for(;;)if(_n(o,12),0!==hQ(gn(o)))return Sn(o);if(1!==R)return Sn(o)}return Sn(o);default:_n(o,20);var L=lQ(gn(o));if(0===L)return e(o);if(1===L)for(;;){_n(o,17);var P=lQ(gn(o));if(0===P)for(;;)if(_n(o,16),0!==hQ(gn(o)))return Sn(o);if(1!==P)return Sn(o)}return Sn(o)}case 20:_n(o,21);var O=Q$(gn(o));if(3>>0)return Sn(o);switch(O){case 0:return e(o);case 1:return i(o);case 2:return s(o);default:return n(o)}case 21:return 33;case 22:return 31;case 23:_n(o,59);var U=gn(o),D=59>>0)return Sn(e);switch(n){case 0:return r(e);case 1:return t(e);default:for(;;){_n(e,14);var a=z$(gn(e));if(0===a)for(;;)if(_n(e,14),0!==hQ(gn(e)))return Sn(e);if(1!==a)return Sn(e)}}}}(n,c),f);Tn(r);var o=s(r);if(77>>0)return xr(NU);var v=o;if(39<=v)switch(v){case 39:return[0,p,90];case 40:return[0,p,91];case 41:return[0,p,86];case 42:return[0,p,87];case 43:return[0,p,105];case 44:return[0,p,106];case 45:return[0,p,68];case 46:return[0,p,94];case 47:return[0,p,67];case 48:return[0,p,66];case 49:return[0,p,96];case 50:return[0,p,95];case 51:return[0,p,77];case 52:return[0,p,76];case 53:return[0,p,74];case 54:return[0,p,75];case 55:return[0,p,72];case 56:return[0,p,71];case 57:return[0,p,70];case 58:return[0,p,69];case 59:return[0,p,92];case 60:return[0,p,93];case 61:return[0,p,97];case 62:return[0,p,98];case 63:return[0,p,Tb];case 64:return[0,p,vu];case 65:return[0,p,cb];case 66:return[0,p,83];case 67:return[0,p,85];case 68:return[0,p,84];case 69:return[0,p,ai];case 70:return[0,p,tv];case 71:return[0,p,78];case 72:return[0,p,12];case 73:return[0,p,73];case 74:return[0,p,99];case 75:return[0,p,14];case 76:return[0,p[4]?WQ(p,JQ(p,r),4):p,rv];default:return[0,VQ(p,JQ(p,r)),zv]}switch(v){case 0:p=KQ(p,r);continue;case 1:p=VQ(p,JQ(p,r));continue;case 2:continue;case 3:var l=JQ(p,r),b=ue(Kb),k=cZ(p,b,r),p=QQ(k[1],l,k[2],b,1);continue;case 4:var h=m$(r);if(p[5]){var d=p[4]?zQ(p,JQ(p,r),h):p,m=H$(1,d),y=In(r);if(fr(d$(r,y-1|0,1),RU)&&sr(d$(r,y-2|0,1),LU))return[0,m,80];p=m;continue}var w=JQ(p,r),g=ue(Kb);se(g,Vr(h,2,wt(h)-2|0));var T=cZ(p,g,r),p=QQ(T[1],w,T[2],g,1);continue;case 5:if(p[4]){p=H$(0,p);continue}An(r);return Tn(r),0===function(t){return 0===FQ(gn(t))?0:Sn(t)}(r)?[0,p,Tb]:xr(PU);case 6:var _=JQ(p,r),S=ue(Kb),A=sZ(p,S,r),p=QQ(A[1],_,A[2],S,0);continue;case 7:if(0===En(r)){p=sZ(p,ue(Kb),r)[1];continue}return[0,p,zv];case 8:var E=m$(r),x=JQ(p,r),I=ue(Kb),C=ue(Kb);se(C,E);var N=iZ(p,E,I,C,0,r),R=N[3],L=N[1],P=E$(x,N[2]),O=ie(C);return[0,L,[1,[0,P,ie(I),O,R]]];case 9:var U=ue(Kb),D=ue(Kb),M=ue(Kb);se(M,m$(r));var F=vZ(p,JQ(p,r),U,D,M,r),X=F[3],B=F[2],j=F[1],G=ie(M),q=ie(D);return[0,j,[2,[0,B,[0,ie(U),q,G],X]]];case 10:return rZ(p,r,function(t,r){if(Tn(r),0===PQ(gn(r)))if(0===IQ(gn(r)))if(0===_Q(gn(r))){for(;;)if(_n(r,0),0!==_Q(gn(r))){e=Sn(r);break}}else e=Sn(r);else e=Sn(r);else var e=Sn(r);return 0===e?[0,t,CU]:xr(IU)});case 11:return[0,p,OU];case 12:return rZ(p,r,function(t,r){if(Tn(r),0===PQ(gn(r)))if(0===DQ(gn(r)))if(0===CQ(gn(r))){for(;;)if(_n(r,0),0!==CQ(gn(r))){e=Sn(r);break}}else e=Sn(r);else e=Sn(r);else var e=Sn(r);return 0===e?[0,t,xU]:xr(EU)});case 13:return[0,p,UU];case 14:return rZ(p,r,function(t,r){if(Tn(r),0===PQ(gn(r)))if(0===CQ(gn(r))){for(;;)if(_n(r,0),0!==CQ(gn(r))){e=Sn(r);break}}else e=Sn(r);else var e=Sn(r);return 0===e?[0,t,AU]:xr(SU)});case 15:return[0,p,DU];case 16:return rZ(p,r,function(t,r){if(Tn(r),0===PQ(gn(r)))if(0===bQ(gn(r)))if(0===oQ(gn(r))){for(;;)if(_n(r,0),0!==oQ(gn(r))){e=Sn(r);break}}else e=Sn(r);else e=Sn(r);else var e=Sn(r);return 0===e?[0,t,_U]:xr(TU)});case 17:return[0,p,MU];case 18:return rZ(p,r,function(t,r){function e(t){for(;;)if(_n(t,0),0!==uQ(gn(t)))return Sn(t)}function n(t){var r=iQ(gn(t));return 0===r?0===uQ(gn(t))?e(t):Sn(t):1===r?e(t):Sn(t)}function a(t){if(0===uQ(gn(t)))for(;;){var r=Z$(gn(t));if(0!==r)return 1===r?n(t):Sn(t)}return Sn(t)}Tn(r);var u=sQ(gn(r));if(0===u)f=a(r);else if(1===u)for(;;){var i=UQ(gn(r));if(2>>0)f=Sn(r);else switch(i){case 0:f=a(r);break;case 1:continue;default:f=n(r);}break}else var f=Sn(r);return 0===f?[0,t,gU]:xr(wU)});case 19:return[0,p,FU];case 20:return rZ(p,r,function(t,r){function e(t){for(;;)if(_n(t,0),0!==uQ(gn(t)))return Sn(t)}Tn(r);var n=sQ(gn(r));if(0===n)u=0===uQ(gn(r))?e(r):Sn(r);else if(1===n)for(;;){_n(r,0);var a=sQ(gn(r));if(0===a){_n(r,0);u=0===uQ(gn(r))?e(r):Sn(r);}else{if(1===a)continue;u=Sn(r);}break}else var u=Sn(r);return 0===u?[0,t,yU]:xr(mU)});case 21:return[0,p,XU];case 22:var Y=m$(r);if(64===cr(Y,0))if(64===cr(Y,1))var J=Vr(Y,2,wt(Y)-2|0),H=1;else H=0;else H=0;if(!H)J=Y;try{return[0,p,Ke(eZ,J)]}catch(r){if((r=mr(r))===nm)return[0,p,0];throw r}case 23:return[0,p,1];case 24:return[0,p,2];case 25:return[0,p,5];case 26:return[0,p,6];case 27:return[0,p,7];case 28:return[0,p,8];case 29:return[0,p,13];case 30:return[0,p,11];case 31:return[0,p,9];case 32:return[0,p,10];case 33:return[0,p,80];case 34:return[0,p,79];case 35:return[0,p,82];case 36:return[0,p,81];case 37:return[0,p,88];default:return[0,p,89]}}},uZ=function(t,r){for(g=t;;){var e=function(t){return 0===fQ(gn(t))&&0===RQ(gn(t))&&0===EQ(gn(t))&&0===nQ(gn(t))&&0===aQ(gn(t))&&0===NQ(gn(t))&&0===LQ(gn(t))&&0===fQ(gn(t))&&0===BQ(gn(t))&&0===cQ(gn(t))&&0===wQ(gn(t))?3:Sn(t)},n=function(t){return _n(t,3),0===GQ(gn(t))?3:Sn(t)},a=function(t){for(;;)if(_n(t,17),0!==hQ(gn(t)))return Sn(t)},u=function(t){return function(r){_n(r,17);var e=lQ(gn(r));if(0===e)return t(r);if(1===e)for(;;){_n(r,14);var n=lQ(gn(r));if(0===n)for(;;)if(_n(r,13),0!==hQ(gn(r)))return Sn(r);if(1!==n)return Sn(r)}return Sn(r)}}(a),i=function(t){return function(r){_n(r,17);var e=K$(gn(r));if(0===e)return t(r);if(1===e)for(;;){_n(r,10);var n=K$(gn(r));if(0===n)for(;;)if(_n(r,9),0!==hQ(gn(r)))return Sn(r);if(1!==n)return Sn(r)}return Sn(r)}}(a),f=function(t){return function(r){_n(r,17);var e=MQ(gn(r));if(0===e)return t(r);if(1===e)for(;;){_n(r,8);var n=MQ(gn(r));if(0===n)for(;;)if(_n(r,7),0!==hQ(gn(r)))return Sn(r);if(1!==n)return Sn(r)}return Sn(r)}}(a),c=function(t){if(0===uQ(gn(t)))for(;;){_n(t,16);var r=z$(gn(t));if(0===r)for(;;)if(_n(t,15),0!==hQ(gn(t)))return Sn(t);if(1!==r)return Sn(t)}return Sn(t)},s=function(t,r){return function(e){_n(e,17);var n=qQ(gn(e));if(2>>0)return Sn(e);switch(n){case 0:return t(e);case 1:return r(e);default:for(;;){_n(e,16);var a=z$(gn(e));if(0===a)for(;;)if(_n(e,15),0!==hQ(gn(e)))return Sn(e);if(1!==a)return Sn(e)}}}}(a,c),o=function(t,r){return function(e){for(;;){_n(e,18);var n=W$(gn(e));if(2>>0)return Sn(e);switch(n){case 0:return t(e);case 1:continue;default:return r(e)}}}}(a,s),v=function(t,r){return function(e){_n(e,18);var n=z$(gn(e));return 0===n?r(e):1===n?t(e):Sn(e)}}(o,a),l=function(t,r,e){return function(n){for(;;){_n(n,18);var a=Q$(gn(n));if(3>>0)return Sn(n);switch(a){case 0:return t(n);case 1:return e(n);case 2:continue;default:return r(n)}}}}(a,s,v),b=function(t){for(;;)if(_n(t,11),0!==hQ(gn(t)))return Sn(t)},k=function(t,r,e){return function(n){for(;;){_n(n,12);var a=XQ(gn(n));if(4>>0)return Sn(n);switch(a){case 0:return r(n);case 1:return t(n);case 2:continue;case 3:for(;;){_n(n,11);var u=Q$(gn(n));if(3>>0)return Sn(n);switch(u){case 0:return r(n);case 1:return t(n);case 2:continue;default:return e(n)}}default:return e(n)}}}}(v,b,function(t,r){return function(e){_n(e,11);var n=qQ(gn(e));if(2>>0)return Sn(e);switch(n){case 0:return r(e);case 1:return t(e);default:for(;;){_n(e,11);var a=z$(gn(e));if(0===a)for(;;)if(_n(e,11),0!==hQ(gn(e)))return Sn(e);if(1!==a)return Sn(e)}}}}(c,b)),p=function(t,r,e,n,a,u,i,f){return function(c){_n(c,18);var s=mQ(gn(c));if(7>>0)return Sn(c);switch(s){case 0:return t(c);case 1:return e(c);case 2:return n(c);case 3:return a(c);case 4:return u(c);case 5:return r(c);case 6:return i(c);default:return f(c)}}}(a,s,v,k,l,f,i,u),h=function(t,r,e,n,a,u,i,f,c,s,o,v,l,b){return function(k){var p=gn(k),h=Fo>>0)return Sn(k);switch(h){case 0:return 50;case 1:return 51;case 2:if(_n(k,1),0===tQ(gn(k)))for(;;)if(_n(k,1),0!==tQ(gn(k)))return Sn(k);return Sn(k);case 3:return 0;case 4:return _n(k,0),0===kQ(gn(k))?0:Sn(k);case 5:return 6;case 6:return _n(k,19),0===AQ(gn(k))?t(k):Sn(k);case 7:if(_n(k,51),0===LQ(gn(k))){var d=gn(k);if(0===(ai>>0)return Sn(k);switch(w){case 0:for(;;){var g=OQ(gn(k));if(3>>0)return Sn(k);switch(g){case 0:continue;case 1:return r(k);case 2:return u(k);default:return c(k)}}case 1:return r(k);case 2:return u(k);default:return c(k)}case 15:_n(k,30);var T=sQ(gn(k));return 0===T?0===$$(gn(k))?29:Sn(k):1===T?e(k):Sn(k);case 16:_n(k,51);var _=TQ(gn(k));if(0===_){_n(k,2);var S=gQ(gn(k));if(2>>0)return Sn(k);switch(S){case 0:for(;;){var A=gQ(gn(k));if(2>>0)return Sn(k);switch(A){case 0:continue;case 1:return l(k);default:return b(k)}}case 1:return l(k);default:return b(k)}}return 1===_?5:Sn(k);case 17:_n(k,18);var E=mQ(gn(k));if(7>>0)return Sn(k);switch(E){case 0:return n(k);case 1:return i(k);case 2:return f(k);case 3:return c(k);case 4:return s(k);case 5:return a(k);case 6:return o(k);default:return v(k)}case 18:_n(k,18);var x=Q$(gn(k));if(3>>0)return Sn(k);switch(x){case 0:return n(k);case 1:return i(k);case 2:return c(k);default:return a(k)}case 19:return 33;case 20:return 31;case 21:return 37;case 22:_n(k,39);var I=gn(k);return 0===(61>>0)return xr(HU);switch(d){case 0:g=KQ(g,r);continue;case 1:continue;case 2:var m=JQ(g,r),y=ue(Kb),w=cZ(g,y,r),g=QQ(w[1],m,w[2],y,1);continue;case 3:var T=m$(r);if(g[5]){var _=g[4]?zQ(g,JQ(g,r),T):g,S=H$(1,_),A=In(r);if(fr(d$(r,A-1|0,1),WU)&&sr(d$(r,A-2|0,1),zU))return[0,S,80];g=S;continue}var E=JQ(g,r),x=ue(Kb);se(x,T);var I=cZ(g,x,r),g=QQ(I[1],E,I[2],x,1);continue;case 4:if(g[4]){g=H$(0,g);continue}An(r);return Tn(r),0===function(t){return 0===FQ(gn(t))?0:Sn(t)}(r)?[0,g,Tb]:xr(VU);case 5:var C=JQ(g,r),N=ue(Kb),R=sZ(g,N,r),g=QQ(R[1],C,R[2],N,0);continue;case 6:var L=m$(r),P=JQ(g,r),O=ue(Kb),U=ue(Kb);se(U,L);var D=iZ(g,L,O,U,0,r),M=D[3],F=D[1],X=E$(P,D[2]),B=ie(U);return[0,F,[1,[0,X,ie(O),B,M]]];case 7:return rZ(g,r,function(t,r){function e(t){if(0===IQ(gn(t))){if(0===_Q(gn(t)))for(;;)if(_n(t,0),0!==_Q(gn(t)))return Sn(t);return Sn(t)}return Sn(t)}Tn(r);var n=eQ(gn(r));if(0===n)for(;;){var a=pQ(gn(r));if(0!==a){u=1===a?e(r):Sn(r);break}}else var u=1===n?e(r):Sn(r);return 0===u?[0,t,tZ(0,m$(r))]:xr(JU)});case 8:return[0,g,tZ(0,m$(r))];case 9:return rZ(g,r,function(t,r){function e(t){if(0===DQ(gn(t))){if(0===CQ(gn(t)))for(;;)if(_n(t,0),0!==CQ(gn(t)))return Sn(t);return Sn(t)}return Sn(t)}Tn(r);var n=eQ(gn(r));if(0===n)for(;;){var a=pQ(gn(r));if(0!==a){u=1===a?e(r):Sn(r);break}}else var u=1===n?e(r):Sn(r);return 0===u?[0,t,tZ(2,m$(r))]:xr(YU)});case 10:return[0,g,tZ(2,m$(r))];case 11:return rZ(g,r,function(t,r){function e(t){if(0===CQ(gn(t)))for(;;)if(_n(t,0),0!==CQ(gn(t)))return Sn(t);return Sn(t)}Tn(r);var n=eQ(gn(r));if(0===n)for(;;){var a=pQ(gn(r));if(0!==a){u=1===a?e(r):Sn(r);break}}else var u=1===n?e(r):Sn(r);return 0===u?[0,t,tZ(1,m$(r))]:xr(qU)});case 12:return[0,g,tZ(1,m$(r))];case 13:return rZ(g,r,function(t,r){function e(t){if(0===bQ(gn(t))){if(0===oQ(gn(t)))for(;;)if(_n(t,0),0!==oQ(gn(t)))return Sn(t);return Sn(t)}return Sn(t)}if(Tn(r),0===function(t){var r=eQ(gn(t));if(0===r)for(;;){var n=pQ(gn(t));if(0!==n)return 1===n?e(t):Sn(t)}return 1===r?e(t):Sn(t)}(r)){var n=m$(r);try{return[0,t,tZ(3,n)]}catch(e){throw e=mr(e)}}return xr(GU)});case 14:var j=m$(r);try{return[0,g,tZ(3,j)]}catch(t){throw t=mr(t)}case 15:return rZ(g,r,function(t,r){function e(t){for(;;)if(_n(t,0),0!==uQ(gn(t)))return Sn(t)}function n(t){var r=iQ(gn(t));return 0===r?0===uQ(gn(t))?e(t):Sn(t):1===r?e(t):Sn(t)}function a(t){if(0===uQ(gn(t)))for(;;){var r=Z$(gn(t));if(0!==r)return 1===r?n(t):Sn(t)}return Sn(t)}function u(t){for(;;){var r=UQ(gn(t));if(2>>0)return Sn(t);switch(r){case 0:return a(t);case 1:continue;default:return n(t)}}}Tn(r);var i=vQ(gn(r));if(2>>0)s=Sn(r);else switch(i){case 0:for(;;){var f=gn(r),c=8>>0)s=Sn(r);else switch(c){case 0:continue;case 1:s=a(r);break;default:s=u(r);}break}break;case 1:s=a(r);break;default:var s=u(r);}return 0===s?[0,t,tZ(3,m$(r))]:xr(jU)});case 16:return[0,g,tZ(3,m$(r))];case 17:return rZ(g,r,function(t,r){function e(t){for(;;)if(_n(t,0),0!==uQ(gn(t)))return Sn(t)}Tn(r);var n=vQ(gn(r));if(2>>0)c=Sn(r);else switch(n){case 0:for(;;){var a=gn(r),u=8>>0)o=Sn(u);else switch(s){case 0:o=2;break;case 1:o=3;break;case 2:o=2;break;case 3:o=0;break;default:var o=1;}if(3>>0)return xr(KU);switch(o){case 0:var v=m$(u);if(se(n,v),fr(r,v))return[0,i,JQ(i,u),f];se(e,v);continue;case 1:se(n,$U);var l=fZ(i,e,u),b=l[2],k=l[1],p=b||f;se(n,m$(u));var i=k,f=p;continue;case 2:var h=m$(u);se(n,h);var d=VQ(i,JQ(i,u));return se(e,h),[0,d,JQ(d,u),f];default:var m=m$(u);se(n,m),se(e,m);continue}}},fZ=function(t,r,e){function n(t){return _n(t,4),0===CQ(gn(t))?3:Sn(t)}Tn(e);var a=gn(e),u=Pf>>0)o=Sn(e);else switch(u){case 0:o=0;break;case 1:o=17;break;case 2:o=16;break;case 3:_n(e,16);o=0===kQ(gn(e))?16:Sn(e);break;case 4:_n(e,5);o=0===CQ(gn(e))?n(e):Sn(e);break;case 5:_n(e,12);o=0===CQ(gn(e))?n(e):Sn(e);break;case 6:o=1;break;case 7:o=6;break;case 8:o=7;break;case 9:o=8;break;case 10:o=9;break;case 11:o=10;break;case 12:_n(e,15);var i=gn(e),f=47>>0)return xr(QU);switch(o){case 0:return[0,t,0];case 1:return se(r,ZU),[0,t,0];case 2:return Fr(function(t){return ce(r,t)},ZQ(Ct(Rr(tD,m$(e))))),[0,t,0];case 3:var v=Ct(Rr(rD,m$(e)));if(256<=v){var l=7&v;Fr(function(t){return ce(r,t)},ZQ(v>>>3|0)),ce(r,jr(48+l|0));}else Fr(function(t){return ce(r,t)},ZQ(v));return[0,t,1];case 4:return Fr(function(t){return ce(r,t)},ZQ(Ct(Rr(eD,m$(e))))),[0,t,1];case 5:return ce(r,jr(0)),[0,t,0];case 6:return ce(r,jr(8)),[0,t,0];case 7:return ce(r,jr(12)),[0,t,0];case 8:return ce(r,jr(10)),[0,t,0];case 9:return ce(r,jr(13)),[0,t,0];case 10:return ce(r,jr(9)),[0,t,0];case 11:return ce(r,jr(11)),[0,t,0];case 12:return Fr(function(t){return ce(r,t)},ZQ(Ct(Rr(nD,m$(e))))),[0,t,1];case 13:var b=m$(e);return Fr(function(t){return ce(r,t)},ZQ(Ct(Rr(aD,Vr(b,1,wt(b)-1|0))))),[0,t,0];case 14:var k=m$(e),p=Ct(Rr(uD,Vr(k,2,wt(k)-3|0))),h=nl>>0)f=Sn(e);else switch(a){case 0:f=3;break;case 1:f=0;break;case 2:_n(e,0);f=0===kQ(gn(e))?0:Sn(e);break;default:_n(e,3);var u=gn(e),i=44>>0){var c=VQ(o,JQ(o,e));return[0,c,JQ(c,e)]}switch(f){case 0:var s=KQ(o,e);se(r,m$(e));var o=s;continue;case 1:var v=JQ(o,e);return[0,o[4]?WQ(o,v,[2,fD,iD]):o,v];case 2:if(o[4])return[0,o,JQ(o,e)];se(r,cD);continue;default:se(r,m$(e));continue}}},sZ=function(t,r,e){for(;;){Tn(e);var n=gn(e),a=13>>0)u=Sn(e);else switch(a){case 0:u=0;break;case 1:u=2;break;case 2:u=1;break;default:_n(e,1);var u=0===kQ(gn(e))?1:Sn(e);}if(2>>0)return xr(sD);switch(u){case 0:return[0,t,JQ(t,e)];case 1:var i=JQ(t,e),f=i[3],c=f[3],s=f[2],o=f[1],v=i[2],l=i[1],b=KQ(t,e),k=In(e);return[0,b,[0,l,v,[0,o,s-k|0,c-k|0]]];default:se(r,m$(e));continue}}},oZ=function(t,r,e,n,a){for(C=t;;){Tn(a);var u=gn(a),i=123>>0)_=Sn(a);else switch(i){case 0:_=1;break;case 1:_=6;break;case 2:_=2;break;case 3:_n(a,2);_=0===kQ(gn(a))?2:Sn(a);break;case 4:_=0;break;default:_n(a,6);var f=gn(a),c=34>>0)return xr(gD);switch(_){case 0:var S=m$(a);switch(r){case 0:A=sr(S,TD)?0:1;break;case 1:A=sr(S,_D)?0:1;break;default:if(sr(S,SD))if(sr(S,AD))var A=0,E=0;else E=1;else E=1;if(E)return An(a),[0,C,JQ(C,a)]}if(A)return[0,C,JQ(C,a)];se(n,S),se(e,S);continue;case 1:var x=VQ(C,JQ(C,a));return[0,x,JQ(x,a)];case 2:var I=m$(a);se(n,I),se(e,I);var C=KQ(C,a);continue;case 3:var N=m$(a),R=Vr(N,3,wt(N)-4|0);se(n,N),Fr(function(t){return ce(e,t)},ZQ(Ct(Rr(ED,R))));continue;case 4:var P=m$(a),O=Vr(P,2,wt(P)-3|0);se(n,P),Fr(function(t){return ce(e,t)},ZQ(Ct(O)));continue;case 5:var U=m$(a),D=Vr(U,1,wt(U)-2|0);se(n,U);var M=L(D,xD);if(0<=M)if(0>>0)s=Sn(u);else switch(f){case 0:s=0;break;case 1:s=6;break;case 2:s=5;break;case 3:_n(u,5);s=0===kQ(gn(u))?4:Sn(u);break;case 4:_n(u,6);var c=gn(u),s=0===(xs>>0)return xr(QJ);switch(s){case 0:var o=VQ(k,JQ(k,u));return[0,o,E$(r,JQ(o,u)),1];case 1:return ce(a,96),[0,k,E$(r,JQ(k,u)),1];case 2:return se(a,ZJ),[0,k,E$(r,JQ(k,u)),0];case 3:ce(n,92),ce(a,92);var v=fZ(k,e,u)[1],l=m$(u);se(n,l),se(a,l);k=v;continue;case 4:se(n,tH),se(a,rH),se(e,eH);k=KQ(k,u);continue;case 5:var b=m$(u);se(n,b),se(a,b),ce(e,10);var k=KQ(k,u);continue;default:var p=m$(u);se(n,p),se(a,p),se(e,p);continue}}},lZ=ee([0,BK]),bZ=function(t,r){return[0,[0],0,r,q$(t[2].slice(),t)]},kZ=function(t,r){var e=r+1|0;if(t[1].length-1>>0)o=Sn(u);else switch(c){case 0:o=0;break;case 1:o=14;break;case 2:if(_n(u,2),0===tQ(gn(u))){for(;;)if(_n(u,2),0!==tQ(gn(u))){o=Sn(u);break}}else o=Sn(u);break;case 3:o=1;break;case 4:_n(u,1);o=0===kQ(gn(u))?1:Sn(u);break;case 5:o=13;break;case 6:if(_n(u,12),0===yQ(gn(u))){for(;;)if(_n(u,12),0!==yQ(gn(u))){o=Sn(u);break}}else o=Sn(u);break;case 7:o=10;break;case 8:_n(u,6);var s=TQ(gn(u)),o=0===s?4:1===s?3:Sn(u);break;case 9:o=9;break;case 10:o=5;break;case 11:o=11;break;case 12:o=7;break;default:o=8;}if(14>>0)x=xr(mD);else switch(o){case 0:x=[0,i,rv];break;case 1:i=KQ(i,u);continue;case 2:continue;case 3:var v=JQ(i,u),l=ue(Kb),b=sZ(i,l,u),i=QQ(b[1],v,b[2],l,0);continue;case 4:var k=JQ(i,u),p=ue(Kb),h=cZ(i,p,u),i=QQ(h[1],k,h[2],p,1);continue;case 5:x=[0,i,92];break;case 6:x=[0,i,99];break;case 7:x=[0,i,93];break;case 8:x=[0,i,1];break;case 9:x=[0,i,80];break;case 10:x=[0,i,11];break;case 11:x=[0,i,78];break;case 12:x=[0,i,$a];break;case 13:var d=m$(u),m=JQ(i,u),y=ue(Kb),w=ue(Kb);se(w,d);var g=fr(d,yD)?0:1,T=oZ(i,g,y,w,u),_=T[2],S=T[1];se(w,d);var A=ie(y),E=ie(w),x=[0,S,[4,[0,E$(m,_),A,E]]];break;default:x=[0,i,zv];}Qt=HQ(x);break}break;case 3:var C=xn(a[2]),N=YQ(a,C,C),R=ue(Kb),L=ue(Kb),P=a[2];Tn(P);var O=gn(P),U=123>>0)D=Sn(P);else switch(U){case 0:D=1;break;case 1:D=4;break;case 2:D=0;break;case 3:_n(P,0);D=0===kQ(gn(P))?0:Sn(P);break;case 4:D=2;break;default:var D=3;}if(4>>0)q=xr(wD);else switch(D){case 0:var M=m$(P);se(L,M),se(R,M);var F=oZ(KQ(a,P),2,R,L,P),X=F[2],B=F[1],j=ie(R),G=ie(L),q=[0,B,[4,[0,E$(N,X),j,G]]];break;case 1:q=[0,a,rv];break;case 2:q=[0,a,92];break;case 3:q=[0,a,1];break;default:var Y=m$(P);se(L,Y),se(R,Y);var J=oZ(a,2,R,L,P),H=J[2],W=J[1],z=ie(R),V=ie(L),q=[0,W,[4,[0,E$(N,H),z,V]]];}Qt=HQ([0,q[1],q[2]]);break;case 4:for(var K=a[2],$=a;;){Tn(K);var Q=gn(K),Z=-1>>0)rt=Sn(K);else switch(Z){case 0:rt=5;break;case 1:if(_n(K,1),0===tQ(gn(K))){for(;;)if(_n(K,1),0!==tQ(gn(K))){rt=Sn(K);break}}else rt=Sn(K);break;case 2:rt=0;break;case 3:_n(K,0);rt=0===kQ(gn(K))?0:Sn(K);break;case 4:_n(K,5);var tt=TQ(gn(K)),rt=0===tt?3:1===tt?2:Sn(K);break;default:rt=4;}if(5