+ (!nameHasComments || n.attributes.length) &&
+ !lastAttrHasTrailingComments;
+
+ // We should print the opening element expanded if any prop value is a
+ // string literal with newlines
+ const shouldBreak =
+ n.attributes &&
+ n.attributes.some(
+ attr =>
+ attr.value &&
+ isStringLiteral(attr.value) &&
+ attr.value.value.includes("\n")
+ );
+
+ return group(
+ concat([
+ "<",
+ path$$1.call(print, "name"),
+ concat([
+ indent(
+ concat(
+ path$$1.map(attr => concat([line, print(attr)]), "attributes")
+ )
+ ),
+ n.selfClosing ? line : bracketSameLine ? ">" : softline
+ ]),
+ n.selfClosing ? "/>" : bracketSameLine ? "" : ">"
+ ]),
+ { shouldBreak }
+ );
+ }
+ case "JSXClosingElement":
+ return concat([""]);
+ case "JSXOpeningFragment":
+ case "JSXClosingFragment":
+ case "TSJsxOpeningFragment":
+ case "TSJsxClosingFragment": {
+ const hasComment = n.comments && n.comments.length;
+ const hasOwnLineComment =
+ hasComment && !n.comments.every(util$1.isBlockComment);
+ const isOpeningFragment =
+ n.type === "JSXOpeningFragment" || n.type === "TSJsxOpeningFragment";
+ return concat([
+ isOpeningFragment ? "<" : ""
+ ]);
+ }
+ case "JSXText":
+ /* istanbul ignore next */
+ throw new Error("JSXTest should be handled by JSXElement");
+ case "JSXEmptyExpression": {
+ const requiresHardline =
+ n.comments && !n.comments.every(util$1.isBlockComment);
+
+ return concat([
+ comments.printDanglingComments(
+ path$$1,
+ options,
+ /* sameIndent */ !requiresHardline
+ ),
+ requiresHardline ? hardline : ""
+ ]);
+ }
+ case "ClassBody":
+ if (!n.comments && n.body.length === 0) {
+ return "{}";
+ }
+
+ return concat([
+ "{",
+ n.body.length > 0
+ ? indent(
+ concat([
+ hardline,
+ path$$1.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body")
+ ])
+ )
+ : comments.printDanglingComments(path$$1, options),
+ hardline,
+ "}"
+ ]);
+ case "ClassProperty":
+ case "TSAbstractClassProperty":
+ case "ClassPrivateProperty": {
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.static) {
+ parts.push("static ");
+ }
+ if (n.type === "TSAbstractClassProperty") {
+ parts.push("abstract ");
+ }
+ if (n.readonly) {
+ parts.push("readonly ");
+ }
+ const variance = getFlowVariance(n);
+ if (variance) {
+ parts.push(variance);
+ }
+ if (n.computed) {
+ parts.push("[", path$$1.call(print, "key"), "]");
+ } else {
+ parts.push(printPropertyKey(path$$1, options, print));
+ }
+ parts.push(printTypeAnnotation(path$$1, options, print));
+ if (n.value) {
+ parts.push(
+ " =",
+ printAssignmentRight(
+ n.value,
+ path$$1.call(print, "value"),
+ false, // canBreak
+ options
+ )
+ );
+ }
+
+ parts.push(semi);
+
+ return concat(parts);
+ }
+ case "ClassDeclaration":
+ case "ClassExpression":
+ case "TSAbstractClassDeclaration":
+ if (isNodeStartingWithDeclare(n, options)) {
+ parts.push("declare ");
+ }
+ parts.push(concat(printClass(path$$1, options, print)));
+ return concat(parts);
+ case "TSInterfaceHeritage":
+ parts.push(path$$1.call(print, "id"));
+
+ if (n.typeParameters) {
+ parts.push(path$$1.call(print, "typeParameters"));
+ }
+
+ return concat(parts);
+ case "TemplateElement":
+ return join(literalline, n.value.raw.split(/\r?\n/g));
+ case "TemplateLiteral": {
+ const expressions = path$$1.map(print, "expressions");
+
+ parts.push("`");
+
+ path$$1.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 `.
+ const tabWidth = options.tabWidth;
+ const indentSize = util$1.getIndentSize(
+ childPath.getValue().value.raw,
+ tabWidth
+ );
+
+ let printed = expressions[i];
+
+ if (
+ (n.expressions[i].comments && n.expressions[i].comments.length) ||
+ n.expressions[i].type === "MemberExpression" ||
+ n.expressions[i].type === "ConditionalExpression"
+ ) {
+ printed = concat([indent(concat([softline, printed])), softline]);
+ }
+
+ const aligned = addAlignmentToDoc(printed, indentSize, tabWidth);
+
+ parts.push(group(concat(["${", aligned, lineSuffixBoundary, "}"])));
+ }
+ }, "quasis");
+
+ parts.push("`");
+
+ return concat(parts);
+ }
+ // These types are unprintable because they serve as abstract
+ // supertypes for other (printable) types.
+ case "TaggedTemplateExpression":
+ return concat([path$$1.call(print, "tag"), path$$1.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":
+ /* istanbul ignore next */
+ throw new Error("unprintable type: " + JSON.stringify(n.type));
+ // Type Annotations for Facebook Flow, typically stripped out or
+ // transformed away before printing.
+ case "TypeAnnotation":
+ case "TSTypeAnnotation":
+ if (n.typeAnnotation) {
+ return path$$1.call(print, "typeAnnotation");
+ }
+
+ /* istanbul ignore next */
+ return "";
+ case "TSTupleType":
+ case "TupleTypeAnnotation": {
+ const typesField = n.type === "TSTupleType" ? "elementTypes" : "types";
+ return group(
+ concat([
+ "[",
+ indent(
+ concat([
+ softline,
+ printArrayItems(path$$1, options, typesField, print)
+ ])
+ ),
+ // TypeScript doesn't support trailing commas in tuple types
+ n.type === "TSTupleType"
+ ? ""
+ : ifBreak(shouldPrintComma(options) ? "," : ""),
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true),
+ softline,
+ "]"
+ ])
+ );
+ }
+
+ case "ExistsTypeAnnotation":
+ return "*";
+ case "EmptyTypeAnnotation":
+ return "empty";
+ case "AnyTypeAnnotation":
+ return "any";
+ case "MixedTypeAnnotation":
+ return "mixed";
+ case "ArrayTypeAnnotation":
+ return concat([path$$1.call(print, "elementType"), "[]"]);
+ case "BooleanTypeAnnotation":
+ return "boolean";
+ case "BooleanLiteralTypeAnnotation":
+ return "" + n.value;
+ case "DeclareClass":
+ return printFlowDeclaration(path$$1, printClass(path$$1, options, print));
+ case "DeclareFunction":
+ // For TypeScript the DeclareFunction node shares the AST
+ // structure with FunctionDeclaration
+ if (n.params) {
+ return concat([
+ "declare ",
+ printFunctionDeclaration(path$$1, print, options),
+ semi
+ ]);
+ }
+ return printFlowDeclaration(path$$1, [
+ "function ",
+ path$$1.call(print, "id"),
+ n.predicate ? " " : "",
+ path$$1.call(print, "predicate"),
+ semi
+ ]);
+ case "DeclareModule":
+ return printFlowDeclaration(path$$1, [
+ "module ",
+ path$$1.call(print, "id"),
+ " ",
+ path$$1.call(print, "body")
+ ]);
+ case "DeclareModuleExports":
+ return printFlowDeclaration(path$$1, [
+ "module.exports",
+ ": ",
+ path$$1.call(print, "typeAnnotation"),
+ semi
+ ]);
+ case "DeclareVariable":
+ return printFlowDeclaration(path$$1, ["var ", path$$1.call(print, "id"), semi]);
+ case "DeclareExportAllDeclaration":
+ return concat(["declare export * from ", path$$1.call(print, "source")]);
+ case "DeclareExportDeclaration":
+ return concat(["declare ", printExportDeclaration(path$$1, options, print)]);
+ case "DeclareOpaqueType":
+ case "OpaqueType": {
+ parts.push(
+ "opaque type ",
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters")
+ );
+
+ if (n.supertype) {
+ parts.push(": ", path$$1.call(print, "supertype"));
+ }
+
+ if (n.impltype) {
+ parts.push(" = ", path$$1.call(print, "impltype"));
+ }
+
+ parts.push(semi);
+
+ if (n.type === "DeclareOpaqueType") {
+ return printFlowDeclaration(path$$1, parts);
+ }
+
+ return concat(parts);
+ }
+
+ case "FunctionTypeAnnotation":
+ case "TSFunctionType": {
+ // FunctionTypeAnnotation is ambiguous:
+ // declare function foo(a: B): void; OR
+ // var A: (a: B) => void;
+ const parent = path$$1.getParentNode(0);
+ const parentParent = path$$1.getParentNode(1);
+ const parentParentParent = path$$1.getParentNode(2);
+ let isArrowFunctionTypeAnnotation =
+ n.type === "TSFunctionType" ||
+ !(
+ (parent.type === "ObjectTypeProperty" &&
+ !getFlowVariance(parent) &&
+ !parent.optional &&
+ options.locStart(parent) === options.locStart(n)) ||
+ parent.type === "ObjectTypeCallProperty" ||
+ (parentParentParent && parentParentParent.type === "DeclareFunction")
+ );
+
+ let needsColon =
+ isArrowFunctionTypeAnnotation &&
+ (parent.type === "TypeAnnotation" ||
+ parent.type === "TSTypeAnnotation");
+
+ // 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" ||
+ parent.type === "TSTypeAnnotation") &&
+ parentParent.type === "ArrowFunctionExpression";
+
+ if (isObjectTypePropertyAFunction(parent, options)) {
+ isArrowFunctionTypeAnnotation = true;
+ needsColon = true;
+ }
+
+ if (needsParens) {
+ parts.push("(");
+ }
+
+ parts.push(
+ printFunctionParams(
+ path$$1,
+ print,
+ options,
+ /* expandArg */ false,
+ /* printTypeParams */ true
+ )
+ );
+
+ // 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$$1.call(print, "returnType"),
+ path$$1.call(print, "predicate"),
+ path$$1.call(print, "typeAnnotation")
+ );
+ }
+ if (needsParens) {
+ parts.push(")");
+ }
+
+ return group(concat(parts));
+ }
+ case "FunctionTypeParam":
+ return concat([
+ path$$1.call(print, "name"),
+ printOptionalToken(path$$1),
+ n.name ? ": " : "",
+ path$$1.call(print, "typeAnnotation")
+ ]);
+ case "GenericTypeAnnotation":
+ return concat([
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters")
+ ]);
+ case "DeclareInterface":
+ case "InterfaceDeclaration": {
+ if (
+ n.type === "DeclareInterface" ||
+ isNodeStartingWithDeclare(n, options)
+ ) {
+ parts.push("declare ");
+ }
+
+ parts.push(
+ "interface ",
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters")
+ );
+
+ if (n["extends"].length > 0) {
+ parts.push(
+ group(
+ indent(
+ concat([line, "extends ", join(", ", path$$1.map(print, "extends"))])
+ )
+ )
+ );
+ }
+
+ parts.push(" ");
+ parts.push(path$$1.call(print, "body"));
+
+ return group(concat(parts));
+ }
+ case "ClassImplements":
+ case "InterfaceExtends":
+ return concat([
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters")
+ ]);
+ case "TSIntersectionType":
+ case "IntersectionTypeAnnotation": {
+ const types = path$$1.map(print, "types");
+ const result = [];
+ let wasIndented = false;
+ for (let i = 0; i < types.length; ++i) {
+ if (i === 0) {
+ result.push(types[i]);
+ } else if (isObjectType(n.types[i - 1]) && isObjectType(n.types[i])) {
+ // If both are objects, don't indent
+ result.push(
+ concat([" & ", wasIndented ? indent(types[i]) : types[i]])
+ );
+ } else if (!isObjectType(n.types[i - 1]) && !isObjectType(n.types[i])) {
+ // If no object is involved, go to the next line if it breaks
+ result.push(indent(concat([" &", line, types[i]])));
+ } else {
+ // If you go from object to non-object or vis-versa, then inline it
+ if (i > 1) {
+ wasIndented = true;
+ }
+ result.push(" & ", i > 1 ? indent(types[i]) : types[i]);
+ }
+ }
+ return group(concat(result));
+ }
+ case "TSUnionType":
+ case "UnionTypeAnnotation": {
+ // single-line variation
+ // A | B | C
+
+ // multi-line variation
+ // | A
+ // | B
+ // | C
+
+ const parent = path$$1.getParentNode();
+
+ // If there's a leading comment, the parent is doing the indentation
+ const shouldIndent =
+ parent.type !== "TypeParameterInstantiation" &&
+ parent.type !== "TSTypeParameterInstantiation" &&
+ parent.type !== "GenericTypeAnnotation" &&
+ parent.type !== "TSTypeReference" &&
+ !(parent.type === "FunctionTypeParam" && !parent.name) &&
+ !(
+ (parent.type === "TypeAlias" ||
+ parent.type === "VariableDeclarator") &&
+ hasLeadingOwnLineComment(options.originalText, n, options)
+ );
+
+ // {
+ // 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$$1.map(typePath => {
+ let printedType = typePath.call(print);
+ if (!shouldHug) {
+ printedType = align(2, printedType);
+ }
+ return comments.printComments(typePath, () => printedType, options);
+ }, "types");
+
+ if (shouldHug) {
+ return join(" | ", printed);
+ }
+
+ const code = concat([
+ ifBreak(concat([shouldIndent ? line : "", "| "])),
+ join(concat([line, "| "]), printed)
+ ]);
+
+ let hasParens;
+
+ if (n.type === "TSUnionType") {
+ const greatGrandParent = path$$1.getParentNode(2);
+ const greatGreatGrandParent = path$$1.getParentNode(3);
+
+ hasParens =
+ greatGrandParent &&
+ greatGrandParent.type === "TSParenthesizedType" &&
+ greatGreatGrandParent &&
+ (greatGreatGrandParent.type === "TSUnionType" ||
+ greatGreatGrandParent.type === "TSIntersectionType");
+ } else {
+ hasParens = needsParens_1(path$$1, options);
+ }
+
+ if (hasParens) {
+ return group(concat([indent(code), softline]));
+ }
+
+ return group(shouldIndent ? indent(code) : code);
+ }
+ case "NullableTypeAnnotation":
+ return concat(["?", path$$1.call(print, "typeAnnotation")]);
+ case "TSNullKeyword":
+ case "NullLiteralTypeAnnotation":
+ return "null";
+ case "ThisTypeAnnotation":
+ return "this";
+ case "NumberTypeAnnotation":
+ return "number";
+ case "ObjectTypeCallProperty":
+ if (n.static) {
+ parts.push("static ");
+ }
+
+ parts.push(path$$1.call(print, "value"));
+
+ return concat(parts);
+ case "ObjectTypeIndexer": {
+ const variance = getFlowVariance(n);
+ return concat([
+ variance || "",
+ "[",
+ path$$1.call(print, "id"),
+ n.id ? ": " : "",
+ path$$1.call(print, "key"),
+ "]: ",
+ path$$1.call(print, "value")
+ ]);
+ }
+ case "ObjectTypeProperty": {
+ const variance = getFlowVariance(n);
+
+ return concat([
+ n.static ? "static " : "",
+ isGetterOrSetter(n) ? n.kind + " " : "",
+ variance || "",
+ printPropertyKey(path$$1, options, print),
+ printOptionalToken(path$$1),
+ isFunctionNotation(n, options) ? "" : ": ",
+ path$$1.call(print, "value")
+ ]);
+ }
+ case "QualifiedTypeIdentifier":
+ return concat([
+ path$$1.call(print, "qualification"),
+ ".",
+ path$$1.call(print, "id")
+ ]);
+ case "StringLiteralTypeAnnotation":
+ return nodeStr(n, options);
+ case "NumberLiteralTypeAnnotation":
+ assert.strictEqual(typeof n.value, "number");
+
+ if (n.extra != null) {
+ return util$1.printNumber(n.extra.raw);
+ }
+ return util$1.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$$1.call(print, "right"),
+ canBreak,
+ options
+ );
+
+ parts.push(
+ "type ",
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters"),
+ " =",
+ printed,
+ semi
+ );
+
+ return group(concat(parts));
+ }
+ case "TypeCastExpression":
+ return concat([
+ "(",
+ path$$1.call(print, "expression"),
+ ": ",
+ path$$1.call(print, "typeAnnotation"),
+ ")"
+ ]);
+ case "TypeParameterDeclaration":
+ case "TypeParameterInstantiation":
+ case "TSTypeParameterDeclaration":
+ case "TSTypeParameterInstantiation":
+ return printTypeParameters(path$$1, options, print, "params");
+
+ case "TSTypeParameter":
+ case "TypeParameter": {
+ const parent = path$$1.getParentNode();
+ if (parent.type === "TSMappedType") {
+ parts.push(path$$1.call(print, "name"));
+ if (n.constraint) {
+ parts.push(" in ", path$$1.call(print, "constraint"));
+ }
+ return concat(parts);
+ }
+
+ const variance = getFlowVariance(n);
+
+ if (variance) {
+ parts.push(variance);
+ }
+
+ parts.push(path$$1.call(print, "name"));
+
+ if (n.bound) {
+ parts.push(": ");
+ parts.push(path$$1.call(print, "bound"));
+ }
+
+ if (n.constraint) {
+ parts.push(" extends ", path$$1.call(print, "constraint"));
+ }
+
+ if (n["default"]) {
+ parts.push(" = ", path$$1.call(print, "default"));
+ }
+
+ return concat(parts);
+ }
+ case "TypeofTypeAnnotation":
+ return concat(["typeof ", path$$1.call(print, "argument")]);
+ case "VoidTypeAnnotation":
+ return "void";
+ 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(["%checks(", path$$1.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([
+ path$$1.call(print, "expression"),
+ " as ",
+ path$$1.call(print, "typeAnnotation")
+ ]);
+ case "TSArrayType":
+ return concat([path$$1.call(print, "elementType"), "[]"]);
+ case "TSPropertySignature": {
+ if (n.export) {
+ parts.push("export ");
+ }
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.static) {
+ parts.push("static ");
+ }
+ if (n.readonly) {
+ parts.push("readonly ");
+ }
+ if (n.computed) {
+ parts.push("[");
+ }
+
+ parts.push(printPropertyKey(path$$1, options, print));
+
+ if (n.computed) {
+ parts.push("]");
+ }
+
+ parts.push(printOptionalToken(path$$1));
+
+ if (n.typeAnnotation) {
+ parts.push(": ");
+ parts.push(path$$1.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$$1.call(print, "initializer"));
+ }
+
+ return concat(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$$1.call(print, "parameter"));
+
+ return concat(parts);
+ case "TSTypeReference":
+ return concat([
+ path$$1.call(print, "typeName"),
+ printTypeParameters(path$$1, options, print, "typeParameters")
+ ]);
+ case "TSTypeQuery":
+ return concat(["typeof ", path$$1.call(print, "exprName")]);
+ case "TSParenthesizedType": {
+ return path$$1.call(print, "typeAnnotation");
+ }
+ case "TSIndexSignature": {
+ const parent = path$$1.getParentNode();
+
+ return concat([
+ n.export ? "export " : "",
+ n.accessibility ? concat([n.accessibility, " "]) : "",
+ n.static ? "static " : "",
+ n.readonly ? "readonly " : "",
+ "[",
+ path$$1.call(print, "index"),
+ "]: ",
+ path$$1.call(print, "typeAnnotation"),
+ parent.type === "ClassBody" ? semi : ""
+ ]);
+ }
+ case "TSTypePredicate":
+ return concat([
+ path$$1.call(print, "parameterName"),
+ " is ",
+ path$$1.call(print, "typeAnnotation")
+ ]);
+ case "TSNonNullExpression":
+ return concat([path$$1.call(print, "expression"), "!"]);
+ case "TSThisType":
+ return "this";
+ case "TSLastTypeNode":
+ return path$$1.call(print, "literal");
+ case "TSIndexedAccessType":
+ return concat([
+ path$$1.call(print, "objectType"),
+ "[",
+ path$$1.call(print, "indexType"),
+ "]"
+ ]);
+ case "TSConstructSignature":
+ case "TSConstructorType":
+ case "TSCallSignature": {
+ if (n.type !== "TSCallSignature") {
+ parts.push("new ");
+ }
+
+ parts.push(
+ group(
+ printFunctionParams(
+ path$$1,
+ print,
+ options,
+ /* expandArg */ false,
+ /* printTypeParams */ true
+ )
+ )
+ );
+
+ if (n.typeAnnotation) {
+ const isType = n.type === "TSConstructorType";
+ parts.push(isType ? " => " : ": ", path$$1.call(print, "typeAnnotation"));
+ }
+ return concat(parts);
+ }
+ case "TSTypeOperator":
+ return concat([n.operator, " ", path$$1.call(print, "typeAnnotation")]);
+ case "TSMappedType":
+ return group(
+ concat([
+ "{",
+ indent(
+ concat([
+ options.bracketSpacing ? line : softline,
+ n.readonlyToken
+ ? concat([
+ getTypeScriptMappedTypeModifier(
+ n.readonlyToken,
+ "readonly"
+ ),
+ " "
+ ])
+ : "",
+ printTypeScriptModifiers(path$$1, options, print),
+ "[",
+ path$$1.call(print, "typeParameter"),
+ "]",
+ n.questionToken
+ ? getTypeScriptMappedTypeModifier(n.questionToken, "?")
+ : "",
+ ": ",
+ path$$1.call(print, "typeAnnotation")
+ ])
+ ),
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true),
+ options.bracketSpacing ? line : softline,
+ "}"
+ ])
+ );
+ case "TSMethodSignature":
+ parts.push(
+ n.accessibility ? concat([n.accessibility, " "]) : "",
+ n.export ? "export " : "",
+ n.static ? "static " : "",
+ n.readonly ? "readonly " : "",
+ n.computed ? "[" : "",
+ path$$1.call(print, "key"),
+ n.computed ? "]" : "",
+ printOptionalToken(path$$1),
+ printFunctionParams(
+ path$$1,
+ print,
+ options,
+ /* expandArg */ false,
+ /* printTypeParams */ true
+ )
+ );
+
+ if (n.typeAnnotation) {
+ parts.push(": ", path$$1.call(print, "typeAnnotation"));
+ }
+ return group(concat(parts));
+ case "TSNamespaceExportDeclaration":
+ parts.push("export as namespace ", path$$1.call(print, "name"));
+
+ if (options.semi) {
+ parts.push(";");
+ }
+
+ return group(concat(parts));
+ case "TSEnumDeclaration":
+ if (isNodeStartingWithDeclare(n, options)) {
+ parts.push("declare ");
+ }
+
+ if (n.modifiers) {
+ parts.push(printTypeScriptModifiers(path$$1, options, print));
+ }
+ if (n.const) {
+ parts.push("const ");
+ }
+
+ parts.push("enum ", path$$1.call(print, "id"), " ");
+
+ if (n.members.length === 0) {
+ parts.push(
+ group(
+ concat([
+ "{",
+ comments.printDanglingComments(path$$1, options),
+ softline,
+ "}"
+ ])
+ )
+ );
+ } else {
+ parts.push(
+ group(
+ concat([
+ "{",
+ indent(
+ concat([
+ hardline,
+ printArrayItems(path$$1, options, "members", print),
+ shouldPrintComma(options, "es5") ? "," : ""
+ ])
+ ),
+ comments.printDanglingComments(
+ path$$1,
+ options,
+ /* sameIndent */ true
+ ),
+ hardline,
+ "}"
+ ])
+ )
+ );
+ }
+
+ return concat(parts);
+ case "TSEnumMember":
+ parts.push(path$$1.call(print, "id"));
+ if (n.initializer) {
+ parts.push(" = ", path$$1.call(print, "initializer"));
+ }
+ return concat(parts);
+ case "TSImportEqualsDeclaration":
+ parts.push(
+ printTypeScriptModifiers(path$$1, options, print),
+ "import ",
+ path$$1.call(print, "name"),
+ " = ",
+ path$$1.call(print, "moduleReference")
+ );
+
+ if (options.semi) {
+ parts.push(";");
+ }
+
+ return group(concat(parts));
+ case "TSExternalModuleReference":
+ return concat(["require(", path$$1.call(print, "expression"), ")"]);
+ case "TSModuleDeclaration": {
+ const parent = path$$1.getParentNode();
+ const isExternalModule = isLiteral(n.id);
+ const parentIsDeclaration = parent.type === "TSModuleDeclaration";
+ const bodyIsDeclaration = n.body && n.body.type === "TSModuleDeclaration";
+
+ if (parentIsDeclaration) {
+ parts.push(".");
+ } else {
+ if (n.declare === true) {
+ parts.push("declare ");
+ }
+ parts.push(printTypeScriptModifiers(path$$1, options, print));
+
+ // Global declaration looks like this:
+ // (declare)? global { ... }
+ const isGlobalDeclaration =
+ n.id.type === "Identifier" &&
+ n.id.name === "global" &&
+ !/namespace|module/.test(
+ options.originalText.slice(
+ options.locStart(n),
+ options.locStart(n.id)
+ )
+ );
+
+ if (!isGlobalDeclaration) {
+ parts.push(isExternalModule ? "module " : "namespace ");
+ }
+ }
+
+ parts.push(path$$1.call(print, "id"));
+
+ if (bodyIsDeclaration) {
+ parts.push(path$$1.call(print, "body"));
+ } else if (n.body) {
+ parts.push(
+ " {",
+ indent(
+ concat([
+ line,
+ path$$1.call(
+ bodyPath =>
+ comments.printDanglingComments(bodyPath, options, true),
+ "body"
+ ),
+ group(path$$1.call(print, "body"))
+ ])
+ ),
+ line,
+ "}"
+ );
+ } else {
+ parts.push(semi);
+ }
+
+ return concat(parts);
+ }
+ case "TSModuleBlock":
+ return path$$1.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body");
+
+ case "PrivateName":
+ return concat(["#", path$$1.call(print, "id")]);
+
+ case "TSConditionalType":
+ return formatTernaryOperator(path$$1, options, print, {
+ beforeParts: () => [
+ path$$1.call(print, "checkType"),
+ " ",
+ "extends",
+ " ",
+ path$$1.call(print, "extendsType")
+ ],
+ shouldCheckJsx: false,
+ operatorName: "TSConditionalType",
+ consequentNode: "trueType",
+ alternateNode: "falseType",
+ testNode: "checkType",
+ breakNested: false
+ });
+
+ case "TSInferType":
+ return concat(["infer", " ", path$$1.call(print, "typeParameter")]);
+
+ default:
+ /* istanbul ignore next */
+ throw new Error("unknown type: " + JSON.stringify(n.type));
+ }
+}
+
+function printStatementSequence(path$$1, options, print) {
+ const printed = [];
+
+ const bodyNode = path$$1.getNode();
+ const isClass = bodyNode.type === "ClassBody";
+
+ path$$1.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.
+ /* istanbul ignore if */
+ 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
+ // don't prepend the only JSX element in a program with semicolon
+ if (
+ !options.semi &&
+ !isClass &&
+ !isTheOnlyJSXElementInMarkdown(options, stmtPath) &&
+ stmtNeedsASIProtection(stmtPath, options)
+ ) {
+ if (stmt.comments && stmt.comments.some(comment => comment.leading)) {
+ 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 (
+ utilShared.isNextLineEmpty(text, stmt, options) &&
+ !isLastStatement(stmtPath)
+ ) {
+ parts.push(hardline);
+ }
+
+ printed.push(concat(parts));
+ });
+
+ return join(hardline, printed);
+}
+
+function printPropertyKey(path$$1, options, print) {
+ const node = path$$1.getNode();
+ const key = node.key;
+
+ if (
+ isStringLiteral(key) &&
+ isIdentifierName(key.value) &&
+ !node.computed &&
+ options.parser !== "json"
+ ) {
+ // 'a' -> a
+ return path$$1.call(
+ keyPath => comments.printComments(keyPath, () => key.value, options),
+ "key"
+ );
+ }
+ return path$$1.call(print, "key");
+}
+
+function printMethod(path$$1, options, print) {
+ const node = path$$1.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.ok(kind === "get" || kind === "set");
+
+ parts.push(kind, " ");
+ }
+
+ let key = printPropertyKey(path$$1, options, print);
+
+ if (node.computed) {
+ key = concat(["[", key, "]"]);
+ }
+
+ parts.push(
+ key,
+ concat(
+ path$$1.call(
+ valuePath => [
+ printFunctionTypeParameters(valuePath, options, print),
+ group(
+ concat([
+ printFunctionParams(valuePath, print, options),
+ printReturnType(valuePath, print, options)
+ ])
+ )
+ ],
+ "value"
+ )
+ )
+ );
+
+ if (!node.value.body || node.value.body.length === 0) {
+ parts.push(semi);
+ } else {
+ parts.push(" ", path$$1.call(print, "value", "body"));
+ }
+
+ return concat(parts);
+}
+
+function couldGroupArg(arg) {
+ return (
+ (arg.type === "ObjectExpression" &&
+ (arg.properties.length > 0 || arg.comments)) ||
+ (arg.type === "ArrayExpression" &&
+ (arg.elements.length > 0 || arg.comments)) ||
+ arg.type === "TSTypeAssertionExpression" ||
+ arg.type === "TSAsExpression" ||
+ 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" ||
+ isJSXNode(arg.body)))
+ );
+}
+
+function shouldGroupLastArg(args) {
+ const lastArg = util$1.getLast(args);
+ const penultimateArg = util$1.getPenultimate(args);
+ return (
+ !hasLeadingComment(lastArg) &&
+ !hasTrailingComment(lastArg) &&
+ 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$$1, options, print) {
+ const args = path$$1.getValue().arguments;
+
+ if (args.length === 0) {
+ return concat([
+ "(",
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true),
+ ")"
+ ]);
+ }
+
+ let anyArgEmptyLine = false;
+ let hasEmptyLineFollowingFirstArg = false;
+ const lastArgIndex = args.length - 1;
+ const printedArguments = path$$1.map((argPath, index) => {
+ const arg = argPath.getNode();
+ const parts = [print(argPath)];
+
+ if (index === lastArgIndex) {
+ // do nothing
+ } else if (utilShared.isNextLineEmpty(options.originalText, arg, options)) {
+ if (index === 0) {
+ hasEmptyLineFollowingFirstArg = true;
+ }
+
+ anyArgEmptyLine = true;
+ parts.push(",", hardline, hardline);
+ } else {
+ parts.push(",", line);
+ }
+
+ return concat(parts);
+ }, "arguments");
+
+ const shouldGroupFirst = shouldGroupFirstArg(args);
+ const shouldGroupLast = shouldGroupLastArg(args);
+ if (shouldGroupFirst || shouldGroupLast) {
+ const shouldBreak =
+ (shouldGroupFirst
+ ? printedArguments.slice(1).some(willBreak$1)
+ : printedArguments.slice(0, -1).some(willBreak$1)) || anyArgEmptyLine;
+
+ // We want to print the last argument with a special flag
+ let printedExpanded;
+ let i = 0;
+ path$$1.each(argPath => {
+ if (shouldGroupFirst && i === 0) {
+ printedExpanded = [
+ concat([
+ argPath.call(p => print(p, { expandFirstArg: true })),
+ printedArguments.length > 1 ? "," : "",
+ hasEmptyLineFollowingFirstArg ? hardline : line,
+ hasEmptyLineFollowingFirstArg ? hardline : ""
+ ])
+ ].concat(printedArguments.slice(1));
+ }
+ if (shouldGroupLast && i === args.length - 1) {
+ printedExpanded = printedArguments
+ .slice(0, -1)
+ .concat(argPath.call(p => print(p, { expandLastArg: true })));
+ }
+ i++;
+ }, "arguments");
+
+ const somePrintedArgumentsWillBreak = printedArguments.some(willBreak$1);
+
+ const maybeTrailingComma = shouldPrintComma(options, "all") ? "," : "";
+
+ return concat([
+ somePrintedArgumentsWillBreak ? breakParent : "",
+ conditionalGroup(
+ [
+ concat([
+ ifBreak(
+ indent(concat(["(", softline, concat(printedExpanded)])),
+ concat(["(", concat(printedExpanded)])
+ ),
+ somePrintedArgumentsWillBreak
+ ? concat([ifBreak(maybeTrailingComma), softline])
+ : "",
+ ")"
+ ]),
+ shouldGroupFirst
+ ? concat([
+ "(",
+ group(printedExpanded[0], { shouldBreak: true }),
+ concat(printedExpanded.slice(1)),
+ ")"
+ ])
+ : concat([
+ "(",
+ concat(printedArguments.slice(0, -1)),
+ group(util$1.getLast(printedExpanded), {
+ shouldBreak: true
+ }),
+ ")"
+ ]),
+ group(
+ concat([
+ "(",
+ indent(concat([line, concat(printedArguments)])),
+ maybeTrailingComma,
+ line,
+ ")"
+ ]),
+ { shouldBreak: true }
+ )
+ ],
+ { shouldBreak }
+ )
+ ]);
+ }
+
+ return group(
+ concat([
+ "(",
+ indent(concat([softline, concat(printedArguments)])),
+ ifBreak(shouldPrintComma(options, "all") ? "," : ""),
+ softline,
+ ")"
+ ]),
+ { shouldBreak: printedArguments.some(willBreak$1) || anyArgEmptyLine }
+ );
+}
+
+function printTypeAnnotation(path$$1, options, print) {
+ const node = path$$1.getValue();
+ if (!node.typeAnnotation) {
+ return "";
+ }
+
+ const parentNode = path$$1.getParentNode();
+ const isDefinite =
+ node.definite ||
+ (parentNode &&
+ parentNode.type === "VariableDeclarator" &&
+ parentNode.definite);
+
+ const isFunctionDeclarationIdentifier =
+ parentNode.type === "DeclareFunction" && parentNode.id === node;
+
+ if (
+ isFlowAnnotationComment(options.originalText, node.typeAnnotation, options)
+ ) {
+ return concat([" /*: ", path$$1.call(print, "typeAnnotation"), " */"]);
+ }
+
+ return concat([
+ isFunctionDeclarationIdentifier ? "" : isDefinite ? "!: " : ": ",
+ path$$1.call(print, "typeAnnotation")
+ ]);
+}
+
+function printFunctionTypeParameters(path$$1, options, print) {
+ const fun = path$$1.getValue();
+ if (fun.typeParameters) {
+ return path$$1.call(print, "typeParameters");
+ }
+ return "";
+}
+
+function printFunctionParams(path$$1, print, options, expandArg, printTypeParams) {
+ const fun = path$$1.getValue();
+ const paramsField = fun.parameters ? "parameters" : "params";
+
+ const typeParams = printTypeParams
+ ? printFunctionTypeParameters(path$$1, options, print)
+ : "";
+
+ let printed = [];
+ if (fun[paramsField]) {
+ printed = path$$1.map(print, paramsField);
+ }
+
+ if (fun.rest) {
+ printed.push(concat(["...", path$$1.call(print, "rest")]));
+ }
+
+ if (printed.length === 0) {
+ return concat([
+ typeParams,
+ "(",
+ comments.printDanglingComments(
+ path$$1,
+ options,
+ /* sameIndent */ true,
+ comment =>
+ util$1.getNextNonSpaceNonCommentCharacter(
+ options.originalText,
+ comment,
+ options.locEnd
+ ) === ")"
+ ),
+ ")"
+ ]);
+ }
+
+ const lastParam = util$1.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 &&
+ !(fun[paramsField] && fun[paramsField].some(n => n.comments))
+ ) {
+ return group(
+ concat([
+ docUtils$3.removeLines(typeParams),
+ "(",
+ join(", ", printed.map(docUtils$3.removeLines)),
+ ")"
+ ])
+ );
+ }
+
+ // Single object destructuring should hug
+ //
+ // function({
+ // a,
+ // b,
+ // c
+ // }) {}
+ if (shouldHugArguments(fun)) {
+ return concat([typeParams, "(", join(", ", printed), ")"]);
+ }
+
+ const parent = path$$1.getParentNode();
+
+ // don't break in specs, eg; `it("should maintain parens around done even when long", (done) => {})`
+ if (parent.type === "CallExpression" && isTestCall(parent)) {
+ return concat([typeParams, "(", join(", ", printed), ")"]);
+ }
+
+ const flowTypeAnnotations = [
+ "AnyTypeAnnotation",
+ "NullLiteralTypeAnnotation",
+ "GenericTypeAnnotation",
+ "ThisTypeAnnotation",
+ "NumberTypeAnnotation",
+ "VoidTypeAnnotation",
+ "EmptyTypeAnnotation",
+ "MixedTypeAnnotation",
+ "BooleanTypeAnnotation",
+ "BooleanLiteralTypeAnnotation",
+ "StringTypeAnnotation"
+ ];
+
+ const isFlowShorthandWithOneArg =
+ (isObjectTypePropertyAFunction(parent, options) ||
+ isTypeAnnotationAFunction(parent, options) ||
+ 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 &&
+ fun.typeParameters === null &&
+ flowTypeAnnotations.indexOf(fun[paramsField][0].typeAnnotation.type) !==
+ -1 &&
+ !(
+ fun[paramsField][0].typeAnnotation.type === "GenericTypeAnnotation" &&
+ fun[paramsField][0].typeAnnotation.typeParameters
+ ) &&
+ !fun.rest;
+
+ if (isFlowShorthandWithOneArg) {
+ if (options.arrowParens === "always") {
+ return concat(["(", concat(printed), ")"]);
+ }
+ return concat(printed);
+ }
+
+ const canHaveTrailingComma =
+ !(lastParam && lastParam.type === "RestElement") && !fun.rest;
+
+ return concat([
+ typeParams,
+ "(",
+ indent(concat([softline, join(concat([",", line]), printed)])),
+ ifBreak(
+ canHaveTrailingComma && shouldPrintComma(options, "all") ? "," : ""
+ ),
+ softline,
+ ")"
+ ]);
+}
+
+function shouldPrintParamsWithoutParens(path$$1, options) {
+ if (options.arrowParens === "always") {
+ return false;
+ }
+
+ if (options.arrowParens === "avoid") {
+ const node = path$$1.getValue();
+ return canPrintParamsWithoutParens(node);
+ }
+
+ // Fallback default; should be unreachable
+ return false;
+}
+
+function canPrintParamsWithoutParens(node) {
+ return (
+ node.params.length === 1 &&
+ !node.rest &&
+ !node.typeParameters &&
+ !hasDanglingComments(node) &&
+ node.params[0].type === "Identifier" &&
+ !node.params[0].typeAnnotation &&
+ !node.params[0].comments &&
+ !node.params[0].optional &&
+ !node.predicate &&
+ !node.returnType
+ );
+}
+
+function printFunctionDeclaration(path$$1, print, options) {
+ const n = path$$1.getValue();
+ const parts = [];
+
+ if (n.async) {
+ parts.push("async ");
+ }
+
+ parts.push("function");
+
+ if (n.generator) {
+ parts.push("*");
+ }
+ if (n.id) {
+ parts.push(" ", path$$1.call(print, "id"));
+ }
+
+ parts.push(
+ printFunctionTypeParameters(path$$1, options, print),
+ group(
+ concat([
+ printFunctionParams(path$$1, print, options),
+ printReturnType(path$$1, print, options)
+ ])
+ ),
+ n.body ? " " : "",
+ path$$1.call(print, "body")
+ );
+
+ return concat(parts);
+}
+
+function printObjectMethod(path$$1, options, print) {
+ const objMethod = path$$1.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$$1, options, print);
+ }
+
+ const key = printPropertyKey(path$$1, options, print);
+
+ if (objMethod.computed) {
+ parts.push("[", key, "]");
+ } else {
+ parts.push(key);
+ }
+
+ parts.push(
+ printFunctionTypeParameters(path$$1, options, print),
+ group(
+ concat([
+ printFunctionParams(path$$1, print, options),
+ printReturnType(path$$1, print, options)
+ ])
+ ),
+ " ",
+ path$$1.call(print, "body")
+ );
+
+ return concat(parts);
+}
+
+function printReturnType(path$$1, print, options) {
+ const n = path$$1.getValue();
+ const returnType = path$$1.call(print, "returnType");
+
+ if (
+ n.returnType &&
+ isFlowAnnotationComment(options.originalText, n.returnType, options)
+ ) {
+ return concat([" /*: ", returnType, " */"]);
+ }
+
+ const parts = [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$$1.call(print, "predicate"));
+ }
+
+ return concat(parts);
+}
+
+function printExportDeclaration(path$$1, options, print) {
+ const decl = path$$1.getValue();
+ const semi = options.semi ? ";" : "";
+ const parts = ["export "];
+
+ const isDefault = decl["default"] || decl.type === "ExportDefaultDeclaration";
+
+ if (isDefault) {
+ parts.push("default ");
+ }
+
+ parts.push(
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true)
+ );
+
+ if (needsHardlineAfterDanglingComment(decl)) {
+ parts.push(hardline);
+ }
+
+ if (decl.declaration) {
+ parts.push(path$$1.call(print, "declaration"));
+
+ if (
+ isDefault &&
+ (decl.declaration.type !== "ClassDeclaration" &&
+ decl.declaration.type !== "FunctionDeclaration" &&
+ decl.declaration.type !== "TSAbstractClassDeclaration" &&
+ decl.declaration.type !== "TSInterfaceDeclaration" &&
+ decl.declaration.type !== "DeclareClass" &&
+ decl.declaration.type !== "DeclareFunction")
+ ) {
+ parts.push(semi);
+ }
+ } else {
+ if (decl.specifiers && decl.specifiers.length > 0) {
+ const specifiers = [];
+ const defaultSpecifiers = [];
+ const namespaceSpecifiers = [];
+ path$$1.each(specifierPath => {
+ const specifierType = path$$1.getValue().type;
+ if (specifierType === "ExportSpecifier") {
+ specifiers.push(print(specifierPath));
+ } else if (specifierType === "ExportDefaultSpecifier") {
+ defaultSpecifiers.push(print(specifierPath));
+ } else if (specifierType === "ExportNamespaceSpecifier") {
+ namespaceSpecifiers.push(concat(["* as ", print(specifierPath)]));
+ }
+ }, "specifiers");
+
+ const isNamespaceFollowed =
+ namespaceSpecifiers.length !== 0 && specifiers.length !== 0;
+
+ const isDefaultFollowed =
+ defaultSpecifiers.length !== 0 &&
+ (namespaceSpecifiers.length !== 0 || specifiers.length !== 0);
+
+ parts.push(
+ decl.exportKind === "type" ? "type " : "",
+ concat(defaultSpecifiers),
+ concat([isDefaultFollowed ? ", " : ""]),
+ concat(namespaceSpecifiers),
+ concat([isNamespaceFollowed ? ", " : ""]),
+ specifiers.length !== 0
+ ? group(
+ concat([
+ "{",
+ indent(
+ concat([
+ options.bracketSpacing ? line : softline,
+ join(concat([",", line]), specifiers)
+ ])
+ ),
+ ifBreak(shouldPrintComma(options) ? "," : ""),
+ options.bracketSpacing ? line : softline,
+ "}"
+ ])
+ )
+ : ""
+ );
+ } else {
+ parts.push("{}");
+ }
+
+ if (decl.source) {
+ parts.push(" from ", path$$1.call(print, "source"));
+ }
+
+ parts.push(semi);
+ }
+
+ return concat(parts);
+}
+
+function printFlowDeclaration(path$$1, parts) {
+ const parentExportDecl = util$1.getParentExportDeclaration(path$$1);
+
+ if (parentExportDecl) {
+ assert.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(parts);
+}
+
+function getFlowVariance(path$$1) {
+ if (!path$$1.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$$1.variance.kind || path$$1.variance;
+
+ switch (variance) {
+ case "plus":
+ return "+";
+ case "minus":
+ return "-";
+ default:
+ /* istanbul ignore next */
+ return variance;
+ }
+}
+
+function printTypeScriptModifiers(path$$1, options, print) {
+ const n = path$$1.getValue();
+ if (!n.modifiers || !n.modifiers.length) {
+ return "";
+ }
+ return concat([join(" ", path$$1.map(print, "modifiers")), " "]);
+}
+
+function printTypeParameters(path$$1, options, print, paramsKey) {
+ const n = path$$1.getValue();
+
+ if (!n[paramsKey]) {
+ return "";
+ }
+
+ // for TypeParameterDeclaration typeParameters is a single node
+ if (!Array.isArray(n[paramsKey])) {
+ return path$$1.call(print, paramsKey);
+ }
+
+ const grandparent = path$$1.getNode(2);
+
+ const isParameterInTestCall =
+ grandparent != null &&
+ grandparent.type === "CallExpression" &&
+ isTestCall(grandparent);
+
+ const shouldInline =
+ isParameterInTestCall ||
+ n[paramsKey].length === 0 ||
+ (n[paramsKey].length === 1 &&
+ (shouldHugType(n[paramsKey][0]) ||
+ (n[paramsKey][0].type === "GenericTypeAnnotation" &&
+ shouldHugType(n[paramsKey][0].id)) ||
+ (n[paramsKey][0].type === "TSTypeReference" &&
+ shouldHugType(n[paramsKey][0].typeName)) ||
+ n[paramsKey][0].type === "NullableTypeAnnotation"));
+
+ if (shouldInline) {
+ return concat(["<", join(", ", path$$1.map(print, paramsKey)), ">"]);
+ }
+
+ return group(
+ concat([
+ "<",
+ indent(
+ concat([
+ softline,
+ join(concat([",", line]), path$$1.map(print, paramsKey))
+ ])
+ ),
+ ifBreak(
+ options.parser !== "typescript" && shouldPrintComma(options, "all")
+ ? ","
+ : ""
+ ),
+ softline,
+ ">"
+ ])
+ );
+}
+
+function printClass(path$$1, options, print) {
+ const n = path$$1.getValue();
+ const parts = [];
+
+ if (n.type === "TSAbstractClassDeclaration") {
+ parts.push("abstract ");
+ }
+
+ parts.push("class");
+
+ if (n.id) {
+ parts.push(" ", path$$1.call(print, "id"));
+ }
+
+ parts.push(path$$1.call(print, "typeParameters"));
+
+ const partsGroup = [];
+ if (n.superClass) {
+ const printed = concat([
+ "extends ",
+ path$$1.call(print, "superClass"),
+ path$$1.call(print, "superTypeParameters")
+ ]);
+ // Keep old behaviour of extends in same line
+ // If there is only on extends and there are not comments
+ if (
+ (!n.implements || n.implements.length === 0) &&
+ (!n.superClass.comments || n.superClass.comments.length === 0)
+ ) {
+ parts.push(
+ concat([
+ " ",
+ path$$1.call(
+ superClass =>
+ comments.printComments(superClass, () => printed, options),
+ "superClass"
+ )
+ ])
+ );
+ } else {
+ partsGroup.push(
+ group(
+ concat([
+ line,
+ path$$1.call(
+ superClass =>
+ comments.printComments(superClass, () => printed, options),
+ "superClass"
+ )
+ ])
+ )
+ );
+ }
+ } else if (n.extends && n.extends.length > 0) {
+ parts.push(" extends ", join(", ", path$$1.map(print, "extends")));
+ }
+
+ if (n["implements"] && n["implements"].length > 0) {
+ partsGroup.push(
+ line,
+ "implements",
+ group(
+ indent(
+ concat([
+ line,
+ join(concat([",", line]), path$$1.map(print, "implements"))
+ ])
+ )
+ )
+ );
+ }
+
+ if (n["mixins"] && n["mixins"].length > 0) {
+ partsGroup.push(
+ line,
+ "mixins ",
+ group(indent(join(concat([",", line]), path$$1.map(print, "mixins"))))
+ );
+ }
+
+ if (partsGroup.length > 0) {
+ parts.push(group(indent(concat(partsGroup))));
+ }
+
+ if (
+ n.body &&
+ n.body.comments &&
+ hasLeadingOwnLineComment(options.originalText, n.body, options)
+ ) {
+ parts.push(hardline);
+ } else {
+ parts.push(" ");
+ }
+ parts.push(path$$1.call(print, "body"));
+
+ return parts;
+}
+
+function printOptionalToken(path$$1) {
+ const node = path$$1.getValue();
+ if (!node.optional) {
+ return "";
+ }
+ if (
+ node.type === "CallExpression" ||
+ (node.type === "MemberExpression" && node.computed)
+ ) {
+ return "?.";
+ }
+ return "?";
+}
+
+function printMemberLookup(path$$1, options, print) {
+ const property = path$$1.call(print, "property");
+ const n = path$$1.getValue();
+ const optional = printOptionalToken(path$$1);
+
+ if (!n.computed) {
+ return concat([optional, ".", property]);
+ }
+
+ if (!n.property || isNumericLiteral(n.property)) {
+ return concat([optional, "[", property, "]"]);
+ }
+
+ return group(
+ concat([optional, "[", indent(concat([softline, property])), softline, "]"])
+ );
+}
+
+function printBindExpressionCallee(path$$1, options, print) {
+ return concat(["::", path$$1.call(print, "callee")]);
+}
+
+// We detect calls on member expressions specially to format a
+// common 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$$1, 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 = [];
+
+ // Here we try to retain one typed empty line after each call expression or
+ // the first group whether it is in parentheses or not
+ function shouldInsertEmptyLineAfter(node) {
+ const originalText = options.originalText;
+ const nextCharIndex = utilShared.getNextNonSpaceNonCommentCharacterIndex(
+ originalText,
+ node,
+ options
+ );
+ const nextChar = originalText.charAt(nextCharIndex);
+
+ // if it is cut off by a parenthesis, we only account for one typed empty
+ // line after that parenthesis
+ if (nextChar == ")") {
+ return utilShared.isNextLineEmptyAfterIndex(
+ originalText,
+ nextCharIndex + 1,
+ options
+ );
+ }
+
+ return utilShared.isNextLineEmpty(originalText, node, options);
+ }
+
+ function rec(path$$1) {
+ const node = path$$1.getValue();
+ if (
+ node.type === "CallExpression" &&
+ (isMemberish(node.callee) || node.callee.type === "CallExpression")
+ ) {
+ printedNodes.unshift({
+ node: node,
+ printed: concat([
+ comments.printComments(
+ path$$1,
+ () =>
+ concat([
+ printOptionalToken(path$$1),
+ printFunctionTypeParameters(path$$1, options, print),
+ printArgumentsList(path$$1, options, print)
+ ]),
+ options
+ ),
+ shouldInsertEmptyLineAfter(node) ? hardline : ""
+ ])
+ });
+ path$$1.call(callee => rec(callee), "callee");
+ } else if (isMemberish(node)) {
+ printedNodes.unshift({
+ node: node,
+ printed: comments.printComments(
+ path$$1,
+ () =>
+ node.type === "MemberExpression"
+ ? printMemberLookup(path$$1, options, print)
+ : printBindExpressionCallee(path$$1, options, print),
+ options
+ )
+ });
+ path$$1.call(object => rec(object), "object");
+ } else if (node.type === "TSNonNullExpression") {
+ printedNodes.unshift({
+ node: node,
+ printed: comments.printComments(path$$1, () => "!", options)
+ });
+ path$$1.call(expression => rec(expression), "expression");
+ } else {
+ printedNodes.unshift({
+ node: node,
+ printed: path$$1.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.
+ const node = path$$1.getValue();
+ printedNodes.unshift({
+ node,
+ printed: concat([
+ printOptionalToken(path$$1),
+ printFunctionTypeParameters(path$$1, options, print),
+ printArgumentsList(path$$1, options, print)
+ ])
+ });
+ path$$1.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()
+ // - as many array acessors as possible
+ // < fn()[0][1][2] >.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 === "TSNonNullExpression" ||
+ printedNodes[i].node.type === "CallExpression" ||
+ (printedNodes[i].node.type === "MemberExpression" &&
+ printedNodes[i].node.computed &&
+ isNumericLiteral(printedNodes[i].node.property))
+ ) {
+ currentGroup.push(printedNodes[i]);
+ } else {
+ break;
+ }
+ }
+ if (printedNodes[0].node.type !== "CallExpression") {
+ for (; i + 1 < printedNodes.length; ++i) {
+ if (
+ isMemberish(printedNodes[i].node) &&
+ isMemberish(printedNodes[i + 1].node)
+ ) {
+ 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 && isMemberish(printedNodes[i].node)) {
+ // [0] should be appended at the end of the group instead of the
+ // beginning of the next one
+ if (
+ printedNodes[i].node.computed &&
+ isNumericLiteral(printedNodes[i].node.property)
+ ) {
+ 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.
+ function isFactory(name) {
+ return name.match(/(^[A-Z])|^[_$]+$/);
+ }
+ 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" &&
+ (isFactory(groups[0][0].node.name) ||
+ (groups[1].length && groups[1][0].node.computed))))) ||
+ (groups[0].length > 1 &&
+ groups[0][groups[0].length - 1].node.type === "MemberExpression" &&
+ groups[0][groups[0].length - 1].node.property.type === "Identifier" &&
+ (isFactory(groups[0][groups[0].length - 1].node.property.name) ||
+ (groups[1].length && groups[1][0].node.computed))));
+
+ function printGroup(printedGroup) {
+ return concat(printedGroup.map(tuple => tuple.printed));
+ }
+
+ function printIndentedGroup(groups) {
+ if (groups.length === 0) {
+ return "";
+ }
+ return indent(
+ group(concat([hardline, join(hardline, groups.map(printGroup))]))
+ );
+ }
+
+ const printedGroups = groups.map(printGroup);
+ const oneLine = concat(printedGroups);
+
+ const cutoff = shouldMerge ? 3 : 2;
+ const flatGroups = groups
+ .slice(0, cutoff)
+ .reduce((res, group) => res.concat(group), []);
+
+ const hasComment =
+ flatGroups.slice(1, -1).some(node => hasLeadingComment(node.node)) ||
+ flatGroups.slice(0, -1).some(node => hasTrailingComment(node.node)) ||
+ (groups[cutoff] && hasLeadingComment(groups[cutoff][0].node));
+
+ // If we only have a single `.`, we shouldn't do anything fancy and just
+ // render everything concatenated together.
+ if (groups.length <= cutoff && !hasComment) {
+ return group(oneLine);
+ }
+
+ // Find out the last node in the first group and check if it has an
+ // empty line after
+ const lastNodeBeforeIndent = util$1.getLast(
+ shouldMerge ? groups.slice(1, 2)[0] : groups[0]
+ ).node;
+ const shouldHaveEmptyLineBeforeIndent =
+ lastNodeBeforeIndent.type !== "CallExpression" &&
+ shouldInsertEmptyLineAfter(lastNodeBeforeIndent);
+
+ const expanded = concat([
+ printGroup(groups[0]),
+ shouldMerge ? concat(groups.slice(1, 2).map(printGroup)) : "",
+ shouldHaveEmptyLineBeforeIndent ? hardline : "",
+ printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))
+ ]);
+
+ const callExpressionCount = printedNodes.filter(
+ tuple => tuple.node.type === "CallExpression"
+ ).length;
+
+ // We don't want to print in one line if there's:
+ // * A comment.
+ // * 3 or more chained calls.
+ // * Any group but the last one has a hard line.
+ // If the last group is a function it's okay to inline if it fits.
+ if (
+ hasComment ||
+ callExpressionCount >= 3 ||
+ printedGroups.slice(0, -1).some(willBreak$1)
+ ) {
+ return group(expanded);
+ }
+
+ return concat([
+ // We only need to check `oneLine` because if `expanded` is chosen
+ // that means that the parent group has already been broken
+ // naturally
+ willBreak$1(oneLine) || shouldHaveEmptyLineBeforeIndent ? breakParent : "",
+ conditionalGroup([oneLine, expanded])
+ ]);
+}
+
+function isJSXNode(node) {
+ return (
+ node.type === "JSXElement" ||
+ node.type === "JSXFragment" ||
+ node.type === "TSJsxFragment"
+ );
+}
+
+function isEmptyJSXElement(node) {
+ if (node.children.length === 0) {
+ return true;
+ }
+ if (node.children.length > 1) {
+ return false;
+ }
+
+ // if there is one text child and does not contain any meaningful text
+ // we can treat the element as empty.
+ const child = node.children[0];
+ return isLiteral(child) && !isMeaningfulJSXText(child);
+}
+
+// Only space, newline, carriage return, and tab are treated as whitespace
+// inside JSX.
+const jsxWhitespaceChars = " \n\r\t";
+const containsNonJsxWhitespaceRegex = new RegExp(
+ "[^" + jsxWhitespaceChars + "]"
+);
+const matchJsxWhitespaceRegex = new RegExp("([" + jsxWhitespaceChars + "]+)");
+
+// Meaningful if it contains non-whitespace characters,
+// or it contains whitespace without a new line.
+function isMeaningfulJSXText(node) {
+ return (
+ isLiteral(node) &&
+ (containsNonJsxWhitespaceRegex.test(rawText(node)) ||
+ !/\n/.test(rawText(node)))
+ );
+}
+
+function conditionalExpressionChainContainsJSX(node) {
+ return Boolean(getConditionalChainContents(node).find(isJSXNode));
+}
+
+// If we have nested conditional expressions, we want to print them in JSX mode
+// if there's at least one JSXElement somewhere in the tree.
+//
+// A conditional expression chain like this should be printed in normal mode,
+// because there aren't JSXElements anywhere in it:
+//
+// isA ? "A" : isB ? "B" : isC ? "C" : "Unknown";
+//
+// But a conditional expression chain like this should be printed in JSX mode,
+// because there is a JSXElement in the last ConditionalExpression:
+//
+// isA ? "A" : isB ? "B" : isC ? "C" :
Unknown;
+//
+// This type of ConditionalExpression chain is structured like this in the AST:
+//
+// ConditionalExpression {
+// test: ...,
+// consequent: ...,
+// alternate: ConditionalExpression {
+// test: ...,
+// consequent: ...,
+// alternate: ConditionalExpression {
+// test: ...,
+// consequent: ...,
+// alternate: ...,
+// }
+// }
+// }
+//
+// We want to traverse over that shape and convert it into a flat structure so
+// that we can find if there's a JSXElement somewhere inside.
+function getConditionalChainContents(node) {
+ // Given this code:
+ //
+ // // Using a ConditionalExpression as the consequent is uncommon, but should
+ // // be handled.
+ // A ? B : C ? D : E ? F ? G : H : I
+ //
+ // which has this AST:
+ //
+ // ConditionalExpression {
+ // test: Identifier(A),
+ // consequent: Identifier(B),
+ // alternate: ConditionalExpression {
+ // test: Identifier(C),
+ // consequent: Identifier(D),
+ // alternate: ConditionalExpression {
+ // test: Identifier(E),
+ // consequent: ConditionalExpression {
+ // test: Identifier(F),
+ // consequent: Identifier(G),
+ // alternate: Identifier(H),
+ // },
+ // alternate: Identifier(I),
+ // }
+ // }
+ // }
+ //
+ // we should return this Array:
+ //
+ // [
+ // Identifier(A),
+ // Identifier(B),
+ // Identifier(C),
+ // Identifier(D),
+ // Identifier(E),
+ // Identifier(F),
+ // Identifier(G),
+ // Identifier(H),
+ // Identifier(I)
+ // ];
+ //
+ // This loses the information about whether each node was the test,
+ // consequent, or alternate, but we don't care about that here- we are only
+ // flattening this structure to find if there's any JSXElements inside.
+ const nonConditionalExpressions = [];
+
+ function recurse(node) {
+ if (node.type === "ConditionalExpression") {
+ recurse(node.test);
+ recurse(node.consequent);
+ recurse(node.alternate);
+ } else {
+ nonConditionalExpressions.push(node);
+ }
+ }
+ recurse(node);
+
+ return nonConditionalExpressions;
+}
+
+// Detect an expression node representing `{" "}`
+function isJSXWhitespaceExpression(node) {
+ return (
+ node.type === "JSXExpressionContainer" &&
+ isLiteral(node.expression) &&
+ node.expression.value === " " &&
+ !node.expression.comments
+ );
+}
+
+// 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.
+//
+// Leading, trailing, and lone whitespace all need to
+// turn themselves into the rather ugly `{' '}` when breaking.
+//
+// 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$$1, options, print, jsxWhitespace) {
+ const n = path$$1.getValue();
+ const children = [];
+
+ // using `map` instead of `each` because it provides `i`
+ path$$1.map((childPath, i) => {
+ const child = childPath.getValue();
+ if (isLiteral(child)) {
+ const text = rawText(child);
+
+ // Contains a non-whitespace character
+ if (isMeaningfulJSXText(child)) {
+ const words = text.split(matchJsxWhitespaceRegex);
+
+ // Starts with whitespace
+ if (words[0] === "") {
+ children.push("");
+ words.shift();
+ if (/\n/.test(words[0])) {
+ children.push(hardline);
+ } else {
+ children.push(jsxWhitespace);
+ }
+ words.shift();
+ }
+
+ let endWhitespace;
+ // Ends with whitespace
+ if (util$1.getLast(words) === "") {
+ words.pop();
+ endWhitespace = words.pop();
+ }
+
+ // This was whitespace only without a new line.
+ if (words.length === 0) {
+ return;
+ }
+
+ words.forEach((word, i) => {
+ if (i % 2 === 1) {
+ children.push(line);
+ } else {
+ children.push(word);
+ }
+ });
+
+ if (endWhitespace !== undefined) {
+ if (/\n/.test(endWhitespace)) {
+ children.push(hardline);
+ } else {
+ children.push(jsxWhitespace);
+ }
+ } else {
+ // Ideally this would be a `hardline` 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(text)) {
+ // Keep (up to one) blank line between tags/expressions/text.
+ // Note: We don't keep blank lines between text elements.
+ if (text.match(/\n/g).length > 1) {
+ children.push("");
+ children.push(hardline);
+ }
+ } else {
+ children.push("");
+ children.push(jsxWhitespace);
+ }
+ } else {
+ const printedChild = print(childPath);
+ children.push(printedChild);
+
+ const next = n.children[i + 1];
+ const directlyFollowedByMeaningfulText =
+ next && isMeaningfulJSXText(next) && !/^[ \n\r\t]/.test(rawText(next));
+ if (directlyFollowedByMeaningfulText) {
+ // Potentially this could be a hardline as well.
+ // See the comment above about the Facebook translation pipeline as
+ // to why this is an empty string.
+ children.push("");
+ } else {
+ children.push(hardline);
+ }
+ }
+ }, "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$$1, options, print) {
+ const n = path$$1.getValue();
+
+ // Turn
into
+ if (n.type === "JSXElement" && isEmptyJSXElement(n)) {
+ n.openingElement.selfClosing = true;
+ return path$$1.call(print, "openingElement");
+ }
+
+ const openingLines =
+ n.type === "JSXElement"
+ ? path$$1.call(print, "openingElement")
+ : path$$1.call(print, "openingFragment");
+ const closingLines =
+ n.type === "JSXElement"
+ ? path$$1.call(print, "closingElement")
+ : path$$1.call(print, "closingFragment");
+
+ if (
+ n.children.length === 1 &&
+ n.children[0].type === "JSXExpressionContainer" &&
+ (n.children[0].expression.type === "TemplateLiteral" ||
+ n.children[0].expression.type === "TaggedTemplateExpression")
+ ) {
+ return concat([
+ openingLines,
+ concat(path$$1.map(print, "children")),
+ closingLines
+ ]);
+ }
+
+ // Convert `{" "}` to text nodes containing a space.
+ // This makes it easy to turn them into `jsxWhitespace` which
+ // can then print as either a space or `{" "}` when breaking.
+ n.children = n.children.map(child => {
+ if (isJSXWhitespaceExpression(child)) {
+ return {
+ type: "JSXText",
+ value: " ",
+ raw: " "
+ };
+ }
+ return child;
+ });
+
+ const containsTag = n.children.filter(isJSXNode).length > 0;
+ const containsMultipleExpressions =
+ n.children.filter(child => child.type === "JSXExpressionContainer").length >
+ 1;
+ const containsMultipleAttributes =
+ n.type === "JSXElement" && n.openingElement.attributes.length > 1;
+
+ // Record any breaks. Should never go from true to false, only false to true.
+ let forcedBreak =
+ willBreak$1(openingLines) ||
+ containsTag ||
+ containsMultipleAttributes ||
+ containsMultipleExpressions;
+
+ const rawJsxWhitespace = options.singleQuote ? "{' '}" : '{" "}';
+ const jsxWhitespace = ifBreak(concat([rawJsxWhitespace, softline]), " ");
+
+ const children = printJSXChildren(path$$1, options, print, jsxWhitespace);
+
+ const containsText =
+ n.children.filter(child => isMeaningfulJSXText(child)).length > 0;
+
+ // We can end up we multiple whitespace elements with empty string
+ // content between them.
+ // We need to remove empty whitespace and softlines before JSX whitespace
+ // to get the correct output.
+ for (let i = children.length - 2; i >= 0; i--) {
+ const isPairOfEmptyStrings = children[i] === "" && children[i + 1] === "";
+ const isPairOfHardlines =
+ children[i] === hardline &&
+ children[i + 1] === "" &&
+ children[i + 2] === hardline;
+ const isLineFollowedByJSXWhitespace =
+ (children[i] === softline || children[i] === hardline) &&
+ children[i + 1] === "" &&
+ children[i + 2] === jsxWhitespace;
+ const isJSXWhitespaceFollowedByLine =
+ children[i] === jsxWhitespace &&
+ children[i + 1] === "" &&
+ (children[i + 2] === softline || children[i + 2] === hardline);
+ const isDoubleJSXWhitespace =
+ children[i] === jsxWhitespace &&
+ children[i + 1] === "" &&
+ children[i + 2] === jsxWhitespace;
+
+ if (
+ (isPairOfHardlines && containsText) ||
+ isPairOfEmptyStrings ||
+ isLineFollowedByJSXWhitespace ||
+ isDoubleJSXWhitespace
+ ) {
+ children.splice(i, 2);
+ } else if (isJSXWhitespaceFollowedByLine) {
+ children.splice(i + 1, 2);
+ }
+ }
+
+ // Trim trailing lines (or empty strings)
+ while (
+ children.length &&
+ (isLineNext$1(util$1.getLast(children)) ||
+ isEmpty$1(util$1.getLast(children)))
+ ) {
+ children.pop();
+ }
+
+ // Trim leading lines (or empty strings)
+ while (
+ children.length &&
+ (isLineNext$1(children[0]) || isEmpty$1(children[0])) &&
+ (isLineNext$1(children[1]) || isEmpty$1(children[1]))
+ ) {
+ children.shift();
+ children.shift();
+ }
+
+ // 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) => {
+ // There are a number of situations where we need to ensure we display
+ // whitespace as `{" "}` when outputting this element over multiple lines.
+ if (child === jsxWhitespace) {
+ if (i === 1 && children[i - 1] === "") {
+ if (children.length === 2) {
+ // Solitary whitespace
+ multilineChildren.push(rawJsxWhitespace);
+ return;
+ }
+ // Leading whitespace
+ multilineChildren.push(concat([rawJsxWhitespace, hardline]));
+ return;
+ } else if (i === children.length - 1) {
+ // Trailing whitespace
+ multilineChildren.push(rawJsxWhitespace);
+ return;
+ } else if (children[i - 1] === "" && children[i - 2] === hardline) {
+ // Whitespace after line break
+ multilineChildren.push(rawJsxWhitespace);
+ return;
+ }
+ }
+
+ multilineChildren.push(child);
+
+ if (willBreak$1(child)) {
+ forcedBreak = true;
+ }
+ });
+
+ // If there is text we use `fill` to fit as much onto each line as possible.
+ // When there is no text (just tags and expressions) we use `group`
+ // to output each on a separate line.
+ const content = containsText
+ ? fill(multilineChildren)
+ : group(concat(multilineChildren), { shouldBreak: true });
+
+ const multiLineElem = group(
+ concat([
+ openingLines,
+ indent(concat([hardline, content])),
+ hardline,
+ closingLines
+ ])
+ );
+
+ if (forcedBreak) {
+ return multiLineElem;
+ }
+
+ return conditionalGroup([
+ group(concat([openingLines, concat(children), closingLines])),
+ multiLineElem
+ ]);
+}
+
+function maybeWrapJSXElementInParens(path$$1, elem) {
+ const parent = path$$1.getParentNode();
+ if (!parent) {
+ return elem;
+ }
+
+ const NO_WRAP_PARENTS = {
+ ArrayExpression: true,
+ JSXAttribute: true,
+ JSXElement: true,
+ JSXExpressionContainer: true,
+ JSXFragment: true,
+ TSJsxFragment: true,
+ ExpressionStatement: true,
+ CallExpression: true,
+ ConditionalExpression: true
+ };
+ if (NO_WRAP_PARENTS[parent.type]) {
+ return elem;
+ }
+
+ return group(
+ concat([
+ ifBreak("("),
+ indent(concat([softline, elem])),
+ softline,
+ ifBreak(")")
+ ])
+ );
+}
+
+function isBinaryish(node) {
+ return node.type === "BinaryExpression" || node.type === "LogicalExpression";
+}
+
+function isMemberish(node) {
+ return (
+ node.type === "MemberExpression" ||
+ (node.type === "BindExpression" && node.object)
+ );
+}
+
+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;
+ }
+
+ if (isJSXNode(node.right)) {
+ 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$$1,
+ print,
+ options,
+ isNested,
+ isInsideParenthesis
+) {
+ let parts = [];
+ const node = path$$1.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$1.shouldFlatten(node.operator, node.left.operator)) {
+ // Flatten them out by recursively calling this function.
+ parts = parts.concat(
+ path$$1.call(
+ left =>
+ printBinaryishExpressions(
+ left,
+ print,
+ options,
+ /* isNested */ true,
+ isInsideParenthesis
+ ),
+ "left"
+ )
+ );
+ } else {
+ parts.push(path$$1.call(print, "left"));
+ }
+
+ const shouldInline = shouldInlineLogicalExpression(node);
+ const lineBeforeOperator = node.operator === "|>";
+
+ const right = shouldInline
+ ? concat([node.operator, " ", path$$1.call(print, "right")])
+ : concat([
+ lineBeforeOperator ? softline : "",
+ node.operator,
+ lineBeforeOperator ? " " : line,
+ path$$1.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$$1.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(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.printComments(path$$1, () => concat(parts), options);
+ }
+ } else {
+ // Our stopping case. Simply print the node normally.
+ parts.push(path$$1.call(print));
+ }
+
+ return parts;
+}
+
+function printAssignmentRight(rightNode, printedRight, canBreak, options) {
+ if (hasLeadingOwnLineComment(options.originalText, rightNode, options)) {
+ return indent(concat([hardline, printedRight]));
+ }
+
+ if (canBreak) {
+ return indent(concat([line, printedRight]));
+ }
+
+ return concat([" ", printedRight]);
+}
+
+function printAssignment(
+ leftNode,
+ printedLeft,
+ operator,
+ rightNode,
+ printedRight,
+ options
+) {
+ if (!rightNode) {
+ return printedLeft;
+ }
+
+ const canBreak =
+ (isBinaryish(rightNode) && !shouldInlineLogicalExpression(rightNode)) ||
+ (rightNode.type === "ConditionalExpression" &&
+ isBinaryish(rightNode.test) &&
+ !shouldInlineLogicalExpression(rightNode.test)) ||
+ ((leftNode.type === "Identifier" ||
+ isStringLiteral(leftNode) ||
+ leftNode.type === "MemberExpression") &&
+ (isStringLiteral(rightNode) || isMemberExpressionChain(rightNode)));
+
+ const printed = printAssignmentRight(
+ rightNode,
+ printedRight,
+ canBreak,
+ options
+ );
+
+ return group(concat([printedLeft, operator, printed]));
+}
+
+function adjustClause(node, clause, forceSpace) {
+ if (node.type === "EmptyStatement") {
+ return ";";
+ }
+
+ if (node.type === "BlockStatement" || forceSpace) {
+ return concat([" ", clause]);
+ }
+
+ return indent(concat([line, clause]));
+}
+
+function nodeStr(node, options, isFlowOrTypeScriptDirectiveLiteral) {
+ const raw = rawText(node);
+ const isDirectiveLiteral =
+ isFlowOrTypeScriptDirectiveLiteral || node.type === "DirectiveLiteral";
+ return util$1.printString(raw, options, isDirectiveLiteral);
+}
+
+function printRegex(node) {
+ const flags = node.flags
+ .split("")
+ .sort()
+ .join("");
+ return `/${node.pattern}/${flags}`;
+}
+
+function isLastStatement(path$$1) {
+ const parent = path$$1.getParentNode();
+ if (!parent) {
+ return true;
+ }
+ const node = path$$1.getValue();
+ const body = (parent.body || parent.consequent).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, options) {
+ if (isJSXNode(node)) {
+ return util$1.hasNodeIgnoreComment(node);
+ }
+
+ const res =
+ node.comments &&
+ node.comments.some(
+ comment =>
+ comment.leading && util$1.hasNewline(text, options.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 === "BindExpression" && !node.object) ||
+ (node.type === "UpdateExpression" && !node.prefix)
+ );
+}
+
+function isFlowAnnotationComment(text, typeAnnotation, options) {
+ const start = options.locStart(typeAnnotation);
+ const end = util$1.skipWhitespace(text, options.locEnd(typeAnnotation));
+ return text.substr(start, 2) === "/*" && text.substr(end, 2) === "*/";
+}
+
+function getLeftSide(node) {
+ if (node.expressions) {
+ return node.expressions[0];
+ }
+ return (
+ node.left ||
+ node.test ||
+ node.callee ||
+ node.object ||
+ node.tag ||
+ node.argument ||
+ node.expression
+ );
+}
+
+function getLeftSidePathName(path$$1, node) {
+ if (node.expressions) {
+ return ["expressions", 0];
+ }
+ if (node.left) {
+ return ["left"];
+ }
+ if (node.test) {
+ return ["test"];
+ }
+ if (node.callee) {
+ return ["callee"];
+ }
+ if (node.object) {
+ return ["object"];
+ }
+ if (node.tag) {
+ return ["tag"];
+ }
+ if (node.argument) {
+ return ["argument"];
+ }
+ if (node.expression) {
+ return ["expression"];
+ }
+ throw new Error("Unexpected node has no left side", node);
+}
+
+function exprNeedsASIProtection(path$$1, options) {
+ const node = path$$1.getValue();
+
+ const maybeASIProblem =
+ needsParens_1(path$$1, options) ||
+ node.type === "ParenthesizedExpression" ||
+ node.type === "TypeCastExpression" ||
+ (node.type === "ArrowFunctionExpression" &&
+ !shouldPrintParamsWithoutParens(path$$1, options)) ||
+ node.type === "ArrayExpression" ||
+ node.type === "ArrayPattern" ||
+ (node.type === "UnaryExpression" &&
+ node.prefix &&
+ (node.operator === "+" || node.operator === "-")) ||
+ node.type === "TemplateLiteral" ||
+ node.type === "TemplateElement" ||
+ isJSXNode(node) ||
+ 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 path$$1.call.apply(
+ path$$1,
+ [childPath => exprNeedsASIProtection(childPath, options)].concat(
+ getLeftSidePathName(path$$1, node)
+ )
+ );
+}
+
+function stmtNeedsASIProtection(path$$1, options) {
+ const node = path$$1.getNode();
+
+ if (node.type !== "ExpressionStatement") {
+ return false;
+ }
+
+ return path$$1.call(
+ childPath => exprNeedsASIProtection(childPath, options),
+ "expression"
+ );
+}
+
+function classPropMayCauseASIProblems(path$$1) {
+ const node = path$$1.getNode();
+
+ if (node.type !== "ClassProperty") {
+ return false;
+ }
+
+ const name = node.key && node.key.name;
+
+ // this isn't actually possible yet with most parsers available today
+ // so isn't properly tested yet.
+ if (
+ (name === "static" || name === "get" || name === "set") &&
+ !node.value &&
+ !node.typeAnnotation
+ ) {
+ return true;
+ }
+}
+
+function classChildNeedsASIProtection(node) {
+ if (!node) {
+ return;
+ }
+
+ if (!node.computed) {
+ const name = node.key && node.key.name;
+ if (name === "in" || name === "instanceof") {
+ return true;
+ }
+ }
+ 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:
+ /* istanbul ignore next */
+ 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, options)) {
+ return true;
+ }
+
+ if (hasNakedLeftSide(argument)) {
+ let leftMost = argument;
+ let newLeftMost;
+ while ((newLeftMost = getLeftSide(leftMost))) {
+ leftMost = newLeftMost;
+
+ if (hasLeadingOwnLineComment(options.originalText, leftMost, options)) {
+ 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, options) {
+ return (
+ node.type === "ObjectTypeProperty" &&
+ node.value.type === "FunctionTypeAnnotation" &&
+ !node.static &&
+ !isFunctionNotation(node, options)
+ );
+}
+
+// TODO: This is a bad hack and we need a better way to distinguish between
+// arrow functions and otherwise
+function isFunctionNotation(node, options) {
+ return isGetterOrSetter(node) || sameLocStart(node, node.value, options);
+}
+
+function isGetterOrSetter(node) {
+ return node.kind === "get" || node.kind === "set";
+}
+
+function sameLocStart(nodeA, nodeB, options) {
+ return options.locStart(nodeA) === options.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, options) {
+ return (
+ (node.type === "TypeAnnotation" || node.type === "TSTypeAnnotation") &&
+ node.typeAnnotation.type === "FunctionTypeAnnotation" &&
+ !node.static &&
+ !sameLocStart(node, node.typeAnnotation, options)
+ );
+}
+
+function isNodeStartingWithDeclare(node, options) {
+ if (!(options.parser === "flow" || options.parser === "typescript")) {
+ return false;
+ }
+ return (
+ options.originalText
+ .slice(0, options.locStart(node))
+ .match(/declare[ \t]*$/) ||
+ options.originalText
+ .slice(node.range[0], node.range[1])
+ .startsWith("declare ")
+ );
+}
+
+function shouldHugType(node) {
+ if (isObjectType(node)) {
+ return true;
+ }
+
+ if (node.type === "UnionTypeAnnotation" || node.type === "TSUnionType") {
+ const voidCount = node.types.filter(
+ n =>
+ n.type === "VoidTypeAnnotation" ||
+ n.type === "TSVoidKeyword" ||
+ n.type === "NullLiteralTypeAnnotation" ||
+ n.type === "TSNullKeyword"
+ ).length;
+
+ const objectCount = node.types.filter(
+ n =>
+ n.type === "ObjectTypeAnnotation" ||
+ n.type === "TSTypeLiteral" ||
+ // This is a bit aggressive but captures Array<{x}>
+ n.type === "GenericTypeAnnotation" ||
+ n.type === "TSTypeReference"
+ ).length;
+
+ if (node.types.length - 1 === voidCount && objectCount > 0) {
+ 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 === "ArrayPattern" ||
+ (fun.params[0].type === "Identifier" &&
+ fun.params[0].typeAnnotation &&
+ (fun.params[0].typeAnnotation.type === "TypeAnnotation" ||
+ fun.params[0].typeAnnotation.type === "TSTypeAnnotation") &&
+ isObjectType(fun.params[0].typeAnnotation.typeAnnotation)) ||
+ (fun.params[0].type === "FunctionTypeParam" &&
+ isObjectType(fun.params[0].typeAnnotation)) ||
+ (fun.params[0].type === "AssignmentPattern" &&
+ (fun.params[0].left.type === "ObjectPattern" ||
+ fun.params[0].left.type === "ArrayPattern") &&
+ (fun.params[0].right.type === "Identifier" ||
+ (fun.params[0].right.type === "ObjectExpression" &&
+ fun.params[0].right.properties.length === 0) ||
+ (fun.params[0].right.type === "ArrayExpression" &&
+ fun.params[0].right.elements.length === 0)))) &&
+ !fun.rest
+ );
+}
+
+function templateLiteralHasNewLines(template) {
+ return template.quasis.some(quasi => quasi.value.raw.includes("\n"));
+}
+
+function isTemplateOnItsOwnLine(n, text, options) {
+ return (
+ ((n.type === "TemplateLiteral" && templateLiteralHasNewLines(n)) ||
+ (n.type === "TaggedTemplateExpression" &&
+ templateLiteralHasNewLines(n.quasi))) &&
+ !util$1.hasNewline(text, options.locStart(n), { backwards: true })
+ );
+}
+
+function printArrayItems(path$$1, options, printPath, print) {
+ const printedElements = [];
+ let separatorParts = [];
+
+ path$$1.each(childPath => {
+ printedElements.push(concat(separatorParts));
+ printedElements.push(group(print(childPath)));
+
+ separatorParts = [",", line];
+ if (
+ childPath.getValue() &&
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ childPath.getValue(),
+ options
+ )
+ ) {
+ separatorParts.push(softline);
+ }
+ }, printPath);
+
+ return concat(printedElements);
+}
+
+function hasDanglingComments(node) {
+ return (
+ node.comments &&
+ node.comments.some(comment => !comment.leading && !comment.trailing)
+ );
+}
+
+function needsHardlineAfterDanglingComment(node) {
+ if (!node.comments) {
+ return false;
+ }
+ const lastDanglingComment = util$1.getLast(
+ node.comments.filter(comment => !comment.leading && !comment.trailing)
+ );
+ return (
+ lastDanglingComment && !util$1.isBlockComment(lastDanglingComment)
+ );
+}
+
+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 isNumericLiteral(node) {
+ return (
+ node.type === "NumericLiteral" ||
+ (node.type === "Literal" && typeof node.value === "number")
+ );
+}
+
+function isStringLiteral(node) {
+ return (
+ node.type === "StringLiteral" ||
+ (node.type === "Literal" && typeof node.value === "string")
+ );
+}
+
+function isObjectType(n) {
+ return n.type === "ObjectTypeAnnotation" || n.type === "TSTypeLiteral";
+}
+
+// eg; `describe("some string", (done) => {})`
+function isTestCall(n, parent) {
+ const unitTestRe = /^(skip|(f|x)?(it|describe|test))$/;
+
+ if (n.arguments.length === 1) {
+ if (
+ n.callee.type === "Identifier" &&
+ n.callee.name === "async" &&
+ parent &&
+ parent.type === "CallExpression" &&
+ isTestCall(parent)
+ ) {
+ return isFunctionOrArrowExpression(n.arguments[0].type);
+ }
+
+ if (isUnitTestSetUp(n)) {
+ return (
+ isFunctionOrArrowExpression(n.arguments[0].type) ||
+ isIdentiferAsync(n.arguments[0])
+ );
+ }
+ } else if (n.arguments.length === 2) {
+ if (
+ ((n.callee.type === "Identifier" && unitTestRe.test(n.callee.name)) ||
+ isSkipOrOnlyBlock(n)) &&
+ (isTemplateLiteral(n.arguments[0]) || isStringLiteral(n.arguments[0]))
+ ) {
+ return (
+ (isFunctionOrArrowExpression(n.arguments[1].type) &&
+ n.arguments[1].params.length <= 1) ||
+ isIdentiferAsync(n.arguments[1])
+ );
+ }
+ }
+ return false;
+}
+
+function isSkipOrOnlyBlock(node) {
+ const unitTestRe = /^(skip|(f|x)?(it|describe|test))$/;
+ return (
+ node.callee.type === "MemberExpression" &&
+ node.callee.object.type === "Identifier" &&
+ node.callee.property.type === "Identifier" &&
+ unitTestRe.test(node.callee.object.name) &&
+ (node.callee.property.name === "only" ||
+ node.callee.property.name === "skip")
+ );
+}
+
+function isTemplateLiteral(node) {
+ return node.type === "TemplateLiteral";
+}
+
+function isIdentiferAsync(node) {
+ return (
+ node.type === "CallExpression" &&
+ node.callee.type === "Identifier" &&
+ node.callee.name === "async"
+ );
+}
+
+function isFunctionOrArrowExpression(type) {
+ return type === "FunctionExpression" || type === "ArrowFunctionExpression";
+}
+
+function isUnitTestSetUp(n) {
+ const unitTestSetUpRe = /^(before|after)(Each|All)$/;
+ return (
+ n.callee.type === "Identifier" &&
+ unitTestSetUpRe.test(n.callee.name) &&
+ n.arguments.length === 1
+ );
+}
+
+function isTheOnlyJSXElementInMarkdown(options, path$$1) {
+ if (options.parentParser !== "markdown") {
+ return false;
+ }
+
+ const node = path$$1.getNode();
+
+ if (!node.expression || !isJSXNode(node.expression)) {
+ return false;
+ }
+
+ const parent = path$$1.getParentNode();
+
+ return parent.type === "Program" && parent.body.length == 1;
+}
+
+function willPrintOwnComments(path$$1) {
+ const node = path$$1.getValue();
+ const parent = path$$1.getParentNode();
+
+ return (
+ ((node && isJSXNode(node)) ||
+ (parent &&
+ (parent.type === "JSXSpreadAttribute" ||
+ parent.type === "JSXSpreadChild" ||
+ parent.type === "UnionTypeAnnotation" ||
+ parent.type === "TSUnionType" ||
+ ((parent.type === "ClassDeclaration" ||
+ parent.type === "ClassExpression") &&
+ parent.superClass === node)))) &&
+ !util$1.hasIgnoreComment(path$$1)
+ );
+}
+
+function canAttachComment(node) {
+ return (
+ node.type &&
+ node.type !== "CommentBlock" &&
+ node.type !== "CommentLine" &&
+ node.type !== "Line" &&
+ node.type !== "Block" &&
+ node.type !== "EmptyStatement" &&
+ node.type !== "TemplateElement" &&
+ node.type !== "Import" &&
+ !(node.callee && node.callee.type === "Import")
+ );
+}
+
+function printComment(commentPath, options) {
+ const comment = commentPath.getValue();
+
+ switch (comment.type) {
+ case "CommentBlock":
+ case "Block": {
+ if (isJsDocComment(comment)) {
+ return printJsDocComment(comment);
+ }
+
+ const isInsideFlowComment =
+ options.originalText.substr(options.locEnd(comment) - 3, 3) === "*-/";
+
+ return "/*" + comment.value + (isInsideFlowComment ? "*-/" : "*/");
+ }
+ case "CommentLine":
+ case "Line":
+ // Print shebangs with the proper comment characters
+ if (
+ options.originalText.slice(options.locStart(comment)).startsWith("#!")
+ ) {
+ return "#!" + comment.value.trimRight();
+ }
+ return "//" + comment.value.trimRight();
+ default:
+ throw new Error("Not a comment: " + JSON.stringify(comment));
+ }
+}
+
+function isJsDocComment(comment) {
+ const lines = comment.value.split("\n");
+ return (
+ lines.length > 1 &&
+ lines.slice(0, lines.length - 1).every(line => line.trim()[0] === "*")
+ );
+}
+
+function printJsDocComment(comment) {
+ const lines = comment.value.split("\n");
+
+ return concat([
+ "/*",
+ join(
+ hardline,
+ lines.map(
+ (line, index) =>
+ (index > 0 ? " " : "") +
+ (index < lines.length - 1 ? line.trim() : line.trimLeft())
+ )
+ ),
+ "*/"
+ ]);
+}
+
+function rawText(node) {
+ return node.extra ? node.extra.raw : node.raw;
+}
+
+var printerEstree = {
+ print: genericPrint,
+ embed: embed_1,
+ insertPragma,
+ massageAstNode: clean_1,
+ hasPrettierIgnore,
+ willPrintOwnComments,
+ canAttachComment,
+ printComment,
+ handleComments: {
+ ownLine: comments$2.handleOwnLineComment,
+ endOfLine: comments$2.handleEndOfLineComment,
+ remaining: comments$2.handleRemainingComment
+ }
+};
+
+const CATEGORY_JAVASCRIPT = "JavaScript";
+
+// format based on https://github.com/prettier/prettier/blob/master/src/common/support.js
+var options = {
+ arrowParens: {
+ since: "1.9.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "choice",
+ default: "avoid",
+ description: "Include parentheses around a sole arrow function parameter.",
+ choices: [
+ {
+ value: "avoid",
+ description: "Omit parens when possible. Example: `x => x`"
+ },
+ {
+ value: "always",
+ description: "Always include parens. Example: `(x) => x`"
+ }
+ ]
+ },
+ bracketSpacing: {
+ since: "0.0.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "boolean",
+ default: true,
+ description: "Print spaces between brackets.",
+ oppositeDescription: "Do not print spaces between brackets."
+ },
+ jsxBracketSameLine: {
+ since: "0.17.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "boolean",
+ default: false,
+ description: "Put > on the last line instead of at a new line."
+ },
+ semi: {
+ since: "1.0.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "boolean",
+ default: true,
+ description: "Print semicolons.",
+ oppositeDescription:
+ "Do not print semicolons, except at the beginning of lines which may need them."
+ },
+ singleQuote: {
+ since: "0.0.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "boolean",
+ default: false,
+ description: "Use single quotes instead of double quotes."
+ },
+ trailingComma: {
+ since: "0.0.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "choice",
+ default: [
+ { since: "0.0.0", value: false },
+ { since: "0.19.0", value: "none" }
+ ],
+ description: "Print trailing commas wherever possible when multi-line.",
+ choices: [
+ { value: "none", description: "No trailing commas." },
+ {
+ value: "es5",
+ description:
+ "Trailing commas where valid in ES5 (objects, arrays, etc.)"
+ },
+ {
+ value: "all",
+ description:
+ "Trailing commas wherever possible (including function arguments)."
+ },
+ { value: true, deprecated: "0.19.0", redirect: "es5" },
+ { value: false, deprecated: "0.19.0", redirect: "none" }
+ ]
+ }
+};
+
+const hasPragma = pragma.hasPragma;
+
+
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const locStart = function(node) {
+ // Handle nodes with decorators. They should start at the first decorator
+ if (
+ node.declaration &&
+ node.declaration.decorators &&
+ node.declaration.decorators.length > 0
+ ) {
+ return locStart(node.declaration.decorators[0]);
+ }
+ if (node.decorators && node.decorators.length > 0) {
+ return locStart(node.decorators[0]);
+ }
+
+ if (node.__location) {
+ return node.__location.startOffset;
+ }
+ if (node.range) {
+ return node.range[0];
+ }
+ if (typeof node.start === "number") {
+ return node.start;
+ }
+ if (node.loc) {
+ return node.loc.start;
+ }
+ return null;
+};
+
+const locEnd = function(node) {
+ const endNode = node.nodes && util$1.getLast(node.nodes);
+ if (endNode && node.source && !node.source.end) {
+ node = endNode;
+ }
+
+ let loc;
+ if (node.range) {
+ loc = node.range[1];
+ } else if (typeof node.end === "number") {
+ loc = node.end;
+ }
+
+ if (node.__location) {
+ return node.__location.endOffset;
+ }
+ if (node.typeAnnotation) {
+ return Math.max(loc, locEnd(node.typeAnnotation));
+ }
+
+ if (node.loc && !loc) {
+ return node.loc.end;
+ }
+
+ return loc;
+};
+
+const languages = [
+ {
+ name: "JavaScript",
+ since: "0.0.0",
+ parsers: ["babylon", "flow"],
+ group: "JavaScript",
+ tmScope: "source.js",
+ aceMode: "javascript",
+ codemirrorMode: "javascript",
+ codemirrorMimeType: "text/javascript",
+ aliases: ["js", "node"],
+ extensions: [
+ ".js",
+ "._js",
+ ".bones",
+ ".es",
+ ".es6",
+ ".frag",
+ ".gs",
+ ".jake",
+ ".jsb",
+ ".jscad",
+ ".jsfl",
+ ".jsm",
+ ".jss",
+ ".mjs",
+ ".njs",
+ ".pac",
+ ".sjs",
+ ".ssjs",
+ ".xsjs",
+ ".xsjslib"
+ ],
+ filenames: ["Jakefile"],
+ linguistLanguageId: 183,
+ vscodeLanguageIds: ["javascript"]
+ },
+ {
+ name: "JSX",
+ since: "0.0.0",
+ parsers: ["babylon", "flow"],
+ group: "JavaScript",
+ extensions: [".jsx"],
+ tmScope: "source.js.jsx",
+ aceMode: "javascript",
+ codemirrorMode: "jsx",
+ codemirrorMimeType: "text/jsx",
+ liguistLanguageId: 178,
+ vscodeLanguageIds: ["javascriptreact"]
+ },
+ {
+ name: "TypeScript",
+ since: "1.4.0",
+ parsers: ["typescript-eslint"],
+ group: "JavaScript",
+ aliases: ["ts"],
+ extensions: [".ts", ".tsx"],
+ tmScope: "source.ts",
+ aceMode: "typescript",
+ codemirrorMode: "javascript",
+ codemirrorMimeType: "application/typescript",
+ liguistLanguageId: 378,
+ vscodeLanguageIds: ["typescript", "typescriptreact"]
+ },
+ {
+ name: "JSON",
+ since: "1.5.0",
+ parsers: ["json"],
+ group: "JavaScript",
+ tmScope: "source.json",
+ aceMode: "json",
+ codemirrorMode: "javascript",
+ codemirrorMimeType: "application/json",
+ extensions: [
+ ".json",
+ ".json5",
+ ".geojson",
+ ".JSON-tmLanguage",
+ ".topojson"
+ ],
+ filenames: [
+ ".arcconfig",
+ ".jshintrc",
+ ".babelrc",
+ ".eslintrc",
+ ".prettierrc",
+ "composer.lock",
+ "mcmod.info"
+ ],
+ linguistLanguageId: 174,
+ vscodeLanguageIds: ["json", "jsonc"]
+ }
+];
+
+const typescript = {
+ get parse() {
+ return require("./parser-typescript");
+ },
+ astFormat: "estree",
+ hasPragma,
+ locStart,
+ locEnd
+};
+
+const babylon = {
+ get parse() {
+ return require("./parser-babylon");
+ },
+ astFormat: "estree",
+ hasPragma,
+ locStart,
+ locEnd
+};
+
+const parsers = {
+ babylon,
+ json: Object.assign({}, babylon, {
+ hasPragma() {
+ return false;
+ }
+ }),
+ flow: {
+ get parse() {
+ return require("./parser-flow");
+ },
+ astFormat: "estree",
+ hasPragma,
+ locStart,
+ locEnd
+ },
+ "typescript-eslint": typescript,
+ // TODO: Delete this in 2.0
+ typescript
+};
+
+const printers = {
+ estree: printerEstree
+};
+
+var languageJs = {
+ languages,
+ options,
+ parsers,
+ printers,
+ locStart,
+ locEnd
+};
+
+var index$1 = [
+ "a",
+ "abbr",
+ "acronym",
+ "address",
+ "applet",
+ "area",
+ "article",
+ "aside",
+ "audio",
+ "b",
+ "base",
+ "basefont",
+ "bdi",
+ "bdo",
+ "bgsound",
+ "big",
+ "blink",
+ "blockquote",
+ "body",
+ "br",
+ "button",
+ "canvas",
+ "caption",
+ "center",
+ "cite",
+ "code",
+ "col",
+ "colgroup",
+ "command",
+ "content",
+ "data",
+ "datalist",
+ "dd",
+ "del",
+ "details",
+ "dfn",
+ "dialog",
+ "dir",
+ "div",
+ "dl",
+ "dt",
+ "element",
+ "em",
+ "embed",
+ "fieldset",
+ "figcaption",
+ "figure",
+ "font",
+ "footer",
+ "form",
+ "frame",
+ "frameset",
+ "h1",
+ "h2",
+ "h3",
+ "h4",
+ "h5",
+ "h6",
+ "head",
+ "header",
+ "hgroup",
+ "hr",
+ "html",
+ "i",
+ "iframe",
+ "image",
+ "img",
+ "input",
+ "ins",
+ "isindex",
+ "kbd",
+ "keygen",
+ "label",
+ "legend",
+ "li",
+ "link",
+ "listing",
+ "main",
+ "map",
+ "mark",
+ "marquee",
+ "math",
+ "menu",
+ "menuitem",
+ "meta",
+ "meter",
+ "multicol",
+ "nav",
+ "nextid",
+ "nobr",
+ "noembed",
+ "noframes",
+ "noscript",
+ "object",
+ "ol",
+ "optgroup",
+ "option",
+ "output",
+ "p",
+ "param",
+ "picture",
+ "plaintext",
+ "pre",
+ "progress",
+ "q",
+ "rb",
+ "rbc",
+ "rp",
+ "rt",
+ "rtc",
+ "ruby",
+ "s",
+ "samp",
+ "script",
+ "section",
+ "select",
+ "shadow",
+ "slot",
+ "small",
+ "source",
+ "spacer",
+ "span",
+ "strike",
+ "strong",
+ "style",
+ "sub",
+ "summary",
+ "sup",
+ "svg",
+ "table",
+ "tbody",
+ "td",
+ "template",
+ "textarea",
+ "tfoot",
+ "th",
+ "thead",
+ "time",
+ "title",
+ "tr",
+ "track",
+ "tt",
+ "u",
+ "ul",
+ "var",
+ "video",
+ "wbr",
+ "xmp"
+]
+;
+
+var htmlTagNames = Object.freeze({
+ default: index$1
+});
+
+var htmlTagNames$1 = ( htmlTagNames && index$1 ) || htmlTagNames;
+
+function clean$2(ast, newObj) {
+ if (
+ ast.type === "media-query" ||
+ ast.type === "media-query-list" ||
+ ast.type === "media-feature-expression"
+ ) {
+ delete newObj.value;
+ }
+
+ if (ast.type === "css-rule") {
+ delete newObj.params;
+ }
+
+ if (ast.type === "selector-combinator") {
+ newObj.value = newObj.value.replace(/\s+/g, " ");
+ }
+
+ if (ast.type === "media-feature") {
+ newObj.value = newObj.value.replace(/ /g, "");
+ }
+
+ if (
+ (ast.type === "value-word" &&
+ ((ast.isColor && ast.isHex) ||
+ ["initial", "inherit", "unset", "revert"].indexOf(
+ newObj.value.replace().toLowerCase()
+ ) !== -1)) ||
+ ast.type === "media-feature" ||
+ ast.type === "selector-root-invalid" ||
+ ast.type === "selector-pseudo"
+ ) {
+ newObj.value = newObj.value.toLowerCase();
+ }
+ if (ast.type === "css-decl") {
+ newObj.prop = newObj.prop.toLowerCase();
+ }
+ if (ast.type === "css-atrule" || ast.type === "css-import") {
+ newObj.name = newObj.name.toLowerCase();
+ }
+ if (ast.type === "value-number") {
+ newObj.unit = newObj.unit.toLowerCase();
+ }
+
+ if (
+ (ast.type === "media-feature" ||
+ ast.type === "media-keyword" ||
+ ast.type === "media-type" ||
+ ast.type === "media-unknown" ||
+ ast.type === "media-url" ||
+ ast.type === "media-value" ||
+ ast.type === "selector-root-invalid" ||
+ ast.type === "selector-attribute" ||
+ ast.type === "selector-string" ||
+ ast.type === "selector-class" ||
+ ast.type === "selector-combinator" ||
+ ast.type === "value-string") &&
+ newObj.value
+ ) {
+ newObj.value = cleanCSSStrings(newObj.value);
+ }
+
+ if (ast.type === "css-import" && newObj.importPath) {
+ newObj.importPath = cleanCSSStrings(newObj.importPath);
+ }
+
+ if (ast.type === "selector-attribute") {
+ newObj.attribute = newObj.attribute.trim();
+
+ if (newObj.namespace) {
+ if (typeof newObj.namespace === "string") {
+ newObj.namespace = newObj.namespace.trim();
+
+ if (newObj.namespace.length === 0) {
+ newObj.namespace = true;
+ }
+ }
+ }
+
+ if (newObj.value) {
+ newObj.value = newObj.value.trim().replace(/^['"]|['"]$/g, "");
+ delete newObj.quoted;
+ }
+ }
+
+ if (
+ (ast.type === "media-value" ||
+ ast.type === "media-type" ||
+ ast.type === "value-number" ||
+ ast.type === "selector-root-invalid" ||
+ ast.type === "selector-class" ||
+ ast.type === "selector-combinator" ||
+ ast.type === "selector-tag") &&
+ newObj.value
+ ) {
+ newObj.value = newObj.value.replace(
+ /([\d.eE+-]+)([a-zA-Z]*)/g,
+ (match, numStr, unit) => {
+ const num = Number(numStr);
+ return isNaN(num) ? match : num + unit.toLowerCase();
+ }
+ );
+ }
+
+ if (ast.type === "media-url") {
+ newObj.value = newObj.value
+ .replace(/^url\(\s+/gi, "url(")
+ .replace(/\s+\)$/gi, ")");
+ }
+
+ if (ast.type === "selector-tag") {
+ const lowercasedValue = ast.value.toLowerCase();
+
+ if (htmlTagNames$1.indexOf(lowercasedValue) !== -1) {
+ newObj.value = lowercasedValue;
+ }
+
+ if (["from", "to"].indexOf(lowercasedValue) !== -1) {
+ newObj.value = lowercasedValue;
+ }
+ }
+}
+
+function cleanCSSStrings(value) {
+ return value.replace(/'/g, '"').replace(/\\([^a-fA-F\d])/g, "$1");
+}
+
+var clean_1$2 = clean$2;
+
+const docBuilders$6 = doc.builders;
+const concat$5 = docBuilders$6.concat;
+const join$4 = docBuilders$6.join;
+const line$2 = docBuilders$6.line;
+const hardline$4 = docBuilders$6.hardline;
+const softline$3 = docBuilders$6.softline;
+const group$2 = docBuilders$6.group;
+const fill$3 = docBuilders$6.fill;
+const indent$4 = docBuilders$6.indent;
+
+const removeLines$1 = doc.utils.removeLines;
+
+function genericPrint$1(path$$1, options, print) {
+ const node = path$$1.getValue();
+
+ /* istanbul ignore if */
+ if (!node) {
+ return "";
+ }
+
+ if (typeof node === "string") {
+ return node;
+ }
+
+ switch (node.type) {
+ case "css-comment-yaml":
+ return node.value;
+ case "css-root": {
+ const nodes = printNodeSequence(path$$1, options, print);
+
+ if (nodes.parts.length) {
+ return concat$5([nodes, hardline$4]);
+ }
+
+ return nodes;
+ }
+ case "css-comment": {
+ if (node.raws.content) {
+ return node.raws.content;
+ }
+ const text = options.originalText.slice(
+ options.locStart(node),
+ options.locEnd(node)
+ );
+ const rawText = node.raws.text || node.text;
+ // Workaround a bug where the location is off.
+ // https://github.com/postcss/postcss-scss/issues/63
+ if (text.indexOf(rawText) === -1) {
+ if (node.raws.inline) {
+ return concat$5(["// ", rawText]);
+ }
+ return concat$5(["/* ", rawText, " */"]);
+ }
+ return text;
+ }
+ case "css-rule": {
+ return concat$5([
+ path$$1.call(print, "selector"),
+ node.important ? " !important" : "",
+ node.nodes
+ ? concat$5([
+ " {",
+ node.nodes.length > 0
+ ? indent$4(
+ concat$5([hardline$4, printNodeSequence(path$$1, options, print)])
+ )
+ : "",
+ hardline$4,
+ "}",
+ isDetachedRulesetDeclaration(node) ? ";" : ""
+ ])
+ : ";"
+ ]);
+ }
+ case "css-decl": {
+ // When the following less construct &:extend(.foo); is parsed with scss,
+ // it will put a space after `:` and break it. Ideally we should parse
+ // less files with less, but we can hardcode this to work with scss as
+ // well.
+ const isValueExtend =
+ node.value.type === "value-root" &&
+ node.value.group.type === "value-value" &&
+ node.value.group.group.type === "value-func" &&
+ node.value.group.group.value === "extend";
+ const isComposed =
+ node.value.type === "value-root" &&
+ node.value.group.type === "value-value" &&
+ node.prop === "composes";
+ const ruleAncestorNode = getAncestorNode(path$$1, "css-rule");
+ const isiCSS =
+ ruleAncestorNode &&
+ ruleAncestorNode.raws.selector &&
+ (ruleAncestorNode.raws.selector.startsWith(":import") ||
+ ruleAncestorNode.raws.selector.startsWith(":export"));
+
+ return concat$5([
+ node.raws.before.replace(/[\s;]/g, ""),
+ isiCSS ? node.prop : maybeToLowerCase(node.prop),
+ node.raws.between.trim() === ":" ? ":" : node.raws.between.trim(),
+ isValueExtend ? "" : " ",
+ isComposed
+ ? removeLines$1(path$$1.call(print, "value"))
+ : path$$1.call(print, "value"),
+ node.raws.important
+ ? node.raws.important.replace(/\s*!\s*important/i, " !important")
+ : node.important
+ ? " !important"
+ : "",
+ node.raws.scssDefault
+ ? node.raws.scssDefault.replace(/\s*!default/i, " !default")
+ : node.scssDefault
+ ? " !default"
+ : "",
+ node.raws.scssGlobal
+ ? node.raws.scssGlobal.replace(/\s*!global/i, " !global")
+ : node.scssGlobal
+ ? " !global"
+ : "",
+ node.nodes
+ ? concat$5([
+ " {",
+ indent$4(
+ concat$5([softline$3, printNodeSequence(path$$1, options, print)])
+ ),
+ softline$3,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ case "css-atrule": {
+ const hasParams =
+ node.params &&
+ !(node.params.type === "media-query-list" && node.params.value === "");
+ const isDetachedRulesetCall = hasParams && /^\(\s*\)$/.test(node.params);
+ const hasParensAround =
+ node.value &&
+ node.value.group.group.type === "value-paren_group" &&
+ node.value.group.group.open !== null &&
+ node.value.group.group.close !== null;
+
+ return concat$5([
+ "@",
+ // If a Less file ends up being parsed with the SCSS parser, Less
+ // variable declarations will be parsed as atrules with names ending
+ // with a colon, so keep the original case then.
+ isDetachedRulesetCall || node.name.endsWith(":")
+ ? node.name
+ : maybeToLowerCase(node.name),
+ hasParams
+ ? concat$5([
+ isDetachedRulesetCall ? "" : " ",
+ path$$1.call(print, "params")
+ ])
+ : "",
+ node.selector
+ ? indent$4(concat$5([" ", path$$1.call(print, "selector")]))
+ : "",
+ node.value
+ ? group$2(
+ concat$5([
+ " ",
+ path$$1.call(print, "value"),
+ isControlDirectiveNode(node)
+ ? hasParensAround
+ ? " "
+ : line$2
+ : ""
+ ])
+ )
+ : node.name === "else"
+ ? " "
+ : "",
+ node.nodes
+ ? concat$5([
+ isControlDirectiveNode(node) ? "" : " ",
+ "{",
+ indent$4(
+ concat$5([
+ node.nodes.length > 0 ? softline$3 : "",
+ printNodeSequence(path$$1, options, print)
+ ])
+ ),
+ softline$3,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ case "css-import": {
+ return concat$5([
+ "@",
+ maybeToLowerCase(node.name),
+ " ",
+ node.directives ? concat$5([node.directives, " "]) : "",
+ adjustStrings(node.importPath, options),
+ node.nodes.length > 0
+ ? concat$5([
+ " {",
+ indent$4(
+ concat$5([softline$3, printNodeSequence(path$$1, options, print)])
+ ),
+ softline$3,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ // postcss-media-query-parser
+ case "media-query-list": {
+ const parts = [];
+ path$$1.each(childPath => {
+ const node = childPath.getValue();
+ if (node.type === "media-query" && node.value === "") {
+ return;
+ }
+ parts.push(childPath.call(print));
+ }, "nodes");
+
+ return group$2(indent$4(join$4(line$2, parts)));
+ }
+ case "media-query": {
+ return concat$5([
+ join$4(" ", path$$1.map(print, "nodes")),
+ isLastNode(path$$1, node) ? "" : ","
+ ]);
+ }
+ case "media-type": {
+ const atRuleAncestorNode = getAncestorNode(path$$1, "css-atrule");
+ if (
+ atRuleAncestorNode &&
+ atRuleAncestorNode.name.toLowerCase() === "charset"
+ ) {
+ return node.value;
+ }
+ return adjustNumbers(adjustStrings(node.value, options));
+ }
+ case "media-feature-expression": {
+ if (!node.nodes) {
+ return node.value;
+ }
+ return concat$5(["(", concat$5(path$$1.map(print, "nodes")), ")"]);
+ }
+ case "media-feature": {
+ return maybeToLowerCase(
+ adjustStrings(node.value.replace(/ +/g, " "), options)
+ );
+ }
+ case "media-colon": {
+ return concat$5([node.value, " "]);
+ }
+ case "media-value": {
+ return adjustNumbers(adjustStrings(node.value, options));
+ }
+ case "media-keyword": {
+ return adjustStrings(node.value, options);
+ }
+ case "media-url": {
+ return adjustStrings(
+ node.value.replace(/^url\(\s+/gi, "url(").replace(/\s+\)$/gi, ")"),
+ options
+ );
+ }
+ case "media-unknown": {
+ return adjustStrings(node.value, options);
+ }
+ // postcss-selector-parser
+ case "selector-root-invalid": {
+ // This is likely a SCSS nested property: `background: { color: red; }`.
+ return adjustNumbers(
+ adjustStrings(maybeToLowerCase(node.value), options)
+ );
+ }
+ case "selector-root": {
+ const atRuleAncestorNode = getAncestorNode(path$$1, "css-atrule");
+ const insideAtRuleNode =
+ atRuleAncestorNode &&
+ ["extend", "custom-selector", "nest"].indexOf(
+ atRuleAncestorNode.name
+ ) !== -1;
+
+ return group$2(
+ concat$5([
+ atRuleAncestorNode && atRuleAncestorNode.name === "custom-selector"
+ ? concat$5([atRuleAncestorNode.customSelector, line$2])
+ : "",
+ join$4(
+ concat$5([",", insideAtRuleNode ? line$2 : hardline$4]),
+ path$$1.map(print, "nodes")
+ )
+ ])
+ );
+ }
+ case "selector-comment": {
+ return node.value;
+ }
+ case "selector-string": {
+ return adjustStrings(node.value, options);
+ }
+ case "selector-tag": {
+ const parentNode = path$$1.getParentNode();
+ const index = parentNode && parentNode.nodes.indexOf(node);
+ const prevNode = index && parentNode.nodes[index - 1];
+
+ return concat$5([
+ node.namespace
+ ? concat$5([node.namespace === true ? "" : node.namespace.trim(), "|"])
+ : "",
+ prevNode.type === "selector-nesting"
+ ? node.value
+ : adjustNumbers(
+ isHTMLTag(node.value) ||
+ isKeyframeAtRuleKeywords(path$$1, node.value)
+ ? node.value.toLowerCase()
+ : node.value
+ )
+ ]);
+ }
+ case "selector-id": {
+ return concat$5(["#", node.value]);
+ }
+ case "selector-class": {
+ return concat$5([".", adjustNumbers(adjustStrings(node.value, options))]);
+ }
+ case "selector-attribute": {
+ return concat$5([
+ "[",
+ node.namespace
+ ? concat$5([node.namespace === true ? "" : node.namespace.trim(), "|"])
+ : "",
+ node.attribute.trim(),
+ node.operator ? node.operator : "",
+ node.value
+ ? quoteAttributeValue(
+ adjustStrings(node.value.trim(), options),
+ options
+ )
+ : "",
+ node.insensitive ? " i" : "",
+ "]"
+ ]);
+ }
+ case "selector-combinator": {
+ if (
+ node.value === "+" ||
+ node.value === ">" ||
+ node.value === "~" ||
+ node.value === ">>>"
+ ) {
+ const parentNode = path$$1.getParentNode();
+ const leading =
+ parentNode.type === "selector-selector" &&
+ parentNode.nodes[0] === node
+ ? ""
+ : line$2;
+ return concat$5([leading, node.value, isLastNode(path$$1, node) ? "" : " "]);
+ }
+ const leading = node.value.trim().startsWith("(") ? line$2 : "";
+ const value =
+ adjustNumbers(adjustStrings(node.value.trim(), options)) || line$2;
+ return concat$5([leading, value]);
+ }
+ case "selector-universal": {
+ return concat$5([
+ node.namespace
+ ? concat$5([node.namespace === true ? "" : node.namespace.trim(), "|"])
+ : "",
+ adjustNumbers(node.value)
+ ]);
+ }
+ case "selector-selector": {
+ return group$2(indent$4(concat$5(path$$1.map(print, "nodes"))));
+ }
+ case "selector-pseudo": {
+ return concat$5([
+ maybeToLowerCase(node.value),
+ node.nodes && node.nodes.length > 0
+ ? concat$5(["(", join$4(", ", path$$1.map(print, "nodes")), ")"])
+ : ""
+ ]);
+ }
+ case "selector-nesting": {
+ return node.value;
+ }
+ // postcss-values-parser
+ case "value-root": {
+ return path$$1.call(print, "group");
+ }
+ case "value-comment": {
+ return concat$5([
+ node.inline ? "//" : "/*",
+ node.value,
+ node.inline ? "" : "*/"
+ ]);
+ }
+ case "value-comma_group": {
+ const parentNode = path$$1.getParentNode();
+ const declAncestorNode = getAncestorNode(path$$1, "css-decl");
+ const declAncestorProp =
+ declAncestorNode &&
+ declAncestorNode.prop &&
+ declAncestorNode.prop.toLowerCase();
+ const isGridValue =
+ declAncestorProp &&
+ parentNode.type === "value-value" &&
+ (declAncestorProp === "grid" ||
+ declAncestorProp.startsWith("grid-template"));
+ const atRuleAncestorNode = getAncestorNode(path$$1, "css-atrule");
+ const isControlDirective =
+ atRuleAncestorNode && isControlDirectiveNode(atRuleAncestorNode);
+
+ const printed = path$$1.map(print, "groups");
+ const parts = [];
+ const functionAncestorNode = getAncestorNode(path$$1, "value-func");
+ const insideInFunction =
+ functionAncestorNode && functionAncestorNode.value;
+ const insideURLFunction =
+ insideInFunction && functionAncestorNode.value.toLowerCase() === "url";
+
+ let didBreak = false;
+ for (let i = 0; i < node.groups.length; ++i) {
+ parts.push(printed[i]);
+
+ // Ignore value inside `url()`
+ if (insideURLFunction) {
+ continue;
+ }
+
+ const iPrevNode = node.groups[i - 1];
+ const iNode = node.groups[i];
+ const iNextNode = node.groups[i + 1];
+ const iNextNextNode = node.groups[i + 2];
+
+ // Ignore after latest node (i.e. before semicolon)
+ if (!iNextNode) {
+ continue;
+ }
+
+ // Ignore colon
+ if (iNode.value === ":") {
+ continue;
+ }
+
+ // Ignore `@` in Less (i.e. `@@var;`)
+ if (iNode.type === "value-atword" && iNode.value === "") {
+ continue;
+ }
+
+ // Ignore `~` in Less (i.e. `content: ~"^//* some horrible but needed css hack";`)
+ if (iNode.value === "~") {
+ continue;
+ }
+
+ if (
+ (iPrevNode &&
+ iPrevNode.type === "value-comment" &&
+ iPrevNode.inline) ||
+ (iNextNode.type === "value-comment" && iNextNode.inline)
+ ) {
+ continue;
+ }
+
+ const isHash = iNode.type === "value-word" && iNode.value === "#";
+ const isLeftCurlyBrace =
+ iNode.type === "value-word" && iNode.value === "{";
+ const isNextLeftCurlyBrace =
+ iNextNode.type === "value-word" && iNextNode.value === "{";
+ const isRightCurlyBrace =
+ iNode.type === "value-word" && iNode.value === "}";
+ const isNextRightCurlyBrace =
+ iNextNode.type === "value-word" && iNextNode.value === "}";
+
+ // Ignore interpolation in SCSS (i.e. ``#{variable}``)
+ if (
+ isHash ||
+ isLeftCurlyBrace ||
+ isNextRightCurlyBrace ||
+ (isNextLeftCurlyBrace &&
+ iNextNode.raws &&
+ iNextNode.raws.before === "") ||
+ (isRightCurlyBrace && iNextNode.raws && iNextNode.raws.before === "")
+ ) {
+ continue;
+ }
+
+ const isNextHash =
+ iNextNode.type === "value-word" && iNextNode.value === "#";
+
+ const isMathOperator = isMathOperatorNode(iNode);
+ const isNextMathOperator = isMathOperatorNode(iNextNode);
+
+ const isMultiplication =
+ !isNextHash && isMathOperator && iNode.value === "*";
+ const isNextMultiplication =
+ !isRightCurlyBrace && isNextMathOperator && iNextNode.value === "*";
+
+ const isDivision = !isNextHash && isMathOperator && iNode.value === "/";
+ const isNextDivision =
+ !isRightCurlyBrace && isNextMathOperator && iNextNode.value === "/";
+
+ const isAddition = !isNextHash && isMathOperator && iNode.value === "+";
+ const isNextAddition =
+ !isRightCurlyBrace && isNextMathOperator && iNextNode.value === "+";
+
+ const isPrevFunction = iPrevNode && iPrevNode.type === "value-func";
+ const isFunction = iNode.type === "value-func";
+ const isNextFunction = iNextNode.type === "value-func";
+ const isNextNextFunction =
+ iNextNextNode && iNextNextNode.type === "value-func";
+
+ const isPrevWord =
+ iPrevNode &&
+ ["value-word", "value-atword"].indexOf(iPrevNode.type) !== -1;
+ const isWord =
+ ["value-word", "value-atword"].indexOf(iNode.type) !== -1;
+ const isNextWord =
+ ["value-word", "value-atword"].indexOf(iNextNode.type) !== -1;
+ const isNextNextWord =
+ iNextNextNode &&
+ ["value-word", "value-atword"].indexOf(iNextNextNode.type) !== -1;
+
+ // Math operators
+ const insideCalcFunction =
+ insideInFunction &&
+ functionAncestorNode.value.toLowerCase() === "calc";
+
+ const hasSpaceBeforeOperator =
+ isNextNextFunction || isNextNextWord || isFunction || isWord;
+
+ const hasSpaceAfterOperator =
+ isNextFunction || isNextWord || isPrevFunction || isPrevWord;
+
+ if (
+ (isMathOperator || isNextMathOperator) &&
+ // Multiplication
+ !isMultiplication &&
+ !isNextMultiplication &&
+ // Division
+ !(isNextDivision && (hasSpaceBeforeOperator || insideCalcFunction)) &&
+ !(isDivision && (hasSpaceAfterOperator || insideCalcFunction)) &&
+ // Addition
+ !(isNextAddition && hasSpaceBeforeOperator) &&
+ !(isAddition && hasSpaceAfterOperator)
+ ) {
+ const isNextParenGroup = isParenGroupNode(iNextNode);
+ const isNextValueNumber = iNextNode.type === "value-number";
+
+ if (
+ (iNextNode.raws && iNextNode.raws.before === "") ||
+ (isMathOperator &&
+ (isNextParenGroup ||
+ isNextWord ||
+ isNextValueNumber ||
+ isMathOperatorNode(iNextNode)) &&
+ (!iPrevNode || (iPrevNode && isMathOperatorNode(iPrevNode))))
+ ) {
+ continue;
+ }
+ }
+
+ const isEqualityOperator =
+ isControlDirective && isEqualityOperatorNode(iNode);
+ const isRelationalOperator =
+ isControlDirective && isRelationalOperatorNode(iNode);
+ const isNextEqualityOperator =
+ isControlDirective && isEqualityOperatorNode(iNextNode);
+ const isNextRelationalOperator =
+ isControlDirective && isRelationalOperatorNode(iNextNode);
+ const isNextIfElseKeyword =
+ isControlDirective && isIfElseKeywordNode(iNextNode);
+ const isEachKeyword = isControlDirective && isEachKeywordNode(iNode);
+ const isNextEachKeyword =
+ isControlDirective && isEachKeywordNode(iNextNode);
+ const isForKeyword =
+ atRuleAncestorNode &&
+ atRuleAncestorNode.name === "for" &&
+ isForKeywordNode(iNode);
+ const isNextForKeyword =
+ isControlDirective && isForKeywordNode(iNextNode);
+ const IsNextColon = iNextNode.value === ":";
+
+ if (isGridValue) {
+ if (iNode.source.start.line !== iNextNode.source.start.line) {
+ parts.push(hardline$4);
+ didBreak = true;
+ } else {
+ parts.push(" ");
+ }
+ } else if (iNode.type === "value-comment" && iNode.inline) {
+ parts.push(hardline$4);
+ } else if (
+ isNextMathOperator ||
+ isNextEqualityOperator ||
+ isNextRelationalOperator ||
+ isNextIfElseKeyword ||
+ isForKeyword ||
+ isEachKeyword
+ ) {
+ parts.push(" ");
+ } else if (
+ !IsNextColon ||
+ isEqualityOperator ||
+ isRelationalOperator ||
+ isNextForKeyword ||
+ isNextEachKeyword
+ ) {
+ parts.push(line$2);
+ }
+ }
+
+ if (didBreak) {
+ parts.unshift(hardline$4);
+ }
+
+ if (isControlDirective) {
+ return group$2(indent$4(concat$5(parts)));
+ }
+
+ return group$2(indent$4(fill$3(parts)));
+ }
+ case "value-paren_group": {
+ const parentNode = path$$1.getParentNode();
+ const isURLCall =
+ parentNode &&
+ parentNode.type === "value-func" &&
+ parentNode.value === "url";
+
+ if (
+ isURLCall &&
+ (node.groups.length === 1 ||
+ (node.groups.length > 0 &&
+ node.groups[0].type === "value-comma_group" &&
+ node.groups[0].groups.length > 0 &&
+ node.groups[0].groups[0].type === "value-word" &&
+ node.groups[0].groups[0].value.startsWith("data:")))
+ ) {
+ return concat$5([
+ node.open ? path$$1.call(print, "open") : "",
+ join$4(",", path$$1.map(print, "groups")),
+ node.close ? path$$1.call(print, "close") : ""
+ ]);
+ }
+
+ if (!node.open) {
+ const printed = path$$1.map(print, "groups");
+ const res = [];
+
+ for (let i = 0; i < printed.length; i++) {
+ if (i !== 0) {
+ res.push(concat$5([",", line$2]));
+ }
+ res.push(printed[i]);
+ }
+ return group$2(indent$4(fill$3(res)));
+ }
+
+ const declNode = path$$1.getParentNode(2);
+ const isMap =
+ declNode &&
+ declNode.type === "css-decl" &&
+ declNode.prop.startsWith("$");
+
+ return group$2(
+ concat$5([
+ node.open ? path$$1.call(print, "open") : "",
+ indent$4(
+ concat$5([
+ softline$3,
+ join$4(
+ concat$5([",", isMap ? hardline$4 : line$2]),
+ path$$1.map(print, "groups")
+ )
+ ])
+ ),
+ softline$3,
+ node.close ? path$$1.call(print, "close") : ""
+ ])
+ );
+ }
+ case "value-value": {
+ return path$$1.call(print, "group");
+ }
+ case "value-func": {
+ return concat$5([node.value, path$$1.call(print, "group")]);
+ }
+ case "value-paren": {
+ return node.value;
+ }
+ case "value-number": {
+ return concat$5([printNumber$1(node.value), maybeToLowerCase(node.unit)]);
+ }
+ case "value-operator": {
+ return node.value;
+ }
+ case "value-word": {
+ if ((node.isColor && node.isHex) || isWideKeywords(node.value)) {
+ return node.value.toLowerCase();
+ }
+ return node.value;
+ }
+ case "value-colon": {
+ return concat$5([node.value, insideURLFunctionNode(path$$1) ? "" : line$2]);
+ }
+ case "value-comma": {
+ return concat$5([node.value, " "]);
+ }
+ case "value-string": {
+ return util$1.printString(
+ node.raws.quote + node.value + node.raws.quote,
+ options
+ );
+ }
+ case "value-atword": {
+ return concat$5(["@", node.value]);
+ }
+ case "value-unicode-range": {
+ return node.value;
+ }
+ default:
+ /* istanbul ignore next */
+ throw new Error(`Unknown postcss type ${JSON.stringify(node.type)}`);
+ }
+}
+
+function isLastNode(path$$1, node) {
+ const parentNode = path$$1.getParentNode();
+ if (!parentNode) {
+ return false;
+ }
+ const nodes = parentNode.nodes;
+ return nodes && nodes.indexOf(node) === nodes.length - 1;
+}
+
+function isDetachedRulesetDeclaration(node) {
+ // If a Less file ends up being parsed with the SCSS parser, Less
+ // variable declarations will be parsed as atrules with names ending
+ // with a colon, so keep the original case then.
+ return (
+ node.selector &&
+ node.selector.type !== "selector-root-invalid" &&
+ ((typeof node.selector === "string" && /^@.+:.*$/.test(node.selector)) ||
+ (node.selector.value && /^@.+:.*$/.test(node.selector.value)))
+ );
+}
+
+function isKeyframeAtRuleKeywords(path$$1, value) {
+ const atRuleAncestorNode = getAncestorNode(path$$1, "css-atrule");
+ return (
+ atRuleAncestorNode &&
+ atRuleAncestorNode.name &&
+ atRuleAncestorNode.name.toLowerCase().endsWith("keyframes") &&
+ ["from", "to"].indexOf(value.toLowerCase()) !== -1
+ );
+}
+
+function isHTMLTag(value) {
+ return htmlTagNames$1.indexOf(value.toLowerCase()) !== -1;
+}
+
+function insideURLFunctionNode(path$$1) {
+ const funcAncestorNode = getAncestorNode(path$$1, "value-func");
+ return (
+ funcAncestorNode &&
+ funcAncestorNode.value &&
+ funcAncestorNode.value === "url"
+ );
+}
+
+function isParenGroupNode(node) {
+ return node.type && node.type === "value-paren_group";
+}
+
+function isForKeywordNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["from", "through", "end"].indexOf(node.value) !== -1
+ );
+}
+
+function isIfElseKeywordNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["and", "or", "not"].indexOf(node.value) !== -1
+ );
+}
+
+function isEachKeywordNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["in"].indexOf(node.value) !== -1
+ );
+}
+
+function isMathOperatorNode(node) {
+ return (
+ node.type &&
+ node.type === "value-operator" &&
+ node.value &&
+ ["+", "-", "/", "*", "%"].indexOf(node.value) !== -1
+ );
+}
+
+function isEqualityOperatorNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["==", "!="].indexOf(node.value) !== -1
+ );
+}
+
+function isRelationalOperatorNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["<", ">", "<=", ">="].indexOf(node.value) !== -1
+ );
+}
+
+function isControlDirectiveNode(node) {
+ return (
+ node.type &&
+ node.type === "css-atrule" &&
+ node.name &&
+ (node.name === "if" ||
+ node.name === "else" ||
+ node.name === "for" ||
+ node.name === "each" ||
+ node.name === "while")
+ );
+}
+
+function getAncestorCounter(path$$1, typeOrTypes) {
+ const types = [].concat(typeOrTypes);
+
+ let counter = -1;
+ let ancestorNode;
+
+ while ((ancestorNode = path$$1.getParentNode(++counter))) {
+ if (types.indexOf(ancestorNode.type) !== -1) {
+ return counter;
+ }
+ }
+
+ return -1;
+}
+
+function getAncestorNode(path$$1, typeOrTypes) {
+ const counter = getAncestorCounter(path$$1, typeOrTypes);
+ return counter === -1 ? null : path$$1.getParentNode(counter);
+}
+
+function printNodeSequence(path$$1, options, print) {
+ const node = path$$1.getValue();
+ const parts = [];
+ let i = 0;
+ path$$1.map(pathChild => {
+ const prevNode = node.nodes[i - 1];
+ if (
+ prevNode &&
+ prevNode.type === "css-comment" &&
+ prevNode.text.trim() === "prettier-ignore"
+ ) {
+ const childNode = pathChild.getValue();
+ parts.push(
+ options.originalText.slice(
+ options.locStart(childNode),
+ options.locEnd(childNode)
+ )
+ );
+ } else {
+ parts.push(pathChild.call(print));
+ }
+
+ if (i !== node.nodes.length - 1) {
+ if (
+ (node.nodes[i + 1].type === "css-comment" &&
+ !util$1.hasNewline(
+ options.originalText,
+ options.locStart(node.nodes[i + 1]),
+ { backwards: true }
+ )) ||
+ (node.nodes[i + 1].type === "css-atrule" &&
+ node.nodes[i + 1].name === "else" &&
+ node.nodes[i].type !== "css-comment")
+ ) {
+ parts.push(" ");
+ } else {
+ parts.push(hardline$4);
+ if (
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ pathChild.getValue(),
+ options
+ )
+ ) {
+ parts.push(hardline$4);
+ }
+ }
+ }
+ i++;
+ }, "nodes");
+
+ return concat$5(parts);
+}
+
+const STRING_REGEX = /(['"])(?:(?!\1)[^\\]|\\[\s\S])*\1/g;
+const NUMBER_REGEX = /(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g;
+const STANDARD_UNIT_REGEX = /[a-zA-Z]+/g;
+const WORD_PART_REGEX = /[$@]?[a-zA-Z_\u0080-\uFFFF][\w\-\u0080-\uFFFF]*/g;
+const ADJUST_NUMBERS_REGEX = RegExp(
+ STRING_REGEX.source +
+ `|` +
+ `(${WORD_PART_REGEX.source})?` +
+ `(${NUMBER_REGEX.source})` +
+ `(${STANDARD_UNIT_REGEX.source})?`,
+ "g"
+);
+
+function adjustStrings(value, options) {
+ return value.replace(STRING_REGEX, match =>
+ util$1.printString(match, options)
+ );
+}
+
+function quoteAttributeValue(value, options) {
+ const quote = options.singleQuote ? "'" : '"';
+ return value.includes('"') || value.includes("'")
+ ? value
+ : quote + value + quote;
+}
+
+function adjustNumbers(value) {
+ return value.replace(
+ ADJUST_NUMBERS_REGEX,
+ (match, quote, wordPart, number, unit) =>
+ !wordPart && number
+ ? (wordPart || "") + printNumber$1(number) + maybeToLowerCase(unit || "")
+ : match
+ );
+}
+
+function printNumber$1(rawNumber) {
+ return (
+ util$1
+ .printNumber(rawNumber)
+ // Remove trailing `.0`.
+ .replace(/\.0(?=$|e)/, "")
+ );
+}
+
+function maybeToLowerCase(value) {
+ return value.includes("$") ||
+ value.includes("@") ||
+ value.includes("#") ||
+ value.startsWith("%") ||
+ value.startsWith("--") ||
+ value.startsWith(":--") ||
+ (value.includes("(") && value.includes(")"))
+ ? value
+ : value.toLowerCase();
+}
+
+function isWideKeywords(value) {
+ return (
+ ["initial", "inherit", "unset", "revert"].indexOf(
+ value.replace().toLowerCase()
+ ) !== -1
+ );
+}
+
+var printerPostcss = {
+ print: genericPrint$1,
+ hasPrettierIgnore: util$1.hasIgnoreComment,
+ massageAstNode: clean_1$2
+};
+
+// format based on https://github.com/prettier/prettier/blob/master/src/common/support.js
+var options$2 = {
+ singleQuote: options.singleQuote
+};
+
+const lineColumnToIndex$1 = util$1.lineColumnToIndex;
+const getLast$1 = util$1.getLast;
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$1 = [
+ {
+ name: "CSS",
+ since: "1.4.0",
+ parsers: ["css"],
+ group: "CSS",
+ tmScope: "source.css",
+ aceMode: "css",
+ codemirrorMode: "css",
+ codemirrorMimeType: "text/css",
+ extensions: [".css", ".pcss", ".postcss"],
+ liguistLanguageId: 50,
+ vscodeLanguageIds: ["css", "postcss"]
+ },
+ {
+ name: "Less",
+ since: "1.4.0",
+ parsers: ["less"],
+ group: "CSS",
+ extensions: [".less"],
+ tmScope: "source.css.less",
+ aceMode: "less",
+ codemirrorMode: "css",
+ codemirrorMimeType: "text/css",
+ liguistLanguageId: 198,
+ vscodeLanguageIds: ["less"]
+ },
+ {
+ name: "SCSS",
+ since: "1.4.0",
+ parsers: ["scss"],
+ group: "CSS",
+ tmScope: "source.scss",
+ aceMode: "scss",
+ codemirrorMode: "css",
+ codemirrorMimeType: "text/x-scss",
+ extensions: [".scss"],
+ liguistLanguageId: 329,
+ vscodeLanguageIds: ["scss"]
+ }
+];
+
+const postcss = {
+ get parse() {
+ return require("./parser-postcss");
+ },
+ astFormat: "postcss",
+ locEnd: function(node) {
+ const endNode = node.nodes && getLast$1(node.nodes);
+ if (endNode && node.source && !node.source.end) {
+ node = endNode;
+ }
+ if (node.source) {
+ return lineColumnToIndex$1(node.source.end, node.source.input.css);
+ }
+ return null;
+ },
+ locStart: function(node) {
+ if (node.source) {
+ return lineColumnToIndex$1(node.source.start, node.source.input.css) - 1;
+ }
+ return null;
+ }
+};
+
+// TODO: switch these to just `postcss` and use `language` instead.
+const parsers$1 = {
+ css: postcss,
+ less: postcss,
+ scss: postcss
+};
+
+const printers$1 = {
+ postcss: printerPostcss
+};
+
+var languageCss = {
+ languages: languages$1,
+ options: options$2,
+ parsers: parsers$1,
+ printers: printers$1
+};
+
+const concat$6 = docBuilders$2.concat;
+const join$5 = docBuilders$2.join;
+const softline$4 = docBuilders$2.softline;
+const hardline$5 = docBuilders$2.hardline;
+const line$3 = docBuilders$2.line;
+const group$3 = docBuilders$2.group;
+const indent$5 = docBuilders$2.indent;
+const ifBreak$2 = docBuilders$2.ifBreak;
+
+// http://w3c.github.io/html/single-page.html#void-elements
+const voidTags = [
+ "area",
+ "base",
+ "br",
+ "col",
+ "embed",
+ "hr",
+ "img",
+ "input",
+ "link",
+ "meta",
+ "param",
+ "source",
+ "track",
+ "wbr"
+];
+
+// Formatter based on @glimmerjs/syntax's built-in test formatter:
+// https://github.com/glimmerjs/glimmer-vm/blob/master/packages/%40glimmer/syntax/lib/generation/print.ts
+
+function print(path$$1, options, print) {
+ const n = path$$1.getValue();
+
+ /* istanbul ignore if*/
+ if (!n) {
+ return "";
+ }
+
+ switch (n.type) {
+ case "Program": {
+ return group$3(
+ join$5(softline$4, path$$1.map(print, "body").filter(text => text !== ""))
+ );
+ }
+ case "ElementNode": {
+ const isVoid = voidTags.indexOf(n.tag) !== -1;
+ const closeTag = isVoid ? concat$6([" />", softline$4]) : ">";
+ const hasChildren = n.children.length > 0;
+ const getParams = (path$$1, print) =>
+ indent$5(
+ concat$6([
+ n.attributes.length ? line$3 : "",
+ join$5(line$3, path$$1.map(print, "attributes")),
+
+ n.modifiers.length ? line$3 : "",
+ join$5(line$3, path$$1.map(print, "modifiers")),
+
+ n.comments.length ? line$3 : "",
+ join$5(line$3, path$$1.map(print, "comments"))
+ ])
+ );
+
+ // The problem here is that I want to not break at all if the children
+ // would not break but I need to force an indent, so I use a hardline.
+ /**
+ * What happens now:
+ *
+ * Hello
+ *
+ * ==>
+ *
Hello
+ * This is due to me using hasChildren to decide to put the hardline in.
+ * I would rather use a {DOES THE WHOLE THING NEED TO BREAK}
+ */
+ return concat$6([
+ group$3(
+ concat$6([
+ "<",
+ n.tag,
+ getParams(path$$1, print),
+ ifBreak$2(softline$4, ""),
+ closeTag
+ ])
+ ),
+ group$3(
+ concat$6([
+ indent$5(join$5(softline$4, [""].concat(path$$1.map(print, "children")))),
+ ifBreak$2(hasChildren ? hardline$5 : "", ""),
+ !isVoid ? concat$6([""]) : ""
+ ])
+ )
+ ]);
+ }
+ case "BlockStatement": {
+ const pp = path$$1.getParentNode(1);
+ const isElseIf =
+ pp &&
+ pp.inverse &&
+ pp.inverse.body[0] === n &&
+ pp.inverse.body[0].path.parts[0] === "if";
+ const hasElseIf =
+ n.inverse &&
+ n.inverse.body[0] &&
+ n.inverse.body[0].type === "BlockStatement" &&
+ n.inverse.body[0].path.parts[0] === "if";
+ const indentElse = hasElseIf ? a => a : indent$5;
+ if (n.inverse) {
+ return concat$6([
+ isElseIf
+ ? concat$6(["{{else ", printPathParams(path$$1, print), "}}"])
+ : printOpenBlock(path$$1, print),
+ indent$5(concat$6([hardline$5, path$$1.call(print, "program")])),
+ n.inverse && !hasElseIf ? concat$6([hardline$5, "{{else}}"]) : "",
+ n.inverse
+ ? indentElse(concat$6([hardline$5, path$$1.call(print, "inverse")]))
+ : "",
+ isElseIf ? "" : concat$6([hardline$5, printCloseBlock(path$$1, print)])
+ ]);
+ } else if (isElseIf) {
+ return concat$6([
+ concat$6(["{{else ", printPathParams(path$$1, print), "}}"]),
+ indent$5(concat$6([hardline$5, path$$1.call(print, "program")]))
+ ]);
+ }
+ /**
+ * I want this boolean to be: if params are going to cause a break,
+ * not that it has params.
+ */
+ const hasParams = n.params.length > 0 || n.hash.pairs.length > 0;
+ const hasChildren = n.program.body.length > 0;
+ return concat$6([
+ printOpenBlock(path$$1, print),
+ group$3(
+ concat$6([
+ indent$5(concat$6([softline$4, path$$1.call(print, "program")])),
+ hasParams && hasChildren ? hardline$5 : "",
+ printCloseBlock(path$$1, print)
+ ])
+ )
+ ]);
+ }
+ case "ElementModifierStatement":
+ case "MustacheStatement": {
+ const pp = path$$1.getParentNode(1);
+ const isConcat = pp && pp.type === "ConcatStatement";
+ return group$3(
+ concat$6([
+ /*n.escaped ? "{{{" : */ "{{",
+ printPathParams(path$$1, print),
+ isConcat ? "" : softline$4,
+ /*.escaped ? "}}}" :*/ "}}"
+ ])
+ );
+ }
+ case "SubExpression": {
+ return group$3(
+ concat$6([
+ "(",
+ printPath(path$$1, print),
+ indent$5(concat$6([line$3, group$3(join$5(line$3, getParams(path$$1, print)))])),
+ softline$4,
+ ")"
+ ])
+ );
+ }
+ case "AttrNode": {
+ const quote = n.value.type === "TextNode" ? '"' : "";
+ return concat$6([n.name, "=", quote, path$$1.call(print, "value"), quote]);
+ }
+ case "ConcatStatement": {
+ return concat$6([
+ '"',
+ group$3(
+ indent$5(
+ join$5(
+ softline$4,
+ path$$1
+ .map(partPath => print(partPath), "parts")
+ .filter(a => a !== "")
+ )
+ )
+ ),
+ '"'
+ ]);
+ }
+ case "Hash": {
+ return concat$6([join$5(line$3, path$$1.map(print, "pairs"))]);
+ }
+ case "HashPair": {
+ return concat$6([n.key, "=", path$$1.call(print, "value")]);
+ }
+ case "TextNode": {
+ return n.chars.replace(/^\s+/, "").replace(/\s+$/, "");
+ }
+ case "MustacheCommentStatement": {
+ const dashes = n.value.indexOf("}}") > -1 ? "--" : "";
+ return concat$6(["{{!", dashes, n.value, dashes, "}}"]);
+ }
+ case "PathExpression": {
+ return n.original;
+ }
+ case "BooleanLiteral": {
+ return String(n.value);
+ }
+ case "CommentStatement": {
+ return concat$6([""]);
+ }
+ case "StringLiteral": {
+ return `"${n.value}"`;
+ }
+ case "NumberLiteral": {
+ return String(n.value);
+ }
+ case "UndefinedLiteral": {
+ return "undefined";
+ }
+ case "NullLiteral": {
+ return "null";
+ }
+
+ /* istanbul ignore next */
+ default:
+ throw new Error("unknown glimmer type: " + JSON.stringify(n.type));
+ }
+}
+
+function printPath(path$$1, print) {
+ return path$$1.call(print, "path");
+}
+
+function getParams(path$$1, print) {
+ const node = path$$1.getValue();
+ let parts = [];
+
+ if (node.params.length > 0) {
+ parts = parts.concat(path$$1.map(print, "params"));
+ }
+
+ if (node.hash && node.hash.pairs.length > 0) {
+ parts.push(path$$1.call(print, "hash"));
+ }
+ return parts;
+}
+
+function printPathParams(path$$1, print) {
+ let parts = [];
+
+ parts.push(printPath(path$$1, print));
+ parts = parts.concat(getParams(path$$1, print));
+
+ return indent$5(group$3(join$5(line$3, parts)));
+}
+
+function printBlockParams(path$$1) {
+ const block = path$$1.getValue();
+ if (!block.program || !block.program.blockParams.length) {
+ return "";
+ }
+ return concat$6([" as |", block.program.blockParams.join(" "), "|"]);
+}
+
+function printOpenBlock(path$$1, print) {
+ return group$3(
+ concat$6([
+ "{{#",
+ printPathParams(path$$1, print),
+ printBlockParams(path$$1, print),
+ softline$4,
+ "}}"
+ ])
+ );
+}
+
+function printCloseBlock(path$$1, print) {
+ return concat$6(["{{/", path$$1.call(print, "path"), "}}"]);
+}
+
+function clean$4(ast, newObj) {
+ // (Glimmer/HTML) ignore TextNode whitespace
+ if (ast.type === "TextNode") {
+ if (ast.chars.replace(/\s+/, "") === "") {
+ return null;
+ }
+ newObj.chars = ast.chars.replace(/^\s+/, "").replace(/\s+$/, "");
+ }
+}
+
+var printerGlimmer = {
+ print,
+ massageAstNode: clean$4
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$2 = [
+ {
+ type: "markup",
+ group: "HTML",
+ aliases: ["hbs", "htmlbars"],
+ extensions: [".handlebars", ".hbs"],
+ tm_scope: "text.html.handlebars",
+ ace_mode: "handlebars",
+ language_id: 155,
+ since: null // unreleased
+ }
+];
+
+const parsers$2 = {
+ glimmer: {
+ get parse() {
+ return require("./parser-glimmer");
+ },
+ astFormat: "glimmer",
+ locEnd: function(node) {
+ return node.loc && node.loc.end;
+ },
+ locStart: function(node) {
+ return node.loc && node.loc.start;
+ }
+ }
+};
+
+const printers$2 = {
+ glimmer: printerGlimmer
+};
+
+var languageHandlebars = {
+ languages: languages$2,
+ parsers: parsers$2,
+ printers: printers$2
+};
+
+const docBuilders$7 = doc.builders;
+const concat$7 = docBuilders$7.concat;
+const join$6 = docBuilders$7.join;
+const hardline$6 = docBuilders$7.hardline;
+const line$4 = docBuilders$7.line;
+const softline$5 = docBuilders$7.softline;
+const group$4 = docBuilders$7.group;
+const indent$6 = docBuilders$7.indent;
+const ifBreak$3 = docBuilders$7.ifBreak;
+
+
+
+function genericPrint$2(path$$1, options, print) {
+ const n = path$$1.getValue();
+ if (!n) {
+ return "";
+ }
+
+ if (typeof n === "string") {
+ return n;
+ }
+
+ switch (n.kind) {
+ case "Document": {
+ return concat$7([
+ join$6(concat$7([hardline$6, hardline$6]), path$$1.map(print, "definitions")),
+ hardline$6
+ ]);
+ }
+ case "OperationDefinition": {
+ const hasOperation = options.originalText[options.locStart(n)] !== "{";
+ const hasName = !!n.name;
+ return concat$7([
+ hasOperation ? n.operation : "",
+ hasOperation && hasName ? concat$7([" ", path$$1.call(print, "name")]) : "",
+ n.variableDefinitions && n.variableDefinitions.length
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.map(print, "variableDefinitions")
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : "",
+ printDirectives(path$$1, print, n),
+ n.selectionSet ? (!hasOperation && !hasName ? "" : " ") : "",
+ path$$1.call(print, "selectionSet")
+ ]);
+ }
+ case "FragmentDefinition": {
+ return concat$7([
+ "fragment ",
+ path$$1.call(print, "name"),
+ " on ",
+ path$$1.call(print, "typeCondition"),
+ printDirectives(path$$1, print, n),
+ " ",
+ path$$1.call(print, "selectionSet")
+ ]);
+ }
+ case "SelectionSet": {
+ return concat$7([
+ "{",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ selectionsPath => printSequence(selectionsPath, options, print),
+ "selections"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ]);
+ }
+ case "Field": {
+ return group$4(
+ concat$7([
+ n.alias ? concat$7([path$$1.call(print, "alias"), ": "]) : "",
+ path$$1.call(print, "name"),
+ n.arguments.length > 0
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.call(
+ argsPath => printSequence(argsPath, options, print),
+ "arguments"
+ )
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : "",
+ printDirectives(path$$1, print, n),
+ n.selectionSet ? " " : "",
+ path$$1.call(print, "selectionSet")
+ ])
+ );
+ }
+ case "Name": {
+ return n.value;
+ }
+ case "StringValue": {
+ if (n.block) {
+ return concat$7([
+ '"""',
+ hardline$6,
+ join$6(hardline$6, n.value.replace(/"""/g, "\\$&").split("\n")),
+ hardline$6,
+ '"""'
+ ]);
+ }
+ return concat$7(['"', n.value.replace(/["\\]/g, "\\$&"), '"']);
+ }
+ case "IntValue":
+ case "FloatValue":
+ case "EnumValue": {
+ return n.value;
+ }
+ case "BooleanValue": {
+ return n.value ? "true" : "false";
+ }
+ case "NullValue": {
+ return "null";
+ }
+ case "Variable": {
+ return concat$7(["$", path$$1.call(print, "name")]);
+ }
+ case "ListValue": {
+ return group$4(
+ concat$7([
+ "[",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.map(print, "values")
+ )
+ ])
+ ),
+ softline$5,
+ "]"
+ ])
+ );
+ }
+ case "ObjectValue": {
+ return group$4(
+ concat$7([
+ "{",
+ options.bracketSpacing && n.fields.length > 0 ? " " : "",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.map(print, "fields")
+ )
+ ])
+ ),
+ softline$5,
+ ifBreak$3("", options.bracketSpacing && n.fields.length > 0 ? " " : ""),
+ "}"
+ ])
+ );
+ }
+ case "ObjectField":
+ case "Argument": {
+ return concat$7([
+ path$$1.call(print, "name"),
+ ": ",
+ path$$1.call(print, "value")
+ ]);
+ }
+
+ case "Directive": {
+ return concat$7([
+ "@",
+ path$$1.call(print, "name"),
+ n.arguments.length > 0
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.call(
+ argsPath => printSequence(argsPath, options, print),
+ "arguments"
+ )
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : ""
+ ]);
+ }
+
+ case "NamedType": {
+ return path$$1.call(print, "name");
+ }
+
+ case "VariableDefinition": {
+ return concat$7([
+ path$$1.call(print, "variable"),
+ ": ",
+ path$$1.call(print, "type"),
+ n.defaultValue ? concat$7([" = ", path$$1.call(print, "defaultValue")]) : ""
+ ]);
+ }
+
+ case "TypeExtensionDefinition": {
+ return concat$7(["extend ", path$$1.call(print, "definition")]);
+ }
+
+ case "ObjectTypeExtension":
+ case "ObjectTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "ObjectTypeExtension" ? "extend " : "",
+ "type ",
+ path$$1.call(print, "name"),
+ n.interfaces.length > 0
+ ? concat$7([
+ " implements ",
+ join$6(
+ determineInterfaceSeparator(
+ options.originalText.substr(
+ options.locStart(n),
+ options.locEnd(n)
+ )
+ ),
+ path$$1.map(print, "interfaces")
+ )
+ ])
+ : "",
+ printDirectives(path$$1, print, n),
+ n.fields.length > 0
+ ? concat$7([
+ " {",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ fieldsPath => printSequence(fieldsPath, options, print),
+ "fields"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ])
+ : ""
+ ]);
+ }
+
+ case "FieldDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ path$$1.call(print, "name"),
+ n.arguments.length > 0
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.call(
+ argsPath => printSequence(argsPath, options, print),
+ "arguments"
+ )
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : "",
+ ": ",
+ path$$1.call(print, "type"),
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "DirectiveDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ "directive ",
+ "@",
+ path$$1.call(print, "name"),
+ n.arguments.length > 0
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.call(
+ argsPath => printSequence(argsPath, options, print),
+ "arguments"
+ )
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : "",
+ concat$7([" on ", join$6(" | ", path$$1.map(print, "locations"))])
+ ]);
+ }
+
+ case "EnumTypeExtension":
+ case "EnumTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "EnumTypeExtension" ? "extend " : "",
+ "enum ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n),
+
+ n.values.length > 0
+ ? concat$7([
+ " {",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ valuesPath => printSequence(valuesPath, options, print),
+ "values"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ])
+ : ""
+ ]);
+ }
+
+ case "EnumValueDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "InputValueDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? (n.description.block ? hardline$6 : line$4) : "",
+ path$$1.call(print, "name"),
+ ": ",
+ path$$1.call(print, "type"),
+ n.defaultValue ? concat$7([" = ", path$$1.call(print, "defaultValue")]) : "",
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "InputObjectTypeExtension":
+ case "InputObjectTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "InputObjectTypeExtension" ? "extend " : "",
+ "input ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n),
+ n.fields.length > 0
+ ? concat$7([
+ " {",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ fieldsPath => printSequence(fieldsPath, options, print),
+ "fields"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ])
+ : ""
+ ]);
+ }
+
+ case "SchemaDefinition": {
+ return concat$7([
+ "schema",
+ printDirectives(path$$1, print, n),
+ " {",
+ n.operationTypes.length > 0
+ ? indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ opsPath => printSequence(opsPath, options, print),
+ "operationTypes"
+ )
+ )
+ ])
+ )
+ : "",
+ hardline$6,
+ "}"
+ ]);
+ }
+
+ case "OperationTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "operation"),
+ ": ",
+ path$$1.call(print, "type")
+ ]);
+ }
+
+ case "InterfaceTypeExtension":
+ case "InterfaceTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "InterfaceTypeExtension" ? "extend " : "",
+ "interface ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n),
+
+ n.fields.length > 0
+ ? concat$7([
+ " {",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ fieldsPath => printSequence(fieldsPath, options, print),
+ "fields"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ])
+ : ""
+ ]);
+ }
+
+ case "FragmentSpread": {
+ return concat$7([
+ "...",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "InlineFragment": {
+ return concat$7([
+ "...",
+ n.typeCondition
+ ? concat$7([" on ", path$$1.call(print, "typeCondition")])
+ : "",
+ printDirectives(path$$1, print, n),
+ " ",
+ path$$1.call(print, "selectionSet")
+ ]);
+ }
+
+ case "UnionTypeExtension":
+ case "UnionTypeDefinition": {
+ return group$4(
+ concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ group$4(
+ concat$7([
+ n.kind === "UnionTypeExtension" ? "extend " : "",
+ "union ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n),
+ n.types.length > 0
+ ? concat$7([
+ " =",
+ ifBreak$3("", " "),
+ indent$6(
+ concat$7([
+ ifBreak$3(concat$7([line$4, " "])),
+ join$6(concat$7([line$4, "| "]), path$$1.map(print, "types"))
+ ])
+ )
+ ])
+ : ""
+ ])
+ )
+ ])
+ );
+ }
+
+ case "ScalarTypeExtension":
+ case "ScalarTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "ScalarTypeExtension" ? "extend " : "",
+ "scalar ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "NonNullType": {
+ return concat$7([path$$1.call(print, "type"), "!"]);
+ }
+
+ case "ListType": {
+ return concat$7(["[", path$$1.call(print, "type"), "]"]);
+ }
+
+ default:
+ /* istanbul ignore next */
+ throw new Error("unknown graphql type: " + JSON.stringify(n.kind));
+ }
+}
+
+function printDirectives(path$$1, print, n) {
+ if (n.directives.length === 0) {
+ return "";
+ }
+
+ return concat$7([
+ " ",
+ group$4(
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", " "), softline$5]),
+ path$$1.map(print, "directives")
+ )
+ ])
+ )
+ )
+ ]);
+}
+
+function printSequence(sequencePath, options, print) {
+ const count = sequencePath.getValue().length;
+
+ return sequencePath.map((path$$1, i) => {
+ const printed = print(path$$1);
+
+ if (
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ path$$1.getValue(),
+ options
+ ) &&
+ i < count - 1
+ ) {
+ return concat$7([printed, hardline$6]);
+ }
+
+ return printed;
+ });
+}
+
+function canAttachComment$1(node) {
+ return node.kind && node.kind !== "Comment";
+}
+
+function printComment$2(commentPath) {
+ const comment = commentPath.getValue();
+
+ switch (comment.kind) {
+ case "Comment":
+ return "#" + comment.value.trimRight();
+ default:
+ throw new Error("Not a comment: " + JSON.stringify(comment));
+ }
+}
+
+function determineInterfaceSeparator(originalSource) {
+ const start = originalSource.indexOf("implements");
+ if (start === -1) {
+ throw new Error("Must implement interfaces: " + originalSource);
+ }
+ let end = originalSource.indexOf("{");
+ if (end === -1) {
+ end = originalSource.length;
+ }
+ return originalSource.substr(start, end).includes("&") ? " & " : ", ";
+}
+
+var printerGraphql = {
+ print: genericPrint$2,
+ hasPrettierIgnore: util$1.hasIgnoreComment,
+ printComment: printComment$2,
+ canAttachComment: canAttachComment$1
+};
+
+// format based on https://github.com/prettier/prettier/blob/master/src/common/support.js
+var options$5 = {
+ bracketSpacing: options.bracketSpacing
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$3 = [
+ {
+ name: "GraphQL",
+ since: "1.5.0",
+ parsers: ["graphql"],
+ extensions: [".graphql", ".gql"],
+ tmScope: "source.graphql",
+ aceMode: "text",
+ liguistLanguageId: 139,
+ vscodeLanguageIds: ["graphql"]
+ }
+];
+
+const parsers$3 = {
+ graphql: {
+ get parse() {
+ return require("./parser-graphql");
+ },
+ astFormat: "graphql",
+ locStart: function(node) {
+ if (typeof node.start === "number") {
+ return node.start;
+ }
+ return node.loc && node.loc.start;
+ },
+ locEnd: function(node) {
+ if (typeof node.end === "number") {
+ return node.end;
+ }
+ return node.loc && node.loc.end;
+ }
+ }
+};
+
+const printers$3 = {
+ graphql: printerGraphql
+};
+
+var languageGraphql = {
+ languages: languages$3,
+ options: options$5,
+ parsers: parsers$3,
+ printers: printers$3
+};
+
+const docBuilders$9 = doc.builders;
+const hardline$8 = docBuilders$9.hardline;
+const literalline$3 = docBuilders$9.literalline;
+const concat$9 = docBuilders$9.concat;
+const markAsRoot$1 = docBuilders$9.markAsRoot;
+
+function embed$2(path$$1, print, textToDoc, options) {
+ const node = path$$1.getValue();
+
+ if (node.type === "code" && node.lang !== null) {
+ // only look for the first string so as to support [markdown-preview-enhanced](https://shd101wyy.github.io/markdown-preview-enhanced/#/code-chunk)
+ const lang = node.lang.split(/\s/, 1)[0];
+ const parser = getParserName(lang);
+ if (parser) {
+ const styleUnit = options.__inJsTemplate ? "~" : "`";
+ const style = styleUnit.repeat(
+ Math.max(3, util$1.getMaxContinuousCount(node.value, styleUnit) + 1)
+ );
+ const doc$$2 = textToDoc(node.value, { parser });
+ return markAsRoot$1(
+ concat$9([
+ style,
+ node.lang,
+ hardline$8,
+ replaceNewlinesWithLiterallines(doc$$2),
+ style
+ ])
+ );
+ }
+ }
+
+ return null;
+
+ function getParserName(lang) {
+ const supportInfo = support.getSupportInfo(null, {
+ plugins: options.plugins,
+ pluginsLoaded: true
+ });
+ const language = supportInfo.languages.find(
+ language =>
+ language.name.toLowerCase() === lang ||
+ (language.extensions &&
+ language.extensions.find(ext => ext.substring(1) === lang))
+ );
+ if (language) {
+ return language.parsers[0];
+ }
+
+ return null;
+ }
+
+ function replaceNewlinesWithLiterallines(doc$$2) {
+ return docUtils.mapDoc(
+ doc$$2,
+ currentDoc =>
+ typeof currentDoc === "string" && currentDoc.includes("\n")
+ ? concat$9(
+ currentDoc
+ .split(/(\n)/g)
+ .map((v, i) => (i % 2 === 0 ? v : literalline$3))
+ )
+ : currentDoc
+ );
+ }
+}
+
+var embed_1$2 = embed$2;
+
+var pragma$2 = createCommonjsModule(function (module) {
+"use strict";
+
+const pragmas = ["format", "prettier"];
+
+function startWithPragma(text) {
+ const pragma = `@(${pragmas.join("|")})`;
+ const regex = new RegExp(
+ [
+ ``,
+ ``
+ ].join("|"),
+ "m"
+ );
+ const matched = text.match(regex);
+ return matched && matched.index === 0;
+}
+
+function extract(text) {
+ // yaml (---) and toml (+++)
+ const matched = text.match(
+ /^((---|\+\+\+)(?:\n[\s\S]*?\n|\n)\2(?:\n|$))?([\s\S]*)/
+ );
+ const frontMatter = matched[1];
+ const mainContent = matched[3];
+ return { frontMatter, mainContent };
+}
+
+module.exports = {
+ startWithPragma,
+ hasPragma: text => startWithPragma(extract(text).mainContent.trimLeft()),
+ insertPragma: text => {
+ const extracted = extract(text);
+ const pragma = ``;
+ return extracted.frontMatter
+ ? `${extracted.frontMatter}\n\n${pragma}\n\n${extracted.mainContent}`
+ : `${pragma}\n\n${extracted.mainContent}`;
+ }
+};
+});
+
+const docBuilders$8 = doc.builders;
+const concat$8 = docBuilders$8.concat;
+const join$7 = docBuilders$8.join;
+const line$5 = docBuilders$8.line;
+const hardline$7 = docBuilders$8.hardline;
+const softline$6 = docBuilders$8.softline;
+const fill$4 = docBuilders$8.fill;
+const align$2 = docBuilders$8.align;
+const group$5 = docBuilders$8.group;
+const printDocToString$2 = doc.printer.printDocToString;
+
+const SINGLE_LINE_NODE_TYPES = ["heading", "tableCell", "link"];
+
+const SIBLING_NODE_TYPES = ["listItem", "definition", "footnoteDefinition"];
+
+const INLINE_NODE_TYPES = [
+ "inlineCode",
+ "emphasis",
+ "strong",
+ "delete",
+ "link",
+ "linkReference",
+ "image",
+ "imageReference",
+ "footnote",
+ "footnoteReference",
+ "sentence",
+ "whitespace",
+ "word",
+ "break"
+];
+
+const INLINE_NODE_WRAPPER_TYPES = INLINE_NODE_TYPES.concat([
+ "tableCell",
+ "paragraph",
+ "heading"
+]);
+
+function genericPrint$3(path$$1, options, print) {
+ const node = path$$1.getValue();
+
+ if (shouldRemainTheSameContent(path$$1)) {
+ return concat$8(
+ util$1
+ .splitText(
+ options.originalText.slice(
+ node.position.start.offset,
+ node.position.end.offset
+ )
+ )
+ .map(
+ node =>
+ node.type === "word"
+ ? node.value
+ : node.value === ""
+ ? ""
+ : printLine(path$$1, node.value, options)
+ )
+ );
+ }
+
+ switch (node.type) {
+ case "root":
+ return concat$8([normalizeDoc(printRoot(path$$1, options, print)), hardline$7]);
+ case "paragraph":
+ return printChildren(path$$1, options, print, {
+ postprocessor: fill$4
+ });
+ case "sentence":
+ return printChildren(path$$1, options, print);
+ case "word":
+ return node.value
+ .replace(/[*]/g, "\\*") // escape all `*`
+ .replace(
+ new RegExp(
+ [
+ `(^|[${util$1.punctuationCharRange}])(_+)`,
+ `(_+)([${util$1.punctuationCharRange}]|$)`
+ ].join("|"),
+ "g"
+ ),
+ (_, text1, underscore1, underscore2, text2) =>
+ (underscore1
+ ? `${text1}${underscore1}`
+ : `${underscore2}${text2}`
+ ).replace(/_/g, "\\_")
+ ); // escape all `_` except concating with non-punctuation, e.g. `1_2_3` is not considered emphasis
+ case "whitespace": {
+ const parentNode = path$$1.getParentNode();
+ const index = parentNode.children.indexOf(node);
+ const nextNode = parentNode.children[index + 1];
+
+ const proseWrap =
+ // leading char that may cause different syntax
+ nextNode && /^>|^([-+*]|#{1,6}|[0-9]+[.)])$/.test(nextNode.value)
+ ? "never"
+ : options.proseWrap;
+
+ return printLine(path$$1, node.value, { proseWrap });
+ }
+ case "emphasis": {
+ const parentNode = path$$1.getParentNode();
+ const index = parentNode.children.indexOf(node);
+ const prevNode = parentNode.children[index - 1];
+ const nextNode = parentNode.children[index + 1];
+ const hasPrevOrNextWord = // `1*2*3` is considered emphais but `1_2_3` is not
+ (prevNode &&
+ prevNode.type === "sentence" &&
+ prevNode.children.length > 0 &&
+ util$1.getLast(prevNode.children).type === "word" &&
+ !util$1.getLast(prevNode.children).hasTrailingPunctuation) ||
+ (nextNode &&
+ nextNode.type === "sentence" &&
+ nextNode.children.length > 0 &&
+ nextNode.children[0].type === "word" &&
+ !nextNode.children[0].hasLeadingPunctuation);
+ const style =
+ hasPrevOrNextWord || getAncestorNode$1(path$$1, "emphasis") ? "*" : "_";
+ return concat$8([style, printChildren(path$$1, options, print), style]);
+ }
+ case "strong":
+ return concat$8(["**", printChildren(path$$1, options, print), "**"]);
+ case "delete":
+ return concat$8(["~~", printChildren(path$$1, options, print), "~~"]);
+ case "inlineCode": {
+ const backtickCount = util$1.getMaxContinuousCount(node.value, "`");
+ const style = backtickCount === 1 ? "``" : "`";
+ const gap = backtickCount ? " " : "";
+ return concat$8([style, gap, node.value, gap, style]);
+ }
+ case "link":
+ switch (options.originalText[node.position.start.offset]) {
+ case "<":
+ return concat$8(["<", node.url, ">"]);
+ case "[":
+ return concat$8([
+ "[",
+ printChildren(path$$1, options, print),
+ "](",
+ printUrl(node.url, ")"),
+ printTitle(node.title, options),
+ ")"
+ ]);
+ default:
+ return options.originalText.slice(
+ node.position.start.offset,
+ node.position.end.offset
+ );
+ }
+ case "image":
+ return concat$8([
+ "![",
+ node.alt || "",
+ "](",
+ printUrl(node.url, ")"),
+ printTitle(node.title, options),
+ ")"
+ ]);
+ case "blockquote":
+ return concat$8(["> ", align$2("> ", printChildren(path$$1, options, print))]);
+ case "heading":
+ return concat$8([
+ "#".repeat(node.depth) + " ",
+ printChildren(path$$1, options, print)
+ ]);
+ case "code": {
+ if (
+ // the first char may point to `\n`, e.g. `\n\t\tbar`, just ignore it
+ /^\n?( {4,}|\t)/.test(
+ options.originalText.slice(
+ node.position.start.offset,
+ node.position.end.offset
+ )
+ )
+ ) {
+ // indented code block
+ const alignment = " ".repeat(4);
+ return align$2(
+ alignment,
+ concat$8([alignment, join$7(hardline$7, node.value.split("\n"))])
+ );
+ }
+
+ // fenced code block
+ const styleUnit = options.__inJsTemplate ? "~" : "`";
+ const style = styleUnit.repeat(
+ Math.max(
+ 3,
+ util$1.getMaxContinuousCount(node.value, styleUnit) + 1
+ )
+ );
+ return concat$8([
+ style,
+ node.lang || "",
+ hardline$7,
+ join$7(hardline$7, node.value.split("\n")),
+ hardline$7,
+ style
+ ]);
+ }
+ case "yaml":
+ case "toml": {
+ const style = node.type === "yaml" ? "---" : "+++";
+ return node.value
+ ? concat$8([style, hardline$7, node.value, hardline$7, style])
+ : concat$8([style, hardline$7, style]);
+ }
+ case "html": {
+ const parentNode = path$$1.getParentNode();
+ return replaceNewlinesWithHardlines(
+ parentNode.type === "root" &&
+ util$1.getLast(parentNode.children) === node
+ ? node.value.trimRight()
+ : node.value
+ );
+ }
+ case "list": {
+ const nthSiblingIndex = getNthListSiblingIndex(
+ node,
+ path$$1.getParentNode()
+ );
+
+ const isGitDiffFriendlyOrderedList =
+ node.ordered &&
+ node.children.length > 1 &&
+ /^\s*1(\.|\))/.test(
+ options.originalText.slice(
+ node.children[1].position.start.offset,
+ node.children[1].position.end.offset
+ )
+ );
+
+ return printChildren(path$$1, options, print, {
+ processor: (childPath, index) => {
+ const prefix = getPrefix();
+ return concat$8([
+ prefix,
+ align$2(
+ " ".repeat(prefix.length),
+ printListItem(childPath, options, print, prefix)
+ )
+ ]);
+
+ function getPrefix() {
+ const rawPrefix = node.ordered
+ ? (index === 0
+ ? node.start
+ : isGitDiffFriendlyOrderedList
+ ? 1
+ : node.start + index) +
+ (nthSiblingIndex % 2 === 0 ? ". " : ") ")
+ : nthSiblingIndex % 2 === 0
+ ? "* "
+ : "- ";
+
+ // do not print trailing spaces for empty list item since it might be treated as `break` node
+ // by [doc-printer](https://github.com/prettier/prettier/blob/1.10.2/src/doc/doc-printer.js#L395-L405),
+ // we don't want to preserve unnecessary trailing spaces.
+ const listItem = childPath.getValue();
+ return listItem.children.length
+ ? alignListPrefix(rawPrefix, options)
+ : rawPrefix;
+ }
+ }
+ });
+ }
+ case "thematicBreak": {
+ const counter = getAncestorCounter$1(path$$1, "list");
+ if (counter === -1) {
+ return "---";
+ }
+ const nthSiblingIndex = getNthListSiblingIndex(
+ path$$1.getParentNode(counter),
+ path$$1.getParentNode(counter + 1)
+ );
+ return nthSiblingIndex % 2 === 0 ? "---" : "***";
+ }
+ case "linkReference":
+ return concat$8([
+ "[",
+ printChildren(path$$1, options, print),
+ "]",
+ node.referenceType === "full"
+ ? concat$8(["[", node.identifier, "]"])
+ : node.referenceType === "collapsed"
+ ? "[]"
+ : ""
+ ]);
+ case "imageReference":
+ switch (node.referenceType) {
+ case "full":
+ return concat$8(["![", node.alt || "", "][", node.identifier, "]"]);
+ default:
+ return concat$8([
+ "![",
+ node.alt,
+ "]",
+ node.referenceType === "collapsed" ? "[]" : ""
+ ]);
+ }
+ case "definition":
+ return concat$8([
+ "[",
+ node.identifier,
+ "]: ",
+ printUrl(node.url),
+ printTitle(node.title, options)
+ ]);
+ case "footnote":
+ return concat$8(["[^", printChildren(path$$1, options, print), "]"]);
+ case "footnoteReference":
+ return concat$8(["[^", node.identifier, "]"]);
+ case "footnoteDefinition": {
+ const nextNode = path$$1.getParentNode().children[path$$1.getName() + 1];
+ return concat$8([
+ "[^",
+ node.identifier,
+ "]: ",
+ group$5(
+ concat$8([
+ align$2(
+ " ".repeat(options.tabWidth),
+ printChildren(path$$1, options, print, {
+ processor: (childPath, index) =>
+ index === 0
+ ? group$5(concat$8([softline$6, softline$6, childPath.call(print)]))
+ : childPath.call(print)
+ })
+ ),
+ nextNode && nextNode.type === "footnoteDefinition" ? softline$6 : ""
+ ])
+ )
+ ]);
+ }
+ case "table":
+ return printTable(path$$1, options, print);
+ case "tableCell":
+ return printChildren(path$$1, options, print);
+ case "break":
+ return concat$8([
+ /\s/.test(options.originalText[node.position.start.offset])
+ ? " "
+ : "\\",
+ hardline$7
+ ]);
+ case "tableRow": // handled in "table"
+ case "listItem": // handled in "list"
+ default:
+ throw new Error(`Unknown markdown type ${JSON.stringify(node.type)}`);
+ }
+}
+
+function printListItem(path$$1, options, print, listPrefix) {
+ const node = path$$1.getValue();
+ const prefix = node.checked === null ? "" : node.checked ? "[x] " : "[ ] ";
+ return concat$8([
+ prefix,
+ printChildren(path$$1, options, print, {
+ processor: (childPath, index) => {
+ if (index === 0 && childPath.getValue().type !== "list") {
+ return align$2(" ".repeat(prefix.length), childPath.call(print));
+ }
+
+ const alignment = " ".repeat(
+ clamp(options.tabWidth - listPrefix.length, 0, 3) // 4+ will cause indented code block
+ );
+ return concat$8([alignment, align$2(alignment, childPath.call(print))]);
+ }
+ })
+ ]);
+}
+
+function alignListPrefix(prefix, options) {
+ const additionalSpaces = getAdditionalSpaces();
+ return (
+ prefix +
+ " ".repeat(
+ additionalSpaces >= 4 ? 0 : additionalSpaces // 4+ will cause indented code block
+ )
+ );
+
+ function getAdditionalSpaces() {
+ const restSpaces = prefix.length % options.tabWidth;
+ return restSpaces === 0 ? 0 : options.tabWidth - restSpaces;
+ }
+}
+
+function getNthListSiblingIndex(node, parentNode) {
+ return getNthSiblingIndex(
+ node,
+ parentNode,
+ siblingNode => siblingNode.ordered === node.ordered
+ );
+}
+
+function replaceNewlinesWithHardlines(str) {
+ return join$7(hardline$7, str.split("\n"));
+}
+
+function getNthSiblingIndex(node, parentNode, condition) {
+ condition = condition || (() => true);
+
+ let index = -1;
+
+ for (const childNode of parentNode.children) {
+ if (childNode.type === node.type && condition(childNode)) {
+ index++;
+ } else {
+ index = -1;
+ }
+
+ if (childNode === node) {
+ return index;
+ }
+ }
+}
+
+function getAncestorCounter$1(path$$1, typeOrTypes) {
+ const types = [].concat(typeOrTypes);
+
+ let counter = -1;
+ let ancestorNode;
+
+ while ((ancestorNode = path$$1.getParentNode(++counter))) {
+ if (types.indexOf(ancestorNode.type) !== -1) {
+ return counter;
+ }
+ }
+
+ return -1;
+}
+
+function getAncestorNode$1(path$$1, typeOrTypes) {
+ const counter = getAncestorCounter$1(path$$1, typeOrTypes);
+ return counter === -1 ? null : path$$1.getParentNode(counter);
+}
+
+function printLine(path$$1, value, options) {
+ if (options.proseWrap === "preserve" && value === "\n") {
+ return hardline$7;
+ }
+
+ const isBreakable =
+ options.proseWrap === "always" &&
+ !getAncestorNode$1(path$$1, SINGLE_LINE_NODE_TYPES);
+ return value !== ""
+ ? isBreakable
+ ? line$5
+ : " "
+ : isBreakable
+ ? softline$6
+ : "";
+}
+
+function printTable(path$$1, options, print) {
+ const node = path$$1.getValue();
+ const contents = []; // { [rowIndex: number]: { [columnIndex: number]: string } }
+
+ path$$1.map(rowPath => {
+ const rowContents = [];
+
+ rowPath.map(cellPath => {
+ rowContents.push(
+ printDocToString$2(cellPath.call(print), options).formatted
+ );
+ }, "children");
+
+ contents.push(rowContents);
+ }, "children");
+
+ const columnMaxWidths = contents.reduce(
+ (currentWidths, rowContents) =>
+ currentWidths.map((width, columnIndex) =>
+ Math.max(width, util$1.getStringWidth(rowContents[columnIndex]))
+ ),
+ contents[0].map(() => 3) // minimum width = 3 (---, :--, :-:, --:)
+ );
+
+ return join$7(hardline$7, [
+ printRow(contents[0]),
+ printSeparator(),
+ join$7(hardline$7, contents.slice(1).map(printRow))
+ ]);
+
+ function printSeparator() {
+ return concat$8([
+ "| ",
+ join$7(
+ " | ",
+ columnMaxWidths.map((width, index) => {
+ switch (node.align[index]) {
+ case "left":
+ return ":" + "-".repeat(width - 1);
+ case "right":
+ return "-".repeat(width - 1) + ":";
+ case "center":
+ return ":" + "-".repeat(width - 2) + ":";
+ default:
+ return "-".repeat(width);
+ }
+ })
+ ),
+ " |"
+ ]);
+ }
+
+ function printRow(rowContents) {
+ return concat$8([
+ "| ",
+ join$7(
+ " | ",
+ rowContents.map((rowContent, columnIndex) => {
+ switch (node.align[columnIndex]) {
+ case "right":
+ return alignRight(rowContent, columnMaxWidths[columnIndex]);
+ case "center":
+ return alignCenter(rowContent, columnMaxWidths[columnIndex]);
+ default:
+ return alignLeft(rowContent, columnMaxWidths[columnIndex]);
+ }
+ })
+ ),
+ " |"
+ ]);
+ }
+
+ function alignLeft(text, width) {
+ return concat$8([text, " ".repeat(width - util$1.getStringWidth(text))]);
+ }
+
+ function alignRight(text, width) {
+ return concat$8([" ".repeat(width - util$1.getStringWidth(text)), text]);
+ }
+
+ function alignCenter(text, width) {
+ const spaces = width - util$1.getStringWidth(text);
+ const left = Math.floor(spaces / 2);
+ const right = spaces - left;
+ return concat$8([" ".repeat(left), text, " ".repeat(right)]);
+ }
+}
+
+function printRoot(path$$1, options, print) {
+ /** @typedef {{ index: number, offset: number }} IgnorePosition */
+ /** @type {Array<{start: IgnorePosition, end: IgnorePosition}>} */
+ const ignoreRanges = [];
+
+ /** @type {IgnorePosition | null} */
+ let ignoreStart = null;
+
+ const children = path$$1.getValue().children;
+ children.forEach((childNode, index) => {
+ switch (isPrettierIgnore(childNode)) {
+ case "start":
+ if (ignoreStart === null) {
+ ignoreStart = { index, offset: childNode.position.end.offset };
+ }
+ break;
+ case "end":
+ if (ignoreStart !== null) {
+ ignoreRanges.push({
+ start: ignoreStart,
+ end: { index, offset: childNode.position.start.offset }
+ });
+ ignoreStart = null;
+ }
+ break;
+ default:
+ // do nothing
+ break;
+ }
+ });
+
+ return printChildren(path$$1, options, print, {
+ processor: (childPath, index) => {
+ if (ignoreRanges.length !== 0) {
+ const ignoreRange = ignoreRanges[0];
+
+ if (index === ignoreRange.start.index) {
+ return concat$8([
+ children[ignoreRange.start.index].value,
+ options.originalText.slice(
+ ignoreRange.start.offset,
+ ignoreRange.end.offset
+ ),
+ children[ignoreRange.end.index].value
+ ]);
+ }
+
+ if (ignoreRange.start.index < index && index < ignoreRange.end.index) {
+ return false;
+ }
+
+ if (index === ignoreRange.end.index) {
+ ignoreRanges.shift();
+ return false;
+ }
+ }
+
+ return childPath.call(print);
+ }
+ });
+}
+
+function printChildren(path$$1, options, print, events$$1) {
+ events$$1 = events$$1 || {};
+
+ const postprocessor = events$$1.postprocessor || concat$8;
+ const processor = events$$1.processor || (childPath => childPath.call(print));
+
+ const node = path$$1.getValue();
+ const parts = [];
+
+ let lastChildNode;
+
+ path$$1.map((childPath, index) => {
+ const childNode = childPath.getValue();
+
+ const result = processor(childPath, index);
+ if (result !== false) {
+ const data = {
+ parts,
+ prevNode: lastChildNode,
+ parentNode: node,
+ options
+ };
+
+ if (!shouldNotPrePrintHardline(childNode, data)) {
+ parts.push(hardline$7);
+
+ if (
+ shouldPrePrintDoubleHardline(childNode, data) ||
+ shouldPrePrintTripleHardline(childNode, data)
+ ) {
+ parts.push(hardline$7);
+ }
+
+ if (shouldPrePrintTripleHardline(childNode, data)) {
+ parts.push(hardline$7);
+ }
+ }
+
+ parts.push(result);
+
+ lastChildNode = childNode;
+ }
+ }, "children");
+
+ return postprocessor(parts);
+}
+
+/** @return {false | 'next' | 'start' | 'end'} */
+function isPrettierIgnore(node) {
+ if (node.type !== "html") {
+ return false;
+ }
+ const match = node.value.match(
+ /^$/
+ );
+ return match === null ? false : match[1] ? match[1] : "next";
+}
+
+function shouldNotPrePrintHardline(node, data) {
+ const isFirstNode = data.parts.length === 0;
+ const isInlineNode = INLINE_NODE_TYPES.indexOf(node.type) !== -1;
+
+ const isInlineHTML =
+ node.type === "html" &&
+ INLINE_NODE_WRAPPER_TYPES.indexOf(data.parentNode.type) !== -1;
+
+ return isFirstNode || isInlineNode || isInlineHTML;
+}
+
+function shouldPrePrintDoubleHardline(node, data) {
+ const isSequence = (data.prevNode && data.prevNode.type) === node.type;
+ const isSiblingNode =
+ isSequence && SIBLING_NODE_TYPES.indexOf(node.type) !== -1;
+
+ const isInTightListItem =
+ data.parentNode.type === "listItem" && !data.parentNode.loose;
+
+ const isPrevNodeLooseListItem =
+ data.prevNode && data.prevNode.type === "listItem" && data.prevNode.loose;
+
+ const isPrevNodePrettierIgnore = isPrettierIgnore(data.prevNode) === "next";
+
+ return (
+ isPrevNodeLooseListItem ||
+ !(isSiblingNode || isInTightListItem || isPrevNodePrettierIgnore)
+ );
+}
+
+function shouldPrePrintTripleHardline(node, data) {
+ const isPrevNodeList = data.prevNode && data.prevNode.type === "list";
+ const isIndentedCode =
+ node.type === "code" &&
+ /\s/.test(data.options.originalText[node.position.start.offset]);
+
+ return isPrevNodeList && isIndentedCode;
+}
+
+function shouldRemainTheSameContent(path$$1) {
+ const ancestorNode = getAncestorNode$1(path$$1, [
+ "linkReference",
+ "imageReference"
+ ]);
+
+ return (
+ ancestorNode &&
+ (ancestorNode.type !== "linkReference" ||
+ ancestorNode.referenceType !== "full")
+ );
+}
+
+function normalizeDoc(doc$$2) {
+ return docUtils.mapDoc(doc$$2, currentDoc => {
+ if (!currentDoc.parts) {
+ return currentDoc;
+ }
+
+ if (currentDoc.type === "concat" && currentDoc.parts.length === 1) {
+ return currentDoc.parts[0];
+ }
+
+ const parts = [];
+
+ currentDoc.parts.forEach(part => {
+ if (part.type === "concat") {
+ parts.push.apply(parts, part.parts);
+ } else if (part !== "") {
+ parts.push(part);
+ }
+ });
+
+ return Object.assign({}, currentDoc, {
+ parts: normalizeParts(parts)
+ });
+ });
+}
+
+function printUrl(url$$1, dangerousCharOrChars) {
+ const dangerousChars = [" "].concat(dangerousCharOrChars || []);
+ return new RegExp(dangerousChars.map(x => `\\${x}`).join("|")).test(url$$1)
+ ? `<${url$$1}>`
+ : url$$1;
+}
+
+function printTitle(title, options) {
+ if (!title) {
+ return "";
+ }
+ if (title.includes('"') && title.includes("'") && !title.includes(")")) {
+ return ` (${title})`; // avoid escaped quotes
+ }
+ // faster than using RegExps: https://jsperf.com/performance-of-match-vs-split
+ const singleCount = title.split("'").length - 1;
+ const doubleCount = title.split('"').length - 1;
+ const quote =
+ singleCount > doubleCount
+ ? '"'
+ : doubleCount > singleCount
+ ? "'"
+ : options.singleQuote
+ ? "'"
+ : '"';
+ title = title.replace(new RegExp(`(${quote})`, "g"), "\\$1");
+ return ` ${quote}${title}${quote}`;
+}
+
+function normalizeParts(parts) {
+ return parts.reduce((current, part) => {
+ const lastPart = util$1.getLast(current);
+
+ if (typeof lastPart === "string" && typeof part === "string") {
+ current.splice(-1, 1, lastPart + part);
+ } else {
+ current.push(part);
+ }
+
+ return current;
+ }, []);
+}
+
+function clamp(value, min, max) {
+ return value < min ? min : value > max ? max : value;
+}
+
+function clean$5(ast, newObj, parent) {
+ // for codeblock
+ if (ast.type === "code") {
+ delete newObj.value;
+ }
+ // for whitespace: "\n" and " " are considered the same
+ if (ast.type === "whitespace" && ast.value === "\n") {
+ newObj.value = " ";
+ }
+ // for insert pragma
+ if (
+ parent &&
+ parent.type === "root" &&
+ (parent.children[0] === ast ||
+ ((parent.children[0].type === "yaml" ||
+ parent.children[0].type === "toml") &&
+ parent.children[1] === ast)) &&
+ ast.type === "html" &&
+ pragma$2.startWithPragma(ast.value)
+ ) {
+ return null;
+ }
+}
+
+function hasPrettierIgnore$1(path$$1) {
+ const index = +path$$1.getName();
+
+ if (index === 0) {
+ return false;
+ }
+
+ const prevNode = path$$1.getParentNode().children[index - 1];
+ return isPrettierIgnore(prevNode) === "next";
+}
+
+var printerMarkdown = {
+ print: genericPrint$3,
+ embed: embed_1$2,
+ massageAstNode: clean$5,
+ hasPrettierIgnore: hasPrettierIgnore$1,
+ insertPragma: pragma$2.insertPragma
+};
+
+const CATEGORY_MARKDOWN = "Markdown";
+
+// format based on https://github.com/prettier/prettier/blob/master/src/common/support.js
+var options$8 = {
+ proseWrap: {
+ since: "1.8.2",
+ category: CATEGORY_MARKDOWN,
+ type: "choice",
+ default: [
+ { since: "1.8.2", value: true },
+ { since: "1.9.0", value: "preserve" }
+ ],
+ description: "How to wrap prose. (markdown)",
+ choices: [
+ {
+ since: "1.9.0",
+ value: "always",
+ description: "Wrap prose if it exceeds the print width."
+ },
+ {
+ since: "1.9.0",
+ value: "never",
+ description: "Do not wrap prose."
+ },
+ {
+ since: "1.9.0",
+ value: "preserve",
+ description: "Wrap prose as-is."
+ },
+ { value: false, deprecated: "1.9.0", redirect: "never" },
+ { value: true, deprecated: "1.9.0", redirect: "always" }
+ ]
+ },
+ singleQuote: options.singleQuote
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$4 = [
+ {
+ name: "Markdown",
+ since: "1.8.0",
+ parsers: ["remark"],
+ aliases: ["pandoc"],
+ aceMode: "markdown",
+ codemirrorMode: "gfm",
+ codemirrorMimeType: "text/x-gfm",
+ wrap: true,
+ extensions: [
+ ".md",
+ ".markdown",
+ ".mdown",
+ ".mdwn",
+ ".mkd",
+ ".mkdn",
+ ".mkdown",
+ ".ron",
+ ".workbook"
+ ],
+ filenames: ["README"],
+ tmScope: "source.gfm",
+ linguistLanguageId: 222,
+ vscodeLanguageIds: ["markdown"]
+ }
+];
+
+const remark = {
+ get parse() {
+ return require("./parser-markdown");
+ },
+ astFormat: "mdast",
+ hasPragma: pragma$2.hasPragma,
+ locStart: node => node.position.start.offset,
+ locEnd: node => node.position.end.offset
+};
+
+const parsers$4 = {
+ remark,
+ // TODO: Delete this in 2.0
+ markdown: remark
+};
+
+const printers$4 = {
+ mdast: printerMarkdown
+};
+
+var languageMarkdown = {
+ languages: languages$4,
+ options: options$8,
+ parsers: parsers$4,
+ printers: printers$4
+};
+
+const docUtils$5 = doc.utils;
+const docBuilders$11 = doc.builders;
+const hardline$10 = docBuilders$11.hardline;
+const concat$11 = docBuilders$11.concat;
+
+function embed$4(path$$1, print, textToDoc, options) {
+ const node = path$$1.getValue();
+
+ switch (node.type) {
+ case "text": {
+ const parent = path$$1.getParentNode();
+ // Inline JavaScript
+ if (
+ parent.type === "script" &&
+ ((!parent.attribs.lang && !parent.attribs.lang) ||
+ parent.attribs.type === "text/javascript" ||
+ parent.attribs.type === "application/javascript")
+ ) {
+ const parser = options.parser === "flow" ? "flow" : "babylon";
+ const doc$$2 = textToDoc(getText(options, node), { parser });
+ return concat$11([hardline$10, doc$$2]);
+ }
+
+ // Inline TypeScript
+ if (
+ parent.type === "script" &&
+ (parent.attribs.type === "application/x-typescript" ||
+ parent.attribs.lang === "ts")
+ ) {
+ const doc$$2 = textToDoc(
+ getText(options, node),
+ { parser: "typescript" },
+ options
+ );
+ return concat$11([hardline$10, doc$$2]);
+ }
+
+ // Inline Styles
+ if (parent.type === "style") {
+ const doc$$2 = textToDoc(getText(options, node), { parser: "css" });
+ return concat$11([hardline$10, docUtils$5.stripTrailingHardline(doc$$2)]);
+ }
+
+ break;
+ }
+
+ case "attribute": {
+ /*
+ * Vue binding sytax: JS expressions
+ * :class="{ 'some-key': value }"
+ * v-bind:id="'list-' + id"
+ * v-if="foo && !bar"
+ * @click="someFunction()"
+ */
+ if (/(^@)|(^v-)|:/.test(node.key) && !/^\w+$/.test(node.value)) {
+ const doc$$2 = textToDoc(node.value, {
+ parser: parseJavaScriptExpression,
+ // Use singleQuote since HTML attributes use double-quotes.
+ // TODO(azz): We still need to do an entity escape on the attribute.
+ singleQuote: true
+ });
+ return concat$11([
+ node.key,
+ '="',
+ util$1.hasNewlineInRange(node.value, 0, node.value.length)
+ ? doc$$2
+ : docUtils$5.removeLines(doc$$2),
+ '"'
+ ]);
+ }
+ }
+ }
+}
+
+function parseJavaScriptExpression(text, parsers) {
+ // Force parsing as an expression
+ const ast = parsers.babylon(`(${text})`);
+ // Extract expression from the declaration
+ return {
+ type: "File",
+ program: ast.program.body[0].expression
+ };
+}
+
+function getText(options, node) {
+ return options.originalText.slice(
+ options.locStart(node),
+ options.locEnd(node)
+ );
+}
+
+var embed_1$4 = embed$4;
+
+const docBuilders$10 = doc.builders;
+const concat$10 = docBuilders$10.concat;
+const join$8 = docBuilders$10.join;
+const hardline$9 = docBuilders$10.hardline;
+const line$6 = docBuilders$10.line;
+const softline$7 = docBuilders$10.softline;
+const group$6 = docBuilders$10.group;
+const indent$7 = docBuilders$10.indent;
+
+// http://w3c.github.io/html/single-page.html#void-elements
+const voidTags$1 = {
+ area: true,
+ base: true,
+ br: true,
+ col: true,
+ embed: true,
+ hr: true,
+ img: true,
+ input: true,
+ link: true,
+ meta: true,
+ param: true,
+ source: true,
+ track: true,
+ wbr: true
+};
+
+function genericPrint$4(path$$1, options, print) {
+ const n = path$$1.getValue();
+ if (!n) {
+ return "";
+ }
+
+ if (typeof n === "string") {
+ return n;
+ }
+
+ switch (n.type) {
+ case "root": {
+ return printChildren$1(path$$1, print);
+ }
+ case "directive": {
+ return concat$10(["<", n.data, ">", hardline$9]);
+ }
+ case "text": {
+ return n.data.replace(/\s+/g, " ").trim();
+ }
+ case "script":
+ case "style":
+ case "tag": {
+ const selfClose = voidTags$1[n.name] ? ">" : " />";
+ const children = printChildren$1(path$$1, print);
+
+ const hasNewline = util$1.hasNewlineInRange(
+ options.originalText,
+ options.locStart(n),
+ options.locEnd(n)
+ );
+
+ return group$6(
+ concat$10([
+ hasNewline ? hardline$9 : "",
+ "<",
+ n.name,
+ printAttributes(path$$1, print),
+
+ n.children.length ? ">" : selfClose,
+
+ n.name.toLowerCase() === "html"
+ ? concat$10([hardline$9, children])
+ : indent$7(children),
+ n.children.length ? concat$10([softline$7, ""]) : hardline$9
+ ])
+ );
+ }
+ case "comment": {
+ return concat$10([""]);
+ }
+ case "attribute": {
+ if (!n.value) {
+ return n.key;
+ }
+ return concat$10([n.key, '="', n.value, '"']);
+ }
+
+ default:
+ /* istanbul ignore next */
+ throw new Error("unknown htmlparser2 type: " + n.type);
+ }
+}
+
+function printAttributes(path$$1, print) {
+ const node = path$$1.getValue();
+
+ return concat$10([
+ node.attributes.length ? " " : "",
+ indent$7(join$8(line$6, path$$1.map(print, "attributes")))
+ ]);
+}
+
+function printChildren$1(path$$1, print) {
+ const children = [];
+ path$$1.each(childPath => {
+ const child = childPath.getValue();
+ if (child.type !== "text") {
+ children.push(hardline$9);
+ }
+ children.push(childPath.call(print));
+ }, "children");
+ return concat$10(children);
+}
+
+var printerHtmlparser2 = {
+ print: genericPrint$4,
+ embed: embed_1$4,
+ hasPrettierIgnore: util$1.hasIgnoreComment
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$5 = [
+ {
+ name: "HTML",
+ since: null, // unreleased
+ parsers: ["parse5"],
+ group: "HTML",
+ tmScope: "text.html.basic",
+ aceMode: "html",
+ codemirrorMode: "htmlmixed",
+ codemirrorMimeType: "text/html",
+ aliases: ["xhtml"],
+ extensions: [".html", ".htm", ".html.hl", ".inc", ".st", ".xht", ".xhtml"],
+ linguistLanguageId: 146,
+ vscodeLanguageIds: ["html"]
+ }
+];
+
+const parsers$5 = {
+ parse5: {
+ get parse() {
+ return require("./parser-parse5");
+ },
+ astFormat: "htmlparser2",
+ locEnd: function(node) {
+ return node.__location && node.__location.endOffset;
+ },
+ locStart: function(node) {
+ return node.__location && node.__location.startOffset;
+ }
+ }
+};
+
+const printers$5 = {
+ htmlparser2: printerHtmlparser2
+};
+
+var languageHtml = {
+ languages: languages$5,
+ parsers: parsers$5,
+ printers: printers$5
+};
+
+const docBuilders$13 = doc.builders;
+const concat$13 = docBuilders$13.concat;
+const hardline$12 = docBuilders$13.hardline;
+
+function embed$6(path$$1, print, textToDoc, options) {
+ const node = path$$1.getValue();
+ const parent = path$$1.getParentNode();
+ if (!parent || parent.tag !== "root" || node.unary) {
+ return null;
+ }
+
+ let parser;
+
+ if (node.tag === "style") {
+ const langAttr = node.attrs.find(attr => attr.name === "lang");
+ if (!langAttr || langAttr.value === "postcss") {
+ parser = "css";
+ } else if (langAttr.value === "scss") {
+ parser = "scss";
+ } else if (langAttr.value === "less") {
+ parser = "less";
+ }
+ }
+
+ if (node.tag === "script") {
+ const langAttr = node.attrs.find(attr => attr.name === "lang");
+ if (!langAttr) {
+ parser = "babylon";
+ } else if (langAttr.value === "ts" || langAttr.value === "tsx") {
+ parser = "typescript";
+ }
+ }
+
+ if (!parser) {
+ return null;
+ }
+
+ return concat$13([
+ options.originalText.slice(node.start, node.contentStart),
+ hardline$12,
+ textToDoc(options.originalText.slice(node.contentStart, node.contentEnd), {
+ parser
+ }),
+ options.originalText.slice(node.contentEnd, node.end)
+ ]);
+}
+
+var embed_1$6 = embed$6;
+
+const docBuilders$12 = doc.builders;
+const concat$12 = docBuilders$12.concat;
+const hardline$11 = docBuilders$12.hardline;
+
+function genericPrint$5(path$$1, options, print) {
+ const n = path$$1.getValue();
+ const res = [];
+ let index = n.start;
+
+ path$$1.each(childPath => {
+ const child = childPath.getValue();
+ res.push(options.originalText.slice(index, child.start));
+ res.push(childPath.call(print));
+ index = child.end;
+ }, "children");
+
+ // If there are no children, we just print the node from start to end.
+ // Otherwise, index should point to the end of the last child, and we
+ // need to print the closing tag.
+ res.push(options.originalText.slice(index, n.end));
+
+ // Only force a trailing newline if there were any contents.
+ if (n.tag === "root" && n.children.length) {
+ res.push(hardline$11);
+ }
+
+ return concat$12(res);
+}
+
+const clean$6 = (ast, newObj) => {
+ delete newObj.contentStart;
+ delete newObj.contentEnd;
+};
+
+var printerVue = {
+ print: genericPrint$5,
+ embed: embed_1$6,
+ massageAstNode: clean$6
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$6 = [
+ {
+ name: "Vue",
+ since: "1.10.0",
+ parsers: ["vue"],
+ group: "HTML",
+ tmScope: "text.html.vue",
+ aceMode: "html",
+ codemirrorMode: "htmlmixed",
+ codemirrorMimeType: "text/html",
+ extensions: [".vue"],
+ linguistLanguageId: 146,
+ vscodeLanguageIds: ["vue"]
+ }
+];
+
+const parsers$6 = {
+ vue: {
+ get parse() {
+ return require("./parser-vue");
+ },
+ astFormat: "vue"
+ }
+};
+
+const printers$6 = {
+ vue: printerVue
+};
+
+var languageVue = {
+ languages: languages$6,
+ parsers: parsers$6,
+ printers: printers$6
+};
+
+function loadPlugins(plugins) {
+ plugins = plugins || [];
+
+ const internalPlugins = [
+ languageJs,
+ languageCss,
+ languageHandlebars,
+ languageGraphql,
+ languageMarkdown,
+ languageHtml,
+ languageVue
+ ];
+
+ const externalPlugins = plugins
+ .concat(
+ getPluginsFromPackage(
+ readPkgUp.sync({
+ normalize: false
+ }).pkg
+ )
+ )
+ .map(plugin => {
+ if (typeof plugin !== "string") {
+ return plugin;
+ }
+
+ const pluginPath = resolve.sync(plugin, { basedir: process.cwd() });
+ return Object.assign({ name: plugin }, require(pluginPath));
+ });
+
+ return deduplicate(internalPlugins.concat(externalPlugins));
+}
+
+function getPluginsFromPackage(pkg) {
+ if (!pkg) {
+ return [];
+ }
+ const deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
+ return Object.keys(deps).filter(
+ dep =>
+ dep.startsWith("prettier-plugin-") || dep.startsWith("@prettier/plugin-")
+ );
+}
+
+function deduplicate(items) {
+ const uniqItems = [];
+ for (const item of items) {
+ if (uniqItems.indexOf(item) < 0) {
+ uniqItems.push(item);
+ }
+ }
+ return uniqItems;
+}
+
+var loadPlugins_1 = loadPlugins;
+
+const CATEGORY_CONFIG = "Config";
+const CATEGORY_EDITOR = "Editor";
+const CATEGORY_FORMAT = "Format";
+const CATEGORY_OTHER = "Other";
+const CATEGORY_OUTPUT = "Output";
+
+const categoryOrder = [
+ CATEGORY_OUTPUT,
+ CATEGORY_FORMAT,
+ CATEGORY_CONFIG,
+ CATEGORY_EDITOR,
+ CATEGORY_OTHER
+];
+
+/**
+ * {
+ * [optionName]: {
+ * // The type of the option. For 'choice', see also `choices` below.
+ * // When passing a type other than the ones listed below, the option is
+ * // treated as taking any string as argument, and `--option <${type}>` will
+ * // be displayed in --help.
+ * type: "boolean" | "choice" | "int" | string;
+ *
+ * // Default value to be passed to the minimist option `default`.
+ * default?: any;
+ *
+ * // Alias name to be passed to the minimist option `alias`.
+ * alias?: string;
+ *
+ * // For grouping options by category in --help.
+ * category?: string;
+ *
+ * // Description to be displayed in --help. If omitted, the option won't be
+ * // shown at all in --help (but see also `oppositeDescription` below).
+ * description?: string;
+ *
+ * // Description for `--no-${name}` to be displayed in --help. If omitted,
+ * // `--no-${name}` won't be shown.
+ * oppositeDescription?: string;
+ *
+ * // Indicate if this option is simply passed to the API.
+ * // true: use camelified name as the API option name.
+ * // string: use this value as the API option name.
+ * forwardToApi?: boolean | string;
+ *
+ * // Indicate that a CLI flag should be an array when forwarded to the API.
+ * array?: boolean;
+ *
+ * // Specify available choices for validation. They will also be displayed
+ * // in --help as
.
+ * // Use an object instead of a string if a choice is deprecated and should
+ * // be treated as `redirect` instead, or if you'd like to add description for
+ * // the choice.
+ * choices?: Array<
+ * | string
+ * | { value: string, description?: string, deprecated?: boolean, redirect?: string }
+ * >;
+ *
+ * // If the option has a value that is an exception to the regular value
+ * // constraints, indicate that value here (or use a function for more
+ * // flexibility).
+ * exception?: ((value: any) => boolean);
+ *
+ * // Indicate that the option is deprecated. Use a string to add an extra
+ * // message to --help for the option, for example to suggest a replacement
+ * // option.
+ * deprecated?: true | string;
+ * }
+ * }
+ *
+ * Note: The options below are sorted alphabetically.
+ */
+const options$11 = {
+ color: {
+ // The supports-color package (a sub sub dependency) looks directly at
+ // `process.argv` for `--no-color` and such-like options. The reason it is
+ // listed here is to avoid "Ignored unknown option: --no-color" warnings.
+ // See https://github.com/chalk/supports-color/#info for more information.
+ type: "boolean",
+ default: true,
+ description: "Colorize error messages.",
+ oppositeDescription: "Do not colorize error messages."
+ },
+ config: {
+ type: "path",
+ category: CATEGORY_CONFIG,
+ description:
+ "Path to a Prettier configuration file (.prettierrc, package.json, prettier.config.js).",
+ oppositeDescription: "Do not look for a configuration file."
+ },
+ "config-precedence": {
+ type: "choice",
+ category: CATEGORY_CONFIG,
+ default: "cli-override",
+ choices: [
+ {
+ value: "cli-override",
+ description: "CLI options take precedence over config file"
+ },
+ {
+ value: "file-override",
+ description: "Config file take precedence over CLI options"
+ },
+ {
+ value: "prefer-file",
+ description: dedent_1`
+ If a config file is found will evaluate it and ignore other CLI options.
+ If no config file is found CLI options will evaluate as normal.
+ `
+ }
+ ],
+ description:
+ "Define in which order config files and CLI options should be evaluated."
+ },
+ "debug-check": {
+ type: "boolean"
+ },
+ "debug-print-doc": {
+ type: "boolean"
+ },
+ editorconfig: {
+ type: "boolean",
+ category: CATEGORY_CONFIG,
+ description: "Take .editorconfig into account when parsing configuration.",
+ oppositeDescription:
+ "Don't take .editorconfig into account when parsing configuration.",
+ default: true
+ },
+ "find-config-path": {
+ type: "path",
+ category: CATEGORY_CONFIG,
+ description:
+ "Find and print the path to a configuration file for the given input file."
+ },
+ help: {
+ type: "flag",
+ alias: "h",
+ description: dedent_1`
+ Show CLI usage, or details about the given flag.
+ Example: --help write
+ `
+ },
+ "ignore-path": {
+ type: "path",
+ category: CATEGORY_CONFIG,
+ default: ".prettierignore",
+ description: "Path to a file with patterns describing files to ignore."
+ },
+ "list-different": {
+ type: "boolean",
+ category: CATEGORY_OUTPUT,
+ alias: "l",
+ description:
+ "Print the names of files that are different from Prettier's formatting."
+ },
+ loglevel: {
+ type: "choice",
+ description: "What level of logs to report.",
+ default: "log",
+ choices: ["silent", "error", "warn", "log", "debug"]
+ },
+ stdin: {
+ type: "boolean",
+ description: "Force reading input from stdin."
+ },
+ "support-info": {
+ type: "boolean",
+ description: "Print support information as JSON."
+ },
+ version: {
+ type: "boolean",
+ alias: "v",
+ description: "Print Prettier version."
+ },
+ "with-node-modules": {
+ type: "boolean",
+ category: CATEGORY_CONFIG,
+ description: "Process files inside 'node_modules' directory."
+ },
+ write: {
+ type: "boolean",
+ category: CATEGORY_OUTPUT,
+ description: "Edit files in-place. (Beware!)"
+ }
+};
+
+const usageSummary = dedent_1`
+ Usage: prettier [options] [file/glob ...]
+
+ By default, output is written to stdout.
+ Stdin is read if it is piped to Prettier and no files are given.
+`;
+
+var constant = {
+ CATEGORY_CONFIG,
+ CATEGORY_EDITOR,
+ CATEGORY_FORMAT,
+ CATEGORY_OTHER,
+ CATEGORY_OUTPUT,
+ categoryOrder,
+ options: options$11,
+ usageSummary
+};
+
+var require$$0$11 = ( _package$1 && _package ) || _package$1;
+
+const currentVersion = require$$0$11.version;
+
+
+
+const CATEGORY_GLOBAL = "Global";
+const CATEGORY_SPECIAL = "Special";
+
+/**
+ * @typedef {Object} OptionInfo
+ * @property {string} since - available since version
+ * @property {string} category
+ * @property {'int' | 'boolean' | 'choice' | 'path'} type
+ * @property {boolean} array - indicate it's an array of the specified type
+ * @property {boolean?} deprecated - deprecated since version
+ * @property {OptionRedirectInfo?} redirect - redirect deprecated option
+ * @property {string} description
+ * @property {string?} oppositeDescription - for `false` option
+ * @property {OptionValueInfo} default
+ * @property {OptionRangeInfo?} range - for type int
+ * @property {OptionChoiceInfo?} choices - for type choice
+ * @property {(value: any) => boolean} exception
+ *
+ * @typedef {number | boolean | string} OptionValue
+ * @typedef {OptionValue | [{ value: OptionValue[] }] | Array<{ since: string, value: OptionValue}>} OptionValueInfo
+ *
+ * @typedef {Object} OptionRedirectInfo
+ * @property {string} option
+ * @property {OptionValue} value
+ *
+ * @typedef {Object} OptionRangeInfo
+ * @property {number} start - recommended range start
+ * @property {number} end - recommended range end
+ * @property {number} step - recommended range step
+ *
+ * @typedef {Object} OptionChoiceInfo
+ * @property {boolean | string} value - boolean for the option that is originally boolean type
+ * @property {string?} description - undefined if redirect
+ * @property {string?} since - undefined if available since the first version of the option
+ * @property {string?} deprecated - deprecated since version
+ * @property {OptionValueInfo?} redirect - redirect deprecated value
+ *
+ * @property {string?} cliName
+ * @property {string?} cliCategory
+ * @property {string?} cliDescription
+ */
+/** @type {{ [name: string]: OptionInfo } */
+const supportOptions = {
+ cursorOffset: {
+ since: "1.4.0",
+ category: CATEGORY_SPECIAL,
+ type: "int",
+ default: -1,
+ range: { start: -1, end: Infinity, step: 1 },
+ description: dedent_1`
+ Print (to stderr) where a cursor at the given position would move to after formatting.
+ This option cannot be used with --range-start and --range-end.
+ `,
+ cliCategory: constant.CATEGORY_EDITOR
+ },
+ filepath: {
+ since: "1.4.0",
+ category: CATEGORY_SPECIAL,
+ type: "path",
+ default: undefined,
+ description:
+ "Specify the input filepath. This will be used to do parser inference.",
+ cliName: "stdin-filepath",
+ cliCategory: constant.CATEGORY_OTHER,
+ cliDescription: "Path to the file to pretend that stdin comes from."
+ },
+ insertPragma: {
+ since: "1.8.0",
+ category: CATEGORY_SPECIAL,
+ type: "boolean",
+ default: false,
+ description: "Insert @format pragma into file's first docblock comment.",
+ cliCategory: constant.CATEGORY_OTHER
+ },
+ parser: {
+ since: "0.0.10",
+ category: CATEGORY_GLOBAL,
+ type: "choice",
+ default: "babylon",
+ description: "Which parser to use.",
+ exception: value =>
+ typeof value === "string" || typeof value === "function",
+ choices: [
+ { value: "flow", description: "Flow" },
+ { value: "babylon", description: "JavaScript" },
+ { value: "typescript", since: "1.4.0", description: "TypeScript" },
+ { value: "css", since: "1.7.1", description: "CSS" },
+ {
+ value: "postcss",
+ since: "1.4.0",
+ description: "CSS/Less/SCSS",
+ deprecated: "1.7.1",
+ redirect: "css"
+ },
+ { value: "less", since: "1.7.1", description: "Less" },
+ { value: "scss", since: "1.7.1", description: "SCSS" },
+ { value: "json", since: "1.5.0", description: "JSON" },
+ { value: "graphql", since: "1.5.0", description: "GraphQL" },
+ { value: "markdown", since: "1.8.0", description: "Markdown" },
+ { value: "vue", since: "1.10.0", description: "Vue" }
+ ]
+ },
+ plugins: {
+ since: "1.10.0",
+ type: "path",
+ array: true,
+ default: [{ value: [] }],
+ category: CATEGORY_GLOBAL,
+ description:
+ "Add a plugin. Multiple plugins can be passed as separate `--plugin`s.",
+ exception: value => typeof value === "string" || typeof value === "object",
+ cliName: "plugin",
+ cliCategory: constant.CATEGORY_CONFIG
+ },
+ printWidth: {
+ since: "0.0.0",
+ category: CATEGORY_GLOBAL,
+ type: "int",
+ default: 80,
+ description: "The line length where Prettier will try wrap.",
+ range: { start: 0, end: Infinity, step: 1 }
+ },
+ rangeEnd: {
+ since: "1.4.0",
+ category: CATEGORY_SPECIAL,
+ type: "int",
+ default: Infinity,
+ range: { start: 0, end: Infinity, step: 1 },
+ description: dedent_1`
+ Format code ending at a given character offset (exclusive).
+ The range will extend forwards to the end of the selected statement.
+ This option cannot be used with --cursor-offset.
+ `,
+ cliCategory: constant.CATEGORY_EDITOR
+ },
+ rangeStart: {
+ since: "1.4.0",
+ category: CATEGORY_SPECIAL,
+ type: "int",
+ default: 0,
+ range: { start: 0, end: Infinity, step: 1 },
+ description: dedent_1`
+ Format code starting at a given character offset.
+ The range will extend backwards to the start of the first line containing the selected statement.
+ This option cannot be used with --cursor-offset.
+ `,
+ cliCategory: constant.CATEGORY_EDITOR
+ },
+ requirePragma: {
+ since: "1.7.0",
+ category: CATEGORY_SPECIAL,
+ type: "boolean",
+ default: false,
+ description: dedent_1`
+ Require either '@prettier' or '@format' to be present in the file's first docblock comment
+ in order for it to be formatted.
+ `,
+ cliCategory: constant.CATEGORY_OTHER
+ },
+ tabWidth: {
+ type: "int",
+ category: CATEGORY_GLOBAL,
+ default: 2,
+ description: "Number of spaces per indentation level.",
+ range: { start: 0, end: Infinity, step: 1 }
+ },
+ useFlowParser: {
+ since: "0.0.0",
+ category: CATEGORY_GLOBAL,
+ type: "boolean",
+ default: false,
+ deprecated: "0.0.10",
+ description: "Use flow parser.",
+ redirect: { option: "parser", value: "flow" },
+ cliName: "flow-parser"
+ },
+ useTabs: {
+ since: "1.0.0",
+ category: CATEGORY_GLOBAL,
+ type: "boolean",
+ default: false,
+ description: "Indent with tabs instead of spaces."
+ }
+};
+
+function getSupportInfo$1(version, opts) {
+ opts = Object.assign(
+ {
+ plugins: [],
+ pluginsLoaded: false,
+ showUnreleased: false,
+ showDeprecated: false,
+ showInternal: false
+ },
+ opts
+ );
+
+ if (!version) {
+ version = currentVersion;
+ }
+
+ const plugins = opts.pluginsLoaded ? opts.plugins : loadPlugins_1(opts.plugins);
+
+ const options = util$1
+ .arrayify(
+ Object.assign(
+ plugins.reduce(
+ (currentOptions, plugin) =>
+ Object.assign(currentOptions, plugin.options),
+ {}
+ ),
+ supportOptions
+ ),
+ "name"
+ )
+ .sort((a, b) => (a.name === b.name ? 0 : a.name < b.name ? -1 : 1))
+ .filter(filterSince)
+ .filter(filterDeprecated)
+ .map(mapDeprecated)
+ .map(mapInternal)
+ .map(option => {
+ const newOption = Object.assign({}, option);
+
+ if (Array.isArray(newOption.default)) {
+ newOption.default =
+ newOption.default.length === 1
+ ? newOption.default[0].value
+ : newOption.default
+ .filter(filterSince)
+ .sort((info1, info2) =>
+ semver.compare(info2.since, info1.since)
+ )[0].value;
+ }
+
+ if (Array.isArray(newOption.choices)) {
+ newOption.choices = newOption.choices
+ .filter(filterSince)
+ .filter(filterDeprecated)
+ .map(mapDeprecated);
+ }
+
+ return newOption;
+ })
+ .map(option => {
+ const filteredPlugins = plugins.filter(
+ plugin => plugin.defaultOptions && plugin.defaultOptions[option.name]
+ );
+ const pluginDefaults = filteredPlugins.reduce((reduced, plugin) => {
+ reduced[plugin.name] = plugin.defaultOptions[option.name];
+ return reduced;
+ }, {});
+ return Object.assign(option, { pluginDefaults });
+ });
+
+ const usePostCssParser = semver.lt(version, "1.7.1");
+
+ const languages = plugins
+ .reduce((all, plugin) => all.concat(plugin.languages), [])
+ .filter(
+ language =>
+ language.since
+ ? semver.gte(version, language.since)
+ : language.since !== null
+ )
+ .map(language => {
+ // Prevent breaking changes
+ if (language.name === "Markdown") {
+ return Object.assign({}, language, {
+ parsers: ["markdown"]
+ });
+ }
+ if (language.name === "TypeScript") {
+ return Object.assign({}, language, {
+ parsers: ["typescript"]
+ });
+ }
+
+ if (usePostCssParser && language.group === "CSS") {
+ return Object.assign({}, language, {
+ parsers: ["postcss"]
+ });
+ }
+ return language;
+ });
+
+ return { languages, options };
+
+ function filterSince(object) {
+ return (
+ opts.showUnreleased ||
+ !("since" in object) ||
+ (object.since && semver.gte(version, object.since))
+ );
+ }
+ function filterDeprecated(object) {
+ return (
+ opts.showDeprecated ||
+ !("deprecated" in object) ||
+ (object.deprecated && semver.lt(version, object.deprecated))
+ );
+ }
+ function mapDeprecated(object) {
+ if (!object.deprecated || opts.showDeprecated) {
+ return object;
+ }
+ const newObject = Object.assign({}, object);
+ delete newObject.deprecated;
+ delete newObject.redirect;
+ return newObject;
+ }
+ function mapInternal(object) {
+ if (opts.showInternal) {
+ return object;
+ }
+ const newObject = Object.assign({}, object);
+ delete newObject.cliName;
+ delete newObject.cliCategory;
+ delete newObject.cliDescription;
+ return newObject;
+ }
+}
+
+var support = {
+ getSupportInfo: getSupportInfo$1
+};
+
+function FastPath(value) {
+ assert.ok(this instanceof FastPath);
+ this.stack = [value];
+}
+
+// The name of the current property is always the penultimate element of
+// this.stack, and always a String.
+FastPath.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.
+ /* istanbul ignore next */
+ return null;
+};
+
+// The value of the current property is always the final element of
+// this.stack.
+FastPath.prototype.getValue = function getValue() {
+ const s = this.stack;
+ return s[s.length - 1];
+};
+
+function getNodeHelper(path$$1, count) {
+ const s = path$$1.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.prototype.getNode = function getNode(count) {
+ return getNodeHelper(this, ~~count);
+};
+
+FastPath.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.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.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.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;
+};
+
+var fastPath = FastPath;
+
+/* eslint-disable no-nested-ternary */
+var arr = [];
+var charCodeCache = [];
+
+var leven = 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;
+};
+
+function apiDescriptor(name, value) {
+ return arguments.length === 1
+ ? JSON.stringify(name)
+ : `\`{ ${apiDescriptor(name)}: ${JSON.stringify(value)} }\``;
+}
+
+function cliDescriptor(name, value) {
+ return value === false
+ ? `\`--no-${name}\``
+ : value === true || arguments.length === 1
+ ? `\`--${name}\``
+ : value === ""
+ ? `\`--${name}\` without an argument`
+ : `\`--${name}=${value}\``;
+}
+
+var optionsDescriptor = {
+ apiDescriptor,
+ cliDescriptor
+};
+
+function validateOption(value, optionInfo, opts) {
+ opts = opts || {};
+ const descriptor = opts.descriptor || optionsDescriptor.apiDescriptor;
+
+ if (
+ typeof optionInfo.exception === "function" &&
+ optionInfo.exception(value)
+ ) {
+ return;
+ }
+
+ try {
+ validateOptionType(value, optionInfo);
+ } catch (error) {
+ throw new Error(
+ `Invalid \`${descriptor(optionInfo.name)}\` value. ${
+ error.message
+ }, but received \`${JSON.stringify(value)}\`.`
+ );
+ }
+}
+
+function validateOptionType(value, optionInfo) {
+ if (optionInfo.array) {
+ if (!Array.isArray(value)) {
+ throw new Error(`Expected an array`);
+ }
+ value.forEach(v =>
+ validateOptionType(v, Object.assign({}, optionInfo, { array: false }))
+ );
+ } else {
+ switch (optionInfo.type) {
+ case "int":
+ validateIntOption(value);
+ break;
+ case "boolean":
+ validateBooleanOption(value);
+ break;
+ case "choice":
+ validateChoiceOption(value, optionInfo.choices);
+ break;
+ }
+ }
+}
+
+function validateBooleanOption(value) {
+ if (typeof value !== "boolean") {
+ throw new Error(`Expected a boolean`);
+ }
+}
+
+function validateIntOption(value) {
+ if (
+ !(
+ typeof value === "number" &&
+ Math.floor(value) === value &&
+ value >= 0 &&
+ value !== Infinity
+ )
+ ) {
+ throw new Error(`Expected an integer`);
+ }
+}
+
+function validateChoiceOption(value, choiceInfos) {
+ if (!choiceInfos.some(choiceInfo => choiceInfo.value === value)) {
+ const choices = choiceInfos
+ .filter(choiceInfo => !choiceInfo.deprecated)
+ .map(choiceInfo => JSON.stringify(choiceInfo.value))
+ .sort();
+ const head = choices.slice(0, -2);
+ const tail = choices.slice(-2);
+ throw new Error(`Expected ${head.concat(tail.join(" or ")).join(", ")}`);
+ }
+}
+
+var optionsValidator = { validateOption };
+
+function normalizeOptions$1(options, optionInfos, opts) {
+ opts = opts || {};
+ const logger =
+ opts.logger === false
+ ? { warn() {} }
+ : opts.logger !== undefined
+ ? opts.logger
+ : console;
+ const descriptor = opts.descriptor || optionsDescriptor.apiDescriptor;
+ const passThrough = opts.passThrough || [];
+
+ const optionInfoMap = optionInfos.reduce(
+ (reduced, optionInfo) =>
+ Object.assign(reduced, { [optionInfo.name]: optionInfo }),
+ {}
+ );
+ const normalizedOptions = Object.keys(options).reduce((newOptions, key) => {
+ const optionInfo = optionInfoMap[key];
+
+ let optionName = key;
+ let optionValue = options[key];
+
+ if (!optionInfo) {
+ if (passThrough === true || passThrough.indexOf(optionName) !== -1) {
+ newOptions[optionName] = optionValue;
+ } else {
+ logger.warn(
+ createUnknownOptionMessage(
+ optionName,
+ optionValue,
+ optionInfos,
+ descriptor
+ )
+ );
+ }
+ return newOptions;
+ }
+
+ if (!optionInfo.deprecated) {
+ optionValue = normalizeOption(optionValue, optionInfo);
+ } else if (typeof optionInfo.redirect === "string") {
+ logger.warn(createRedirectOptionMessage(optionInfo, descriptor));
+ optionName = optionInfo.redirect;
+ } else if (optionValue) {
+ logger.warn(createRedirectOptionMessage(optionInfo, descriptor));
+ optionValue = optionInfo.redirect.value;
+ optionName = optionInfo.redirect.option;
+ }
+
+ if (optionInfo.choices) {
+ const choiceInfo = optionInfo.choices.find(
+ choice => choice.value === optionValue
+ );
+ if (choiceInfo && choiceInfo.deprecated) {
+ logger.warn(
+ createRedirectChoiceMessage(optionInfo, choiceInfo, descriptor)
+ );
+ optionValue = choiceInfo.redirect;
+ }
+ }
+
+ if (optionInfo.array && !Array.isArray(optionValue)) {
+ optionValue = [optionValue];
+ }
+
+ if (optionValue !== optionInfo.default) {
+ optionsValidator.validateOption(optionValue, optionInfoMap[optionName], {
+ descriptor
+ });
+ }
+
+ newOptions[optionName] = optionValue;
+ return newOptions;
+ }, {});
+
+ return normalizedOptions;
+}
+
+function normalizeOption(option, optionInfo) {
+ return optionInfo.type === "int" ? Number(option) : option;
+}
+
+function createUnknownOptionMessage(key, value, optionInfos, descriptor) {
+ const messages = [`Ignored unknown option ${descriptor(key, value)}.`];
+
+ const suggestedOptionInfo = optionInfos.find(
+ optionInfo => leven(optionInfo.name, key) < 3
+ );
+ if (suggestedOptionInfo) {
+ messages.push(`Did you mean ${JSON.stringify(suggestedOptionInfo.name)}?`);
+ }
+
+ return messages.join(" ");
+}
+
+function createRedirectOptionMessage(optionInfo, descriptor) {
+ return `${descriptor(
+ optionInfo.name
+ )} is deprecated. Prettier now treats it as ${
+ typeof optionInfo.redirect === "string"
+ ? descriptor(optionInfo.redirect)
+ : descriptor(optionInfo.redirect.option, optionInfo.redirect.value)
+ }.`;
+}
+
+function createRedirectChoiceMessage(optionInfo, choiceInfo, descriptor) {
+ return `${descriptor(
+ optionInfo.name,
+ choiceInfo.value
+ )} is deprecated. Prettier now treats it as ${descriptor(
+ optionInfo.name,
+ choiceInfo.redirect
+ )}.`;
+}
+
+function normalizeApiOptions(options, optionInfos, opts) {
+ return normalizeOptions$1(
+ options,
+ optionInfos,
+ Object.assign({ descriptor: optionsDescriptor.apiDescriptor }, opts)
+ );
+}
+
+function normalizeCliOptions(options, optionInfos, opts) {
+ const args = options["_"] || [];
+
+ const newOptions = normalizeOptions$1(
+ Object.keys(options).reduce(
+ (reduced, key) =>
+ Object.assign(
+ reduced,
+ key.length === 1 // omit alias
+ ? null
+ : { [key]: options[key] }
+ ),
+ {}
+ ),
+ optionInfos,
+ Object.assign({ descriptor: optionsDescriptor.cliDescriptor }, opts)
+ );
+ newOptions["_"] = args;
+
+ return newOptions;
+}
+
+var optionsNormalizer = {
+ normalizeApiOptions,
+ normalizeCliOptions
+};
+
+class ConfigError$1 extends Error {}
+class DebugError extends Error {}
+
+var errors = {
+ ConfigError: ConfigError$1,
+ DebugError
+};
+
+var jsTokens = 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
+};
+});
+
+unwrapExports(jsTokens);
+
+var colorName = {
+ "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 = createCommonjsModule(function (module) {
+/* MIT license */
+
+
+// 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 colorName) {
+ if (colorName.hasOwnProperty(key)) {
+ reverseKeywords[colorName[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 colorName) {
+ if (colorName.hasOwnProperty(keyword)) {
+ var value = colorName[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 colorName[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];
+};
+});
+
+/*
+ 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);
+
+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[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$$1 = [graph[toModel].parent, toModel];
+ var fn = conversions[graph[toModel].parent][toModel];
+
+ var cur = graph[toModel].parent;
+ while (graph[cur].parent) {
+ path$$1.unshift(graph[cur].parent);
+ fn = link(conversions[graph[cur].parent][cur], fn);
+ cur = graph[cur].parent;
+ }
+
+ fn.conversion = path$$1;
+ return fn;
+}
+
+var route = 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 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 colorConvert = convert;
+
+var ansiStyles = createCommonjsModule(function (module) {
+'use strict';
+
+
+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],
+
+ // Bright color
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 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],
+
+ // Bright color
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 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] = {
+ open: `\u001B[${style[0]}m`,
+ close: `\u001B[${style[1]}m`
+ };
+
+ group[styleName] = styles[styleName];
+ });
+
+ 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
+});
+});
+
+var hasFlag = function (flag, argv) {
+ argv = argv || process.argv;
+
+ var terminatorPos = argv.indexOf('--');
+ var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+ var pos = argv.indexOf(prefix + flag);
+
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};
+
+var supportsColor = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+const env = process.env;
+
+const support = level => {
+ if (level === 0) {
+ return false;
+ }
+
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+};
+
+let supportLevel = (() => {
+ if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ return 0;
+ }
+
+ if (hasFlag('color=16m') ||
+ hasFlag('color=full') ||
+ hasFlag('color=truecolor')) {
+ return 3;
+ }
+
+ if (hasFlag('color=256')) {
+ return 2;
+ }
+
+ if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ return 1;
+ }
+
+ if (process.stdout && !process.stdout.isTTY) {
+ return 0;
+ }
+
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+ // release that supports 256 colors.
+ const osRelease = os.release().split('.');
+ if (
+ Number(process.version.split('.')[0]) >= 8 &&
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return 2;
+ }
+
+ return 1;
+ }
+
+ if ('CI' in env) {
+ if ('TRAVIS' in env || env.CI === 'Travis' || 'CIRCLECI' in env) {
+ return 1;
+ }
+
+ return 0;
+ }
+
+ if ('TEAMCITY_VERSION' in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
+
+ if ('TERM_PROGRAM' in env) {
+ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Hyper':
+ return 3;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
+
+ if (/^(screen|xterm)-256(?:color)?/.test(env.TERM)) {
+ return 2;
+ }
+
+ if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
+
+ if ('COLORTERM' in env) {
+ return 1;
+ }
+
+ if (env.TERM === 'dumb') {
+ return 0;
+ }
+
+ return 0;
+})();
+
+if ('FORCE_COLOR' in env) {
+ supportLevel = parseInt(env.FORCE_COLOR, 10) === 0 ? 0 : (supportLevel || 1);
+}
+
+module.exports = process && support(supportLevel);
+});
+
+var templates = createCommonjsModule(function (module) {
+'use strict';
+const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
+
+const ESCAPES = new Map([
+ ['n', '\n'],
+ ['r', '\r'],
+ ['t', '\t'],
+ ['b', '\b'],
+ ['f', '\f'],
+ ['v', '\v'],
+ ['0', '\0'],
+ ['\\', '\\'],
+ ['e', '\u001B'],
+ ['a', '\u0007']
+]);
+
+function unescape(c) {
+ if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
+ }
+
+ return ESCAPES.get(c) || c;
+}
+
+function parseArguments(name, args) {
+ const results = [];
+ const chunks = args.trim().split(/\s*,\s*/g);
+ let matches;
+
+ for (const chunk of chunks) {
+ if (!isNaN(chunk)) {
+ results.push(Number(chunk));
+ } else if ((matches = chunk.match(STRING_REGEX))) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
+
+ return results;
+}
+
+function parseStyle(style) {
+ STYLE_REGEX.lastIndex = 0;
+
+ const results = [];
+ let matches;
+
+ while ((matches = STYLE_REGEX.exec(style)) !== null) {
+ const name = matches[1];
+
+ if (matches[2]) {
+ const args = parseArguments(name, matches[2]);
+ results.push([name].concat(args));
+ } else {
+ results.push([name]);
+ }
+ }
+
+ return results;
+}
+
+function buildStyle(chalk, styles) {
+ const enabled = {};
+
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
+
+ let current = chalk;
+ for (const styleName of Object.keys(enabled)) {
+ if (Array.isArray(enabled[styleName])) {
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
+
+ if (enabled[styleName].length > 0) {
+ current = current[styleName].apply(current, enabled[styleName]);
+ } else {
+ current = current[styleName];
+ }
+ }
+ }
+
+ return current;
+}
+
+module.exports = (chalk, tmp) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
+
+ // eslint-disable-next-line max-params
+ tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+ if (escapeChar) {
+ chunk.push(unescape(escapeChar));
+ } else if (style) {
+ const str = chunk.join('');
+ chunk = [];
+ chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+ styles.push({inverse, styles: parseStyle(style)});
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error('Found extraneous } in Chalk template literal');
+ }
+
+ chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(chr);
+ }
+ });
+
+ chunks.push(chunk.join(''));
+
+ if (styles.length > 0) {
+ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+ throw new Error(errMsg);
+ }
+
+ return chunks.join('');
+};
+});
+
+var chalk = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+
+
+
+const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+
+// `color-convert` models to exclude from the Chalk API due to conflicts and such
+const skipModels = new Set(['gray']);
+
+const styles = Object.create(null);
+
+function applyOptions(obj, options) {
+ options = options || {};
+
+ // Detect level if not set manually
+ const scLevel = supportsColor ? supportsColor.level : 0;
+ obj.level = options.level === undefined ? scLevel : options.level;
+ obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
+}
+
+function Chalk(options) {
+ // We check for this.template here since calling `chalk.constructor()`
+ // by itself will have a `this` of a previously constructed chalk object
+ if (!this || !(this instanceof Chalk) || this.template) {
+ const chalk = {};
+ applyOptions(chalk, options);
+
+ chalk.template = function () {
+ const args = [].slice.call(arguments);
+ return chalkTag.apply(null, [chalk.template].concat(args));
+ };
+
+ Object.setPrototypeOf(chalk, Chalk.prototype);
+ Object.setPrototypeOf(chalk.template, chalk);
+
+ chalk.template.constructor = Chalk;
+
+ return chalk.template;
+ }
+
+ applyOptions(this, options);
+}
+
+// Use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+ ansiStyles.blue.open = '\u001B[94m';
+}
+
+for (const key of Object.keys(ansiStyles)) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+
+ styles[key] = {
+ get() {
+ const codes = ansiStyles[key];
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+ }
+ };
+}
+
+styles.visible = {
+ get() {
+ return build.call(this, this._styles || [], true, 'visible');
+ }
+};
+
+ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
+for (const model of Object.keys(ansiStyles.color.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
+
+ styles[model] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.color.close,
+ closeRe: ansiStyles.color.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+}
+
+ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
+
+ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.bgColor.close,
+ closeRe: ansiStyles.bgColor.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+}
+
+const proto = Object.defineProperties(() => {}, styles);
+
+function build(_styles, _empty, key) {
+ const builder = function () {
+ return applyStyle.apply(builder, arguments);
+ };
+
+ builder._styles = _styles;
+ builder._empty = _empty;
+
+ const self = this;
+
+ Object.defineProperty(builder, 'level', {
+ enumerable: true,
+ get() {
+ return self.level;
+ },
+ set(level) {
+ self.level = level;
+ }
+ });
+
+ Object.defineProperty(builder, 'enabled', {
+ enumerable: true,
+ get() {
+ return self.enabled;
+ },
+ set(enabled) {
+ self.enabled = enabled;
+ }
+ });
+
+ // See below for fix regarding invisible grey/dim combination on Windows
+ builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+
+ // `__proto__` is used because we must return a function, but there is
+ // no way to create a function with a different prototype
+ builder.__proto__ = proto; // eslint-disable-line no-proto
+
+ return builder;
+}
+
+function applyStyle() {
+ // Support varags, but simply cast to string in case there's only one arg
+ const args = arguments;
+ const argsLen = args.length;
+ let str = String(arguments[0]);
+
+ if (argsLen === 0) {
+ return '';
+ }
+
+ if (argsLen > 1) {
+ // Don't slice `arguments`, it prevents V8 optimizations
+ for (let a = 1; a < argsLen; a++) {
+ str += ' ' + args[a];
+ }
+ }
+
+ if (!this.enabled || this.level <= 0 || !str) {
+ return this._empty ? '' : str;
+ }
+
+ // 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.
+ const originalDim = ansiStyles.dim.open;
+ if (isSimpleWindowsTerm && this.hasGrey) {
+ ansiStyles.dim.open = '';
+ }
+
+ for (const code of this._styles.slice().reverse()) {
+ // 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;
+
+ // Close the styling before a linebreak and reopen
+ // after next line to fix a bleed issue on macOS
+ // https://github.com/chalk/chalk/pull/92
+ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+ }
+
+ // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
+ ansiStyles.dim.open = originalDim;
+
+ return str;
+}
+
+function chalkTag(chalk, strings) {
+ if (!Array.isArray(strings)) {
+ // If chalk() was called by itself or with a string,
+ // return the string itself as a string.
+ return [].slice.call(arguments, 1).join(' ');
+ }
+
+ const args = [].slice.call(arguments, 2);
+ const parts = [strings.raw[0]];
+
+ for (let i = 1; i < strings.length; i++) {
+ parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+ parts.push(String(strings.raw[i]));
+ }
+
+ return templates(chalk, parts.join(''));
+}
+
+Object.defineProperties(Chalk.prototype, styles);
+
+module.exports = Chalk(); // eslint-disable-line new-cap
+module.exports.supportsColor = supportsColor;
+module.exports.default = module.exports; // For TypeScript
+});
+
+var lib$5 = createCommonjsModule(function (module, exports) {
+"use strict";
+
+exports.__esModule = true;
+exports.shouldHighlight = shouldHighlight;
+exports.getChalk = getChalk;
+exports.default = highlight;
+
+var _jsTokens = _interopRequireWildcard(jsTokens);
+
+var _esutils = _interopRequireDefault(utils$2);
+
+var _chalk = _interopRequireDefault(chalk);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function getDefs(chalk$$1) {
+ return {
+ keyword: chalk$$1.cyan,
+ capitalized: chalk$$1.yellow,
+ jsx_tag: chalk$$1.yellow,
+ punctuator: chalk$$1.yellow,
+ number: chalk$$1.magenta,
+ string: chalk$$1.green,
+ regex: chalk$$1.magenta,
+ comment: chalk$$1.grey,
+ invalid: chalk$$1.white.bgRed.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 (_esutils.default.keyword.isReservedWordES6(token.value)) {
+ return "keyword";
+ }
+
+ if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == ""), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
+ } else {
+ return " " + maybeHighlight(defs.gutter, gutter) + line;
+ }
+ }).join("\n");
+
+ if (opts.message && !hasColumns) {
+ frame = "" + " ".repeat(numberMaxWidth + 1) + opts.message + "\n" + frame;
+ }
+
+ if (highlighted) {
+ return chalk.reset(frame);
+ } else {
+ return frame;
+ }
+}
+
+function _default(rawLines, lineNumber, colNumber, opts) {
+ if (opts === void 0) {
+ opts = {};
+ }
+
+ if (!deprecationWarningShown) {
+ deprecationWarningShown = true;
+ var deprecationError = new Error("Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.");
+ deprecationError.name = "DeprecationWarning";
+
+ if (process.emitWarning) {
+ process.emitWarning(deprecationError);
+ } else {
+ console.warn(deprecationError);
+ }
+ }
+
+ colNumber = Math.max(colNumber, 0);
+ var location = {
+ start: {
+ column: colNumber,
+ line: lineNumber
+ }
+ };
+ return codeFrameColumns(rawLines, location, opts);
+}
+});
+
+unwrapExports(lib$4);
+
+const ConfigError = errors.ConfigError;
+
+
+const locStart$1 = languageJs.locStart;
+const locEnd$1 = languageJs.locEnd;
+
+function getParsers(options) {
+ return options.plugins.reduce(
+ (parsers, plugin) => Object.assign({}, parsers, plugin.parsers),
+ {}
+ );
+}
+
+function resolveParser$1(opts, parsers) {
+ parsers = parsers || getParsers(opts);
+
+ if (typeof opts.parser === "function") {
+ // Custom parser API always works with JavaScript.
+ return {
+ parse: opts.parser,
+ astFormat: "estree",
+ locStart: locStart$1,
+ locEnd: locEnd$1
+ };
+ }
+
+ if (typeof opts.parser === "string") {
+ if (parsers.hasOwnProperty(opts.parser)) {
+ return parsers[opts.parser];
+ }
+ try {
+ return {
+ parse: require(path.resolve(process.cwd(), opts.parser)),
+ astFormat: "estree",
+ locStart: locStart$1,
+ locEnd: locEnd$1
+ };
+ } catch (err) {
+ /* istanbul ignore next */
+ throw new ConfigError(`Couldn't resolve parser "${opts.parser}"`);
+ }
+ }
+ /* istanbul ignore next */
+ return parsers.babylon;
+}
+
+function parse$3(text, opts) {
+ const parsers = getParsers(opts);
+
+ // Copy the "parse" function from parser to a new object whose values are
+ // functions. Use defineProperty()/getOwnPropertyDescriptor() such that we
+ // don't invoke the parser.parse getters.
+ const parsersForCustomParserApi = Object.keys(parsers).reduce(
+ (object, parserName) =>
+ Object.defineProperty(
+ object,
+ parserName,
+ Object.getOwnPropertyDescriptor(parsers[parserName], "parse")
+ ),
+ {}
+ );
+
+ const parser = resolveParser$1(opts, parsers);
+
+ try {
+ if (parser.preprocess) {
+ text = parser.preprocess(text, opts);
+ }
+
+ return {
+ text,
+ ast: parser.parse(text, parsersForCustomParserApi, opts)
+ };
+ } catch (error) {
+ const loc = error.loc;
+
+ if (loc) {
+ const codeFrame = lib$4;
+ error.codeFrame = codeFrame.codeFrameColumns(text, loc, {
+ highlightCode: true
+ });
+ error.message += "\n" + error.codeFrame;
+ throw error;
+ }
+
+ /* istanbul ignore next */
+ throw error.stack;
+ }
+}
+
+var parser$3 = { parse: parse$3, resolveParser: resolveParser$1 };
+
+function getPlugin(options) {
+ const astFormat = options.astFormat;
+
+ if (!astFormat) {
+ throw new Error("getPlugin() requires astFormat to be set");
+ }
+ const printerPlugin = options.plugins.find(
+ plugin => plugin.printers[astFormat]
+ );
+ if (!printerPlugin) {
+ throw new Error(`Couldn't find plugin for AST format "${astFormat}"`);
+ }
+
+ return printerPlugin;
+}
+
+var getPlugin_1 = getPlugin;
+
+const getSupportInfo$2 = support.getSupportInfo;
+
+
+const resolveParser = parser$3.resolveParser;
+
+
+const hiddenDefaults = {
+ astFormat: "estree",
+ printer: {},
+ locStart: null,
+ locEnd: null
+};
+
+// Copy options and fill in default values.
+function normalize$2(options, opts) {
+ opts = opts || {};
+
+ const rawOptions = Object.assign({}, options);
+
+ const plugins = loadPlugins_1(rawOptions.plugins);
+ rawOptions.plugins = plugins;
+
+ const supportOptions = getSupportInfo$2(null, {
+ plugins,
+ pluginsLoaded: true,
+ showUnreleased: true,
+ showDeprecated: true
+ }).options;
+ const defaults = supportOptions.reduce(
+ (reduced, optionInfo) =>
+ Object.assign(reduced, { [optionInfo.name]: optionInfo.default }),
+ Object.assign({}, hiddenDefaults)
+ );
+
+ if (opts.inferParser !== false) {
+ if (
+ rawOptions.filepath &&
+ (!rawOptions.parser || rawOptions.parser === defaults.parser)
+ ) {
+ const inferredParser = inferParser(
+ rawOptions.filepath,
+ rawOptions.plugins
+ );
+ if (inferredParser) {
+ rawOptions.parser = inferredParser;
+ }
+ }
+ }
+
+ const parser = resolveParser(
+ !rawOptions.parser
+ ? rawOptions
+ : // handle deprecated parsers
+ optionsNormalizer.normalizeApiOptions(
+ rawOptions,
+ [supportOptions.find(x => x.name === "parser")],
+ { passThrough: true, logger: false }
+ )
+ );
+ rawOptions.astFormat = parser.astFormat;
+ rawOptions.locEnd = parser.locEnd;
+ rawOptions.locStart = parser.locStart;
+
+ const plugin = getPlugin_1(rawOptions);
+ rawOptions.printer = plugin.printers[rawOptions.astFormat];
+
+ const pluginDefaults = supportOptions
+ .filter(
+ optionInfo =>
+ optionInfo.pluginDefaults && optionInfo.pluginDefaults[plugin.name]
+ )
+ .reduce(
+ (reduced, optionInfo) =>
+ Object.assign(reduced, {
+ [optionInfo.name]: optionInfo.pluginDefaults[plugin.name]
+ }),
+ {}
+ );
+
+ const mixedDefaults = Object.assign({}, defaults, pluginDefaults);
+
+ Object.keys(mixedDefaults).forEach(k => {
+ if (rawOptions[k] == null) {
+ rawOptions[k] = mixedDefaults[k];
+ }
+ });
+
+ if (rawOptions.parser === "json") {
+ rawOptions.trailingComma = "none";
+ }
+
+ return optionsNormalizer.normalizeApiOptions(
+ rawOptions,
+ supportOptions,
+ Object.assign({ passThrough: Object.keys(hiddenDefaults) }, opts)
+ );
+}
+
+function inferParser(filepath, plugins) {
+ const extension = path.extname(filepath);
+ const filename = path.basename(filepath).toLowerCase();
+
+ const language = getSupportInfo$2(null, {
+ plugins,
+ pluginsLoaded: true
+ }).languages.find(
+ language =>
+ language.since !== null &&
+ (language.extensions.indexOf(extension) > -1 ||
+ (language.filenames &&
+ language.filenames.find(name => name.toLowerCase() === filename)))
+ );
+
+ return language && language.parsers[0];
+}
+
+var options$12 = { normalize: normalize$2, hiddenDefaults };
+
+const normalize$1 = options$12.normalize;
+
+
+function printSubtree(path$$1, print, options) {
+ if (options.printer.embed) {
+ return options.printer.embed(
+ path$$1,
+ print,
+ (text, partialNextOptions) =>
+ textToDoc(text, partialNextOptions, options),
+ options
+ );
+ }
+}
+
+function textToDoc(text, partialNextOptions, parentOptions) {
+ const nextOptions = normalize$1(
+ Object.assign({}, parentOptions, partialNextOptions, {
+ parentParser: parentOptions.parser,
+ originalText: text
+ }),
+ { passThrough: true, inferParser: false }
+ );
+
+ const result = parser$3.parse(text, nextOptions);
+ const ast = result.ast;
+ text = result.text;
+
+ const astComments = ast.comments;
+ delete ast.comments;
+ comments.attach(astComments, ast, text, nextOptions);
+ return astToDoc(ast, nextOptions);
+}
+
+var multiparser = {
+ printSubtree
+};
+
+const doc$3 = doc;
+const docBuilders$14 = doc$3.builders;
+const concat$14 = docBuilders$14.concat;
+const hardline$13 = docBuilders$14.hardline;
+const addAlignmentToDoc$2 = docBuilders$14.addAlignmentToDoc;
+const docUtils$6 = doc$3.utils;
+
+function printAstToDoc(ast, options, addAlignmentSize) {
+ addAlignmentSize = addAlignmentSize || 0;
+
+ const printer = options.printer;
+ const cache = new Map();
+
+ function printGenerically(path$$1, args) {
+ const node = path$$1.getValue();
+
+ const shouldCache = node && typeof node === "object" && args === undefined;
+ if (shouldCache && cache.has(node)) {
+ return cache.get(node);
+ }
+
+ // We let JSXElement print its comments itself because it adds () around
+ // UnionTypeAnnotation has to align the child without the comments
+ let res;
+ if (printer.willPrintOwnComments && printer.willPrintOwnComments(path$$1)) {
+ res = genericPrint$6(path$$1, options, printGenerically, args);
+ } else {
+ res = comments.printComments(
+ path$$1,
+ p => genericPrint$6(p, options, printGenerically, args),
+ options,
+ args && args.needsSemi
+ );
+ }
+
+ if (shouldCache) {
+ cache.set(node, res);
+ }
+
+ return res;
+ }
+
+ let doc$$2 = 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$$2 = addAlignmentToDoc$2(
+ docUtils$6.removeLines(concat$14([hardline$13, doc$$2])),
+ addAlignmentSize,
+ options.tabWidth
+ );
+ }
+ docUtils$6.propagateBreaks(doc$$2);
+
+ if (options.parser === "json") {
+ doc$$2 = concat$14([doc$$2, hardline$13]);
+ }
+
+ return doc$$2;
+}
+
+function genericPrint$6(path$$1, options, printPath, args) {
+ assert.ok(path$$1 instanceof fastPath);
+
+ const node = path$$1.getValue();
+ const printer = options.printer;
+
+ // Escape hatch
+ if (printer.hasPrettierIgnore && printer.hasPrettierIgnore(path$$1)) {
+ return options.originalText.slice(
+ options.locStart(node),
+ options.locEnd(node)
+ );
+ }
+
+ if (node) {
+ try {
+ // Potentially switch to a different parser
+ const sub = multiparser.printSubtree(path$$1, printPath, options);
+ if (sub) {
+ return sub;
+ }
+ } catch (error) {
+ /* istanbul ignore if */
+ if (process.env.PRETTIER_DEBUG) {
+ throw error;
+ }
+ // Continue with current parser
+ }
+ }
+
+ return printer.print(path$$1, options, printPath, args);
+}
+
+var astToDoc = printAstToDoc;
+
+var concatMap = function (xs, fn) {
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ var x = fn(xs[i], i);
+ if (isArray(x)) res.push.apply(res, x);
+ else res.push(x);
+ }
+ return res;
+};
+
+var isArray = Array.isArray || function (xs) {
+ return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+var balancedMatch = balanced;
+function balanced(a, b, str) {
+ if (a instanceof RegExp) a = maybeMatch(a, str);
+ if (b instanceof RegExp) b = maybeMatch(b, str);
+
+ var r = range(a, b, str);
+
+ return r && {
+ start: r[0],
+ end: r[1],
+ pre: str.slice(0, r[0]),
+ body: str.slice(r[0] + a.length, r[1]),
+ post: str.slice(r[1] + b.length)
+ };
+}
+
+function maybeMatch(reg, str) {
+ var m = str.match(reg);
+ return m ? m[0] : null;
+}
+
+balanced.range = range;
+function range(a, b, str) {
+ var begs, beg, left, right, result;
+ var ai = str.indexOf(a);
+ var bi = str.indexOf(b, ai + 1);
+ var i = ai;
+
+ if (ai >= 0 && bi > 0) {
+ begs = [];
+ left = str.length;
+
+ while (i >= 0 && !result) {
+ if (i == ai) {
+ begs.push(i);
+ ai = str.indexOf(a, i + 1);
+ } else if (begs.length == 1) {
+ result = [ begs.pop(), bi ];
+ } else {
+ beg = begs.pop();
+ if (beg < left) {
+ left = beg;
+ right = bi;
+ }
+
+ bi = str.indexOf(b, i + 1);
+ }
+
+ i = ai < bi && ai >= 0 ? ai : bi;
+ }
+
+ if (begs.length) {
+ result = [ left, right ];
+ }
+ }
+
+ return result;
+}
+
+var braceExpansion = expandTop;
+
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
+
+function numeric(str) {
+ return parseInt(str, 10) == str
+ ? parseInt(str, 10)
+ : str.charCodeAt(0);
+}
+
+function escapeBraces(str) {
+ return str.split('\\\\').join(escSlash)
+ .split('\\{').join(escOpen)
+ .split('\\}').join(escClose)
+ .split('\\,').join(escComma)
+ .split('\\.').join(escPeriod);
+}
+
+function unescapeBraces(str) {
+ return str.split(escSlash).join('\\')
+ .split(escOpen).join('{')
+ .split(escClose).join('}')
+ .split(escComma).join(',')
+ .split(escPeriod).join('.');
+}
+
+
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+ if (!str)
+ return [''];
+
+ var parts = [];
+ var m = balancedMatch('{', '}', str);
+
+ if (!m)
+ return str.split(',');
+
+ var pre = m.pre;
+ var body = m.body;
+ var post = m.post;
+ var p = pre.split(',');
+
+ p[p.length-1] += '{' + body + '}';
+ var postParts = parseCommaParts(post);
+ if (post.length) {
+ p[p.length-1] += postParts.shift();
+ p.push.apply(p, postParts);
+ }
+
+ parts.push.apply(parts, p);
+
+ return parts;
+}
+
+function expandTop(str) {
+ if (!str)
+ return [];
+
+ // I don't know why Bash 4.3 does this, but it does.
+ // Anything starting with {} will have the first two bytes preserved
+ // but *only* at the top level, so {},a}b will not expand to anything,
+ // but a{},b}c will be expanded to [a}c,abc].
+ // One could argue that this is a bug in Bash, but since the goal of
+ // this module is to match Bash's rules, we escape a leading {}
+ if (str.substr(0, 2) === '{}') {
+ str = '\\{\\}' + str.substr(2);
+ }
+
+ return expand(escapeBraces(str), true).map(unescapeBraces);
+}
+
+function embrace(str) {
+ return '{' + str + '}';
+}
+function isPadded(el) {
+ return /^-?0\d/.test(el);
+}
+
+function lte(i, y) {
+ return i <= y;
+}
+function gte(i, y) {
+ return i >= y;
+}
+
+function expand(str, isTop) {
+ var expansions = [];
+
+ var m = balancedMatch('{', '}', str);
+ if (!m || /\$$/.test(m.pre)) return [str];
+
+ var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+ var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+ var isSequence = isNumericSequence || isAlphaSequence;
+ var isOptions = m.body.indexOf(',') >= 0;
+ if (!isSequence && !isOptions) {
+ // {a},b}
+ if (m.post.match(/,.*\}/)) {
+ str = m.pre + '{' + m.body + escClose + m.post;
+ return expand(str);
+ }
+ return [str];
+ }
+
+ var n;
+ if (isSequence) {
+ n = m.body.split(/\.\./);
+ } else {
+ n = parseCommaParts(m.body);
+ if (n.length === 1) {
+ // x{{a,b}}y ==> x{a}y x{b}y
+ n = expand(n[0], false).map(embrace);
+ if (n.length === 1) {
+ var post = m.post.length
+ ? expand(m.post, false)
+ : [''];
+ return post.map(function(p) {
+ return m.pre + n[0] + p;
+ });
+ }
+ }
+ }
+
+ // at this point, n is the parts, and we know it's not a comma set
+ // with a single entry.
+
+ // no need to expand pre, since it is guaranteed to be free of brace-sets
+ var pre = m.pre;
+ var post = m.post.length
+ ? expand(m.post, false)
+ : [''];
+
+ var N;
+
+ if (isSequence) {
+ var x = numeric(n[0]);
+ var y = numeric(n[1]);
+ var width = Math.max(n[0].length, n[1].length);
+ var incr = n.length == 3
+ ? Math.abs(numeric(n[2]))
+ : 1;
+ var test = lte;
+ var reverse = y < x;
+ if (reverse) {
+ incr *= -1;
+ test = gte;
+ }
+ var pad = n.some(isPadded);
+
+ N = [];
+
+ for (var i = x; test(i, y); i += incr) {
+ var c;
+ if (isAlphaSequence) {
+ c = String.fromCharCode(i);
+ if (c === '\\')
+ c = '';
+ } else {
+ c = String(i);
+ if (pad) {
+ var need = width - c.length;
+ if (need > 0) {
+ var z = new Array(need + 1).join('0');
+ if (i < 0)
+ c = '-' + z + c.slice(1);
+ else
+ c = z + c;
+ }
+ }
+ }
+ N.push(c);
+ }
+ } else {
+ N = concatMap(n, function(el) { return expand(el, false) });
+ }
+
+ for (var j = 0; j < N.length; j++) {
+ for (var k = 0; k < post.length; k++) {
+ var expansion = pre + N[j] + post[k];
+ if (!isTop || isSequence || expansion)
+ expansions.push(expansion);
+ }
+ }
+
+ return expansions;
+}
+
+var minimatch_1 = minimatch;
+minimatch.Minimatch = Minimatch;
+
+var path$3 = { sep: '/' };
+try {
+ path$3 = path;
+} catch (er) {}
+
+var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
+
+
+var plTypes = {
+ '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+ '?': { open: '(?:', close: ')?' },
+ '+': { open: '(?:', close: ')+' },
+ '*': { open: '(?:', close: ')*' },
+ '@': { open: '(?:', close: ')' }
+};
+
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]';
+
+// * => any number of characters
+var star = qmark + '*?';
+
+// ** when dots are allowed. Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?';
+
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';
+
+// characters that need to be escaped in RegExp.
+var reSpecials = charSet('().*{}+?[]^$\\!');
+
+// "abc" -> { a:true, b:true, c:true }
+function charSet (s) {
+ return s.split('').reduce(function (set, c) {
+ set[c] = true;
+ return set
+ }, {})
+}
+
+// normalizes slashes.
+var slashSplit = /\/+/;
+
+minimatch.filter = filter;
+function filter (pattern, options) {
+ options = options || {};
+ return function (p, i, list) {
+ return minimatch(p, pattern, options)
+ }
+}
+
+function ext (a, b) {
+ a = a || {};
+ b = b || {};
+ var t = {};
+ Object.keys(b).forEach(function (k) {
+ t[k] = b[k];
+ });
+ Object.keys(a).forEach(function (k) {
+ t[k] = a[k];
+ });
+ return t
+}
+
+minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return minimatch
+
+ var orig = minimatch;
+
+ var m = function minimatch (p, pattern, options) {
+ return orig.minimatch(p, pattern, ext(def, options))
+ };
+
+ m.Minimatch = function Minimatch (pattern, options) {
+ return new orig.Minimatch(pattern, ext(def, options))
+ };
+
+ return m
+};
+
+Minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return Minimatch
+ return minimatch.defaults(def).Minimatch
+};
+
+function minimatch (p, pattern, options) {
+ if (typeof pattern !== 'string') {
+ throw new TypeError('glob pattern string required')
+ }
+
+ if (!options) options = {};
+
+ // shortcut: comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === '#') {
+ return false
+ }
+
+ // "" only matches ""
+ if (pattern.trim() === '') return p === ''
+
+ return new Minimatch(pattern, options).match(p)
+}
+
+function Minimatch (pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options)
+ }
+
+ if (typeof pattern !== 'string') {
+ throw new TypeError('glob pattern string required')
+ }
+
+ if (!options) options = {};
+ pattern = pattern.trim();
+
+ // windows support: need to use /, not \
+ if (path$3.sep !== '/') {
+ pattern = pattern.split(path$3.sep).join('/');
+ }
+
+ this.options = options;
+ this.set = [];
+ this.pattern = pattern;
+ this.regexp = null;
+ this.negate = false;
+ this.comment = false;
+ this.empty = false;
+
+ // make the set of regexps etc.
+ this.make();
+}
+
+Minimatch.prototype.debug = function () {};
+
+Minimatch.prototype.make = make;
+function make () {
+ // don't do it more than once.
+ if (this._made) return
+
+ var pattern = this.pattern;
+ var options = this.options;
+
+ // empty patterns and comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === '#') {
+ this.comment = true;
+ return
+ }
+ if (!pattern) {
+ this.empty = true;
+ return
+ }
+
+ // step 1: figure out negation, etc.
+ this.parseNegate();
+
+ // step 2: expand braces
+ var set = this.globSet = this.braceExpand();
+
+ if (options.debug) this.debug = console.error;
+
+ this.debug(this.pattern, set);
+
+ // step 3: now we have a set, so turn each one into a series of path-portion
+ // matching patterns.
+ // These will be regexps, except in the case of "**", which is
+ // set to the GLOBSTAR object for globstar behavior,
+ // and will not contain any / characters
+ set = this.globParts = set.map(function (s) {
+ return s.split(slashSplit)
+ });
+
+ this.debug(this.pattern, set);
+
+ // glob --> regexps
+ set = set.map(function (s, si, set) {
+ return s.map(this.parse, this)
+ }, this);
+
+ this.debug(this.pattern, set);
+
+ // filter out everything that didn't compile properly.
+ set = set.filter(function (s) {
+ return s.indexOf(false) === -1
+ });
+
+ this.debug(this.pattern, set);
+
+ this.set = set;
+}
+
+Minimatch.prototype.parseNegate = parseNegate;
+function parseNegate () {
+ var pattern = this.pattern;
+ var negate = false;
+ var options = this.options;
+ var negateOffset = 0;
+
+ if (options.nonegate) return
+
+ for (var i = 0, l = pattern.length
+ ; i < l && pattern.charAt(i) === '!'
+ ; i++) {
+ negate = !negate;
+ negateOffset++;
+ }
+
+ if (negateOffset) this.pattern = pattern.substr(negateOffset);
+ this.negate = negate;
+}
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+minimatch.braceExpand = function (pattern, options) {
+ return braceExpand(pattern, options)
+};
+
+Minimatch.prototype.braceExpand = braceExpand;
+
+function braceExpand (pattern, options) {
+ if (!options) {
+ if (this instanceof Minimatch) {
+ options = this.options;
+ } else {
+ options = {};
+ }
+ }
+
+ pattern = typeof pattern === 'undefined'
+ ? this.pattern : pattern;
+
+ if (typeof pattern === 'undefined') {
+ throw new TypeError('undefined pattern')
+ }
+
+ if (options.nobrace ||
+ !pattern.match(/\{.*\}/)) {
+ // shortcut. no need to expand.
+ return [pattern]
+ }
+
+ return braceExpansion(pattern)
+}
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion. Otherwise, any series
+// of * is equivalent to a single *. Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+Minimatch.prototype.parse = parse$4;
+var SUBPARSE = {};
+function parse$4 (pattern, isSub) {
+ if (pattern.length > 1024 * 64) {
+ throw new TypeError('pattern is too long')
+ }
+
+ var options = this.options;
+
+ // shortcuts
+ if (!options.noglobstar && pattern === '**') return GLOBSTAR
+ if (pattern === '') return ''
+
+ var re = '';
+ var hasMagic = !!options.nocase;
+ var escaping = false;
+ // ? => one single character
+ var patternListStack = [];
+ var negativeLists = [];
+ var stateChar;
+ var inClass = false;
+ var reClassStart = -1;
+ var classStart = -1;
+ // . and .. never match anything that doesn't start with .,
+ // even when options.dot is set.
+ var patternStart = pattern.charAt(0) === '.' ? '' // anything
+ // not (start or / followed by . or .. followed by / or end)
+ : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+ : '(?!\\.)';
+ var self = this;
+
+ function clearStateChar () {
+ if (stateChar) {
+ // we had some state-tracking character
+ // that wasn't consumed by this pass.
+ switch (stateChar) {
+ case '*':
+ re += star;
+ hasMagic = true;
+ break
+ case '?':
+ re += qmark;
+ hasMagic = true;
+ break
+ default:
+ re += '\\' + stateChar;
+ break
+ }
+ self.debug('clearStateChar %j %j', stateChar, re);
+ stateChar = false;
+ }
+ }
+
+ for (var i = 0, len = pattern.length, c
+ ; (i < len) && (c = pattern.charAt(i))
+ ; i++) {
+ this.debug('%s\t%s %s %j', pattern, i, re, c);
+
+ // skip over any that are escaped.
+ if (escaping && reSpecials[c]) {
+ re += '\\' + c;
+ escaping = false;
+ continue
+ }
+
+ switch (c) {
+ case '/':
+ // completely not allowed, even escaped.
+ // Should already be path-split by now.
+ return false
+
+ case '\\':
+ clearStateChar();
+ escaping = true;
+ continue
+
+ // the various stateChar values
+ // for the "extglob" stuff.
+ case '?':
+ case '*':
+ case '+':
+ case '@':
+ case '!':
+ this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);
+
+ // all of those are literals inside a class, except that
+ // the glob [!a] means [^a] in regexp
+ if (inClass) {
+ this.debug(' in class');
+ if (c === '!' && i === classStart + 1) c = '^';
+ re += c;
+ continue
+ }
+
+ // if we already have a stateChar, then it means
+ // that there was something like ** or +? in there.
+ // Handle the stateChar, then proceed with this one.
+ self.debug('call clearStateChar %j', stateChar);
+ clearStateChar();
+ stateChar = c;
+ // if extglob is disabled, then +(asdf|foo) isn't a thing.
+ // just clear the statechar *now*, rather than even diving into
+ // the patternList stuff.
+ if (options.noext) clearStateChar();
+ continue
+
+ case '(':
+ if (inClass) {
+ re += '(';
+ continue
+ }
+
+ if (!stateChar) {
+ re += '\\(';
+ continue
+ }
+
+ patternListStack.push({
+ type: stateChar,
+ start: i - 1,
+ reStart: re.length,
+ open: plTypes[stateChar].open,
+ close: plTypes[stateChar].close
+ });
+ // negation is (?:(?!js)[^/]*)
+ re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
+ this.debug('plType %j %j', stateChar, re);
+ stateChar = false;
+ continue
+
+ case ')':
+ if (inClass || !patternListStack.length) {
+ re += '\\)';
+ continue
+ }
+
+ clearStateChar();
+ hasMagic = true;
+ var pl = patternListStack.pop();
+ // negation is (?:(?!js)[^/]*)
+ // The others are (?:)
+ re += pl.close;
+ if (pl.type === '!') {
+ negativeLists.push(pl);
+ }
+ pl.reEnd = re.length;
+ continue
+
+ case '|':
+ if (inClass || !patternListStack.length || escaping) {
+ re += '\\|';
+ escaping = false;
+ continue
+ }
+
+ clearStateChar();
+ re += '|';
+ continue
+
+ // these are mostly the same in regexp and glob
+ case '[':
+ // swallow any state-tracking char before the [
+ clearStateChar();
+
+ if (inClass) {
+ re += '\\' + c;
+ continue
+ }
+
+ inClass = true;
+ classStart = i;
+ reClassStart = re.length;
+ re += c;
+ continue
+
+ case ']':
+ // a right bracket shall lose its special
+ // meaning and represent itself in
+ // a bracket expression if it occurs
+ // first in the list. -- POSIX.2 2.8.3.2
+ if (i === classStart + 1 || !inClass) {
+ re += '\\' + c;
+ escaping = false;
+ continue
+ }
+
+ // handle the case where we left a class open.
+ // "[z-a]" is valid, equivalent to "\[z-a\]"
+ if (inClass) {
+ // split where the last [ was, make sure we don't have
+ // an invalid re. if so, re-walk the contents of the
+ // would-be class to re-translate any characters that
+ // were passed through as-is
+ // TODO: It would probably be faster to determine this
+ // without a try/catch and a new RegExp, but it's tricky
+ // to do safely. For now, this is safe and works.
+ var cs = pattern.substring(classStart + 1, i);
+ try {
+ RegExp('[' + cs + ']');
+ } catch (er) {
+ // not a valid class!
+ var sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
+ hasMagic = hasMagic || sp[1];
+ inClass = false;
+ continue
+ }
+ }
+
+ // finish up the class.
+ hasMagic = true;
+ inClass = false;
+ re += c;
+ continue
+
+ default:
+ // swallow any state char that wasn't consumed
+ clearStateChar();
+
+ if (escaping) {
+ // no need
+ escaping = false;
+ } else if (reSpecials[c]
+ && !(c === '^' && inClass)) {
+ re += '\\';
+ }
+
+ re += c;
+
+ } // switch
+ } // for
+
+ // handle the case where we left a class open.
+ // "[abc" is valid, equivalent to "\[abc"
+ if (inClass) {
+ // split where the last [ was, and escape it
+ // this is a huge pita. We now have to re-walk
+ // the contents of the would-be class to re-translate
+ // any characters that were passed through as-is
+ cs = pattern.substr(classStart + 1);
+ sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + '\\[' + sp[0];
+ hasMagic = hasMagic || sp[1];
+ }
+
+ // handle the case where we had a +( thing at the *end*
+ // of the pattern.
+ // each pattern list stack adds 3 chars, and we need to go through
+ // and escape any | chars that were passed through as-is for the regexp.
+ // Go through and escape them, taking care not to double-escape any
+ // | chars that were already escaped.
+ for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+ var tail = re.slice(pl.reStart + pl.open.length);
+ this.debug('setting tail', re, pl);
+ // maybe some even number of \, then maybe 1 \, followed by a |
+ tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
+ if (!$2) {
+ // the | isn't already escaped, so escape it.
+ $2 = '\\';
+ }
+
+ // need to escape all those slashes *again*, without escaping the
+ // one that we need for escaping the | character. As it works out,
+ // escaping an even number of slashes can be done by simply repeating
+ // it exactly after itself. That's why this trick works.
+ //
+ // I am sorry that you have to see this.
+ return $1 + $1 + $2 + '|'
+ });
+
+ this.debug('tail=%j\n %s', tail, tail, pl, re);
+ var t = pl.type === '*' ? star
+ : pl.type === '?' ? qmark
+ : '\\' + pl.type;
+
+ hasMagic = true;
+ re = re.slice(0, pl.reStart) + t + '\\(' + tail;
+ }
+
+ // handle trailing things that only matter at the very end.
+ clearStateChar();
+ if (escaping) {
+ // trailing \\
+ re += '\\\\';
+ }
+
+ // only need to apply the nodot start if the re starts with
+ // something that could conceivably capture a dot
+ var addPatternStart = false;
+ switch (re.charAt(0)) {
+ case '.':
+ case '[':
+ case '(': addPatternStart = true;
+ }
+
+ // Hack to work around lack of negative lookbehind in JS
+ // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+ // like 'a.xyz.yz' doesn't match. So, the first negative
+ // lookahead, has to look ALL the way ahead, to the end of
+ // the pattern.
+ for (var n = negativeLists.length - 1; n > -1; n--) {
+ var nl = negativeLists[n];
+
+ var nlBefore = re.slice(0, nl.reStart);
+ var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+ var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+ var nlAfter = re.slice(nl.reEnd);
+
+ nlLast += nlAfter;
+
+ // Handle nested stuff like *(*.js|!(*.json)), where open parens
+ // mean that we should *not* include the ) in the bit that is considered
+ // "after" the negated section.
+ var openParensBefore = nlBefore.split('(').length - 1;
+ var cleanAfter = nlAfter;
+ for (i = 0; i < openParensBefore; i++) {
+ cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
+ }
+ nlAfter = cleanAfter;
+
+ var dollar = '';
+ if (nlAfter === '' && isSub !== SUBPARSE) {
+ dollar = '$';
+ }
+ var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+ re = newRe;
+ }
+
+ // if the re is not "" at this point, then we need to make sure
+ // it doesn't match against an empty path part.
+ // Otherwise a/* will match a/, which it should not.
+ if (re !== '' && hasMagic) {
+ re = '(?=.)' + re;
+ }
+
+ if (addPatternStart) {
+ re = patternStart + re;
+ }
+
+ // parsing just a piece of a larger pattern.
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic]
+ }
+
+ // skip the regexp for non-magical patterns
+ // unescape anything in it, though, so that it'll be
+ // an exact match against a file etc.
+ if (!hasMagic) {
+ return globUnescape(pattern)
+ }
+
+ var flags = options.nocase ? 'i' : '';
+ try {
+ var regExp = new RegExp('^' + re + '$', flags);
+ } catch (er) {
+ // If it was an invalid regular expression, then it can't match
+ // anything. This trick looks for a character after the end of
+ // the string, which is of course impossible, except in multi-line
+ // mode, but it's not a /m regex.
+ return new RegExp('$.')
+ }
+
+ regExp._glob = pattern;
+ regExp._src = re;
+
+ return regExp
+}
+
+minimatch.makeRe = function (pattern, options) {
+ return new Minimatch(pattern, options || {}).makeRe()
+};
+
+Minimatch.prototype.makeRe = makeRe;
+function makeRe () {
+ if (this.regexp || this.regexp === false) return this.regexp
+
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ var set = this.set;
+
+ if (!set.length) {
+ this.regexp = false;
+ return this.regexp
+ }
+ var options = this.options;
+
+ var twoStar = options.noglobstar ? star
+ : options.dot ? twoStarDot
+ : twoStarNoDot;
+ var flags = options.nocase ? 'i' : '';
+
+ var re = set.map(function (pattern) {
+ return pattern.map(function (p) {
+ return (p === GLOBSTAR) ? twoStar
+ : (typeof p === 'string') ? regExpEscape(p)
+ : p._src
+ }).join('\\\/')
+ }).join('|');
+
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = '^(?:' + re + ')$';
+
+ // can match anything, as long as it's not this.
+ if (this.negate) re = '^(?!' + re + ').*$';
+
+ try {
+ this.regexp = new RegExp(re, flags);
+ } catch (ex) {
+ this.regexp = false;
+ }
+ return this.regexp
+}
+
+minimatch.match = function (list, pattern, options) {
+ options = options || {};
+ var mm = new Minimatch(pattern, options);
+ list = list.filter(function (f) {
+ return mm.match(f)
+ });
+ if (mm.options.nonull && !list.length) {
+ list.push(pattern);
+ }
+ return list
+};
+
+Minimatch.prototype.match = match;
+function match (f, partial) {
+ this.debug('match', f, this.pattern);
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) return false
+ if (this.empty) return f === ''
+
+ if (f === '/' && partial) return true
+
+ var options = this.options;
+
+ // windows: need to use /, not \
+ if (path$3.sep !== '/') {
+ f = f.split(path$3.sep).join('/');
+ }
+
+ // treat the test path as a set of pathparts.
+ f = f.split(slashSplit);
+ this.debug(this.pattern, 'split', f);
+
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
+
+ var set = this.set;
+ this.debug(this.pattern, 'set', set);
+
+ // Find the basename of the path by looking for the last non-empty segment
+ var filename;
+ var i;
+ for (i = f.length - 1; i >= 0; i--) {
+ filename = f[i];
+ if (filename) break
+ }
+
+ for (i = 0; i < set.length; i++) {
+ var pattern = set[i];
+ var file = f;
+ if (options.matchBase && pattern.length === 1) {
+ file = [filename];
+ }
+ var hit = this.matchOne(file, pattern, partial);
+ if (hit) {
+ if (options.flipNegate) return true
+ return !this.negate
+ }
+ }
+
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) return false
+ return this.negate
+}
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+Minimatch.prototype.matchOne = function (file, pattern, partial) {
+ var options = this.options;
+
+ this.debug('matchOne',
+ { 'this': this, file: file, pattern: pattern });
+
+ this.debug('matchOne', file.length, pattern.length);
+
+ for (var fi = 0,
+ pi = 0,
+ fl = file.length,
+ pl = pattern.length
+ ; (fi < fl) && (pi < pl)
+ ; fi++, pi++) {
+ this.debug('matchOne loop');
+ var p = pattern[pi];
+ var f = file[fi];
+
+ this.debug(pattern, p, f);
+
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ if (p === false) return false
+
+ if (p === GLOBSTAR) {
+ this.debug('GLOBSTAR', [pattern, p, f]);
+
+ // "**"
+ // a/**/b/**/c would match the following:
+ // a/b/x/y/z/c
+ // a/x/y/z/b/c
+ // a/b/x/b/x/c
+ // a/b/c
+ // To do this, take the rest of the pattern after
+ // the **, and see if it would match the file remainder.
+ // If so, return success.
+ // If not, the ** "swallows" a segment, and try again.
+ // This is recursively awful.
+ //
+ // a/**/b/**/c matching a/b/x/y/z/c
+ // - a matches a
+ // - doublestar
+ // - matchOne(b/x/y/z/c, b/**/c)
+ // - b matches b
+ // - doublestar
+ // - matchOne(x/y/z/c, c) -> no
+ // - matchOne(y/z/c, c) -> no
+ // - matchOne(z/c, c) -> no
+ // - matchOne(c, c) yes, hit
+ var fr = fi;
+ var pr = pi + 1;
+ if (pr === pl) {
+ this.debug('** at the end');
+ // a ** at the end will just swallow the rest.
+ // We have found a match.
+ // however, it will not swallow /.x, unless
+ // options.dot is set.
+ // . and .. are *never* matched by **, for explosively
+ // exponential reasons.
+ for (; fi < fl; fi++) {
+ if (file[fi] === '.' || file[fi] === '..' ||
+ (!options.dot && file[fi].charAt(0) === '.')) return false
+ }
+ return true
+ }
+
+ // ok, let's see if we can swallow whatever we can.
+ while (fr < fl) {
+ var swallowee = file[fr];
+
+ this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
+
+ // XXX remove this slice. Just pass the start index.
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ this.debug('globstar found match!', fr, fl, swallowee);
+ // found a match.
+ return true
+ } else {
+ // can't swallow "." or ".." ever.
+ // can only swallow ".foo" when explicitly asked.
+ if (swallowee === '.' || swallowee === '..' ||
+ (!options.dot && swallowee.charAt(0) === '.')) {
+ this.debug('dot detected!', file, fr, pattern, pr);
+ break
+ }
+
+ // ** swallows a segment, and continue.
+ this.debug('globstar swallow a segment, and continue');
+ fr++;
+ }
+ }
+
+ // no match was found.
+ // However, in partial mode, we can't say this is necessarily over.
+ // If there's more *pattern* left, then
+ if (partial) {
+ // ran out of file
+ this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
+ if (fr === fl) return true
+ }
+ return false
+ }
+
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ var hit;
+ if (typeof p === 'string') {
+ if (options.nocase) {
+ hit = f.toLowerCase() === p.toLowerCase();
+ } else {
+ hit = f === p;
+ }
+ this.debug('string match', p, f, hit);
+ } else {
+ hit = f.match(p);
+ this.debug('pattern match', p, f, hit);
+ }
+
+ if (!hit) return false
+ }
+
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
+
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true
+ } else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial
+ } else if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');
+ return emptyFileEnd
+ }
+
+ // should be unreachable.
+ throw new Error('wtf?')
+};
+
+// replace stuff like \* with *
+function globUnescape (s) {
+ return s.replace(/\\(.)/g, '$1')
+}
+
+function regExpEscape (s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}
+
+var mimicFn = (to, from) => {
+ // TODO: use `Reflect.ownKeys()` when targeting Node.js 6
+ for (const prop of Object.getOwnPropertyNames(from).concat(Object.getOwnPropertySymbols(from))) {
+ Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+ }
+};
+
+var mem = createCommonjsModule(function (module) {
+'use strict';
+
+
+const cacheStore = new WeakMap();
+
+const defaultCacheKey = function (x) {
+ if (arguments.length === 1 && (x === null || x === undefined || (typeof x !== 'function' && typeof x !== 'object'))) {
+ return x;
+ }
+
+ return JSON.stringify(arguments);
+};
+
+module.exports = (fn, opts) => {
+ opts = Object.assign({
+ cacheKey: defaultCacheKey,
+ cache: new Map()
+ }, opts);
+
+ const memoized = function () {
+ const cache = cacheStore.get(memoized);
+ const key = opts.cacheKey.apply(null, arguments);
+
+ if (cache.has(key)) {
+ const c = cache.get(key);
+
+ if (typeof opts.maxAge !== 'number' || Date.now() < c.maxAge) {
+ return c.data;
+ }
+ }
+
+ const ret = fn.apply(null, arguments);
+
+ cache.set(key, {
+ data: ret,
+ maxAge: Date.now() + (opts.maxAge || 0)
+ });
+
+ return ret;
+ };
+
+ mimicFn(memoized, fn);
+
+ cacheStore.set(memoized, opts.cache);
+
+ return memoized;
+};
+
+module.exports.clear = fn => {
+ const cache = cacheStore.get(fn);
+
+ if (cache && typeof cache.clear === 'function') {
+ cache.clear();
+ }
+};
+});
+
+var semver$3 = createCommonjsModule(function (module, exports) {
+exports = module.exports = SemVer;
+
+// The debug function is excluded entirely from the minified version.
+/* nomin */ var debug;
+/* nomin */ if (typeof process === 'object' &&
+ /* nomin */ process.env &&
+ /* nomin */ process.env.NODE_DEBUG &&
+ /* nomin */ /\bsemver\b/i.test(process.env.NODE_DEBUG))
+ /* nomin */ debug = function() {
+ /* nomin */ var args = Array.prototype.slice.call(arguments, 0);
+ /* nomin */ args.unshift('SEMVER');
+ /* nomin */ console.log.apply(console, args);
+ /* nomin */ };
+/* nomin */ else
+ /* nomin */ debug = function() {};
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0';
+
+var MAX_LENGTH = 256;
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+
+// Max safe segment length for coercion.
+var MAX_SAFE_COMPONENT_LENGTH = 16;
+
+// The actual regexps go on exports.re
+var re = exports.re = [];
+var src = exports.src = [];
+var R = 0;
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+var NUMERICIDENTIFIER = R++;
+src[NUMERICIDENTIFIER] = '0|[1-9]\\d*';
+var NUMERICIDENTIFIERLOOSE = R++;
+src[NUMERICIDENTIFIERLOOSE] = '[0-9]+';
+
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+var NONNUMERICIDENTIFIER = R++;
+src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*';
+
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+var MAINVERSION = R++;
+src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')';
+
+var MAINVERSIONLOOSE = R++;
+src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')';
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+var PRERELEASEIDENTIFIER = R++;
+src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+var PRERELEASEIDENTIFIERLOOSE = R++;
+src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+var PRERELEASE = R++;
+src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))';
+
+var PRERELEASELOOSE = R++;
+src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))';
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+var BUILDIDENTIFIER = R++;
+src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+';
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+var BUILD = R++;
+src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
+ '(?:\\.' + src[BUILDIDENTIFIER] + ')*))';
+
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups. The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+var FULL = R++;
+var FULLPLAIN = 'v?' + src[MAINVERSION] +
+ src[PRERELEASE] + '?' +
+ src[BUILD] + '?';
+
+src[FULL] = '^' + FULLPLAIN + '$';
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
+ src[PRERELEASELOOSE] + '?' +
+ src[BUILD] + '?';
+
+var LOOSE = R++;
+src[LOOSE] = '^' + LOOSEPLAIN + '$';
+
+var GTLT = R++;
+src[GTLT] = '((?:<|>)?=?)';
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+var XRANGEIDENTIFIERLOOSE = R++;
+src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
+var XRANGEIDENTIFIER = R++;
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*';
+
+var XRANGEPLAIN = R++;
+src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:' + src[PRERELEASE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?';
+
+var XRANGEPLAINLOOSE = R++;
+src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:' + src[PRERELEASELOOSE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?';
+
+var XRANGE = R++;
+src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$';
+var XRANGELOOSE = R++;
+src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$';
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+var COERCE = R++;
+src[COERCE] = '(?:^|[^\\d])' +
+ '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
+ '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+ '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+ '(?:$|[^\\d])';
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+var LONETILDE = R++;
+src[LONETILDE] = '(?:~>?)';
+
+var TILDETRIM = R++;
+src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+';
+re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g');
+var tildeTrimReplace = '$1~';
+
+var TILDE = R++;
+src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$';
+var TILDELOOSE = R++;
+src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$';
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+var LONECARET = R++;
+src[LONECARET] = '(?:\\^)';
+
+var CARETTRIM = R++;
+src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+';
+re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g');
+var caretTrimReplace = '$1^';
+
+var CARET = R++;
+src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$';
+var CARETLOOSE = R++;
+src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$';
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+var COMPARATORLOOSE = R++;
+src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$';
+var COMPARATOR = R++;
+src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$';
+
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+var COMPARATORTRIM = R++;
+src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
+ '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';
+
+// this one has to use the /g flag
+re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g');
+var comparatorTrimReplace = '$1$2$3';
+
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+var HYPHENRANGE = R++;
+src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAIN] + ')' +
+ '\\s*$';
+
+var HYPHENRANGELOOSE = R++;
+src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s*$';
+
+// Star ranges basically just allow anything at all.
+var STAR = R++;
+src[STAR] = '(<|>)?=?\\s*\\*';
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+ debug(i, src[i]);
+ if (!re[i])
+ re[i] = new RegExp(src[i]);
+}
+
+exports.parse = parse;
+function parse(version, loose) {
+ if (version instanceof SemVer)
+ return version;
+
+ if (typeof version !== 'string')
+ return null;
+
+ if (version.length > MAX_LENGTH)
+ return null;
+
+ var r = loose ? re[LOOSE] : re[FULL];
+ if (!r.test(version))
+ return null;
+
+ try {
+ return new SemVer(version, loose);
+ } catch (er) {
+ return null;
+ }
+}
+
+exports.valid = valid;
+function valid(version, loose) {
+ var v = parse(version, loose);
+ return v ? v.version : null;
+}
+
+
+exports.clean = clean;
+function clean(version, loose) {
+ var s = parse(version.trim().replace(/^[=v]+/, ''), loose);
+ return s ? s.version : null;
+}
+
+exports.SemVer = SemVer;
+
+function SemVer(version, loose) {
+ if (version instanceof SemVer) {
+ if (version.loose === loose)
+ return version;
+ else
+ version = version.version;
+ } else if (typeof version !== 'string') {
+ throw new TypeError('Invalid Version: ' + version);
+ }
+
+ if (version.length > MAX_LENGTH)
+ throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
+
+ if (!(this instanceof SemVer))
+ return new SemVer(version, loose);
+
+ debug('SemVer', version, loose);
+ this.loose = loose;
+ var m = version.trim().match(loose ? re[LOOSE] : re[FULL]);
+
+ if (!m)
+ throw new TypeError('Invalid Version: ' + version);
+
+ this.raw = version;
+
+ // these are actually numbers
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
+
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0)
+ throw new TypeError('Invalid major version')
+
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0)
+ throw new TypeError('Invalid minor version')
+
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0)
+ throw new TypeError('Invalid patch version')
+
+ // numberify any prerelease numeric ids
+ if (!m[4])
+ this.prerelease = [];
+ else
+ this.prerelease = m[4].split('.').map(function(id) {
+ if (/^[0-9]+$/.test(id)) {
+ var num = +id;
+ if (num >= 0 && num < MAX_SAFE_INTEGER)
+ return num;
+ }
+ return id;
+ });
+
+ this.build = m[5] ? m[5].split('.') : [];
+ this.format();
+}
+
+SemVer.prototype.format = function() {
+ this.version = this.major + '.' + this.minor + '.' + this.patch;
+ if (this.prerelease.length)
+ this.version += '-' + this.prerelease.join('.');
+ return this.version;
+};
+
+SemVer.prototype.toString = function() {
+ return this.version;
+};
+
+SemVer.prototype.compare = function(other) {
+ debug('SemVer.compare', this.version, this.loose, other);
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ return this.compareMain(other) || this.comparePre(other);
+};
+
+SemVer.prototype.compareMain = function(other) {
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ return compareIdentifiers(this.major, other.major) ||
+ compareIdentifiers(this.minor, other.minor) ||
+ compareIdentifiers(this.patch, other.patch);
+};
+
+SemVer.prototype.comparePre = function(other) {
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ // NOT having a prerelease is > having one
+ if (this.prerelease.length && !other.prerelease.length)
+ return -1;
+ else if (!this.prerelease.length && other.prerelease.length)
+ return 1;
+ else if (!this.prerelease.length && !other.prerelease.length)
+ return 0;
+
+ var i = 0;
+ do {
+ var a = this.prerelease[i];
+ var b = other.prerelease[i];
+ debug('prerelease compare', i, a, b);
+ if (a === undefined && b === undefined)
+ return 0;
+ else if (b === undefined)
+ return 1;
+ else if (a === undefined)
+ return -1;
+ else if (a === b)
+ continue;
+ else
+ return compareIdentifiers(a, b);
+ } while (++i);
+};
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function(release, identifier) {
+ switch (release) {
+ case 'premajor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc('pre', identifier);
+ break;
+ case 'preminor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc('pre', identifier);
+ break;
+ case 'prepatch':
+ // If this is already a prerelease, it will bump to the next version
+ // drop any prereleases that might already exist, since they are not
+ // relevant at this point.
+ this.prerelease.length = 0;
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break;
+ // If the input is a non-prerelease version, this acts the same as
+ // prepatch.
+ case 'prerelease':
+ if (this.prerelease.length === 0)
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break;
+
+ case 'major':
+ // If this is a pre-major version, bump up to the same major version.
+ // Otherwise increment major.
+ // 1.0.0-5 bumps to 1.0.0
+ // 1.1.0 bumps to 2.0.0
+ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0)
+ this.major++;
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case 'minor':
+ // If this is a pre-minor version, bump up to the same minor version.
+ // Otherwise increment minor.
+ // 1.2.0-5 bumps to 1.2.0
+ // 1.2.1 bumps to 1.3.0
+ if (this.patch !== 0 || this.prerelease.length === 0)
+ this.minor++;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case 'patch':
+ // If this is not a pre-release version, it will increment the patch.
+ // If it is a pre-release it will bump up to the same patch version.
+ // 1.2.0-5 patches to 1.2.0
+ // 1.2.0 patches to 1.2.1
+ if (this.prerelease.length === 0)
+ this.patch++;
+ this.prerelease = [];
+ break;
+ // This probably shouldn't be used publicly.
+ // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
+ case 'pre':
+ if (this.prerelease.length === 0)
+ this.prerelease = [0];
+ else {
+ var i = this.prerelease.length;
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === 'number') {
+ this.prerelease[i]++;
+ i = -2;
+ }
+ }
+ if (i === -1) // didn't increment anything
+ this.prerelease.push(0);
+ }
+ if (identifier) {
+ // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+ if (this.prerelease[0] === identifier) {
+ if (isNaN(this.prerelease[1]))
+ this.prerelease = [identifier, 0];
+ } else
+ this.prerelease = [identifier, 0];
+ }
+ break;
+
+ default:
+ throw new Error('invalid increment argument: ' + release);
+ }
+ this.format();
+ this.raw = this.version;
+ return this;
+};
+
+exports.inc = inc;
+function inc(version, release, loose, identifier) {
+ if (typeof(loose) === 'string') {
+ identifier = loose;
+ loose = undefined;
+ }
+
+ try {
+ return new SemVer(version, loose).inc(release, identifier).version;
+ } catch (er) {
+ return null;
+ }
+}
+
+exports.diff = diff;
+function diff(version1, version2) {
+ if (eq(version1, version2)) {
+ return null;
+ } else {
+ var v1 = parse(version1);
+ var v2 = parse(version2);
+ if (v1.prerelease.length || v2.prerelease.length) {
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return 'pre'+key;
+ }
+ }
+ }
+ return 'prerelease';
+ }
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return key;
+ }
+ }
+ }
+ }
+}
+
+exports.compareIdentifiers = compareIdentifiers;
+
+var numeric = /^[0-9]+$/;
+function compareIdentifiers(a, b) {
+ var anum = numeric.test(a);
+ var bnum = numeric.test(b);
+
+ if (anum && bnum) {
+ a = +a;
+ b = +b;
+ }
+
+ return (anum && !bnum) ? -1 :
+ (bnum && !anum) ? 1 :
+ a < b ? -1 :
+ a > b ? 1 :
+ 0;
+}
+
+exports.rcompareIdentifiers = rcompareIdentifiers;
+function rcompareIdentifiers(a, b) {
+ return compareIdentifiers(b, a);
+}
+
+exports.major = major;
+function major(a, loose) {
+ return new SemVer(a, loose).major;
+}
+
+exports.minor = minor;
+function minor(a, loose) {
+ return new SemVer(a, loose).minor;
+}
+
+exports.patch = patch;
+function patch(a, loose) {
+ return new SemVer(a, loose).patch;
+}
+
+exports.compare = compare;
+function compare(a, b, loose) {
+ return new SemVer(a, loose).compare(new SemVer(b, loose));
+}
+
+exports.compareLoose = compareLoose;
+function compareLoose(a, b) {
+ return compare(a, b, true);
+}
+
+exports.rcompare = rcompare;
+function rcompare(a, b, loose) {
+ return compare(b, a, loose);
+}
+
+exports.sort = sort;
+function sort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports.compare(a, b, loose);
+ });
+}
+
+exports.rsort = rsort;
+function rsort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports.rcompare(a, b, loose);
+ });
+}
+
+exports.gt = gt;
+function gt(a, b, loose) {
+ return compare(a, b, loose) > 0;
+}
+
+exports.lt = lt;
+function lt(a, b, loose) {
+ return compare(a, b, loose) < 0;
+}
+
+exports.eq = eq;
+function eq(a, b, loose) {
+ return compare(a, b, loose) === 0;
+}
+
+exports.neq = neq;
+function neq(a, b, loose) {
+ return compare(a, b, loose) !== 0;
+}
+
+exports.gte = gte;
+function gte(a, b, loose) {
+ return compare(a, b, loose) >= 0;
+}
+
+exports.lte = lte;
+function lte(a, b, loose) {
+ return compare(a, b, loose) <= 0;
+}
+
+exports.cmp = cmp;
+function cmp(a, op, b, loose) {
+ var ret;
+ switch (op) {
+ case '===':
+ if (typeof a === 'object') a = a.version;
+ if (typeof b === 'object') b = b.version;
+ ret = a === b;
+ break;
+ case '!==':
+ if (typeof a === 'object') a = a.version;
+ if (typeof b === 'object') b = b.version;
+ ret = a !== b;
+ break;
+ case '': case '=': case '==': ret = eq(a, b, loose); break;
+ case '!=': ret = neq(a, b, loose); break;
+ case '>': ret = gt(a, b, loose); break;
+ case '>=': ret = gte(a, b, loose); break;
+ case '<': ret = lt(a, b, loose); break;
+ case '<=': ret = lte(a, b, loose); break;
+ default: throw new TypeError('Invalid operator: ' + op);
+ }
+ return ret;
+}
+
+exports.Comparator = Comparator;
+function Comparator(comp, loose) {
+ if (comp instanceof Comparator) {
+ if (comp.loose === loose)
+ return comp;
+ else
+ comp = comp.value;
+ }
+
+ if (!(this instanceof Comparator))
+ return new Comparator(comp, loose);
+
+ debug('comparator', comp, loose);
+ this.loose = loose;
+ this.parse(comp);
+
+ if (this.semver === ANY)
+ this.value = '';
+ else
+ this.value = this.operator + this.semver.version;
+
+ debug('comp', this);
+}
+
+var ANY = {};
+Comparator.prototype.parse = function(comp) {
+ var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+ var m = comp.match(r);
+
+ if (!m)
+ throw new TypeError('Invalid comparator: ' + comp);
+
+ this.operator = m[1];
+ if (this.operator === '=')
+ this.operator = '';
+
+ // if it literally is just '>' or '' then allow anything.
+ if (!m[2])
+ this.semver = ANY;
+ else
+ this.semver = new SemVer(m[2], this.loose);
+};
+
+Comparator.prototype.toString = function() {
+ return this.value;
+};
+
+Comparator.prototype.test = function(version) {
+ debug('Comparator.test', version, this.loose);
+
+ if (this.semver === ANY)
+ return true;
+
+ if (typeof version === 'string')
+ version = new SemVer(version, this.loose);
+
+ return cmp(version, this.operator, this.semver, this.loose);
+};
+
+Comparator.prototype.intersects = function(comp, loose) {
+ if (!(comp instanceof Comparator)) {
+ throw new TypeError('a Comparator is required');
+ }
+
+ var rangeTmp;
+
+ if (this.operator === '') {
+ rangeTmp = new Range(comp.value, loose);
+ return satisfies(this.value, rangeTmp, loose);
+ } else if (comp.operator === '') {
+ rangeTmp = new Range(this.value, loose);
+ return satisfies(comp.semver, rangeTmp, loose);
+ }
+
+ var sameDirectionIncreasing =
+ (this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '>=' || comp.operator === '>');
+ var sameDirectionDecreasing =
+ (this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '<=' || comp.operator === '<');
+ var sameSemVer = this.semver.version === comp.semver.version;
+ var differentDirectionsInclusive =
+ (this.operator === '>=' || this.operator === '<=') &&
+ (comp.operator === '>=' || comp.operator === '<=');
+ var oppositeDirectionsLessThan =
+ cmp(this.semver, '<', comp.semver, loose) &&
+ ((this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '<=' || comp.operator === '<'));
+ var oppositeDirectionsGreaterThan =
+ cmp(this.semver, '>', comp.semver, loose) &&
+ ((this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '>=' || comp.operator === '>'));
+
+ return sameDirectionIncreasing || sameDirectionDecreasing ||
+ (sameSemVer && differentDirectionsInclusive) ||
+ oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+};
+
+
+exports.Range = Range;
+function Range(range, loose) {
+ if (range instanceof Range) {
+ if (range.loose === loose) {
+ return range;
+ } else {
+ return new Range(range.raw, loose);
+ }
+ }
+
+ if (range instanceof Comparator) {
+ return new Range(range.value, loose);
+ }
+
+ if (!(this instanceof Range))
+ return new Range(range, loose);
+
+ this.loose = loose;
+
+ // First, split based on boolean or ||
+ this.raw = range;
+ this.set = range.split(/\s*\|\|\s*/).map(function(range) {
+ return this.parseRange(range.trim());
+ }, this).filter(function(c) {
+ // throw out any that are not relevant for whatever reason
+ return c.length;
+ });
+
+ if (!this.set.length) {
+ throw new TypeError('Invalid SemVer Range: ' + range);
+ }
+
+ this.format();
+}
+
+Range.prototype.format = function() {
+ this.range = this.set.map(function(comps) {
+ return comps.join(' ').trim();
+ }).join('||').trim();
+ return this.range;
+};
+
+Range.prototype.toString = function() {
+ return this.range;
+};
+
+Range.prototype.parseRange = function(range) {
+ var loose = this.loose;
+ range = range.trim();
+ debug('range', range, loose);
+ // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+ var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace);
+ debug('hyphen replace', range);
+ // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+ range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace);
+ debug('comparator trim', range, re[COMPARATORTRIM]);
+
+ // `~ 1.2.3` => `~1.2.3`
+ range = range.replace(re[TILDETRIM], tildeTrimReplace);
+
+ // `^ 1.2.3` => `^1.2.3`
+ range = range.replace(re[CARETTRIM], caretTrimReplace);
+
+ // normalize spaces
+ range = range.split(/\s+/).join(' ');
+
+ // At this point, the range is completely trimmed and
+ // ready to be split into comparators.
+
+ var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+ var set = range.split(' ').map(function(comp) {
+ return parseComparator(comp, loose);
+ }).join(' ').split(/\s+/);
+ if (this.loose) {
+ // in loose mode, throw out any that are not valid comparators
+ set = set.filter(function(comp) {
+ return !!comp.match(compRe);
+ });
+ }
+ set = set.map(function(comp) {
+ return new Comparator(comp, loose);
+ });
+
+ return set;
+};
+
+Range.prototype.intersects = function(range, loose) {
+ if (!(range instanceof Range)) {
+ throw new TypeError('a Range is required');
+ }
+
+ return this.set.some(function(thisComparators) {
+ return thisComparators.every(function(thisComparator) {
+ return range.set.some(function(rangeComparators) {
+ return rangeComparators.every(function(rangeComparator) {
+ return thisComparator.intersects(rangeComparator, loose);
+ });
+ });
+ });
+ });
+};
+
+// Mostly just for testing and legacy API reasons
+exports.toComparators = toComparators;
+function toComparators(range, loose) {
+ return new Range(range, loose).set.map(function(comp) {
+ return comp.map(function(c) {
+ return c.value;
+ }).join(' ').trim().split(' ');
+ });
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+function parseComparator(comp, loose) {
+ debug('comp', comp);
+ comp = replaceCarets(comp, loose);
+ debug('caret', comp);
+ comp = replaceTildes(comp, loose);
+ debug('tildes', comp);
+ comp = replaceXRanges(comp, loose);
+ debug('xrange', comp);
+ comp = replaceStars(comp, loose);
+ debug('stars', comp);
+ return comp;
+}
+
+function isX(id) {
+ return !id || id.toLowerCase() === 'x' || id === '*';
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes(comp, loose) {
+ return comp.trim().split(/\s+/).map(function(comp) {
+ return replaceTilde(comp, loose);
+ }).join(' ');
+}
+
+function replaceTilde(comp, loose) {
+ var r = loose ? re[TILDELOOSE] : re[TILDE];
+ return comp.replace(r, function(_, M, m, p, pr) {
+ debug('tilde', comp, _, M, m, p, pr);
+ var ret;
+
+ if (isX(M))
+ ret = '';
+ else if (isX(m))
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ else if (isX(p))
+ // ~1.2 == >=1.2.0 <1.3.0
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ else if (pr) {
+ debug('replaceTilde pr', pr);
+ if (pr.charAt(0) !== '-')
+ pr = '-' + pr;
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ // ~1.2.3 == >=1.2.3 <1.3.0
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0';
+
+ debug('tilde return', ret);
+ return ret;
+ });
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets(comp, loose) {
+ return comp.trim().split(/\s+/).map(function(comp) {
+ return replaceCaret(comp, loose);
+ }).join(' ');
+}
+
+function replaceCaret(comp, loose) {
+ debug('caret', comp, loose);
+ var r = loose ? re[CARETLOOSE] : re[CARET];
+ return comp.replace(r, function(_, M, m, p, pr) {
+ debug('caret', comp, _, M, m, p, pr);
+ var ret;
+
+ if (isX(M))
+ ret = '';
+ else if (isX(m))
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ else if (isX(p)) {
+ if (M === '0')
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ else
+ ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';
+ } else if (pr) {
+ debug('replaceCaret pr', pr);
+ if (pr.charAt(0) !== '-')
+ pr = '-' + pr;
+ if (M === '0') {
+ if (m === '0')
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + m + '.' + (+p + 1);
+ else
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + (+M + 1) + '.0.0';
+ } else {
+ debug('no pr');
+ if (M === '0') {
+ if (m === '0')
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + m + '.' + (+p + 1);
+ else
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + (+M + 1) + '.0.0';
+ }
+
+ debug('caret return', ret);
+ return ret;
+ });
+}
+
+function replaceXRanges(comp, loose) {
+ debug('replaceXRanges', comp, loose);
+ return comp.split(/\s+/).map(function(comp) {
+ return replaceXRange(comp, loose);
+ }).join(' ');
+}
+
+function replaceXRange(comp, loose) {
+ comp = comp.trim();
+ var r = loose ? re[XRANGELOOSE] : re[XRANGE];
+ return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
+ debug('xRange', comp, ret, gtlt, M, m, p, pr);
+ var xM = isX(M);
+ var xm = xM || isX(m);
+ var xp = xm || isX(p);
+ var anyX = xp;
+
+ if (gtlt === '=' && anyX)
+ gtlt = '';
+
+ if (xM) {
+ if (gtlt === '>' || gtlt === '<') {
+ // nothing is allowed
+ ret = '<0.0.0';
+ } else {
+ // nothing is forbidden
+ ret = '*';
+ }
+ } else if (gtlt && anyX) {
+ // replace X with 0
+ if (xm)
+ m = 0;
+ if (xp)
+ p = 0;
+
+ if (gtlt === '>') {
+ // >1 => >=2.0.0
+ // >1.2 => >=1.3.0
+ // >1.2.3 => >= 1.2.4
+ gtlt = '>=';
+ if (xm) {
+ M = +M + 1;
+ m = 0;
+ p = 0;
+ } else if (xp) {
+ m = +m + 1;
+ p = 0;
+ }
+ } else if (gtlt === '<=') {
+ // <=0.7.x is actually <0.8.0, since any 0.7.x should
+ // pass. Similarly, <=7.x is actually <8.0.0, etc.
+ gtlt = '<';
+ if (xm)
+ M = +M + 1;
+ else
+ m = +m + 1;
+ }
+
+ ret = gtlt + M + '.' + m + '.' + p;
+ } else if (xm) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ } else if (xp) {
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ }
+
+ debug('xRange return', ret);
+
+ return ret;
+ });
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars(comp, loose) {
+ debug('replaceStars', comp, loose);
+ // Looseness is ignored here. star is always as loose as it gets!
+ return comp.trim().replace(re[STAR], '');
+}
+
+// This function is passed to string.replace(re[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0
+function hyphenReplace($0,
+ from, fM, fm, fp, fpr, fb,
+ to, tM, tm, tp, tpr, tb) {
+
+ if (isX(fM))
+ from = '';
+ else if (isX(fm))
+ from = '>=' + fM + '.0.0';
+ else if (isX(fp))
+ from = '>=' + fM + '.' + fm + '.0';
+ else
+ from = '>=' + from;
+
+ if (isX(tM))
+ to = '';
+ else if (isX(tm))
+ to = '<' + (+tM + 1) + '.0.0';
+ else if (isX(tp))
+ to = '<' + tM + '.' + (+tm + 1) + '.0';
+ else if (tpr)
+ to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;
+ else
+ to = '<=' + to;
+
+ return (from + ' ' + to).trim();
+}
+
+
+// if ANY of the sets match ALL of its comparators, then pass
+Range.prototype.test = function(version) {
+ if (!version)
+ return false;
+
+ if (typeof version === 'string')
+ version = new SemVer(version, this.loose);
+
+ for (var i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version))
+ return true;
+ }
+ return false;
+};
+
+function testSet(set, version) {
+ for (var i = 0; i < set.length; i++) {
+ if (!set[i].test(version))
+ return false;
+ }
+
+ if (version.prerelease.length) {
+ // Find the set of versions that are allowed to have prereleases
+ // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+ // That should allow `1.2.3-pr.2` to pass.
+ // However, `1.2.4-alpha.notready` should NOT be allowed,
+ // even though it's within the range set by the comparators.
+ for (var i = 0; i < set.length; i++) {
+ debug(set[i].semver);
+ if (set[i].semver === ANY)
+ continue;
+
+ if (set[i].semver.prerelease.length > 0) {
+ var allowed = set[i].semver;
+ if (allowed.major === version.major &&
+ allowed.minor === version.minor &&
+ allowed.patch === version.patch)
+ return true;
+ }
+ }
+
+ // Version has a -pre, but it's not one of the ones we like.
+ return false;
+ }
+
+ return true;
+}
+
+exports.satisfies = satisfies;
+function satisfies(version, range, loose) {
+ try {
+ range = new Range(range, loose);
+ } catch (er) {
+ return false;
+ }
+ return range.test(version);
+}
+
+exports.maxSatisfying = maxSatisfying;
+function maxSatisfying(versions, range, loose) {
+ var max = null;
+ var maxSV = null;
+ try {
+ var rangeObj = new Range(range, loose);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) { // satisfies(v, range, loose)
+ if (!max || maxSV.compare(v) === -1) { // compare(max, v, true)
+ max = v;
+ maxSV = new SemVer(max, loose);
+ }
+ }
+ });
+ return max;
+}
+
+exports.minSatisfying = minSatisfying;
+function minSatisfying(versions, range, loose) {
+ var min = null;
+ var minSV = null;
+ try {
+ var rangeObj = new Range(range, loose);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) { // satisfies(v, range, loose)
+ if (!min || minSV.compare(v) === 1) { // compare(min, v, true)
+ min = v;
+ minSV = new SemVer(min, loose);
+ }
+ }
+ });
+ return min;
+}
+
+exports.validRange = validRange;
+function validRange(range, loose) {
+ try {
+ // Return '*' instead of '' so that truthiness works.
+ // This will throw if it's invalid anyway
+ return new Range(range, loose).range || '*';
+ } catch (er) {
+ return null;
+ }
+}
+
+// Determine if version is less than all the versions possible in the range
+exports.ltr = ltr;
+function ltr(version, range, loose) {
+ return outside(version, range, '<', loose);
+}
+
+// Determine if version is greater than all the versions possible in the range.
+exports.gtr = gtr;
+function gtr(version, range, loose) {
+ return outside(version, range, '>', loose);
+}
+
+exports.outside = outside;
+function outside(version, range, hilo, loose) {
+ version = new SemVer(version, loose);
+ range = new Range(range, loose);
+
+ var gtfn, ltefn, ltfn, comp, ecomp;
+ switch (hilo) {
+ case '>':
+ gtfn = gt;
+ ltefn = lte;
+ ltfn = lt;
+ comp = '>';
+ ecomp = '>=';
+ break;
+ case '<':
+ gtfn = lt;
+ ltefn = gte;
+ ltfn = gt;
+ comp = '<';
+ ecomp = '<=';
+ break;
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+
+ // If it satisifes the range it is not outside
+ if (satisfies(version, range, loose)) {
+ return false;
+ }
+
+ // From now on, variable terms are as if we're in "gtr" mode.
+ // but note that everything is flipped for the "ltr" function.
+
+ for (var i = 0; i < range.set.length; ++i) {
+ var comparators = range.set[i];
+
+ var high = null;
+ var low = null;
+
+ comparators.forEach(function(comparator) {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator('>=0.0.0');
+ }
+ high = high || comparator;
+ low = low || comparator;
+ if (gtfn(comparator.semver, high.semver, loose)) {
+ high = comparator;
+ } else if (ltfn(comparator.semver, low.semver, loose)) {
+ low = comparator;
+ }
+ });
+
+ // If the edge version comparator has a operator then our version
+ // isn't outside it
+ if (high.operator === comp || high.operator === ecomp) {
+ return false;
+ }
+
+ // If the lowest version comparator has an operator and our version
+ // is less than it then it isn't higher than the range
+ if ((!low.operator || low.operator === comp) &&
+ ltefn(version, low.semver)) {
+ return false;
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+exports.prerelease = prerelease;
+function prerelease(version, loose) {
+ var parsed = parse(version, loose);
+ return (parsed && parsed.prerelease.length) ? parsed.prerelease : null;
+}
+
+exports.intersects = intersects;
+function intersects(r1, r2, loose) {
+ r1 = new Range(r1, loose);
+ r2 = new Range(r2, loose);
+ return r1.intersects(r2)
+}
+
+exports.coerce = coerce;
+function coerce(version) {
+ if (version instanceof SemVer)
+ return version;
+
+ if (typeof version !== 'string')
+ return null;
+
+ var match = version.match(re[COERCE]);
+
+ if (match == null)
+ return null;
+
+ return parse((match[1] || '0') + '.' + (match[2] || '0') + '.' + (match[3] || '0'));
+}
+});
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var pseudomap = PseudoMap;
+
+function PseudoMap (set) {
+ if (!(this instanceof PseudoMap)) // whyyyyyyy
+ throw new TypeError("Constructor PseudoMap requires 'new'")
+
+ this.clear();
+
+ if (set) {
+ if ((set instanceof PseudoMap) ||
+ (typeof Map === 'function' && set instanceof Map))
+ set.forEach(function (value, key) {
+ this.set(key, value);
+ }, this);
+ else if (Array.isArray(set))
+ set.forEach(function (kv) {
+ this.set(kv[0], kv[1]);
+ }, this);
+ else
+ throw new TypeError('invalid argument')
+ }
+}
+
+PseudoMap.prototype.forEach = function (fn, thisp) {
+ thisp = thisp || this;
+ Object.keys(this._data).forEach(function (k) {
+ if (k !== 'size')
+ fn.call(thisp, this._data[k].value, this._data[k].key);
+ }, this);
+};
+
+PseudoMap.prototype.has = function (k) {
+ return !!find(this._data, k)
+};
+
+PseudoMap.prototype.get = function (k) {
+ var res = find(this._data, k);
+ return res && res.value
+};
+
+PseudoMap.prototype.set = function (k, v) {
+ set(this._data, k, v);
+};
+
+PseudoMap.prototype.delete = function (k) {
+ var res = find(this._data, k);
+ if (res) {
+ delete this._data[res._index];
+ this._data.size--;
+ }
+};
+
+PseudoMap.prototype.clear = function () {
+ var data = Object.create(null);
+ data.size = 0;
+
+ Object.defineProperty(this, '_data', {
+ value: data,
+ enumerable: false,
+ configurable: true,
+ writable: false
+ });
+};
+
+Object.defineProperty(PseudoMap.prototype, 'size', {
+ get: function () {
+ return this._data.size
+ },
+ set: function (n) {},
+ enumerable: true,
+ configurable: true
+});
+
+PseudoMap.prototype.values =
+PseudoMap.prototype.keys =
+PseudoMap.prototype.entries = function () {
+ throw new Error('iterators are not implemented in this version')
+};
+
+// Either identical, or both NaN
+function same (a, b) {
+ return a === b || a !== a && b !== b
+}
+
+function Entry$1 (k, v, i) {
+ this.key = k;
+ this.value = v;
+ this._index = i;
+}
+
+function find (data, k) {
+ for (var i = 0, s = '_' + k, key = s;
+ hasOwnProperty.call(data, key);
+ key = s + i++) {
+ if (same(data[key].key, k))
+ return data[key]
+ }
+}
+
+function set (data, k, v) {
+ for (var i = 0, s = '_' + k, key = s;
+ hasOwnProperty.call(data, key);
+ key = s + i++) {
+ if (same(data[key].key, k)) {
+ data[key].value = v;
+ return
+ }
+ }
+ data.size++;
+ data[key] = new Entry$1(k, v, key);
+}
+
+var map = createCommonjsModule(function (module) {
+if (process.env.npm_package_name === 'pseudomap' &&
+ process.env.npm_lifecycle_script === 'test')
+ process.env.TEST_PSEUDOMAP = 'true';
+
+if (typeof Map === 'function' && !process.env.TEST_PSEUDOMAP) {
+ module.exports = Map;
+} else {
+ module.exports = pseudomap;
+}
+});
+
+var yallist = Yallist;
+
+Yallist.Node = Node;
+Yallist.create = Yallist;
+
+function Yallist (list) {
+ var self = this;
+ if (!(self instanceof Yallist)) {
+ self = new Yallist();
+ }
+
+ self.tail = null;
+ self.head = null;
+ self.length = 0;
+
+ if (list && typeof list.forEach === 'function') {
+ list.forEach(function (item) {
+ self.push(item);
+ });
+ } else if (arguments.length > 0) {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ self.push(arguments[i]);
+ }
+ }
+
+ return self
+}
+
+Yallist.prototype.removeNode = function (node) {
+ if (node.list !== this) {
+ throw new Error('removing node which does not belong to this list')
+ }
+
+ var next = node.next;
+ var prev = node.prev;
+
+ if (next) {
+ next.prev = prev;
+ }
+
+ if (prev) {
+ prev.next = next;
+ }
+
+ if (node === this.head) {
+ this.head = next;
+ }
+ if (node === this.tail) {
+ this.tail = prev;
+ }
+
+ node.list.length--;
+ node.next = null;
+ node.prev = null;
+ node.list = null;
+};
+
+Yallist.prototype.unshiftNode = function (node) {
+ if (node === this.head) {
+ return
+ }
+
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+
+ var head = this.head;
+ node.list = this;
+ node.next = head;
+ if (head) {
+ head.prev = node;
+ }
+
+ this.head = node;
+ if (!this.tail) {
+ this.tail = node;
+ }
+ this.length++;
+};
+
+Yallist.prototype.pushNode = function (node) {
+ if (node === this.tail) {
+ return
+ }
+
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+
+ var tail = this.tail;
+ node.list = this;
+ node.prev = tail;
+ if (tail) {
+ tail.next = node;
+ }
+
+ this.tail = node;
+ if (!this.head) {
+ this.head = node;
+ }
+ this.length++;
+};
+
+Yallist.prototype.push = function () {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ push(this, arguments[i]);
+ }
+ return this.length
+};
+
+Yallist.prototype.unshift = function () {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ unshift(this, arguments[i]);
+ }
+ return this.length
+};
+
+Yallist.prototype.pop = function () {
+ if (!this.tail) {
+ return undefined
+ }
+
+ var res = this.tail.value;
+ this.tail = this.tail.prev;
+ if (this.tail) {
+ this.tail.next = null;
+ } else {
+ this.head = null;
+ }
+ this.length--;
+ return res
+};
+
+Yallist.prototype.shift = function () {
+ if (!this.head) {
+ return undefined
+ }
+
+ var res = this.head.value;
+ this.head = this.head.next;
+ if (this.head) {
+ this.head.prev = null;
+ } else {
+ this.tail = null;
+ }
+ this.length--;
+ return res
+};
+
+Yallist.prototype.forEach = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.head, i = 0; walker !== null; i++) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.next;
+ }
+};
+
+Yallist.prototype.forEachReverse = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.prev;
+ }
+};
+
+Yallist.prototype.get = function (n) {
+ for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+ // abort out of the list early if we hit a cycle
+ walker = walker.next;
+ }
+ if (i === n && walker !== null) {
+ return walker.value
+ }
+};
+
+Yallist.prototype.getReverse = function (n) {
+ for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+ // abort out of the list early if we hit a cycle
+ walker = walker.prev;
+ }
+ if (i === n && walker !== null) {
+ return walker.value
+ }
+};
+
+Yallist.prototype.map = function (fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.head; walker !== null;) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.next;
+ }
+ return res
+};
+
+Yallist.prototype.mapReverse = function (fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.tail; walker !== null;) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.prev;
+ }
+ return res
+};
+
+Yallist.prototype.reduce = function (fn, initial) {
+ var acc;
+ var walker = this.head;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.head) {
+ walker = this.head.next;
+ acc = this.head.value;
+ } else {
+ throw new TypeError('Reduce of empty list with no initial value')
+ }
+
+ for (var i = 0; walker !== null; i++) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.next;
+ }
+
+ return acc
+};
+
+Yallist.prototype.reduceReverse = function (fn, initial) {
+ var acc;
+ var walker = this.tail;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.tail) {
+ walker = this.tail.prev;
+ acc = this.tail.value;
+ } else {
+ throw new TypeError('Reduce of empty list with no initial value')
+ }
+
+ for (var i = this.length - 1; walker !== null; i--) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.prev;
+ }
+
+ return acc
+};
+
+Yallist.prototype.toArray = function () {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.head; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.next;
+ }
+ return arr
+};
+
+Yallist.prototype.toArrayReverse = function () {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.tail; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.prev;
+ }
+ return arr
+};
+
+Yallist.prototype.slice = function (from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+ walker = walker.next;
+ }
+ for (; walker !== null && i < to; i++, walker = walker.next) {
+ ret.push(walker.value);
+ }
+ return ret
+};
+
+Yallist.prototype.sliceReverse = function (from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+ walker = walker.prev;
+ }
+ for (; walker !== null && i > from; i--, walker = walker.prev) {
+ ret.push(walker.value);
+ }
+ return ret
+};
+
+Yallist.prototype.reverse = function () {
+ var head = this.head;
+ var tail = this.tail;
+ for (var walker = head; walker !== null; walker = walker.prev) {
+ var p = walker.prev;
+ walker.prev = walker.next;
+ walker.next = p;
+ }
+ this.head = tail;
+ this.tail = head;
+ return this
+};
+
+function push (self, item) {
+ self.tail = new Node(item, self.tail, null, self);
+ if (!self.head) {
+ self.head = self.tail;
+ }
+ self.length++;
+}
+
+function unshift (self, item) {
+ self.head = new Node(item, null, self.head, self);
+ if (!self.tail) {
+ self.tail = self.head;
+ }
+ self.length++;
+}
+
+function Node (value, prev, next, list) {
+ if (!(this instanceof Node)) {
+ return new Node(value, prev, next, list)
+ }
+
+ this.list = list;
+ this.value = value;
+
+ if (prev) {
+ prev.next = this;
+ this.prev = prev;
+ } else {
+ this.prev = null;
+ }
+
+ if (next) {
+ next.prev = this;
+ this.next = next;
+ } else {
+ this.next = null;
+ }
+}
+
+var lruCache = LRUCache;
+
+// This will be a proper iterable 'Map' in engines that support it,
+// or a fakey-fake PseudoMap in older versions.
+
+
+
+// A linked list to keep track of recently-used-ness
+
+
+// use symbols if possible, otherwise just _props
+var hasSymbol = typeof Symbol === 'function';
+var makeSymbol;
+if (hasSymbol) {
+ makeSymbol = function (key) {
+ return Symbol.for(key)
+ };
+} else {
+ makeSymbol = function (key) {
+ return '_' + key
+ };
+}
+
+var MAX = makeSymbol('max');
+var LENGTH = makeSymbol('length');
+var LENGTH_CALCULATOR = makeSymbol('lengthCalculator');
+var ALLOW_STALE = makeSymbol('allowStale');
+var MAX_AGE = makeSymbol('maxAge');
+var DISPOSE = makeSymbol('dispose');
+var NO_DISPOSE_ON_SET = makeSymbol('noDisposeOnSet');
+var LRU_LIST = makeSymbol('lruList');
+var CACHE = makeSymbol('cache');
+
+function naiveLength () { return 1 }
+
+// lruList is a yallist where the head is the youngest
+// item, and the tail is the oldest. the list contains the Hit
+// objects as the entries.
+// Each Hit object has a reference to its Yallist.Node. This
+// never changes.
+//
+// cache is a Map (or PseudoMap) that matches the keys to
+// the Yallist.Node object.
+function LRUCache (options) {
+ if (!(this instanceof LRUCache)) {
+ return new LRUCache(options)
+ }
+
+ if (typeof options === 'number') {
+ options = { max: options };
+ }
+
+ if (!options) {
+ options = {};
+ }
+
+ var max = this[MAX] = options.max;
+ // Kind of weird to have a default max of Infinity, but oh well.
+ if (!max ||
+ !(typeof max === 'number') ||
+ max <= 0) {
+ this[MAX] = Infinity;
+ }
+
+ var lc = options.length || naiveLength;
+ if (typeof lc !== 'function') {
+ lc = naiveLength;
+ }
+ this[LENGTH_CALCULATOR] = lc;
+
+ this[ALLOW_STALE] = options.stale || false;
+ this[MAX_AGE] = options.maxAge || 0;
+ this[DISPOSE] = options.dispose;
+ this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+ this.reset();
+}
+
+// resize the cache when the max changes.
+Object.defineProperty(LRUCache.prototype, 'max', {
+ set: function (mL) {
+ if (!mL || !(typeof mL === 'number') || mL <= 0) {
+ mL = Infinity;
+ }
+ this[MAX] = mL;
+ trim(this);
+ },
+ get: function () {
+ return this[MAX]
+ },
+ enumerable: true
+});
+
+Object.defineProperty(LRUCache.prototype, 'allowStale', {
+ set: function (allowStale) {
+ this[ALLOW_STALE] = !!allowStale;
+ },
+ get: function () {
+ return this[ALLOW_STALE]
+ },
+ enumerable: true
+});
+
+Object.defineProperty(LRUCache.prototype, 'maxAge', {
+ set: function (mA) {
+ if (!mA || !(typeof mA === 'number') || mA < 0) {
+ mA = 0;
+ }
+ this[MAX_AGE] = mA;
+ trim(this);
+ },
+ get: function () {
+ return this[MAX_AGE]
+ },
+ enumerable: true
+});
+
+// resize the cache when the lengthCalculator changes.
+Object.defineProperty(LRUCache.prototype, 'lengthCalculator', {
+ set: function (lC) {
+ if (typeof lC !== 'function') {
+ lC = naiveLength;
+ }
+ if (lC !== this[LENGTH_CALCULATOR]) {
+ this[LENGTH_CALCULATOR] = lC;
+ this[LENGTH] = 0;
+ this[LRU_LIST].forEach(function (hit) {
+ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
+ this[LENGTH] += hit.length;
+ }, this);
+ }
+ trim(this);
+ },
+ get: function () { return this[LENGTH_CALCULATOR] },
+ enumerable: true
+});
+
+Object.defineProperty(LRUCache.prototype, 'length', {
+ get: function () { return this[LENGTH] },
+ enumerable: true
+});
+
+Object.defineProperty(LRUCache.prototype, 'itemCount', {
+ get: function () { return this[LRU_LIST].length },
+ enumerable: true
+});
+
+LRUCache.prototype.rforEach = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this[LRU_LIST].tail; walker !== null;) {
+ var prev = walker.prev;
+ forEachStep(this, fn, walker, thisp);
+ walker = prev;
+ }
+};
+
+function forEachStep (self, fn, node, thisp) {
+ var hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE]) {
+ hit = undefined;
+ }
+ }
+ if (hit) {
+ fn.call(thisp, hit.value, hit.key, self);
+ }
+}
+
+LRUCache.prototype.forEach = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this[LRU_LIST].head; walker !== null;) {
+ var next = walker.next;
+ forEachStep(this, fn, walker, thisp);
+ walker = next;
+ }
+};
+
+LRUCache.prototype.keys = function () {
+ return this[LRU_LIST].toArray().map(function (k) {
+ return k.key
+ }, this)
+};
+
+LRUCache.prototype.values = function () {
+ return this[LRU_LIST].toArray().map(function (k) {
+ return k.value
+ }, this)
+};
+
+LRUCache.prototype.reset = function () {
+ if (this[DISPOSE] &&
+ this[LRU_LIST] &&
+ this[LRU_LIST].length) {
+ this[LRU_LIST].forEach(function (hit) {
+ this[DISPOSE](hit.key, hit.value);
+ }, this);
+ }
+
+ this[CACHE] = new map(); // hash of items by key
+ this[LRU_LIST] = new yallist(); // list of items in order of use recency
+ this[LENGTH] = 0; // length of items in the list
+};
+
+LRUCache.prototype.dump = function () {
+ return this[LRU_LIST].map(function (hit) {
+ if (!isStale(this, hit)) {
+ return {
+ k: hit.key,
+ v: hit.value,
+ e: hit.now + (hit.maxAge || 0)
+ }
+ }
+ }, this).toArray().filter(function (h) {
+ return h
+ })
+};
+
+LRUCache.prototype.dumpLru = function () {
+ return this[LRU_LIST]
+};
+
+LRUCache.prototype.inspect = function (n, opts) {
+ var str = 'LRUCache {';
+ var extras = false;
+
+ var as = this[ALLOW_STALE];
+ if (as) {
+ str += '\n allowStale: true';
+ extras = true;
+ }
+
+ var max = this[MAX];
+ if (max && max !== Infinity) {
+ if (extras) {
+ str += ',';
+ }
+ str += '\n max: ' + util.inspect(max, opts);
+ extras = true;
+ }
+
+ var maxAge = this[MAX_AGE];
+ if (maxAge) {
+ if (extras) {
+ str += ',';
+ }
+ str += '\n maxAge: ' + util.inspect(maxAge, opts);
+ extras = true;
+ }
+
+ var lc = this[LENGTH_CALCULATOR];
+ if (lc && lc !== naiveLength) {
+ if (extras) {
+ str += ',';
+ }
+ str += '\n length: ' + util.inspect(this[LENGTH], opts);
+ extras = true;
+ }
+
+ var didFirst = false;
+ this[LRU_LIST].forEach(function (item) {
+ if (didFirst) {
+ str += ',\n ';
+ } else {
+ if (extras) {
+ str += ',\n';
+ }
+ didFirst = true;
+ str += '\n ';
+ }
+ var key = util.inspect(item.key).split('\n').join('\n ');
+ var val = { value: item.value };
+ if (item.maxAge !== maxAge) {
+ val.maxAge = item.maxAge;
+ }
+ if (lc !== naiveLength) {
+ val.length = item.length;
+ }
+ if (isStale(this, item)) {
+ val.stale = true;
+ }
+
+ val = util.inspect(val, opts).split('\n').join('\n ');
+ str += key + ' => ' + val;
+ });
+
+ if (didFirst || extras) {
+ str += '\n';
+ }
+ str += '}';
+
+ return str
+};
+
+LRUCache.prototype.set = function (key, value, maxAge) {
+ maxAge = maxAge || this[MAX_AGE];
+
+ var now = maxAge ? Date.now() : 0;
+ var len = this[LENGTH_CALCULATOR](value, key);
+
+ if (this[CACHE].has(key)) {
+ if (len > this[MAX]) {
+ del(this, this[CACHE].get(key));
+ return false
+ }
+
+ var node = this[CACHE].get(key);
+ var item = node.value;
+
+ // dispose of the old one before overwriting
+ // split out into 2 ifs for better coverage tracking
+ if (this[DISPOSE]) {
+ if (!this[NO_DISPOSE_ON_SET]) {
+ this[DISPOSE](key, item.value);
+ }
+ }
+
+ item.now = now;
+ item.maxAge = maxAge;
+ item.value = value;
+ this[LENGTH] += len - item.length;
+ item.length = len;
+ this.get(key);
+ trim(this);
+ return true
+ }
+
+ var hit = new Entry(key, value, len, now, maxAge);
+
+ // oversized objects fall out of cache automatically.
+ if (hit.length > this[MAX]) {
+ if (this[DISPOSE]) {
+ this[DISPOSE](key, value);
+ }
+ return false
+ }
+
+ this[LENGTH] += hit.length;
+ this[LRU_LIST].unshift(hit);
+ this[CACHE].set(key, this[LRU_LIST].head);
+ trim(this);
+ return true
+};
+
+LRUCache.prototype.has = function (key) {
+ if (!this[CACHE].has(key)) return false
+ var hit = this[CACHE].get(key).value;
+ if (isStale(this, hit)) {
+ return false
+ }
+ return true
+};
+
+LRUCache.prototype.get = function (key) {
+ return get(this, key, true)
+};
+
+LRUCache.prototype.peek = function (key) {
+ return get(this, key, false)
+};
+
+LRUCache.prototype.pop = function () {
+ var node = this[LRU_LIST].tail;
+ if (!node) return null
+ del(this, node);
+ return node.value
+};
+
+LRUCache.prototype.del = function (key) {
+ del(this, this[CACHE].get(key));
+};
+
+LRUCache.prototype.load = function (arr) {
+ // reset the cache
+ this.reset();
+
+ var now = Date.now();
+ // A previous serialized cache has the most recent items first
+ for (var l = arr.length - 1; l >= 0; l--) {
+ var hit = arr[l];
+ var expiresAt = hit.e || 0;
+ if (expiresAt === 0) {
+ // the item was created without expiration in a non aged cache
+ this.set(hit.k, hit.v);
+ } else {
+ var maxAge = expiresAt - now;
+ // dont add already expired items
+ if (maxAge > 0) {
+ this.set(hit.k, hit.v, maxAge);
+ }
+ }
+ }
+};
+
+LRUCache.prototype.prune = function () {
+ var self = this;
+ this[CACHE].forEach(function (value, key) {
+ get(self, key, false);
+ });
+};
+
+function get (self, key, doUse) {
+ var node = self[CACHE].get(key);
+ if (node) {
+ var hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE]) hit = undefined;
+ } else {
+ if (doUse) {
+ self[LRU_LIST].unshiftNode(node);
+ }
+ }
+ if (hit) hit = hit.value;
+ }
+ return hit
+}
+
+function isStale (self, hit) {
+ if (!hit || (!hit.maxAge && !self[MAX_AGE])) {
+ return false
+ }
+ var stale = false;
+ var diff = Date.now() - hit.now;
+ if (hit.maxAge) {
+ stale = diff > hit.maxAge;
+ } else {
+ stale = self[MAX_AGE] && (diff > self[MAX_AGE]);
+ }
+ return stale
+}
+
+function trim (self) {
+ if (self[LENGTH] > self[MAX]) {
+ for (var walker = self[LRU_LIST].tail;
+ self[LENGTH] > self[MAX] && walker !== null;) {
+ // We know that we're about to delete this one, and also
+ // what the next least recently used key will be, so just
+ // go ahead and set it now.
+ var prev = walker.prev;
+ del(self, walker);
+ walker = prev;
+ }
+ }
+}
+
+function del (self, node) {
+ if (node) {
+ var hit = node.value;
+ if (self[DISPOSE]) {
+ self[DISPOSE](hit.key, hit.value);
+ }
+ self[LENGTH] -= hit.length;
+ self[CACHE].delete(hit.key);
+ self[LRU_LIST].removeNode(node);
+ }
+}
+
+// classy, since V8 prefers predictable objects.
+function Entry (key, value, length, now, maxAge) {
+ this.key = key;
+ this.value = value;
+ this.length = length;
+ this.now = now;
+ this.maxAge = maxAge || 0;
+}
+
+var sigmund_1 = sigmund;
+function sigmund (subject, maxSessions) {
+ maxSessions = maxSessions || 10;
+ var notes = [];
+ var analysis = '';
+ var RE = RegExp;
+
+ function psychoAnalyze (subject, session) {
+ if (session > maxSessions) return;
+
+ if (typeof subject === 'function' ||
+ typeof subject === 'undefined') {
+ return;
+ }
+
+ if (typeof subject !== 'object' || !subject ||
+ (subject instanceof RE)) {
+ analysis += subject;
+ return;
+ }
+
+ if (notes.indexOf(subject) !== -1 || session === maxSessions) return;
+
+ notes.push(subject);
+ analysis += '{';
+ Object.keys(subject).forEach(function (issue, _, __) {
+ // pseudo-private values. skip those.
+ if (issue.charAt(0) === '_') return;
+ var to = typeof subject[issue];
+ if (to === 'function' || to === 'undefined') return;
+ analysis += issue;
+ psychoAnalyze(subject[issue], session + 1);
+ });
+ }
+ psychoAnalyze(subject, 0);
+ return analysis;
+}
+
+// vim: set softtabstop=4 shiftwidth=4:
+
+var fnmatch = createCommonjsModule(function (module, exports) {
+// Based on minimatch.js by isaacs
+
+ var platform = typeof process === "object" ? process.platform : "win32";
+
+ if (module) module.exports = minimatch;
+ else exports.minimatch = minimatch;
+
+ minimatch.Minimatch = Minimatch;
+
+ var cache = minimatch.cache = new lruCache({max: 100})
+ , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
+
+ var qmark = "[^/]"
+
+ // * => any number of characters
+ , star = qmark + "*?"
+
+ // ** when dots are allowed. Anything goes, except .. and .
+ // not (^ or / followed by one or two dots followed by $ or /),
+ // followed by anything, any number of times.
+ , twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?"
+
+ // not a ^ or / followed by a dot,
+ // followed by anything, any number of times.
+ , twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?"
+
+ // characters that need to be escaped in RegExp.
+ , reSpecials = charSet("().*{}+?[]^$\\!");
+
+// "abc" -> { a:true, b:true, c:true }
+ function charSet (s) {
+ return s.split("").reduce(function (set, c) {
+ set[c] = true;
+ return set
+ }, {})
+ }
+
+// normalizes slashes.
+ var slashSplit = /\/+/;
+
+ minimatch.monkeyPatch = monkeyPatch;
+ function monkeyPatch () {
+ var desc = Object.getOwnPropertyDescriptor(String.prototype, "match");
+ var orig = desc.value;
+ desc.value = function (p) {
+ if (p instanceof Minimatch) return p.match(this)
+ return orig.call(this, p)
+ };
+ Object.defineProperty(String.prototype, desc);
+ }
+
+ minimatch.filter = filter;
+ function filter (pattern, options) {
+ options = options || {};
+ return function (p, i, list) {
+ return minimatch(p, pattern, options)
+ }
+ }
+
+ function ext (a, b) {
+ a = a || {};
+ b = b || {};
+ var t = {};
+ Object.keys(b).forEach(function (k) {
+ t[k] = b[k];
+ });
+ Object.keys(a).forEach(function (k) {
+ t[k] = a[k];
+ });
+ return t
+ }
+
+ minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return minimatch
+
+ var orig = minimatch;
+
+ var m = function minimatch (p, pattern, options) {
+ return orig.minimatch(p, pattern, ext(def, options))
+ };
+
+ m.Minimatch = function Minimatch (pattern, options) {
+ return new orig.Minimatch(pattern, ext(def, options))
+ };
+
+ return m
+ };
+
+ Minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return Minimatch
+ return minimatch.defaults(def).Minimatch
+ };
+
+
+ function minimatch (p, pattern, options) {
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required")
+ }
+
+ if (!options) options = {};
+
+ // shortcut: comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ return false
+ }
+
+ // "" only matches ""
+ if (pattern.trim() === "") return p === ""
+
+ return new Minimatch(pattern, options).match(p)
+ }
+
+ function Minimatch (pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options, cache)
+ }
+
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required")
+ }
+
+ if (!options) options = {};
+
+ // windows: need to use /, not \
+ // On other platforms, \ is a valid (albeit bad) filename char.
+ if (platform === "win32") {
+ pattern = pattern.split("\\").join("/");
+ }
+
+ // lru storage.
+ // these things aren't particularly big, but walking down the string
+ // and turning it into a regexp can get pretty costly.
+ var cacheKey = pattern + "\n" + sigmund_1(options);
+ var cached = minimatch.cache.get(cacheKey);
+ if (cached) return cached
+ minimatch.cache.set(cacheKey, this);
+
+ this.options = options;
+ this.set = [];
+ this.pattern = pattern;
+ this.regexp = null;
+ this.negate = false;
+ this.comment = false;
+ this.empty = false;
+
+ // make the set of regexps etc.
+ this.make();
+ }
+
+ Minimatch.prototype.make = make;
+ function make () {
+ // don't do it more than once.
+ if (this._made) return
+
+ var pattern = this.pattern;
+ var options = this.options;
+
+ // empty patterns and comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ this.comment = true;
+ return
+ }
+ if (!pattern) {
+ this.empty = true;
+ return
+ }
+
+ // step 1: figure out negation, etc.
+ this.parseNegate();
+
+ // step 2: expand braces
+ var set = this.globSet = this.braceExpand();
+
+ if (options.debug) console.error(this.pattern, set);
+
+ // step 3: now we have a set, so turn each one into a series of path-portion
+ // matching patterns.
+ // These will be regexps, except in the case of "**", which is
+ // set to the GLOBSTAR object for globstar behavior,
+ // and will not contain any / characters
+ set = this.globParts = set.map(function (s) {
+ return s.split(slashSplit)
+ });
+
+ if (options.debug) console.error(this.pattern, set);
+
+ // glob --> regexps
+ set = set.map(function (s, si, set) {
+ return s.map(this.parse, this)
+ }, this);
+
+ if (options.debug) console.error(this.pattern, set);
+
+ // filter out everything that didn't compile properly.
+ set = set.filter(function (s) {
+ return -1 === s.indexOf(false)
+ });
+
+ if (options.debug) console.error(this.pattern, set);
+
+ this.set = set;
+ }
+
+ Minimatch.prototype.parseNegate = parseNegate;
+ function parseNegate () {
+ var pattern = this.pattern
+ , negate = false
+ , options = this.options
+ , negateOffset = 0;
+
+ if (options.nonegate) return
+
+ for ( var i = 0, l = pattern.length
+ ; i < l && pattern.charAt(i) === "!"
+ ; i ++) {
+ negate = !negate;
+ negateOffset ++;
+ }
+
+ if (negateOffset) this.pattern = pattern.substr(negateOffset);
+ this.negate = negate;
+ }
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+ minimatch.braceExpand = function (pattern, options) {
+ return new Minimatch(pattern, options).braceExpand()
+ };
+
+ Minimatch.prototype.braceExpand = braceExpand;
+ function braceExpand (pattern, options) {
+ options = options || this.options;
+ pattern = typeof pattern === "undefined"
+ ? this.pattern : pattern;
+
+ if (typeof pattern === "undefined") {
+ throw new Error("undefined pattern")
+ }
+
+ if (options.nobrace ||
+ !pattern.match(/\{.*\}/)) {
+ // shortcut. no need to expand.
+ return [pattern]
+ }
+
+ var escaping = false;
+
+ // examples and comments refer to this crazy pattern:
+ // a{b,c{d,e},{f,g}h}x{y,z}
+ // expected:
+ // abxy
+ // abxz
+ // acdxy
+ // acdxz
+ // acexy
+ // acexz
+ // afhxy
+ // afhxz
+ // aghxy
+ // aghxz
+
+ // everything before the first \{ is just a prefix.
+ // So, we pluck that off, and work with the rest,
+ // and then prepend it to everything we find.
+ if (pattern.charAt(0) !== "{") {
+ // console.error(pattern)
+ var prefix = null;
+ for (var i = 0, l = pattern.length; i < l; i ++) {
+ var c = pattern.charAt(i);
+ // console.error(i, c)
+ if (c === "\\") {
+ escaping = !escaping;
+ } else if (c === "{" && !escaping) {
+ prefix = pattern.substr(0, i);
+ break
+ }
+ }
+
+ // actually no sets, all { were escaped.
+ if (prefix === null) {
+ // console.error("no sets")
+ return [pattern]
+ }
+
+ var tail = braceExpand(pattern.substr(i), options);
+ return tail.map(function (t) {
+ return prefix + t
+ })
+ }
+
+ // now we have something like:
+ // {b,c{d,e},{f,g}h}x{y,z}
+ // walk through the set, expanding each part, until
+ // the set ends. then, we'll expand the suffix.
+ // If the set only has a single member, then'll put the {} back
+
+ // first, handle numeric sets, since they're easier
+ var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/);
+ if (numset) {
+ // console.error("numset", numset[1], numset[2])
+ var suf = braceExpand(pattern.substr(numset[0].length), options)
+ , start = +numset[1]
+ , end = +numset[2]
+ , inc = start > end ? -1 : 1
+ , set = [];
+ for (var i = start; i != (end + inc); i += inc) {
+ // append all the suffixes
+ for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
+ set.push(i + suf[ii]);
+ }
+ }
+ return set
+ }
+
+ // ok, walk through the set
+ // We hope, somewhat optimistically, that there
+ // will be a } at the end.
+ // If the closing brace isn't found, then the pattern is
+ // interpreted as braceExpand("\\" + pattern) so that
+ // the leading \{ will be interpreted literally.
+ var i = 1 // skip the \{
+ , depth = 1
+ , set = []
+ , member = ""
+ , sawEnd = false
+ , escaping = false;
+
+ function addMember () {
+ set.push(member);
+ member = "";
+ }
+
+ // console.error("Entering for")
+ FOR: for (i = 1, l = pattern.length; i < l; i ++) {
+ var c = pattern.charAt(i);
+ // console.error("", i, c)
+
+ if (escaping) {
+ escaping = false;
+ member += "\\" + c;
+ } else {
+ switch (c) {
+ case "\\":
+ escaping = true;
+ continue
+
+ case "{":
+ depth ++;
+ member += "{";
+ continue
+
+ case "}":
+ depth --;
+ // if this closes the actual set, then we're done
+ if (depth === 0) {
+ addMember();
+ // pluck off the close-brace
+ i ++;
+ break FOR
+ } else {
+ member += c;
+ continue
+ }
+
+ case ",":
+ if (depth === 1) {
+ addMember();
+ } else {
+ member += c;
+ }
+ continue
+
+ default:
+ member += c;
+ continue
+ } // switch
+ } // else
+ } // for
+
+ // now we've either finished the set, and the suffix is
+ // pattern.substr(i), or we have *not* closed the set,
+ // and need to escape the leading brace
+ if (depth !== 0) {
+ // console.error("didn't close", pattern)
+ return braceExpand("\\" + pattern, options)
+ }
+
+ // x{y,z} -> ["xy", "xz"]
+ // console.error("set", set)
+ // console.error("suffix", pattern.substr(i))
+ var suf = braceExpand(pattern.substr(i), options);
+ // ["b", "c{d,e}","{f,g}h"] ->
+ // [["b"], ["cd", "ce"], ["fh", "gh"]]
+ var addBraces = set.length === 1;
+ // console.error("set pre-expanded", set)
+ set = set.map(function (p) {
+ return braceExpand(p, options)
+ });
+ // console.error("set expanded", set)
+
+
+ // [["b"], ["cd", "ce"], ["fh", "gh"]] ->
+ // ["b", "cd", "ce", "fh", "gh"]
+ set = set.reduce(function (l, r) {
+ return l.concat(r)
+ });
+
+ if (addBraces) {
+ set = set.map(function (s) {
+ return "{" + s + "}"
+ });
+ }
+
+ // now attach the suffixes.
+ var ret = [];
+ for (var i = 0, l = set.length; i < l; i ++) {
+ for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
+ ret.push(set[i] + suf[ii]);
+ }
+ }
+ return ret
+ }
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion. Otherwise, any series
+// of * is equivalent to a single *. Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+ Minimatch.prototype.parse = parse;
+ var SUBPARSE = {};
+ function parse (pattern, isSub) {
+ var options = this.options;
+
+ // shortcuts
+ if (!options.noglobstar && pattern === "**") return GLOBSTAR
+ if (pattern === "") return ""
+
+ var re = ""
+ , hasMagic = !!options.nocase
+ , escaping = false
+ // ? => one single character
+ , patternListStack = []
+ , plType
+ , stateChar
+ , inClass = false
+ , reClassStart = -1
+ , classStart = -1
+ // . and .. never match anything that doesn't start with .,
+ // even when options.dot is set.
+ , patternStart = pattern.charAt(0) === "." ? "" // anything
+ // not (start or / followed by . or .. followed by / or end)
+ : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))"
+ : "(?!\\.)";
+
+ function clearStateChar () {
+ if (stateChar) {
+ // we had some state-tracking character
+ // that wasn't consumed by this pass.
+ switch (stateChar) {
+ case "*":
+ re += star;
+ hasMagic = true;
+ break
+ case "?":
+ re += qmark;
+ hasMagic = true;
+ break
+ default:
+ re += "\\"+stateChar;
+ break
+ }
+ stateChar = false;
+ }
+ }
+
+ for ( var i = 0, len = pattern.length, c
+ ; (i < len) && (c = pattern.charAt(i))
+ ; i ++ ) {
+
+ if (options.debug) {
+ console.error("%s\t%s %s %j", pattern, i, re, c);
+ }
+
+ // skip over any that are escaped.
+ if (escaping && reSpecials[c]) {
+ re += "\\" + c;
+ escaping = false;
+ continue
+ }
+
+ SWITCH: switch (c) {
+ case "/":
+ // completely not allowed, even escaped.
+ // Should already be path-split by now.
+ return false
+
+ case "\\":
+ clearStateChar();
+ escaping = true;
+ continue
+
+ // the various stateChar values
+ // for the "extglob" stuff.
+ case "?":
+ case "*":
+ case "+":
+ case "@":
+ case "!":
+ if (options.debug) {
+ console.error("%s\t%s %s %j <-- stateChar", pattern, i, re, c);
+ }
+
+ // all of those are literals inside a class, except that
+ // the glob [!a] means [^a] in regexp
+ if (inClass) {
+ if (c === "!" && i === classStart + 1) c = "^";
+ re += c;
+ continue
+ }
+
+ // if we already have a stateChar, then it means
+ // that there was something like ** or +? in there.
+ // Handle the stateChar, then proceed with this one.
+ clearStateChar();
+ stateChar = c;
+ // if extglob is disabled, then +(asdf|foo) isn't a thing.
+ // just clear the statechar *now*, rather than even diving into
+ // the patternList stuff.
+ if (options.noext) clearStateChar();
+ continue
+
+ case "(":
+ if (inClass) {
+ re += "(";
+ continue
+ }
+
+ if (!stateChar) {
+ re += "\\(";
+ continue
+ }
+
+ plType = stateChar;
+ patternListStack.push({ type: plType
+ , start: i - 1
+ , reStart: re.length });
+ // negation is (?:(?!js)[^/]*)
+ re += stateChar === "!" ? "(?:(?!" : "(?:";
+ stateChar = false;
+ continue
+
+ case ")":
+ if (inClass || !patternListStack.length) {
+ re += "\\)";
+ continue
+ }
+
+ hasMagic = true;
+ re += ")";
+ plType = patternListStack.pop().type;
+ // negation is (?:(?!js)[^/]*)
+ // The others are (?:)
+ switch (plType) {
+ case "!":
+ re += "[^/]*?)";
+ break
+ case "?":
+ case "+":
+ case "*": re += plType;
+ case "@": break // the default anyway
+ }
+ continue
+
+ case "|":
+ if (inClass || !patternListStack.length || escaping) {
+ re += "\\|";
+ escaping = false;
+ continue
+ }
+
+ re += "|";
+ continue
+
+ // these are mostly the same in regexp and glob
+ case "[":
+ // swallow any state-tracking char before the [
+ clearStateChar();
+
+ if (inClass) {
+ re += "\\" + c;
+ continue
+ }
+
+ inClass = true;
+ classStart = i;
+ reClassStart = re.length;
+ re += c;
+ continue
+
+ case "]":
+ // a right bracket shall lose its special
+ // meaning and represent itself in
+ // a bracket expression if it occurs
+ // first in the list. -- POSIX.2 2.8.3.2
+ if (i === classStart + 1 || !inClass) {
+ re += "\\" + c;
+ escaping = false;
+ continue
+ }
+
+ // finish up the class.
+ hasMagic = true;
+ inClass = false;
+ re += c;
+ continue
+
+ default:
+ // swallow any state char that wasn't consumed
+ clearStateChar();
+
+ if (escaping) {
+ // no need
+ escaping = false;
+ } else if (reSpecials[c]
+ && !(c === "^" && inClass)) {
+ re += "\\";
+ }
+
+ re += c;
+
+ } // switch
+ } // for
+
+
+ // handle the case where we left a class open.
+ // "[abc" is valid, equivalent to "\[abc"
+ if (inClass) {
+ // split where the last [ was, and escape it
+ // this is a huge pita. We now have to re-walk
+ // the contents of the would-be class to re-translate
+ // any characters that were passed through as-is
+ var cs = pattern.substr(classStart + 1)
+ , sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0];
+ hasMagic = hasMagic || sp[1];
+ }
+
+ // handle the case where we had a +( thing at the *end*
+ // of the pattern.
+ // each pattern list stack adds 3 chars, and we need to go through
+ // and escape any | chars that were passed through as-is for the regexp.
+ // Go through and escape them, taking care not to double-escape any
+ // | chars that were already escaped.
+ var pl;
+ while (pl = patternListStack.pop()) {
+ var tail = re.slice(pl.reStart + 3);
+ // maybe some even number of \, then maybe 1 \, followed by a |
+ tail = tail.replace(/((?:\\{2})*)(\\?)\|/g, function (_, $1, $2) {
+ if (!$2) {
+ // the | isn't already escaped, so escape it.
+ $2 = "\\";
+ }
+
+ // need to escape all those slashes *again*, without escaping the
+ // one that we need for escaping the | character. As it works out,
+ // escaping an even number of slashes can be done by simply repeating
+ // it exactly after itself. That's why this trick works.
+ //
+ // I am sorry that you have to see this.
+ return $1 + $1 + $2 + "|"
+ });
+
+ // console.error("tail=%j\n %s", tail, tail)
+ var t = pl.type === "*" ? star
+ : pl.type === "?" ? qmark
+ : "\\" + pl.type;
+
+ hasMagic = true;
+ re = re.slice(0, pl.reStart)
+ + t + "\\("
+ + tail;
+ }
+
+ // handle trailing things that only matter at the very end.
+ clearStateChar();
+ if (escaping) {
+ // trailing \\
+ re += "\\\\";
+ }
+
+ // only need to apply the nodot start if the re starts with
+ // something that could conceivably capture a dot
+ var addPatternStart = false;
+ switch (re.charAt(0)) {
+ case ".":
+ case "[":
+ case "(": addPatternStart = true;
+ }
+
+ // if the re is not "" at this point, then we need to make sure
+ // it doesn't match against an empty path part.
+ // Otherwise a/* will match a/, which it should not.
+ if (re !== "" && hasMagic) re = "(?=.)" + re;
+
+ if (addPatternStart) re = patternStart + re;
+
+ // parsing just a piece of a larger pattern.
+ if (isSub === SUBPARSE) {
+ return [ re, hasMagic ]
+ }
+
+ // skip the regexp for non-magical patterns
+ // unescape anything in it, though, so that it'll be
+ // an exact match against a file etc.
+ if (!hasMagic) {
+ return globUnescape(pattern)
+ }
+
+ var flags = options.nocase ? "i" : ""
+ , regExp = new RegExp("^" + re + "$", flags);
+
+ regExp._glob = pattern;
+ regExp._src = re;
+
+ return regExp
+ }
+
+ minimatch.makeRe = function (pattern, options) {
+ return new Minimatch(pattern, options || {}).makeRe()
+ };
+
+ Minimatch.prototype.makeRe = makeRe;
+ function makeRe () {
+ if (this.regexp || this.regexp === false) return this.regexp
+
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ var set = this.set;
+
+ if (!set.length) return this.regexp = false
+ var options = this.options;
+
+ var twoStar = options.noglobstar ? star
+ : options.dot ? twoStarDot
+ : twoStarNoDot
+ , flags = options.nocase ? "i" : "";
+
+ var re = set.map(function (pattern) {
+ return pattern.map(function (p) {
+ return (p === GLOBSTAR) ? twoStar
+ : (typeof p === "string") ? regExpEscape(p)
+ : p._src
+ }).join("\\\/")
+ }).join("|");
+
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = "^(?:" + re + ")$";
+
+ // can match anything, as long as it's not this.
+ if (this.negate) re = "^(?!" + re + ").*$";
+
+ try {
+ return this.regexp = new RegExp(re, flags)
+ } catch (ex) {
+ return this.regexp = false
+ }
+ }
+
+ minimatch.match = function (list, pattern, options) {
+ var mm = new Minimatch(pattern, options);
+ list = list.filter(function (f) {
+ return mm.match(f)
+ });
+ if (options.nonull && !list.length) {
+ list.push(pattern);
+ }
+ return list
+ };
+
+ Minimatch.prototype.match = match;
+ function match (f, partial) {
+ // console.error("match", f, this.pattern)
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) return false
+ if (this.empty) return f === ""
+
+ if (f === "/" && partial) return true
+
+ var options = this.options;
+
+ // windows: need to use /, not \
+ // On other platforms, \ is a valid (albeit bad) filename char.
+ if (platform === "win32") {
+ f = f.split("\\").join("/");
+ }
+
+ // treat the test path as a set of pathparts.
+ f = f.split(slashSplit);
+ if (options.debug) {
+ console.error(this.pattern, "split", f);
+ }
+
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
+
+ var set = this.set;
+ // console.error(this.pattern, "set", set)
+
+ for (var i = 0, l = set.length; i < l; i ++) {
+ var pattern = set[i];
+ var hit = this.matchOne(f, pattern, partial);
+ if (hit) {
+ if (options.flipNegate) return true
+ return !this.negate
+ }
+ }
+
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) return false
+ return this.negate
+ }
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+ Minimatch.prototype.matchOne = function (file, pattern, partial) {
+ var options = this.options;
+
+ if (options.debug) {
+ console.error("matchOne",
+ { "this": this
+ , file: file
+ , pattern: pattern });
+ }
+
+ if (options.matchBase && pattern.length === 1) {
+ file = path.basename(file.join("/")).split("/");
+ }
+
+ if (options.debug) {
+ console.error("matchOne", file.length, pattern.length);
+ }
+
+ for ( var fi = 0
+ , pi = 0
+ , fl = file.length
+ , pl = pattern.length
+ ; (fi < fl) && (pi < pl)
+ ; fi ++, pi ++ ) {
+
+ if (options.debug) {
+ console.error("matchOne loop");
+ }
+ var p = pattern[pi]
+ , f = file[fi];
+
+ if (options.debug) {
+ console.error(pattern, p, f);
+ }
+
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ if (p === false) return false
+
+ if (p === GLOBSTAR) {
+ if (options.debug)
+ console.error('GLOBSTAR', [pattern, p, f]);
+
+ // "**"
+ // a/**/b/**/c would match the following:
+ // a/b/x/y/z/c
+ // a/x/y/z/b/c
+ // a/b/x/b/x/c
+ // a/b/c
+ // To do this, take the rest of the pattern after
+ // the **, and see if it would match the file remainder.
+ // If so, return success.
+ // If not, the ** "swallows" a segment, and try again.
+ // This is recursively awful.
+ //
+ // a/**/b/**/c matching a/b/x/y/z/c
+ // - a matches a
+ // - doublestar
+ // - matchOne(b/x/y/z/c, b/**/c)
+ // - b matches b
+ // - doublestar
+ // - matchOne(x/y/z/c, c) -> no
+ // - matchOne(y/z/c, c) -> no
+ // - matchOne(z/c, c) -> no
+ // - matchOne(c, c) yes, hit
+ var fr = fi
+ , pr = pi + 1;
+ if (pr === pl) {
+ if (options.debug)
+ console.error('** at the end');
+ // a ** at the end will just swallow the rest.
+ // We have found a match.
+ // however, it will not swallow /.x, unless
+ // options.dot is set.
+ // . and .. are *never* matched by **, for explosively
+ // exponential reasons.
+ for ( ; fi < fl; fi ++) {
+ if (file[fi] === "." || file[fi] === ".." ||
+ (!options.dot && file[fi].charAt(0) === ".")) return false
+ }
+ return true
+ }
+
+ // ok, let's see if we can swallow whatever we can.
+ WHILE: while (fr < fl) {
+ var swallowee = file[fr];
+
+ if (options.debug) {
+ console.error('\nglobstar while',
+ file, fr, pattern, pr, swallowee);
+ }
+
+ // XXX remove this slice. Just pass the start index.
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ if (options.debug)
+ console.error('globstar found match!', fr, fl, swallowee);
+ // found a match.
+ return true
+ } else {
+ // can't swallow "." or ".." ever.
+ // can only swallow ".foo" when explicitly asked.
+ if (swallowee === "." || swallowee === ".." ||
+ (!options.dot && swallowee.charAt(0) === ".")) {
+ if (options.debug)
+ console.error("dot detected!", file, fr, pattern, pr);
+ break WHILE
+ }
+
+ // ** swallows a segment, and continue.
+ if (options.debug)
+ console.error('globstar swallow a segment, and continue');
+ fr ++;
+ }
+ }
+ // no match was found.
+ // However, in partial mode, we can't say this is necessarily over.
+ // If there's more *pattern* left, then
+ if (partial) {
+ // ran out of file
+ // console.error("\n>>> no match, partial?", file, fr, pattern, pr)
+ if (fr === fl) return true
+ }
+ return false
+ }
+
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ var hit;
+ if (typeof p === "string") {
+ if (options.nocase) {
+ hit = f.toLowerCase() === p.toLowerCase();
+ } else {
+ hit = f === p;
+ }
+ if (options.debug) {
+ console.error("string match", p, f, hit);
+ }
+ } else {
+ hit = f.match(p);
+ if (options.debug) {
+ console.error("pattern match", p, f, hit);
+ }
+ }
+
+ if (!hit) return false
+ }
+
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
+
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true
+ } else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial
+ } else if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ var emptyFileEnd = (fi === fl - 1) && (file[fi] === "");
+ return emptyFileEnd
+ }
+
+ // should be unreachable.
+ throw new Error("wtf?")
+ };
+
+
+// replace stuff like \* with *
+ function globUnescape (s) {
+ return s.replace(/\\(.)/g, "$1")
+ }
+
+
+ function regExpEscape (s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")
+ }
+});
+
+var ini = createCommonjsModule(function (module, exports) {
+"use strict";
+// Based on iniparser by shockie
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+ function verb(n) { return function (v) { return step([n, v]); }; }
+ function step(op) {
+ if (f) throw new TypeError("Generator is already executing.");
+ while (_) try {
+ if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+ if (y = 0, t) op = [0, t.value];
+ switch (op[0]) {
+ case 0: case 1: t = op; break;
+ case 4: _.label++; return { value: op[1], done: false };
+ case 5: _.label++; y = op[1]; op = [0]; continue;
+ case 7: op = _.ops.pop(); _.trys.pop(); continue;
+ default:
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+ if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+ if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+ if (t[2]) _.ops.pop();
+ _.trys.pop(); continue;
+ }
+ op = body.call(thisArg, _);
+ } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+ if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+ }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+/**
+ * define the possible values:
+ * section: [section]
+ * param: key=value
+ * comment: ;this is a comment
+ */
+var regex = {
+ section: /^\s*\[(([^#;]|\\#|\\;)+)\]\s*([#;].*)?$/,
+ param: /^\s*([\w\.\-\_]+)\s*[=:]\s*(.*?)\s*([#;].*)?$/,
+ comment: /^\s*[#;].*$/,
+};
+/**
+ * Parses an .ini file
+ * @param file The location of the .ini file
+ */
+function parse(file) {
+ return __awaiter(this, void 0, void 0, function () {
+ return __generator(this, function (_a) {
+ return [2 /*return*/, new Promise(function (resolve, reject) {
+ fs.readFile(file, 'utf8', function (err, data) {
+ if (err) {
+ reject(err);
+ return;
+ }
+ resolve(parseString(data));
+ });
+ })];
+ });
+ });
+}
+exports.parse = parse;
+function parseSync(file) {
+ return parseString(fs.readFileSync(file, 'utf8'));
+}
+exports.parseSync = parseSync;
+function parseString(data) {
+ var sectionBody = {};
+ var sectionName = null;
+ var value = [[sectionName, sectionBody]];
+ var lines = data.split(/\r\n|\r|\n/);
+ lines.forEach(function (line) {
+ var match;
+ if (regex.comment.test(line)) {
+ return;
+ }
+ if (regex.param.test(line)) {
+ match = line.match(regex.param);
+ sectionBody[match[1]] =
+ match[2];
+ }
+ else if (regex.section.test(line)) {
+ match = line.match(regex.section);
+ sectionName = match[1];
+ sectionBody = {};
+ value.push([sectionName, sectionBody]);
+ }
+ });
+ return value;
+}
+exports.parseString = parseString;
+});
+
+unwrapExports(ini);
+
+var name$1 = "editorconfig";
+var version$2 = "0.15.0";
+var description$1 = "EditorConfig File Locator and Interpreter for Node.js";
+var keywords = ["editorconfig","core"];
+var main$1 = "index.js";
+var bin$1 = {"editorconfig":"bin/editorconfig"};
+var contributors = ["Hong Xu (topbug.net)","Jed Mao (https://github.com/jedmao/)","Trey Hunner (http://treyhunner.com)"];
+var directories = {"bin":"./bin","lib":"./lib"};
+var scripts$1 = {"clean":"rimraf dist","prebuild":"npm run clean","build":"tsc","pretest":"npm run lint && npm run build && npm run copy && cmake .","test":"ctest .","pretest:ci":"npm run pretest","test:ci":"ctest -VV --output-on-failure .","lint":"npm run eclint && npm run tslint","eclint":"eclint check --indent_size ignore \"src/**\"","tslint":"tslint --project tslint.json","copy":"cpy package.json .npmignore LICENSE README.md CHANGELOG.md dist && cpy src/bin/* dist/bin && cpy src/lib/fnmatch*.* dist/lib","prepub":"npm run lint && npm run build && npm run copy","pub":"npm publish ./dist"};
+var repository$1 = {"type":"git","url":"git://github.com/editorconfig/editorconfig-core-js.git"};
+var bugs$1 = "https://github.com/editorconfig/editorconfig-core-js/issues";
+var author$1 = "EditorConfig Team";
+var license$1 = "MIT";
+var dependencies$1 = {"@types/commander":"^2.11.0","@types/semver":"^5.4.0","commander":"^2.11.0","lru-cache":"^4.1.1","semver":"^5.4.1","sigmund":"^1.0.1"};
+var devDependencies$1 = {"@types/mocha":"^2.2.43","cpy-cli":"^1.0.1","eclint":"^2.4.3","mocha":"^4.0.1","rimraf":"^2.6.2","should":"^13.1.2","tslint":"^5.7.0","typescript":"^2.5.3"};
+var _package$2 = {
+ name: name$1,
+ version: version$2,
+ description: description$1,
+ keywords: keywords,
+ main: main$1,
+ bin: bin$1,
+ contributors: contributors,
+ directories: directories,
+ scripts: scripts$1,
+ repository: repository$1,
+ bugs: bugs$1,
+ author: author$1,
+ license: license$1,
+ dependencies: dependencies$1,
+ devDependencies: devDependencies$1
+};
+
+var _package$3 = Object.freeze({
+ name: name$1,
+ version: version$2,
+ description: description$1,
+ keywords: keywords,
+ main: main$1,
+ bin: bin$1,
+ contributors: contributors,
+ directories: directories,
+ scripts: scripts$1,
+ repository: repository$1,
+ bugs: bugs$1,
+ author: author$1,
+ license: license$1,
+ dependencies: dependencies$1,
+ devDependencies: devDependencies$1,
+ default: _package$2
+});
+
+var pkg = ( _package$3 && _package$2 ) || _package$3;
+
+var editorconfig = createCommonjsModule(function (module, exports) {
+"use strict";
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+ function verb(n) { return function (v) { return step([n, v]); }; }
+ function step(op) {
+ if (f) throw new TypeError("Generator is already executing.");
+ while (_) try {
+ if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+ if (y = 0, t) op = [0, t.value];
+ switch (op[0]) {
+ case 0: case 1: t = op; break;
+ case 4: _.label++; return { value: op[1], done: false };
+ case 5: _.label++; y = op[1]; op = [0]; continue;
+ case 7: op = _.ops.pop(); _.trys.pop(); continue;
+ default:
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+ if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+ if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+ if (t[2]) _.ops.pop();
+ _.trys.pop(); continue;
+ }
+ op = body.call(thisArg, _);
+ } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+ if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+ }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+
+
+
+exports.parseString = ini.parseString;
+// tslint:disable-next-line:no-var-requires
+
+var knownProps = {
+ end_of_line: true,
+ indent_style: true,
+ indent_size: true,
+ insert_final_newline: true,
+ trim_trailing_whitespace: true,
+ charset: true,
+};
+function fnmatch$$1(filepath, glob) {
+ var matchOptions = { matchBase: true, dot: true, noext: true };
+ glob = glob.replace(/\*\*/g, '{*,**/**/**}');
+ return fnmatch(filepath, glob, matchOptions);
+}
+function getConfigFileNames(filepath, options) {
+ var paths = [];
+ do {
+ filepath = path.dirname(filepath);
+ paths.push(path.join(filepath, options.config));
+ } while (filepath !== options.root);
+ return paths;
+}
+function processMatches(matches, version) {
+ // Set indent_size to 'tab' if indent_size is unspecified and
+ // indent_style is set to 'tab'.
+ if ('indent_style' in matches
+ && matches.indent_style === 'tab'
+ && !('indent_size' in matches)
+ && semver$3.gte(version, '0.10.0')) {
+ matches.indent_size = 'tab';
+ }
+ // Set tab_width to indent_size if indent_size is specified and
+ // tab_width is unspecified
+ if ('indent_size' in matches
+ && !('tab_width' in matches)
+ && matches.indent_size !== 'tab') {
+ matches.tab_width = matches.indent_size;
+ }
+ // Set indent_size to tab_width if indent_size is 'tab'
+ if ('indent_size' in matches
+ && 'tab_width' in matches
+ && matches.indent_size === 'tab') {
+ matches.indent_size = matches.tab_width;
+ }
+ return matches;
+}
+function processOptions(options, filepath) {
+ if (options === void 0) { options = {}; }
+ return {
+ config: options.config || '.editorconfig',
+ version: options.version || pkg.version,
+ root: path.resolve(options.root || path.parse(filepath).root),
+ };
+}
+function buildFullGlob(pathPrefix, glob) {
+ switch (glob.indexOf('/')) {
+ case -1:
+ glob = '**/' + glob;
+ break;
+ case 0:
+ glob = glob.substring(1);
+ break;
+ default:
+ break;
+ }
+ return path.join(pathPrefix, glob);
+}
+function extendProps(props, options) {
+ if (props === void 0) { props = {}; }
+ if (options === void 0) { options = {}; }
+ for (var key in options) {
+ if (options.hasOwnProperty(key)) {
+ var value = options[key];
+ var key2 = key.toLowerCase();
+ var value2 = value;
+ if (knownProps[key2]) {
+ value2 = value.toLowerCase();
+ }
+ try {
+ value2 = JSON.parse(value);
+ }
+ catch (e) { }
+ if (typeof value === 'undefined' || value === null) {
+ // null and undefined are values specific to JSON (no special meaning
+ // in editorconfig) & should just be returned as regular strings.
+ value2 = String(value);
+ }
+ props[key2] = value2;
+ }
+ }
+ return props;
+}
+function parseFromConfigs(configs, filepath, options) {
+ return processMatches(configs
+ .reverse()
+ .reduce(function (matches, file) {
+ var pathPrefix = path.dirname(file.name);
+ file.contents.forEach(function (section) {
+ var glob = section[0];
+ var options2 = section[1];
+ if (!glob) {
+ return;
+ }
+ var fullGlob = buildFullGlob(pathPrefix, glob);
+ if (!fnmatch$$1(filepath, fullGlob)) {
+ return;
+ }
+ matches = extendProps(matches, options2);
+ });
+ return matches;
+ }, {}), options.version);
+}
+function getConfigsForFiles(files) {
+ var configs = [];
+ for (var i in files) {
+ if (files.hasOwnProperty(i)) {
+ var file = files[i];
+ var contents = ini.parseString(file.contents);
+ configs.push({
+ name: file.name,
+ contents: contents,
+ });
+ if ((contents[0][1].root || '').toLowerCase() === 'true') {
+ break;
+ }
+ }
+ }
+ return configs;
+}
+function readConfigFiles(filepaths) {
+ return __awaiter(this, void 0, void 0, function () {
+ return __generator(this, function (_a) {
+ return [2 /*return*/, Promise.all(filepaths.map(function (name) { return new Promise(function (resolve) {
+ fs.readFile(name, 'utf8', function (err, data) {
+ resolve({
+ name: name,
+ contents: err ? '' : data,
+ });
+ });
+ }); }))];
+ });
+ });
+}
+function readConfigFilesSync(filepaths) {
+ var files = [];
+ var file;
+ filepaths.forEach(function (filepath) {
+ try {
+ file = fs.readFileSync(filepath, 'utf8');
+ }
+ catch (e) {
+ file = '';
+ }
+ files.push({
+ name: filepath,
+ contents: file,
+ });
+ });
+ return files;
+}
+function opts(filepath, options) {
+ if (options === void 0) { options = {}; }
+ var resolvedFilePath = path.resolve(filepath);
+ return [
+ resolvedFilePath,
+ processOptions(options, resolvedFilePath),
+ ];
+}
+function parseFromFiles(filepath, files, options) {
+ if (options === void 0) { options = {}; }
+ return __awaiter(this, void 0, void 0, function () {
+ var _a, resolvedFilePath, processedOptions;
+ return __generator(this, function (_b) {
+ _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1];
+ return [2 /*return*/, files.then(getConfigsForFiles)
+ .then(function (configs) { return parseFromConfigs(configs, resolvedFilePath, processedOptions); })];
+ });
+ });
+}
+exports.parseFromFiles = parseFromFiles;
+function parseFromFilesSync(filepath, files, options) {
+ if (options === void 0) { options = {}; }
+ var _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1];
+ return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions);
+}
+exports.parseFromFilesSync = parseFromFilesSync;
+function parse(_filepath, _options) {
+ if (_options === void 0) { _options = {}; }
+ return __awaiter(this, void 0, void 0, function () {
+ var _a, resolvedFilePath, processedOptions, filepaths;
+ return __generator(this, function (_b) {
+ _a = opts(_filepath, _options), resolvedFilePath = _a[0], processedOptions = _a[1];
+ filepaths = getConfigFileNames(resolvedFilePath, processedOptions);
+ return [2 /*return*/, readConfigFiles(filepaths)
+ .then(getConfigsForFiles)
+ .then(function (configs) { return parseFromConfigs(configs, resolvedFilePath, processedOptions); })];
+ });
+ });
+}
+exports.parse = parse;
+function parseSync(_filepath, _options) {
+ if (_options === void 0) { _options = {}; }
+ var _a = opts(_filepath, _options), resolvedFilePath = _a[0], processedOptions = _a[1];
+ var filepaths = getConfigFileNames(resolvedFilePath, processedOptions);
+ var files = readConfigFilesSync(filepaths);
+ return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions);
+}
+exports.parseSync = parseSync;
+});
+
+unwrapExports(editorconfig);
+
+var editorconfigToPrettier = editorConfigToPrettier;
+
+function editorConfigToPrettier(editorConfig) {
+ if (!editorConfig || Object.keys(editorConfig).length === 0) {
+ return null;
+ }
+
+ const result = {};
+
+ if (editorConfig.indent_style) {
+ result.useTabs = editorConfig.indent_style === "tab";
+ }
+
+ if (editorConfig.indent_size === "tab") {
+ result.useTabs = true;
+ }
+
+ if (result.useTabs && editorConfig.tab_width) {
+ result.tabWidth = editorConfig.tab_width;
+ } else if (
+ editorConfig.indent_style === "space" &&
+ editorConfig.indent_size &&
+ editorConfig.indent_size !== "tab"
+ ) {
+ result.tabWidth = editorConfig.indent_size;
+ } else if (editorConfig.tab_width !== undefined) {
+ result.tabWidth = editorConfig.tab_width;
+ }
+
+ if (editorConfig.max_line_length && editorConfig.max_line_length !== "off") {
+ result.printWidth = editorConfig.max_line_length;
+ }
+
+ if (editorConfig.quote_type === "single") {
+ result.singleQuote = true;
+ } else if (editorConfig.quote_type === "double") {
+ result.singleQuote = false;
+ }
+
+ return result;
+}
+
+function markerExists (files, markers) {
+ return markers.some(function(marker) {
+ return files.some(function(file) {
+ return file === marker;
+ });
+ });
+}
+
+function traverseFolder (directory, levels, markers) {
+ var files = fs.readdirSync(directory);
+ if (levels === 0) {
+ return null;
+ } else if (markerExists(files, markers)) {
+ return directory;
+ } else {
+ return traverseFolder(path.resolve(directory, '..'), levels - 1, markers);
+ }
+}
+
+var findProjectRoot = function findRoot(dir, opts) {
+ if (!dir) throw new Error("Directory not defined");
+ opts = opts || {};
+ var levels = opts.maxDepth || findRoot.MAX_DEPTH;
+ var markers = opts.markers || findRoot.MARKERS;
+ return traverseFolder(dir, levels, markers);
+};
+
+var MAX_DEPTH = 9;
+var MARKERS = [ '.git', '.hg' ];
+
+findProjectRoot.MAX_DEPTH = MAX_DEPTH;
+findProjectRoot.MARKERS = MARKERS;
+
+var resolveConfigEditorconfig = createCommonjsModule(function (module) {
+"use strict";
+
+
+
+
+
+
+
+
+const maybeParse = (filePath, config, parse) => {
+ const root = findProjectRoot(path.dirname(path.resolve(filePath)));
+ return filePath && parse(filePath, { root });
+};
+
+const editorconfigAsyncNoCache = (filePath, config) => {
+ return Promise.resolve(maybeParse(filePath, config, editorconfig.parse)).then(
+ editorconfigToPrettier
+ );
+};
+const editorconfigAsyncWithCache = mem(editorconfigAsyncNoCache);
+
+const editorconfigSyncNoCache = (filePath, config) => {
+ return editorconfigToPrettier(
+ maybeParse(filePath, config, editorconfig.parseSync)
+ );
+};
+const editorconfigSyncWithCache = mem(editorconfigSyncNoCache);
+
+function getLoadFunction(opts) {
+ if (!opts.editorconfig) {
+ return () => null;
+ }
+
+ if (opts.sync) {
+ return opts.cache ? editorconfigSyncWithCache : editorconfigSyncNoCache;
+ }
+
+ return opts.cache ? editorconfigAsyncWithCache : editorconfigAsyncNoCache;
+}
+
+function clearCache() {
+ mem.clear(editorconfigSyncWithCache);
+ mem.clear(editorconfigAsyncWithCache);
+}
+
+module.exports = {
+ getLoadFunction,
+ clearCache
+};
+});
+
+var thirdParty$1 = ( thirdParty && thirdParty__default ) || thirdParty;
+
+var resolveConfig_1 = createCommonjsModule(function (module) {
+"use strict";
+
+
+
+
+
+
+
+
+const getExplorerMemoized = mem(opts =>
+ thirdParty$1.cosmiconfig("prettier", {
+ sync: opts.sync,
+ cache: opts.cache,
+ rcExtensions: true,
+ transform: result => {
+ if (result && result.config) {
+ delete result.config.$schema;
+ }
+ return result;
+ }
+ })
+);
+
+/** @param {{ cache: boolean, sync: boolean }} opts */
+function getLoadFunction(opts) {
+ // Normalize opts before passing to a memoized function
+ opts = Object.assign({ sync: false, cache: false }, opts);
+ return getExplorerMemoized(opts).load;
+}
+
+function _resolveConfig(filePath, opts, sync) {
+ opts = Object.assign({ useCache: true }, opts);
+ const loadOpts = {
+ cache: !!opts.useCache,
+ sync: !!sync,
+ editorconfig: !!opts.editorconfig
+ };
+ const load = getLoadFunction(loadOpts);
+ const loadEditorConfig = resolveConfigEditorconfig.getLoadFunction(loadOpts);
+ const arr = [load, loadEditorConfig].map(l => l(filePath, opts.config));
+
+ const unwrapAndMerge = arr => {
+ const result = arr[0];
+ const editorConfigured = arr[1];
+ const merged = Object.assign(
+ {},
+ editorConfigured,
+ mergeOverrides(Object.assign({}, result), filePath)
+ );
+
+ if (!result && !editorConfigured) {
+ return null;
+ }
+
+ return merged;
+ };
+
+ if (loadOpts.sync) {
+ return unwrapAndMerge(arr);
+ }
+
+ return Promise.all(arr).then(unwrapAndMerge);
+}
+
+const resolveConfig = (filePath, opts) => _resolveConfig(filePath, opts, false);
+
+resolveConfig.sync = (filePath, opts) => _resolveConfig(filePath, opts, true);
+
+function clearCache() {
+ mem.clear(getExplorerMemoized);
+ resolveConfigEditorconfig.clearCache();
+}
+
+function resolveConfigFile(filePath) {
+ const load = getLoadFunction({ sync: false });
+ return load(filePath).then(result => {
+ return result ? result.filepath : null;
+ });
+}
+
+resolveConfigFile.sync = filePath => {
+ const load = getLoadFunction({ sync: true });
+ const result = load(filePath);
+ return result ? result.filepath : null;
+};
+
+function mergeOverrides(configResult, filePath) {
+ const options = Object.assign({}, configResult.config);
+ if (filePath && options.overrides) {
+ const relativeFilePath = path.relative(
+ path.dirname(configResult.filepath),
+ filePath
+ );
+ for (const override of options.overrides) {
+ if (
+ pathMatchesGlobs(
+ relativeFilePath,
+ override.files,
+ override.excludeFiles
+ )
+ ) {
+ Object.assign(options, override.options);
+ }
+ }
+ }
+
+ delete options.overrides;
+ return options;
+}
+
+// Based on eslint: https://github.com/eslint/eslint/blob/master/lib/config/config-ops.js
+function pathMatchesGlobs(filePath, patterns, excludedPatterns) {
+ const patternList = [].concat(patterns);
+ const excludedPatternList = [].concat(excludedPatterns || []);
+ const opts = { matchBase: true };
+
+ return (
+ patternList.some(pattern => minimatch_1(filePath, pattern, opts)) &&
+ !excludedPatternList.some(excludedPattern =>
+ minimatch_1(filePath, excludedPattern, opts)
+ )
+ );
+}
+
+module.exports = {
+ resolveConfig,
+ resolveConfigFile,
+ clearCache
+};
+});
+
+const version = require$$0$11.version;
+
+
+
+const getSupportInfo = support.getSupportInfo;
+
+
+
+const normalizeOptions = options$12.normalize;
+
+
+
+
+
+const printDocToString = doc.printer.printDocToString;
+const printDocToDebug = doc.debug.printDocToDebug;
+
+function guessLineEnding(text) {
+ const index = text.indexOf("\n");
+ if (index >= 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 formatWithCursor(text, opts, addAlignmentSize) {
+ const selectedParser = parser$3.resolveParser(opts);
+ const hasPragma = !selectedParser.hasPragma || selectedParser.hasPragma(text);
+ if (opts.requirePragma && !hasPragma) {
+ return { formatted: text };
+ }
+
+ const UTF8BOM = 0xfeff;
+ const hasUnicodeBOM = text.charCodeAt(0) === UTF8BOM;
+ if (hasUnicodeBOM) {
+ text = text.substring(1);
+ }
+
+ if (
+ opts.insertPragma &&
+ opts.printer.insertPragma &&
+ !hasPragma &&
+ opts.rangeStart === 0 &&
+ opts.rangeEnd === Infinity
+ ) {
+ text = opts.printer.insertPragma(text);
+ }
+
+ addAlignmentSize = addAlignmentSize || 0;
+
+ const result = parser$3.parse(text, opts);
+ const ast = result.ast;
+ text = result.text;
+
+ const formattedRangeOnly = formatRange(text, opts, ast);
+ if (formattedRangeOnly) {
+ return { formatted: formattedRangeOnly };
+ }
+
+ let cursorOffset;
+ if (opts.cursorOffset >= 0) {
+ const cursorNodeAndParents = findNodeAtOffset(ast, opts.cursorOffset, opts);
+ const cursorNode = cursorNodeAndParents.node;
+ if (cursorNode) {
+ cursorOffset = opts.cursorOffset - opts.locStart(cursorNode);
+ opts.cursorNode = cursorNode;
+ }
+ }
+
+ const astComments = attachComments(text, ast, opts);
+ const doc$$1 = astToDoc(ast, opts, addAlignmentSize);
+ opts.newLine = guessLineEnding(text);
+ const toStringResult = printDocToString(doc$$1, opts);
+ let str = toStringResult.formatted;
+ if (hasUnicodeBOM) {
+ str = String.fromCharCode(UTF8BOM) + str;
+ }
+ const cursorOffsetResult = toStringResult.cursor;
+ ensureAllCommentsPrinted(astComments);
+ // Remove extra leading indentation as well as the added indentation after last newline
+ if (addAlignmentSize > 0) {
+ return { formatted: str.trim() + opts.newLine };
+ }
+
+ if (cursorOffset !== undefined) {
+ return {
+ formatted: str,
+ cursorOffset: cursorOffsetResult + cursorOffset
+ };
+ }
+
+ return { formatted: str };
+}
+
+function format(text, opts, addAlignmentSize) {
+ return formatWithCursor(text, opts, addAlignmentSize).formatted;
+}
+
+function findSiblingAncestors(startNodeAndParents, endNodeAndParents, opts) {
+ let resultStartNode = startNodeAndParents.node;
+ let resultEndNode = endNodeAndParents.node;
+
+ if (resultStartNode === resultEndNode) {
+ return {
+ startNode: resultStartNode,
+ endNode: resultEndNode
+ };
+ }
+
+ for (const endParent of endNodeAndParents.parentNodes) {
+ if (
+ endParent.type !== "Program" &&
+ endParent.type !== "File" &&
+ opts.locStart(endParent) >= opts.locStart(startNodeAndParents.node)
+ ) {
+ resultEndNode = endParent;
+ } else {
+ break;
+ }
+ }
+
+ for (const startParent of startNodeAndParents.parentNodes) {
+ if (
+ startParent.type !== "Program" &&
+ startParent.type !== "File" &&
+ opts.locEnd(startParent) <= opts.locEnd(endNodeAndParents.node)
+ ) {
+ resultStartNode = startParent;
+ } else {
+ break;
+ }
+ }
+
+ return {
+ startNode: resultStartNode,
+ endNode: resultEndNode
+ };
+}
+
+function findNodeAtOffset(node, offset, options, predicate, parentNodes) {
+ predicate = predicate || (() => true);
+ parentNodes = parentNodes || [];
+ const start = options.locStart(node, options.locStart);
+ const end = options.locEnd(node, options.locEnd);
+ if (start <= offset && offset <= end) {
+ for (const childNode of comments.getSortedChildNodes(
+ node,
+ undefined /* text */,
+ options
+ )) {
+ const childResult = findNodeAtOffset(
+ childNode,
+ offset,
+ options,
+ predicate,
+ [node].concat(parentNodes)
+ );
+ if (childResult) {
+ return childResult;
+ }
+ }
+
+ if (predicate(node)) {
+ return {
+ node: node,
+ parentNodes: parentNodes
+ };
+ }
+ }
+}
+
+// See https://www.ecma-international.org/ecma-262/5.1/#sec-A.5
+function isSourceElement(opts, node) {
+ if (node == null) {
+ return false;
+ }
+ // JS and JS like to avoid repetitions
+ const jsSourceElements = [
+ "FunctionDeclaration",
+ "BlockStatement",
+ "BreakStatement",
+ "ContinueStatement",
+ "DebuggerStatement",
+ "DoWhileStatement",
+ "EmptyStatement",
+ "ExpressionStatement",
+ "ForInStatement",
+ "ForStatement",
+ "IfStatement",
+ "LabeledStatement",
+ "ReturnStatement",
+ "SwitchStatement",
+ "ThrowStatement",
+ "TryStatement",
+ "VariableDeclaration",
+ "WhileStatement",
+ "WithStatement",
+ "ClassDeclaration", // ES 2015
+ "ImportDeclaration", // Module
+ "ExportDefaultDeclaration", // Module
+ "ExportNamedDeclaration", // Module
+ "ExportAllDeclaration", // Module
+ "TypeAlias", // Flow
+ "InterfaceDeclaration", // Flow, TypeScript
+ "TypeAliasDeclaration", // TypeScript
+ "ExportAssignment", // TypeScript
+ "ExportDeclaration" // TypeScript
+ ];
+ const jsonSourceElements = [
+ "ObjectExpression",
+ "ArrayExpression",
+ "StringLiteral",
+ "NumericLiteral",
+ "BooleanLiteral",
+ "NullLiteral"
+ ];
+ const graphqlSourceElements = [
+ "OperationDefinition",
+ "FragmentDefinition",
+ "VariableDefinition",
+ "TypeExtensionDefinition",
+ "ObjectTypeDefinition",
+ "FieldDefinition",
+ "DirectiveDefinition",
+ "EnumTypeDefinition",
+ "EnumValueDefinition",
+ "InputValueDefinition",
+ "InputObjectTypeDefinition",
+ "SchemaDefinition",
+ "OperationTypeDefinition",
+ "InterfaceTypeDefinition",
+ "UnionTypeDefinition",
+ "ScalarTypeDefinition"
+ ];
+ switch (opts.parser) {
+ case "flow":
+ case "babylon":
+ case "typescript":
+ return jsSourceElements.indexOf(node.type) > -1;
+ case "json":
+ return jsonSourceElements.indexOf(node.type) > -1;
+ case "graphql":
+ return graphqlSourceElements.indexOf(node.kind) > -1;
+ }
+ 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,
+ opts,
+ node => isSourceElement(opts, node)
+ );
+ const endNodeAndParents = findNodeAtOffset(
+ ast,
+ endNonWhitespace,
+ opts,
+ node => isSourceElement(opts, node)
+ );
+
+ if (!startNodeAndParents || !endNodeAndParents) {
+ return {
+ rangeStart: 0,
+ rangeEnd: 0
+ };
+ }
+
+ const siblingAncestors = findSiblingAncestors(
+ startNodeAndParents,
+ endNodeAndParents,
+ opts
+ );
+ const startNode = siblingAncestors.startNode;
+ const endNode = siblingAncestors.endNode;
+ const rangeStart = Math.min(
+ opts.locStart(startNode, opts.locStart),
+ opts.locStart(endNode, opts.locStart)
+ );
+ const rangeEnd = Math.max(
+ opts.locEnd(startNode, opts.locEnd),
+ opts.locEnd(endNode, opts.locEnd)
+ );
+
+ return {
+ rangeStart: rangeStart,
+ rangeEnd: rangeEnd
+ };
+}
+
+function formatRange(text, opts, ast) {
+ if (opts.rangeStart <= 0 && text.length <= opts.rangeEnd) {
+ return;
+ }
+
+ 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$1.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);
+}
+
+var prettier$2 = {
+ formatWithCursor: function(text, opts) {
+ return formatWithCursor(text, normalizeOptions(opts));
+ },
+
+ format: function(text, opts) {
+ return format(text, normalizeOptions(opts));
+ },
+
+ check: function(text, opts) {
+ try {
+ const formatted = format(text, normalizeOptions(opts));
+ return formatted === text;
+ } catch (e) {
+ return false;
+ }
+ },
+
+ doc,
+
+ resolveConfig: resolveConfig_1.resolveConfig,
+ clearConfigCache: resolveConfig_1.clearCache,
+
+ getSupportInfo,
+
+ version,
+
+ util: utilShared,
+
+ /* istanbul ignore next */
+ __debug: {
+ parse: function(text, opts) {
+ opts = normalizeOptions(opts);
+ return parser$3.parse(text, opts);
+ },
+ formatAST: function(ast, opts) {
+ opts = normalizeOptions(opts);
+ const doc$$1 = astToDoc(ast, opts);
+ const str = printDocToString(doc$$1, opts);
+ return str;
+ },
+ // Doesn't handle shebang for now
+ formatDoc: function(doc$$1, opts) {
+ opts = normalizeOptions(opts);
+ const debug = printDocToDebug(doc$$1);
+ const str = format(debug, opts);
+ return str;
+ },
+ printToDoc: function(text, opts) {
+ opts = normalizeOptions(opts);
+ const result = parser$3.parse(text, opts);
+ const ast = result.ast;
+ text = result.text;
+ attachComments(text, ast, opts);
+ const doc$$1 = astToDoc(ast, opts);
+ return doc$$1;
+ },
+ printDocToString: function(doc$$1, opts) {
+ opts = normalizeOptions(opts);
+ const str = printDocToString(doc$$1, opts);
+ return str;
+ }
+ }
+};
+
+var at;
+var ch;
+var escapee = {
+ '"': '"',
+ '\\': '\\',
+ '/': '/',
+ b: '\b',
+ f: '\f',
+ n: '\n',
+ r: '\r',
+ t: '\t'
+ };
+var text;
+var error = function (m) {
+ // Call error when something is wrong.
+ throw {
+ name: 'SyntaxError',
+ message: m,
+ at: at,
+ text: text
+ };
+ };
+var next = function (c) {
+ // If a c parameter is provided, verify that it matches the current character.
+ if (c && c !== ch) {
+ error("Expected '" + c + "' instead of '" + ch + "'");
+ }
+
+ // Get the next character. When there are no more characters,
+ // return the empty string.
+
+ ch = text.charAt(at);
+ at += 1;
+ return ch;
+ };
+var number = function () {
+ // Parse a number value.
+ var number,
+ string = '';
+
+ if (ch === '-') {
+ string = '-';
+ next('-');
+ }
+ while (ch >= '0' && ch <= '9') {
+ string += ch;
+ next();
+ }
+ if (ch === '.') {
+ string += '.';
+ while (next() && ch >= '0' && ch <= '9') {
+ string += ch;
+ }
+ }
+ if (ch === 'e' || ch === 'E') {
+ string += ch;
+ next();
+ if (ch === '-' || ch === '+') {
+ string += ch;
+ next();
+ }
+ while (ch >= '0' && ch <= '9') {
+ string += ch;
+ next();
+ }
+ }
+ number = +string;
+ if (!isFinite(number)) {
+ error("Bad number");
+ } else {
+ return number;
+ }
+ };
+var string = function () {
+ // Parse a string value.
+ var hex,
+ i,
+ string = '',
+ uffff;
+
+ // When parsing for string values, we must look for " and \ characters.
+ if (ch === '"') {
+ while (next()) {
+ if (ch === '"') {
+ next();
+ return string;
+ } else if (ch === '\\') {
+ next();
+ if (ch === 'u') {
+ uffff = 0;
+ for (i = 0; i < 4; i += 1) {
+ hex = parseInt(next(), 16);
+ if (!isFinite(hex)) {
+ break;
+ }
+ uffff = uffff * 16 + hex;
+ }
+ string += String.fromCharCode(uffff);
+ } else if (typeof escapee[ch] === 'string') {
+ string += escapee[ch];
+ } else {
+ break;
+ }
+ } else {
+ string += ch;
+ }
+ }
+ }
+ error("Bad string");
+ };
+var white = function () {
+
+// Skip whitespace.
+
+ while (ch && ch <= ' ') {
+ next();
+ }
+ };
+var word = function () {
+
+// true, false, or null.
+
+ switch (ch) {
+ case 't':
+ next('t');
+ next('r');
+ next('u');
+ next('e');
+ return true;
+ case 'f':
+ next('f');
+ next('a');
+ next('l');
+ next('s');
+ next('e');
+ return false;
+ case 'n':
+ next('n');
+ next('u');
+ next('l');
+ next('l');
+ return null;
+ }
+ error("Unexpected '" + ch + "'");
+ };
+var value;
+var array = function () {
+
+// Parse an array value.
+
+ var array = [];
+
+ if (ch === '[') {
+ next('[');
+ white();
+ if (ch === ']') {
+ next(']');
+ return array; // empty array
+ }
+ while (ch) {
+ array.push(value());
+ white();
+ if (ch === ']') {
+ next(']');
+ return array;
+ }
+ next(',');
+ white();
+ }
+ }
+ error("Bad array");
+ };
+var object = function () {
+
+// Parse an object value.
+
+ var key,
+ object = {};
+
+ if (ch === '{') {
+ next('{');
+ white();
+ if (ch === '}') {
+ next('}');
+ return object; // empty object
+ }
+ while (ch) {
+ key = string();
+ white();
+ next(':');
+ if (Object.hasOwnProperty.call(object, key)) {
+ error('Duplicate key "' + key + '"');
+ }
+ object[key] = value();
+ white();
+ if (ch === '}') {
+ next('}');
+ return object;
+ }
+ next(',');
+ white();
+ }
+ }
+ error("Bad object");
+ };
+
+value = function () {
+
+// Parse a JSON value. It could be an object, an array, a string, a number,
+// or a word.
+
+ white();
+ switch (ch) {
+ case '{':
+ return object();
+ case '[':
+ return array();
+ case '"':
+ return string();
+ case '-':
+ return number();
+ default:
+ return ch >= '0' && ch <= '9' ? number() : word();
+ }
+};
+
+// Return the json_parse function. It will have access to all of the above
+// functions and variables.
+
+var parse$6 = function (source, reviver) {
+ var result;
+
+ text = source;
+ at = 0;
+ ch = ' ';
+ result = value();
+ white();
+ if (ch) {
+ error("Syntax error");
+ }
+
+ // If there is a reviver function, we recursively walk the new structure,
+ // passing each name/value pair to the reviver function for possible
+ // transformation, starting with a temporary root object that holds the result
+ // in an empty key. If there is not a reviver function, we simply return the
+ // result.
+
+ return typeof reviver === 'function' ? (function walk(holder, key) {
+ var k, v, value = holder[key];
+ if (value && typeof value === 'object') {
+ for (k in value) {
+ if (Object.prototype.hasOwnProperty.call(value, k)) {
+ v = walk(value, k);
+ if (v !== undefined) {
+ value[k] = v;
+ } else {
+ delete value[k];
+ }
+ }
+ }
+ }
+ return reviver.call(holder, key, value);
+ }({'': result}, '')) : result;
+};
+
+var escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
+var gap;
+var indent$8;
+var meta = { // table of character substitutions
+ '\b': '\\b',
+ '\t': '\\t',
+ '\n': '\\n',
+ '\f': '\\f',
+ '\r': '\\r',
+ '"' : '\\"',
+ '\\': '\\\\'
+ };
+var rep;
+
+function quote(string) {
+ // If the string contains no control characters, no quote characters, and no
+ // backslash characters, then we can safely slap some quotes around it.
+ // Otherwise we must also replace the offending characters with safe escape
+ // sequences.
+
+ escapable.lastIndex = 0;
+ return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+ var c = meta[a];
+ return typeof c === 'string' ? c :
+ '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ }) + '"' : '"' + string + '"';
+}
+
+function str(key, holder) {
+ // Produce a string from holder[key].
+ var i, // The loop counter.
+ k, // The member key.
+ v, // The member value.
+ length,
+ mind = gap,
+ partial,
+ value = holder[key];
+
+ // If the value has a toJSON method, call it to obtain a replacement value.
+ if (value && typeof value === 'object' &&
+ typeof value.toJSON === 'function') {
+ value = value.toJSON(key);
+ }
+
+ // If we were called with a replacer function, then call the replacer to
+ // obtain a replacement value.
+ if (typeof rep === 'function') {
+ value = rep.call(holder, key, value);
+ }
+
+ // What happens next depends on the value's type.
+ switch (typeof value) {
+ case 'string':
+ return quote(value);
+
+ case 'number':
+ // JSON numbers must be finite. Encode non-finite numbers as null.
+ return isFinite(value) ? String(value) : 'null';
+
+ case 'boolean':
+ case 'null':
+ // If the value is a boolean or null, convert it to a string. Note:
+ // typeof null does not produce 'null'. The case is included here in
+ // the remote chance that this gets fixed someday.
+ return String(value);
+
+ case 'object':
+ if (!value) return 'null';
+ gap += indent$8;
+ partial = [];
+
+ // Array.isArray
+ if (Object.prototype.toString.apply(value) === '[object Array]') {
+ length = value.length;
+ for (i = 0; i < length; i += 1) {
+ partial[i] = str(i, value) || 'null';
+ }
+
+ // Join all of the elements together, separated with commas, and
+ // wrap them in brackets.
+ v = partial.length === 0 ? '[]' : gap ?
+ '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
+ '[' + partial.join(',') + ']';
+ gap = mind;
+ return v;
+ }
+
+ // If the replacer is an array, use it to select the members to be
+ // stringified.
+ if (rep && typeof rep === 'object') {
+ length = rep.length;
+ for (i = 0; i < length; i += 1) {
+ k = rep[i];
+ if (typeof k === 'string') {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ }
+ else {
+ // Otherwise, iterate through all of the keys in the object.
+ for (k in value) {
+ if (Object.prototype.hasOwnProperty.call(value, k)) {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ }
+
+ // Join all of the member texts together, separated with commas,
+ // and wrap them in braces.
+
+ v = partial.length === 0 ? '{}' : gap ?
+ '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
+ '{' + partial.join(',') + '}';
+ gap = mind;
+ return v;
+ }
+}
+
+var stringify$1 = function (value, replacer, space) {
+ var i;
+ gap = '';
+ indent$8 = '';
+
+ // If the space parameter is a number, make an indent string containing that
+ // many spaces.
+ if (typeof space === 'number') {
+ for (i = 0; i < space; i += 1) {
+ indent$8 += ' ';
+ }
+ }
+ // If the space parameter is a string, it will be used as the indent string.
+ else if (typeof space === 'string') {
+ indent$8 = space;
+ }
+
+ // If there is a replacer, it must be a function or an array.
+ // Otherwise, throw an error.
+ rep = replacer;
+ if (replacer && typeof replacer !== 'function'
+ && (typeof replacer !== 'object' || typeof replacer.length !== 'number')) {
+ throw new Error('JSON.stringify');
+ }
+
+ // Make a fake root object containing our value under the key of ''.
+ // Return the result of stringifying the value.
+ return str('', {'': value});
+};
+
+var parse$5 = parse$6;
+var stringify = stringify$1;
+
+var jsonify = {
+ parse: parse$5,
+ stringify: stringify
+};
+
+var json = typeof JSON !== 'undefined' ? JSON : jsonify;
+
+var jsonStableStringify = function (obj, opts) {
+ if (!opts) opts = {};
+ if (typeof opts === 'function') opts = { cmp: opts };
+ var space = opts.space || '';
+ if (typeof space === 'number') space = Array(space+1).join(' ');
+ var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;
+ var replacer = opts.replacer || function(key, value) { return value; };
+
+ var cmp = opts.cmp && (function (f) {
+ return function (node) {
+ return function (a, b) {
+ var aobj = { key: a, value: node[a] };
+ var bobj = { key: b, value: node[b] };
+ return f(aobj, bobj);
+ };
+ };
+ })(opts.cmp);
+
+ var seen = [];
+ return (function stringify (parent, key, node, level) {
+ var indent = space ? ('\n' + new Array(level + 1).join(space)) : '';
+ var colonSeparator = space ? ': ' : ':';
+
+ if (node && node.toJSON && typeof node.toJSON === 'function') {
+ node = node.toJSON();
+ }
+
+ node = replacer.call(parent, key, node);
+
+ if (node === undefined) {
+ return;
+ }
+ if (typeof node !== 'object' || node === null) {
+ return json.stringify(node);
+ }
+ if (isArray$1(node)) {
+ var out = [];
+ for (var i = 0; i < node.length; i++) {
+ var item = stringify(node, i, node[i], level+1) || json.stringify(null);
+ out.push(indent + space + item);
+ }
+ return '[' + out.join(',') + indent + ']';
+ }
+ else {
+ if (seen.indexOf(node) !== -1) {
+ if (cycles) return json.stringify('__cycle__');
+ throw new TypeError('Converting circular structure to JSON');
+ }
+ else seen.push(node);
+
+ var keys = objectKeys(node).sort(cmp && cmp(node));
+ var out = [];
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ var value = stringify(node, key, node[key], level+1);
+
+ if(!value) continue;
+
+ var keyValue = json.stringify(key)
+ + colonSeparator
+ + value;
+
+ out.push(indent + space + keyValue);
+ }
+ seen.splice(seen.indexOf(node), 1);
+ return '{' + out.join(',') + indent + '}';
+ }
+ })({ '': obj }, '', obj, 0);
+};
+
+var isArray$1 = Array.isArray || function (x) {
+ return {}.toString.call(x) === '[object Array]';
+};
+
+var objectKeys = Object.keys || function (obj) {
+ var has = Object.prototype.hasOwnProperty || function () { return true };
+ var keys = [];
+ for (var key in obj) {
+ if (has.call(obj, key)) keys.push(key);
+ }
+ return keys;
+};
+
+function preserveCamelCase(str) {
+ let isLastCharLower = false;
+ let isLastCharUpper = false;
+ let isLastLastCharUpper = false;
+
+ for (let i = 0; i < str.length; i++) {
+ const c = str[i];
+
+ if (isLastCharLower && /[a-zA-Z]/.test(c) && c.toUpperCase() === c) {
+ str = str.substr(0, i) + '-' + str.substr(i);
+ isLastCharLower = false;
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = true;
+ i++;
+ } else if (isLastCharUpper && isLastLastCharUpper && /[a-zA-Z]/.test(c) && c.toLowerCase() === c) {
+ str = str.substr(0, i - 1) + '-' + str.substr(i - 1);
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = false;
+ isLastCharLower = true;
+ } else {
+ isLastCharLower = c.toLowerCase() === c;
+ isLastLastCharUpper = isLastCharUpper;
+ isLastCharUpper = c.toUpperCase() === c;
+ }
+ }
+
+ return str;
+}
+
+var camelcase = function (str) {
+ if (arguments.length > 1) {
+ str = Array.from(arguments)
+ .map(x => x.trim())
+ .filter(x => x.length)
+ .join('-');
+ } else {
+ str = str.trim();
+ }
+
+ if (str.length === 0) {
+ return '';
+ }
+
+ if (str.length === 1) {
+ return str.toLowerCase();
+ }
+
+ if (/^[a-z0-9]+$/.test(str)) {
+ return str;
+ }
+
+ const hasUpperCase = str !== str.toLowerCase();
+
+ if (hasUpperCase) {
+ str = preserveCamelCase(str);
+ }
+
+ return str
+ .replace(/^[_.\- ]+/, '')
+ .toLowerCase()
+ .replace(/[_.\- ]+(\w|$)/g, (m, p1) => p1.toUpperCase());
+};
+
+/*!
+ * dashify
+ *
+ * Copyright (c) 2015 Jon Schlinkert.
+ * Licensed under the MIT license.
+ */
+
+var dashify = function dashify(str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('expected a string');
+ }
+ str = str.replace(/([a-z])([A-Z])/g, '$1-$2');
+ str = str.replace(/[ \t\W]/g, '-');
+ str = str.replace(/^-+|-+$/g, '');
+ return str.toLowerCase();
+};
+
+var PENDING = 'pending';
+var SETTLED = 'settled';
+var FULFILLED = 'fulfilled';
+var REJECTED = 'rejected';
+var NOOP = function () {};
+var isNode = typeof commonjsGlobal !== 'undefined' && typeof commonjsGlobal.process !== 'undefined' && typeof commonjsGlobal.process.emit === 'function';
+
+var asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate;
+var asyncQueue = [];
+var asyncTimer;
+
+function asyncFlush() {
+ // run promise callbacks
+ for (var i = 0; i < asyncQueue.length; i++) {
+ asyncQueue[i][0](asyncQueue[i][1]);
+ }
+
+ // reset async asyncQueue
+ asyncQueue = [];
+ asyncTimer = false;
+}
+
+function asyncCall(callback, arg) {
+ asyncQueue.push([callback, arg]);
+
+ if (!asyncTimer) {
+ asyncTimer = true;
+ asyncSetTimer(asyncFlush, 0);
+ }
+}
+
+function invokeResolver(resolver, promise) {
+ function resolvePromise(value) {
+ resolve$3(promise, value);
+ }
+
+ function rejectPromise(reason) {
+ reject(promise, reason);
+ }
+
+ try {
+ resolver(resolvePromise, rejectPromise);
+ } catch (e) {
+ rejectPromise(e);
+ }
+}
+
+function invokeCallback(subscriber) {
+ var owner = subscriber.owner;
+ var settled = owner._state;
+ var value = owner._data;
+ var callback = subscriber[settled];
+ var promise = subscriber.then;
+
+ if (typeof callback === 'function') {
+ settled = FULFILLED;
+ try {
+ value = callback(value);
+ } catch (e) {
+ reject(promise, e);
+ }
+ }
+
+ if (!handleThenable(promise, value)) {
+ if (settled === FULFILLED) {
+ resolve$3(promise, value);
+ }
+
+ if (settled === REJECTED) {
+ reject(promise, value);
+ }
+ }
+}
+
+function handleThenable(promise, value) {
+ var resolved;
+
+ try {
+ if (promise === value) {
+ throw new TypeError('A promises callback cannot return that same promise.');
+ }
+
+ if (value && (typeof value === 'function' || typeof value === 'object')) {
+ // then should be retrieved only once
+ var then = value.then;
+
+ if (typeof then === 'function') {
+ then.call(value, function (val) {
+ if (!resolved) {
+ resolved = true;
+
+ if (value === val) {
+ fulfill(promise, val);
+ } else {
+ resolve$3(promise, val);
+ }
+ }
+ }, function (reason) {
+ if (!resolved) {
+ resolved = true;
+
+ reject(promise, reason);
+ }
+ });
+
+ return true;
+ }
+ }
+ } catch (e) {
+ if (!resolved) {
+ reject(promise, e);
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+function resolve$3(promise, value) {
+ if (promise === value || !handleThenable(promise, value)) {
+ fulfill(promise, value);
+ }
+}
+
+function fulfill(promise, value) {
+ if (promise._state === PENDING) {
+ promise._state = SETTLED;
+ promise._data = value;
+
+ asyncCall(publishFulfillment, promise);
+ }
+}
+
+function reject(promise, reason) {
+ if (promise._state === PENDING) {
+ promise._state = SETTLED;
+ promise._data = reason;
+
+ asyncCall(publishRejection, promise);
+ }
+}
+
+function publish(promise) {
+ promise._then = promise._then.forEach(invokeCallback);
+}
+
+function publishFulfillment(promise) {
+ promise._state = FULFILLED;
+ publish(promise);
+}
+
+function publishRejection(promise) {
+ promise._state = REJECTED;
+ publish(promise);
+ if (!promise._handled && isNode) {
+ commonjsGlobal.process.emit('unhandledRejection', promise._data, promise);
+ }
+}
+
+function notifyRejectionHandled(promise) {
+ commonjsGlobal.process.emit('rejectionHandled', promise);
+}
+
+/**
+ * @class
+ */
+function Promise$1(resolver) {
+ if (typeof resolver !== 'function') {
+ throw new TypeError('Promise resolver ' + resolver + ' is not a function');
+ }
+
+ if (this instanceof Promise$1 === false) {
+ throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.');
+ }
+
+ this._then = [];
+
+ invokeResolver(resolver, this);
+}
+
+Promise$1.prototype = {
+ constructor: Promise$1,
+
+ _state: PENDING,
+ _then: null,
+ _data: undefined,
+ _handled: false,
+
+ then: function (onFulfillment, onRejection) {
+ var subscriber = {
+ owner: this,
+ then: new this.constructor(NOOP),
+ fulfilled: onFulfillment,
+ rejected: onRejection
+ };
+
+ if ((onRejection || onFulfillment) && !this._handled) {
+ this._handled = true;
+ if (this._state === REJECTED && isNode) {
+ asyncCall(notifyRejectionHandled, this);
+ }
+ }
+
+ if (this._state === FULFILLED || this._state === REJECTED) {
+ // already resolved, call callback async
+ asyncCall(invokeCallback, subscriber);
+ } else {
+ // subscribe
+ this._then.push(subscriber);
+ }
+
+ return subscriber.then;
+ },
+
+ catch: function (onRejection) {
+ return this.then(null, onRejection);
+ }
+};
+
+Promise$1.all = function (promises) {
+ if (!Array.isArray(promises)) {
+ throw new TypeError('You must pass an array to Promise.all().');
+ }
+
+ return new Promise$1(function (resolve, reject) {
+ var results = [];
+ var remaining = 0;
+
+ function resolver(index) {
+ remaining++;
+ return function (value) {
+ results[index] = value;
+ if (!--remaining) {
+ resolve(results);
+ }
+ };
+ }
+
+ for (var i = 0, promise; i < promises.length; i++) {
+ promise = promises[i];
+
+ if (promise && typeof promise.then === 'function') {
+ promise.then(resolver(i), reject);
+ } else {
+ results[i] = promise;
+ }
+ }
+
+ if (!remaining) {
+ resolve(results);
+ }
+ });
+};
+
+Promise$1.race = function (promises) {
+ if (!Array.isArray(promises)) {
+ throw new TypeError('You must pass an array to Promise.race().');
+ }
+
+ return new Promise$1(function (resolve, reject) {
+ for (var i = 0, promise; i < promises.length; i++) {
+ promise = promises[i];
+
+ if (promise && typeof promise.then === 'function') {
+ promise.then(resolve, reject);
+ } else {
+ resolve(promise);
+ }
+ }
+ });
+};
+
+Promise$1.resolve = function (value) {
+ if (value && typeof value === 'object' && value.constructor === Promise$1) {
+ return value;
+ }
+
+ return new Promise$1(function (resolve) {
+ resolve(value);
+ });
+};
+
+Promise$1.reject = function (reason) {
+ return new Promise$1(function (resolve, reject) {
+ reject(reason);
+ });
+};
+
+var pinkie = Promise$1;
+
+var pinkiePromise = typeof Promise === 'function' ? Promise : pinkie;
+
+var arrayUniq = createCommonjsModule(function (module) {
+'use strict';
+
+// there's 3 implementations written in increasing order of efficiency
+
+// 1 - no Set type is defined
+function uniqNoSet(arr) {
+ var ret = [];
+
+ for (var i = 0; i < arr.length; i++) {
+ if (ret.indexOf(arr[i]) === -1) {
+ ret.push(arr[i]);
+ }
+ }
+
+ return ret;
+}
+
+// 2 - a simple Set type is defined
+function uniqSet(arr) {
+ var seen = new Set();
+ return arr.filter(function (el) {
+ if (!seen.has(el)) {
+ seen.add(el);
+ return true;
+ }
+
+ return false;
+ });
+}
+
+// 3 - a standard Set type is defined and it has a forEach method
+function uniqSetWithForEach(arr) {
+ var ret = [];
+
+ (new Set(arr)).forEach(function (el) {
+ ret.push(el);
+ });
+
+ return ret;
+}
+
+// V8 currently has a broken implementation
+// https://github.com/joyent/node/issues/8449
+function doesForEachActuallyWork() {
+ var ret = false;
+
+ (new Set([true])).forEach(function (el) {
+ ret = el;
+ });
+
+ return ret === true;
+}
+
+if ('Set' in commonjsGlobal) {
+ if (typeof Set.prototype.forEach === 'function' && doesForEachActuallyWork()) {
+ module.exports = uniqSetWithForEach;
+ } else {
+ module.exports = uniqSet;
+ }
+} else {
+ module.exports = uniqNoSet;
+}
+});
+
+var arrayUnion = function () {
+ return arrayUniq([].concat.apply([], arguments));
+};
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+function toObject(val) {
+ if (val === null || val === undefined) {
+ throw new TypeError('Object.assign cannot be called with null or undefined');
+ }
+
+ return Object(val);
+}
+
+function shouldUseNative() {
+ try {
+ if (!Object.assign) {
+ return false;
+ }
+
+ // Detect buggy property enumeration order in older V8 versions.
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=4118
+ var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
+ test1[5] = 'de';
+ if (Object.getOwnPropertyNames(test1)[0] === '5') {
+ return false;
+ }
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+ var test2 = {};
+ for (var i = 0; i < 10; i++) {
+ test2['_' + String.fromCharCode(i)] = i;
+ }
+ var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+ return test2[n];
+ });
+ if (order2.join('') !== '0123456789') {
+ return false;
+ }
+
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+ var test3 = {};
+ 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+ test3[letter] = letter;
+ });
+ if (Object.keys(Object.assign({}, test3)).join('') !==
+ 'abcdefghijklmnopqrst') {
+ return false;
+ }
+
+ return true;
+ } catch (err) {
+ // We don't expect any of the above to throw, but better to be safe.
+ return false;
+ }
+}
+
+var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+ var from;
+ var to = toObject(target);
+ var symbols;
+
+ for (var s = 1; s < arguments.length; s++) {
+ from = Object(arguments[s]);
+
+ for (var key in from) {
+ if (hasOwnProperty$1.call(from, key)) {
+ to[key] = from[key];
+ }
+ }
+
+ if (getOwnPropertySymbols) {
+ symbols = getOwnPropertySymbols(from);
+ for (var i = 0; i < symbols.length; i++) {
+ if (propIsEnumerable.call(from, symbols[i])) {
+ to[symbols[i]] = from[symbols[i]];
+ }
+ }
+ }
+ }
+
+ return to;
+};
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+var isWindows = process.platform === 'win32';
+
+
+// JavaScript implementation of realpath, ported from node pre-v6
+
+var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+
+function rethrow() {
+ // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
+ // is fairly slow to generate.
+ var callback;
+ if (DEBUG) {
+ var backtrace = new Error;
+ callback = debugCallback;
+ } else
+ callback = missingCallback;
+
+ return callback;
+
+ function debugCallback(err) {
+ if (err) {
+ backtrace.message = err.message;
+ err = backtrace;
+ missingCallback(err);
+ }
+ }
+
+ function missingCallback(err) {
+ if (err) {
+ if (process.throwDeprecation)
+ throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs
+ else if (!process.noDeprecation) {
+ var msg = 'fs: missing callback ' + (err.stack || err.message);
+ if (process.traceDeprecation)
+ console.trace(msg);
+ else
+ console.error(msg);
+ }
+ }
+ }
+}
+
+function maybeCallback(cb) {
+ return typeof cb === 'function' ? cb : rethrow();
+}
+
+// Regexp that finds the next partion of a (partial) path
+// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
+if (isWindows) {
+ var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+} else {
+ var nextPartRe = /(.*?)(?:[\/]+|$)/g;
+}
+
+// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
+if (isWindows) {
+ var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+} else {
+ var splitRootRe = /^[\/]*/;
+}
+
+var realpathSync$1 = function realpathSync(p, cache) {
+ // make p is absolute
+ p = path.resolve(p);
+
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return cache[p];
+ }
+
+ var original = p,
+ seenLinks = {},
+ knownHard = {};
+
+ // current character position in p
+ var pos;
+ // the partial path so far, including a trailing slash if any
+ var current;
+ // the partial path without a trailing slash (except when pointing at a root)
+ var base;
+ // the partial path scanned in the previous round, with slash
+ var previous;
+
+ start();
+
+ function start() {
+ // Skip over roots
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = '';
+
+ // On windows, check that the root exists. On unix there is no need.
+ if (isWindows && !knownHard[base]) {
+ fs.lstatSync(base);
+ knownHard[base] = true;
+ }
+ }
+
+ // walk down the path, swapping out linked pathparts for their real
+ // values
+ // NB: p.length changes.
+ while (pos < p.length) {
+ // find the next part
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+
+ // continue if not a symlink
+ if (knownHard[base] || (cache && cache[base] === base)) {
+ continue;
+ }
+
+ var resolvedLink;
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ // some known symbolic link. no need to stat again.
+ resolvedLink = cache[base];
+ } else {
+ var stat = fs.lstatSync(base);
+ if (!stat.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache) cache[base] = base;
+ continue;
+ }
+
+ // read the link if it wasn't read before
+ // dev/ino always return 0 on windows, so skip the check.
+ var linkTarget = null;
+ if (!isWindows) {
+ var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ linkTarget = seenLinks[id];
+ }
+ }
+ if (linkTarget === null) {
+ fs.statSync(base);
+ linkTarget = fs.readlinkSync(base);
+ }
+ resolvedLink = path.resolve(previous, linkTarget);
+ // track this, if given a cache.
+ if (cache) cache[base] = resolvedLink;
+ if (!isWindows) seenLinks[id] = linkTarget;
+ }
+
+ // resolve the link, then start over
+ p = path.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+
+ if (cache) cache[original] = p;
+
+ return p;
+};
+
+
+var realpath$1 = function realpath(p, cache, cb) {
+ if (typeof cb !== 'function') {
+ cb = maybeCallback(cache);
+ cache = null;
+ }
+
+ // make p is absolute
+ p = path.resolve(p);
+
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return process.nextTick(cb.bind(null, null, cache[p]));
+ }
+
+ var original = p,
+ seenLinks = {},
+ knownHard = {};
+
+ // current character position in p
+ var pos;
+ // the partial path so far, including a trailing slash if any
+ var current;
+ // the partial path without a trailing slash (except when pointing at a root)
+ var base;
+ // the partial path scanned in the previous round, with slash
+ var previous;
+
+ start();
+
+ function start() {
+ // Skip over roots
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = '';
+
+ // On windows, check that the root exists. On unix there is no need.
+ if (isWindows && !knownHard[base]) {
+ fs.lstat(base, function(err) {
+ if (err) return cb(err);
+ knownHard[base] = true;
+ LOOP();
+ });
+ } else {
+ process.nextTick(LOOP);
+ }
+ }
+
+ // walk down the path, swapping out linked pathparts for their real
+ // values
+ function LOOP() {
+ // stop if scanned past end of path
+ if (pos >= p.length) {
+ if (cache) cache[original] = p;
+ return cb(null, p);
+ }
+
+ // find the next part
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+
+ // continue if not a symlink
+ if (knownHard[base] || (cache && cache[base] === base)) {
+ return process.nextTick(LOOP);
+ }
+
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ // known symbolic link. no need to stat again.
+ return gotResolvedLink(cache[base]);
+ }
+
+ return fs.lstat(base, gotStat);
+ }
+
+ function gotStat(err, stat) {
+ if (err) return cb(err);
+
+ // if not a symlink, skip to the next path part
+ if (!stat.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache) cache[base] = base;
+ return process.nextTick(LOOP);
+ }
+
+ // stat & read the link if not read before
+ // call gotTarget as soon as the link target is known
+ // dev/ino always return 0 on windows, so skip the check.
+ if (!isWindows) {
+ var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ return gotTarget(null, seenLinks[id], base);
+ }
+ }
+ fs.stat(base, function(err) {
+ if (err) return cb(err);
+
+ fs.readlink(base, function(err, target) {
+ if (!isWindows) seenLinks[id] = target;
+ gotTarget(err, target);
+ });
+ });
+ }
+
+ function gotTarget(err, target, base) {
+ if (err) return cb(err);
+
+ var resolvedLink = path.resolve(previous, target);
+ if (cache) cache[base] = resolvedLink;
+ gotResolvedLink(resolvedLink);
+ }
+
+ function gotResolvedLink(resolvedLink) {
+ // resolve the link, then start over
+ p = path.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+};
+
+var old = {
+ realpathSync: realpathSync$1,
+ realpath: realpath$1
+};
+
+var fs_realpath = realpath;
+realpath.realpath = realpath;
+realpath.sync = realpathSync;
+realpath.realpathSync = realpathSync;
+realpath.monkeypatch = monkeypatch;
+realpath.unmonkeypatch = unmonkeypatch;
+
+
+var origRealpath = fs.realpath;
+var origRealpathSync = fs.realpathSync;
+
+var version$3 = process.version;
+var ok = /^v[0-5]\./.test(version$3);
+
+
+function newError (er) {
+ return er && er.syscall === 'realpath' && (
+ er.code === 'ELOOP' ||
+ er.code === 'ENOMEM' ||
+ er.code === 'ENAMETOOLONG'
+ )
+}
+
+function realpath (p, cache, cb) {
+ if (ok) {
+ return origRealpath(p, cache, cb)
+ }
+
+ if (typeof cache === 'function') {
+ cb = cache;
+ cache = null;
+ }
+ origRealpath(p, cache, function (er, result) {
+ if (newError(er)) {
+ old.realpath(p, cache, cb);
+ } else {
+ cb(er, result);
+ }
+ });
+}
+
+function realpathSync (p, cache) {
+ if (ok) {
+ return origRealpathSync(p, cache)
+ }
+
+ try {
+ return origRealpathSync(p, cache)
+ } catch (er) {
+ if (newError(er)) {
+ return old.realpathSync(p, cache)
+ } else {
+ throw er
+ }
+ }
+}
+
+function monkeypatch () {
+ fs.realpath = realpath;
+ fs.realpathSync = realpathSync;
+}
+
+function unmonkeypatch () {
+ fs.realpath = origRealpath;
+ fs.realpathSync = origRealpathSync;
+}
+
+var inherits_browser = createCommonjsModule(function (module) {
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor;
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor;
+ var TempCtor = function () {};
+ TempCtor.prototype = superCtor.prototype;
+ ctor.prototype = new TempCtor();
+ ctor.prototype.constructor = ctor;
+ };
+}
+});
+
+var inherits = createCommonjsModule(function (module) {
+try {
+ var util$$2 = util;
+ if (typeof util$$2.inherits !== 'function') throw '';
+ module.exports = util$$2.inherits;
+} catch (e) {
+ module.exports = inherits_browser;
+}
+});
+
+function posix(path$$1) {
+ return path$$1.charAt(0) === '/';
+}
+
+function win32(path$$1) {
+ // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
+ var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+ var result = splitDeviceRe.exec(path$$1);
+ var device = result[1] || '';
+ var isUnc = Boolean(device && device.charAt(1) !== ':');
+
+ // UNC paths are always absolute
+ return Boolean(result[2] || isUnc);
+}
+
+var pathIsAbsolute = process.platform === 'win32' ? win32 : posix;
+var posix_1 = posix;
+var win32_1 = win32;
+
+pathIsAbsolute.posix = posix_1;
+pathIsAbsolute.win32 = win32_1;
+
+var alphasort_1 = alphasort$2;
+var alphasorti_1 = alphasorti$2;
+var setopts_1 = setopts$2;
+var ownProp_1 = ownProp$2;
+var makeAbs_1 = makeAbs;
+var finish_1 = finish;
+var mark_1 = mark;
+var isIgnored_1 = isIgnored$2;
+var childrenIgnored_1 = childrenIgnored$2;
+
+function ownProp$2 (obj, field) {
+ return Object.prototype.hasOwnProperty.call(obj, field)
+}
+
+
+
+
+var Minimatch$3 = minimatch_1.Minimatch;
+
+function alphasorti$2 (a, b) {
+ return a.toLowerCase().localeCompare(b.toLowerCase())
+}
+
+function alphasort$2 (a, b) {
+ return a.localeCompare(b)
+}
+
+function setupIgnores (self, options) {
+ self.ignore = options.ignore || [];
+
+ if (!Array.isArray(self.ignore))
+ self.ignore = [self.ignore];
+
+ if (self.ignore.length) {
+ self.ignore = self.ignore.map(ignoreMap);
+ }
+}
+
+// ignore patterns are always in dot:true mode.
+function ignoreMap (pattern) {
+ var gmatcher = null;
+ if (pattern.slice(-3) === '/**') {
+ var gpattern = pattern.replace(/(\/\*\*)+$/, '');
+ gmatcher = new Minimatch$3(gpattern, { dot: true });
+ }
+
+ return {
+ matcher: new Minimatch$3(pattern, { dot: true }),
+ gmatcher: gmatcher
+ }
+}
+
+function setopts$2 (self, pattern, options) {
+ if (!options)
+ options = {};
+
+ // base-matching: just use globstar for that.
+ if (options.matchBase && -1 === pattern.indexOf("/")) {
+ if (options.noglobstar) {
+ throw new Error("base matching requires globstar")
+ }
+ pattern = "**/" + pattern;
+ }
+
+ self.silent = !!options.silent;
+ self.pattern = pattern;
+ self.strict = options.strict !== false;
+ self.realpath = !!options.realpath;
+ self.realpathCache = options.realpathCache || Object.create(null);
+ self.follow = !!options.follow;
+ self.dot = !!options.dot;
+ self.mark = !!options.mark;
+ self.nodir = !!options.nodir;
+ if (self.nodir)
+ self.mark = true;
+ self.sync = !!options.sync;
+ self.nounique = !!options.nounique;
+ self.nonull = !!options.nonull;
+ self.nosort = !!options.nosort;
+ self.nocase = !!options.nocase;
+ self.stat = !!options.stat;
+ self.noprocess = !!options.noprocess;
+ self.absolute = !!options.absolute;
+
+ self.maxLength = options.maxLength || Infinity;
+ self.cache = options.cache || Object.create(null);
+ self.statCache = options.statCache || Object.create(null);
+ self.symlinks = options.symlinks || Object.create(null);
+
+ setupIgnores(self, options);
+
+ self.changedCwd = false;
+ var cwd = process.cwd();
+ if (!ownProp$2(options, "cwd"))
+ self.cwd = cwd;
+ else {
+ self.cwd = path.resolve(options.cwd);
+ self.changedCwd = self.cwd !== cwd;
+ }
+
+ self.root = options.root || path.resolve(self.cwd, "/");
+ self.root = path.resolve(self.root);
+ if (process.platform === "win32")
+ self.root = self.root.replace(/\\/g, "/");
+
+ // TODO: is an absolute `cwd` supposed to be resolved against `root`?
+ // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
+ self.cwdAbs = pathIsAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+ if (process.platform === "win32")
+ self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
+ self.nomount = !!options.nomount;
+
+ // disable comments and negation in Minimatch.
+ // Note that they are not supported in Glob itself anyway.
+ options.nonegate = true;
+ options.nocomment = true;
+
+ self.minimatch = new Minimatch$3(pattern, options);
+ self.options = self.minimatch.options;
+}
+
+function finish (self) {
+ var nou = self.nounique;
+ var all = nou ? [] : Object.create(null);
+
+ for (var i = 0, l = self.matches.length; i < l; i ++) {
+ var matches = self.matches[i];
+ if (!matches || Object.keys(matches).length === 0) {
+ if (self.nonull) {
+ // do like the shell, and spit out the literal glob
+ var literal = self.minimatch.globSet[i];
+ if (nou)
+ all.push(literal);
+ else
+ all[literal] = true;
+ }
+ } else {
+ // had matches
+ var m = Object.keys(matches);
+ if (nou)
+ all.push.apply(all, m);
+ else
+ m.forEach(function (m) {
+ all[m] = true;
+ });
+ }
+ }
+
+ if (!nou)
+ all = Object.keys(all);
+
+ if (!self.nosort)
+ all = all.sort(self.nocase ? alphasorti$2 : alphasort$2);
+
+ // at *some* point we statted all of these
+ if (self.mark) {
+ for (var i = 0; i < all.length; i++) {
+ all[i] = self._mark(all[i]);
+ }
+ if (self.nodir) {
+ all = all.filter(function (e) {
+ var notDir = !(/\/$/.test(e));
+ var c = self.cache[e] || self.cache[makeAbs(self, e)];
+ if (notDir && c)
+ notDir = c !== 'DIR' && !Array.isArray(c);
+ return notDir
+ });
+ }
+ }
+
+ if (self.ignore.length)
+ all = all.filter(function(m) {
+ return !isIgnored$2(self, m)
+ });
+
+ self.found = all;
+}
+
+function mark (self, p) {
+ var abs = makeAbs(self, p);
+ var c = self.cache[abs];
+ var m = p;
+ if (c) {
+ var isDir = c === 'DIR' || Array.isArray(c);
+ var slash = p.slice(-1) === '/';
+
+ if (isDir && !slash)
+ m += '/';
+ else if (!isDir && slash)
+ m = m.slice(0, -1);
+
+ if (m !== p) {
+ var mabs = makeAbs(self, m);
+ self.statCache[mabs] = self.statCache[abs];
+ self.cache[mabs] = self.cache[abs];
+ }
+ }
+
+ return m
+}
+
+// lotta situps...
+function makeAbs (self, f) {
+ var abs = f;
+ if (f.charAt(0) === '/') {
+ abs = path.join(self.root, f);
+ } else if (pathIsAbsolute(f) || f === '') {
+ abs = f;
+ } else if (self.changedCwd) {
+ abs = path.resolve(self.cwd, f);
+ } else {
+ abs = path.resolve(f);
+ }
+
+ if (process.platform === 'win32')
+ abs = abs.replace(/\\/g, '/');
+
+ return abs
+}
+
+
+// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
+// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
+function isIgnored$2 (self, path$$2) {
+ if (!self.ignore.length)
+ return false
+
+ return self.ignore.some(function(item) {
+ return item.matcher.match(path$$2) || !!(item.gmatcher && item.gmatcher.match(path$$2))
+ })
+}
+
+function childrenIgnored$2 (self, path$$2) {
+ if (!self.ignore.length)
+ return false
+
+ return self.ignore.some(function(item) {
+ return !!(item.gmatcher && item.gmatcher.match(path$$2))
+ })
+}
+
+var common = {
+ alphasort: alphasort_1,
+ alphasorti: alphasorti_1,
+ setopts: setopts_1,
+ ownProp: ownProp_1,
+ makeAbs: makeAbs_1,
+ finish: finish_1,
+ mark: mark_1,
+ isIgnored: isIgnored_1,
+ childrenIgnored: childrenIgnored_1
+};
+
+var sync$4 = globSync;
+globSync.GlobSync = GlobSync$1;
+
+
+
+
+var setopts$1 = common.setopts;
+var ownProp$1 = common.ownProp;
+var childrenIgnored$1 = common.childrenIgnored;
+var isIgnored$1 = common.isIgnored;
+
+function globSync (pattern, options) {
+ if (typeof options === 'function' || arguments.length === 3)
+ throw new TypeError('callback provided to sync glob\n'+
+ 'See: https://github.com/isaacs/node-glob/issues/167')
+
+ return new GlobSync$1(pattern, options).found
+}
+
+function GlobSync$1 (pattern, options) {
+ if (!pattern)
+ throw new Error('must provide pattern')
+
+ if (typeof options === 'function' || arguments.length === 3)
+ throw new TypeError('callback provided to sync glob\n'+
+ 'See: https://github.com/isaacs/node-glob/issues/167')
+
+ if (!(this instanceof GlobSync$1))
+ return new GlobSync$1(pattern, options)
+
+ setopts$1(this, pattern, options);
+
+ if (this.noprocess)
+ return this
+
+ var n = this.minimatch.set.length;
+ this.matches = new Array(n);
+ for (var i = 0; i < n; i ++) {
+ this._process(this.minimatch.set[i], i, false);
+ }
+ this._finish();
+}
+
+GlobSync$1.prototype._finish = function () {
+ assert(this instanceof GlobSync$1);
+ if (this.realpath) {
+ var self = this;
+ this.matches.forEach(function (matchset, index) {
+ var set = self.matches[index] = Object.create(null);
+ for (var p in matchset) {
+ try {
+ p = self._makeAbs(p);
+ var real = fs_realpath.realpathSync(p, self.realpathCache);
+ set[real] = true;
+ } catch (er) {
+ if (er.syscall === 'stat')
+ set[self._makeAbs(p)] = true;
+ else
+ throw er
+ }
+ }
+ });
+ }
+ common.finish(this);
+};
+
+
+GlobSync$1.prototype._process = function (pattern, index, inGlobStar) {
+ assert(this instanceof GlobSync$1);
+
+ // Get the first [n] parts of pattern that are all strings.
+ var n = 0;
+ while (typeof pattern[n] === 'string') {
+ n ++;
+ }
+ // now n is the index of the first one that is *not* a string.
+
+ // See if there's anything else
+ var prefix;
+ switch (n) {
+ // if not, then this is rather simple
+ case pattern.length:
+ this._processSimple(pattern.join('/'), index);
+ return
+
+ case 0:
+ // pattern *starts* with some non-trivial item.
+ // going to readdir(cwd), but not include the prefix in matches.
+ prefix = null;
+ break
+
+ default:
+ // pattern has some string bits in the front.
+ // whatever it starts with, whether that's 'absolute' like /foo/bar,
+ // or 'relative' like '../baz'
+ prefix = pattern.slice(0, n).join('/');
+ break
+ }
+
+ var remain = pattern.slice(n);
+
+ // get the list of entries.
+ var read;
+ if (prefix === null)
+ read = '.';
+ else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
+ if (!prefix || !pathIsAbsolute(prefix))
+ prefix = '/' + prefix;
+ read = prefix;
+ } else
+ read = prefix;
+
+ var abs = this._makeAbs(read);
+
+ //if ignored, skip processing
+ if (childrenIgnored$1(this, read))
+ return
+
+ var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
+};
+
+
+GlobSync$1.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
+ var entries = this._readdir(abs, inGlobStar);
+
+ // if the abs isn't a dir, then nothing can match!
+ if (!entries)
+ return
+
+ // It will only match dot entries if it starts with a dot, or if
+ // dot is set. Stuff like @(.foo|.bar) isn't allowed.
+ var pn = remain[0];
+ var negate = !!this.minimatch.negate;
+ var rawGlob = pn._glob;
+ var dotOk = this.dot || rawGlob.charAt(0) === '.';
+
+ var matchedEntries = [];
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (e.charAt(0) !== '.' || dotOk) {
+ var m;
+ if (negate && !prefix) {
+ m = !e.match(pn);
+ } else {
+ m = e.match(pn);
+ }
+ if (m)
+ matchedEntries.push(e);
+ }
+ }
+
+ var len = matchedEntries.length;
+ // If there are no matched entries, then nothing matches.
+ if (len === 0)
+ return
+
+ // if this is the last remaining pattern bit, then no need for
+ // an additional stat *unless* the user has specified mark or
+ // stat explicitly. We know they exist, since readdir returned
+ // them.
+
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+
+ for (var i = 0; i < len; i ++) {
+ var e = matchedEntries[i];
+ if (prefix) {
+ if (prefix.slice(-1) !== '/')
+ e = prefix + '/' + e;
+ else
+ e = prefix + e;
+ }
+
+ if (e.charAt(0) === '/' && !this.nomount) {
+ e = path.join(this.root, e);
+ }
+ this._emitMatch(index, e);
+ }
+ // This was the last one, and no stats were needed
+ return
+ }
+
+ // now test all matched entries as stand-ins for that part
+ // of the pattern.
+ remain.shift();
+ for (var i = 0; i < len; i ++) {
+ var e = matchedEntries[i];
+ var newPattern;
+ if (prefix)
+ newPattern = [prefix, e];
+ else
+ newPattern = [e];
+ this._process(newPattern.concat(remain), index, inGlobStar);
+ }
+};
+
+
+GlobSync$1.prototype._emitMatch = function (index, e) {
+ if (isIgnored$1(this, e))
+ return
+
+ var abs = this._makeAbs(e);
+
+ if (this.mark)
+ e = this._mark(e);
+
+ if (this.absolute) {
+ e = abs;
+ }
+
+ if (this.matches[index][e])
+ return
+
+ if (this.nodir) {
+ var c = this.cache[abs];
+ if (c === 'DIR' || Array.isArray(c))
+ return
+ }
+
+ this.matches[index][e] = true;
+
+ if (this.stat)
+ this._stat(e);
+};
+
+
+GlobSync$1.prototype._readdirInGlobStar = function (abs) {
+ // follow all symlinked directories forever
+ // just proceed as if this is a non-globstar situation
+ if (this.follow)
+ return this._readdir(abs, false)
+
+ var entries;
+ var lstat;
+ var stat;
+ try {
+ lstat = fs.lstatSync(abs);
+ } catch (er) {
+ if (er.code === 'ENOENT') {
+ // lstat failed, doesn't exist
+ return null
+ }
+ }
+
+ var isSym = lstat && lstat.isSymbolicLink();
+ this.symlinks[abs] = isSym;
+
+ // If it's not a symlink or a dir, then it's definitely a regular file.
+ // don't bother doing a readdir in that case.
+ if (!isSym && lstat && !lstat.isDirectory())
+ this.cache[abs] = 'FILE';
+ else
+ entries = this._readdir(abs, false);
+
+ return entries
+};
+
+GlobSync$1.prototype._readdir = function (abs, inGlobStar) {
+ var entries;
+
+ if (inGlobStar && !ownProp$1(this.symlinks, abs))
+ return this._readdirInGlobStar(abs)
+
+ if (ownProp$1(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (!c || c === 'FILE')
+ return null
+
+ if (Array.isArray(c))
+ return c
+ }
+
+ try {
+ return this._readdirEntries(abs, fs.readdirSync(abs))
+ } catch (er) {
+ this._readdirError(abs, er);
+ return null
+ }
+};
+
+GlobSync$1.prototype._readdirEntries = function (abs, entries) {
+ // if we haven't asked to stat everything, then just
+ // assume that everything in there exists, so we can avoid
+ // having to stat it a second time.
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i ++) {
+ var e = entries[i];
+ if (abs === '/')
+ e = abs + e;
+ else
+ e = abs + '/' + e;
+ this.cache[e] = true;
+ }
+ }
+
+ this.cache[abs] = entries;
+
+ // mark and cache dir-ness
+ return entries
+};
+
+GlobSync$1.prototype._readdirError = function (f, er) {
+ // handle errors, and cache the information
+ switch (er.code) {
+ case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
+ case 'ENOTDIR': // totally normal. means it *does* exist.
+ var abs = this._makeAbs(f);
+ this.cache[abs] = 'FILE';
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + ' invalid cwd ' + this.cwd);
+ error.path = this.cwd;
+ error.code = er.code;
+ throw error
+ }
+ break
+
+ case 'ENOENT': // not terribly unusual
+ case 'ELOOP':
+ case 'ENAMETOOLONG':
+ case 'UNKNOWN':
+ this.cache[this._makeAbs(f)] = false;
+ break
+
+ default: // some unusual error. Treat as failure.
+ this.cache[this._makeAbs(f)] = false;
+ if (this.strict)
+ throw er
+ if (!this.silent)
+ console.error('glob error', er);
+ break
+ }
+};
+
+GlobSync$1.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
+
+ var entries = this._readdir(abs, inGlobStar);
+
+ // no entries means not a dir, so it can never have matches
+ // foo.txt/** doesn't match foo.txt
+ if (!entries)
+ return
+
+ // test without the globstar, and with every child both below
+ // and replacing the globstar.
+ var remainWithoutGlobStar = remain.slice(1);
+ var gspref = prefix ? [ prefix ] : [];
+ var noGlobStar = gspref.concat(remainWithoutGlobStar);
+
+ // the noGlobStar pattern exits the inGlobStar state
+ this._process(noGlobStar, index, false);
+
+ var len = entries.length;
+ var isSym = this.symlinks[abs];
+
+ // If it's a symlink, and we're in a globstar, then stop
+ if (isSym && inGlobStar)
+ return
+
+ for (var i = 0; i < len; i++) {
+ var e = entries[i];
+ if (e.charAt(0) === '.' && !this.dot)
+ continue
+
+ // these two cases enter the inGlobStar state
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+ this._process(instead, index, true);
+
+ var below = gspref.concat(entries[i], remain);
+ this._process(below, index, true);
+ }
+};
+
+GlobSync$1.prototype._processSimple = function (prefix, index) {
+ // XXX review this. Shouldn't it be doing the mounting etc
+ // before doing stat? kinda weird?
+ var exists = this._stat(prefix);
+
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+
+ // If it doesn't exist, then just mark the lack of results
+ if (!exists)
+ return
+
+ if (prefix && pathIsAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix);
+ if (prefix.charAt(0) === '/') {
+ prefix = path.join(this.root, prefix);
+ } else {
+ prefix = path.resolve(this.root, prefix);
+ if (trail)
+ prefix += '/';
+ }
+ }
+
+ if (process.platform === 'win32')
+ prefix = prefix.replace(/\\/g, '/');
+
+ // Mark this as a match
+ this._emitMatch(index, prefix);
+};
+
+// Returns either 'DIR', 'FILE', or false
+GlobSync$1.prototype._stat = function (f) {
+ var abs = this._makeAbs(f);
+ var needDir = f.slice(-1) === '/';
+
+ if (f.length > this.maxLength)
+ return false
+
+ if (!this.stat && ownProp$1(this.cache, abs)) {
+ var c = this.cache[abs];
+
+ if (Array.isArray(c))
+ c = 'DIR';
+
+ // It exists, but maybe not how we need it
+ if (!needDir || c === 'DIR')
+ return c
+
+ if (needDir && c === 'FILE')
+ return false
+
+ // otherwise we have to stat, because maybe c=true
+ // if we know it exists, but not what it is.
+ }
+
+ var exists;
+ var stat = this.statCache[abs];
+ if (!stat) {
+ var lstat;
+ try {
+ lstat = fs.lstatSync(abs);
+ } catch (er) {
+ if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+ this.statCache[abs] = false;
+ return false
+ }
+ }
+
+ if (lstat && lstat.isSymbolicLink()) {
+ try {
+ stat = fs.statSync(abs);
+ } catch (er) {
+ stat = lstat;
+ }
+ } else {
+ stat = lstat;
+ }
+ }
+
+ this.statCache[abs] = stat;
+
+ var c = true;
+ if (stat)
+ c = stat.isDirectory() ? 'DIR' : 'FILE';
+
+ this.cache[abs] = this.cache[abs] || c;
+
+ if (needDir && c === 'FILE')
+ return false
+
+ return c
+};
+
+GlobSync$1.prototype._mark = function (p) {
+ return common.mark(this, p)
+};
+
+GlobSync$1.prototype._makeAbs = function (f) {
+ return common.makeAbs(this, f)
+};
+
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+var wrappy_1 = wrappy;
+function wrappy (fn, cb) {
+ if (fn && cb) return wrappy(fn)(cb)
+
+ if (typeof fn !== 'function')
+ throw new TypeError('need wrapper function')
+
+ Object.keys(fn).forEach(function (k) {
+ wrapper[k] = fn[k];
+ });
+
+ return wrapper
+
+ function wrapper() {
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+ var ret = fn.apply(this, args);
+ var cb = args[args.length-1];
+ if (typeof ret === 'function' && ret !== cb) {
+ Object.keys(cb).forEach(function (k) {
+ ret[k] = cb[k];
+ });
+ }
+ return ret
+ }
+}
+
+var once_1 = wrappy_1(once);
+var strict = wrappy_1(onceStrict);
+
+once.proto = once(function () {
+ Object.defineProperty(Function.prototype, 'once', {
+ value: function () {
+ return once(this)
+ },
+ configurable: true
+ });
+
+ Object.defineProperty(Function.prototype, 'onceStrict', {
+ value: function () {
+ return onceStrict(this)
+ },
+ configurable: true
+ });
+});
+
+function once (fn) {
+ var f = function () {
+ if (f.called) return f.value
+ f.called = true;
+ return f.value = fn.apply(this, arguments)
+ };
+ f.called = false;
+ return f
+}
+
+function onceStrict (fn) {
+ var f = function () {
+ if (f.called)
+ throw new Error(f.onceError)
+ f.called = true;
+ return f.value = fn.apply(this, arguments)
+ };
+ var name = fn.name || 'Function wrapped with `once`';
+ f.onceError = name + " shouldn't be called more than once";
+ f.called = false;
+ return f
+}
+
+once_1.strict = strict;
+
+var reqs = Object.create(null);
+
+
+var inflight_1 = wrappy_1(inflight);
+
+function inflight (key, cb) {
+ if (reqs[key]) {
+ reqs[key].push(cb);
+ return null
+ } else {
+ reqs[key] = [cb];
+ return makeres(key)
+ }
+}
+
+function makeres (key) {
+ return once_1(function RES () {
+ var cbs = reqs[key];
+ var len = cbs.length;
+ var args = slice(arguments);
+
+ // XXX It's somewhat ambiguous whether a new callback added in this
+ // pass should be queued for later execution if something in the
+ // list of callbacks throws, or if it should just be discarded.
+ // However, it's such an edge case that it hardly matters, and either
+ // choice is likely as surprising as the other.
+ // As it happens, we do go ahead and schedule it for later execution.
+ try {
+ for (var i = 0; i < len; i++) {
+ cbs[i].apply(null, args);
+ }
+ } finally {
+ if (cbs.length > len) {
+ // added more in the interim.
+ // de-zalgo, just in case, but don't call again.
+ cbs.splice(0, len);
+ process.nextTick(function () {
+ RES.apply(null, args);
+ });
+ } else {
+ delete reqs[key];
+ }
+ }
+ })
+}
+
+function slice (args) {
+ var length = args.length;
+ var array = [];
+
+ for (var i = 0; i < length; i++) array[i] = args[i];
+ return array
+}
+
+// Approach:
+//
+// 1. Get the minimatch set
+// 2. For each pattern in the set, PROCESS(pattern, false)
+// 3. Store matches per-set, then uniq them
+//
+// PROCESS(pattern, inGlobStar)
+// Get the first [n] items from pattern that are all strings
+// Join these together. This is PREFIX.
+// If there is no more remaining, then stat(PREFIX) and
+// add to matches if it succeeds. END.
+//
+// If inGlobStar and PREFIX is symlink and points to dir
+// set ENTRIES = []
+// else readdir(PREFIX) as ENTRIES
+// If fail, END
+//
+// with ENTRIES
+// If pattern[n] is GLOBSTAR
+// // handle the case where the globstar match is empty
+// // by pruning it out, and testing the resulting pattern
+// PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
+// // handle other cases.
+// for ENTRY in ENTRIES (not dotfiles)
+// // attach globstar + tail onto the entry
+// // Mark that this entry is a globstar match
+// PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
+//
+// else // not globstar
+// for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
+// Test ENTRY against pattern[n]
+// If fails, continue
+// If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
+//
+// Caveat:
+// Cache all stats and readdirs results to minimize syscall. Since all
+// we ever care about is existence and directory-ness, we can just keep
+// `true` for files, and [children,...] for directories, or `false` for
+// things that don't exist.
+
+var glob_1 = glob;
+
+
+
+
+var EE = events.EventEmitter;
+
+
+
+
+
+var setopts = common.setopts;
+var ownProp = common.ownProp;
+
+
+var childrenIgnored = common.childrenIgnored;
+var isIgnored = common.isIgnored;
+
+
+
+function glob (pattern, options, cb) {
+ if (typeof options === 'function') cb = options, options = {};
+ if (!options) options = {};
+
+ if (options.sync) {
+ if (cb)
+ throw new TypeError('callback provided to sync glob')
+ return sync$4(pattern, options)
+ }
+
+ return new Glob(pattern, options, cb)
+}
+
+glob.sync = sync$4;
+var GlobSync = glob.GlobSync = sync$4.GlobSync;
+
+// old api surface
+glob.glob = glob;
+
+function extend (origin, add) {
+ if (add === null || typeof add !== 'object') {
+ return origin
+ }
+
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin
+}
+
+glob.hasMagic = function (pattern, options_) {
+ var options = extend({}, options_);
+ options.noprocess = true;
+
+ var g = new Glob(pattern, options);
+ var set = g.minimatch.set;
+
+ if (!pattern)
+ return false
+
+ if (set.length > 1)
+ return true
+
+ for (var j = 0; j < set[0].length; j++) {
+ if (typeof set[0][j] !== 'string')
+ return true
+ }
+
+ return false
+};
+
+glob.Glob = Glob;
+inherits(Glob, EE);
+function Glob (pattern, options, cb) {
+ if (typeof options === 'function') {
+ cb = options;
+ options = null;
+ }
+
+ if (options && options.sync) {
+ if (cb)
+ throw new TypeError('callback provided to sync glob')
+ return new GlobSync(pattern, options)
+ }
+
+ if (!(this instanceof Glob))
+ return new Glob(pattern, options, cb)
+
+ setopts(this, pattern, options);
+ this._didRealPath = false;
+
+ // process each pattern in the minimatch set
+ var n = this.minimatch.set.length;
+
+ // The matches are stored as {: true,...} so that
+ // duplicates are automagically pruned.
+ // Later, we do an Object.keys() on these.
+ // Keep them as a list so we can fill in when nonull is set.
+ this.matches = new Array(n);
+
+ if (typeof cb === 'function') {
+ cb = once_1(cb);
+ this.on('error', cb);
+ this.on('end', function (matches) {
+ cb(null, matches);
+ });
+ }
+
+ var self = this;
+ this._processing = 0;
+
+ this._emitQueue = [];
+ this._processQueue = [];
+ this.paused = false;
+
+ if (this.noprocess)
+ return this
+
+ if (n === 0)
+ return done()
+
+ var sync = true;
+ for (var i = 0; i < n; i ++) {
+ this._process(this.minimatch.set[i], i, false, done);
+ }
+ sync = false;
+
+ function done () {
+ --self._processing;
+ if (self._processing <= 0) {
+ if (sync) {
+ process.nextTick(function () {
+ self._finish();
+ });
+ } else {
+ self._finish();
+ }
+ }
+ }
+}
+
+Glob.prototype._finish = function () {
+ assert(this instanceof Glob);
+ if (this.aborted)
+ return
+
+ if (this.realpath && !this._didRealpath)
+ return this._realpath()
+
+ common.finish(this);
+ this.emit('end', this.found);
+};
+
+Glob.prototype._realpath = function () {
+ if (this._didRealpath)
+ return
+
+ this._didRealpath = true;
+
+ var n = this.matches.length;
+ if (n === 0)
+ return this._finish()
+
+ var self = this;
+ for (var i = 0; i < this.matches.length; i++)
+ this._realpathSet(i, next);
+
+ function next () {
+ if (--n === 0)
+ self._finish();
+ }
+};
+
+Glob.prototype._realpathSet = function (index, cb) {
+ var matchset = this.matches[index];
+ if (!matchset)
+ return cb()
+
+ var found = Object.keys(matchset);
+ var self = this;
+ var n = found.length;
+
+ if (n === 0)
+ return cb()
+
+ var set = this.matches[index] = Object.create(null);
+ found.forEach(function (p, i) {
+ // If there's a problem with the stat, then it means that
+ // one or more of the links in the realpath couldn't be
+ // resolved. just return the abs value in that case.
+ p = self._makeAbs(p);
+ fs_realpath.realpath(p, self.realpathCache, function (er, real) {
+ if (!er)
+ set[real] = true;
+ else if (er.syscall === 'stat')
+ set[p] = true;
+ else
+ self.emit('error', er); // srsly wtf right here
+
+ if (--n === 0) {
+ self.matches[index] = set;
+ cb();
+ }
+ });
+ });
+};
+
+Glob.prototype._mark = function (p) {
+ return common.mark(this, p)
+};
+
+Glob.prototype._makeAbs = function (f) {
+ return common.makeAbs(this, f)
+};
+
+Glob.prototype.abort = function () {
+ this.aborted = true;
+ this.emit('abort');
+};
+
+Glob.prototype.pause = function () {
+ if (!this.paused) {
+ this.paused = true;
+ this.emit('pause');
+ }
+};
+
+Glob.prototype.resume = function () {
+ if (this.paused) {
+ this.emit('resume');
+ this.paused = false;
+ if (this._emitQueue.length) {
+ var eq = this._emitQueue.slice(0);
+ this._emitQueue.length = 0;
+ for (var i = 0; i < eq.length; i ++) {
+ var e = eq[i];
+ this._emitMatch(e[0], e[1]);
+ }
+ }
+ if (this._processQueue.length) {
+ var pq = this._processQueue.slice(0);
+ this._processQueue.length = 0;
+ for (var i = 0; i < pq.length; i ++) {
+ var p = pq[i];
+ this._processing--;
+ this._process(p[0], p[1], p[2], p[3]);
+ }
+ }
+ }
+};
+
+Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
+ assert(this instanceof Glob);
+ assert(typeof cb === 'function');
+
+ if (this.aborted)
+ return
+
+ this._processing++;
+ if (this.paused) {
+ this._processQueue.push([pattern, index, inGlobStar, cb]);
+ return
+ }
+
+ //console.error('PROCESS %d', this._processing, pattern)
+
+ // Get the first [n] parts of pattern that are all strings.
+ var n = 0;
+ while (typeof pattern[n] === 'string') {
+ n ++;
+ }
+ // now n is the index of the first one that is *not* a string.
+
+ // see if there's anything else
+ var prefix;
+ switch (n) {
+ // if not, then this is rather simple
+ case pattern.length:
+ this._processSimple(pattern.join('/'), index, cb);
+ return
+
+ case 0:
+ // pattern *starts* with some non-trivial item.
+ // going to readdir(cwd), but not include the prefix in matches.
+ prefix = null;
+ break
+
+ default:
+ // pattern has some string bits in the front.
+ // whatever it starts with, whether that's 'absolute' like /foo/bar,
+ // or 'relative' like '../baz'
+ prefix = pattern.slice(0, n).join('/');
+ break
+ }
+
+ var remain = pattern.slice(n);
+
+ // get the list of entries.
+ var read;
+ if (prefix === null)
+ read = '.';
+ else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
+ if (!prefix || !pathIsAbsolute(prefix))
+ prefix = '/' + prefix;
+ read = prefix;
+ } else
+ read = prefix;
+
+ var abs = this._makeAbs(read);
+
+ //if ignored, skip _processing
+ if (childrenIgnored(this, read))
+ return cb()
+
+ var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
+};
+
+Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self = this;
+ this._readdir(abs, inGlobStar, function (er, entries) {
+ return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
+ });
+};
+
+Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+
+ // if the abs isn't a dir, then nothing can match!
+ if (!entries)
+ return cb()
+
+ // It will only match dot entries if it starts with a dot, or if
+ // dot is set. Stuff like @(.foo|.bar) isn't allowed.
+ var pn = remain[0];
+ var negate = !!this.minimatch.negate;
+ var rawGlob = pn._glob;
+ var dotOk = this.dot || rawGlob.charAt(0) === '.';
+
+ var matchedEntries = [];
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (e.charAt(0) !== '.' || dotOk) {
+ var m;
+ if (negate && !prefix) {
+ m = !e.match(pn);
+ } else {
+ m = e.match(pn);
+ }
+ if (m)
+ matchedEntries.push(e);
+ }
+ }
+
+ //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
+
+ var len = matchedEntries.length;
+ // If there are no matched entries, then nothing matches.
+ if (len === 0)
+ return cb()
+
+ // if this is the last remaining pattern bit, then no need for
+ // an additional stat *unless* the user has specified mark or
+ // stat explicitly. We know they exist, since readdir returned
+ // them.
+
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+
+ for (var i = 0; i < len; i ++) {
+ var e = matchedEntries[i];
+ if (prefix) {
+ if (prefix !== '/')
+ e = prefix + '/' + e;
+ else
+ e = prefix + e;
+ }
+
+ if (e.charAt(0) === '/' && !this.nomount) {
+ e = path.join(this.root, e);
+ }
+ this._emitMatch(index, e);
+ }
+ // This was the last one, and no stats were needed
+ return cb()
+ }
+
+ // now test all matched entries as stand-ins for that part
+ // of the pattern.
+ remain.shift();
+ for (var i = 0; i < len; i ++) {
+ var e = matchedEntries[i];
+ var newPattern;
+ if (prefix) {
+ if (prefix !== '/')
+ e = prefix + '/' + e;
+ else
+ e = prefix + e;
+ }
+ this._process([e].concat(remain), index, inGlobStar, cb);
+ }
+ cb();
+};
+
+Glob.prototype._emitMatch = function (index, e) {
+ if (this.aborted)
+ return
+
+ if (isIgnored(this, e))
+ return
+
+ if (this.paused) {
+ this._emitQueue.push([index, e]);
+ return
+ }
+
+ var abs = pathIsAbsolute(e) ? e : this._makeAbs(e);
+
+ if (this.mark)
+ e = this._mark(e);
+
+ if (this.absolute)
+ e = abs;
+
+ if (this.matches[index][e])
+ return
+
+ if (this.nodir) {
+ var c = this.cache[abs];
+ if (c === 'DIR' || Array.isArray(c))
+ return
+ }
+
+ this.matches[index][e] = true;
+
+ var st = this.statCache[abs];
+ if (st)
+ this.emit('stat', e, st);
+
+ this.emit('match', e);
+};
+
+Glob.prototype._readdirInGlobStar = function (abs, cb) {
+ if (this.aborted)
+ return
+
+ // follow all symlinked directories forever
+ // just proceed as if this is a non-globstar situation
+ if (this.follow)
+ return this._readdir(abs, false, cb)
+
+ var lstatkey = 'lstat\0' + abs;
+ var self = this;
+ var lstatcb = inflight_1(lstatkey, lstatcb_);
+
+ if (lstatcb)
+ fs.lstat(abs, lstatcb);
+
+ function lstatcb_ (er, lstat) {
+ if (er && er.code === 'ENOENT')
+ return cb()
+
+ var isSym = lstat && lstat.isSymbolicLink();
+ self.symlinks[abs] = isSym;
+
+ // If it's not a symlink or a dir, then it's definitely a regular file.
+ // don't bother doing a readdir in that case.
+ if (!isSym && lstat && !lstat.isDirectory()) {
+ self.cache[abs] = 'FILE';
+ cb();
+ } else
+ self._readdir(abs, false, cb);
+ }
+};
+
+Glob.prototype._readdir = function (abs, inGlobStar, cb) {
+ if (this.aborted)
+ return
+
+ cb = inflight_1('readdir\0'+abs+'\0'+inGlobStar, cb);
+ if (!cb)
+ return
+
+ //console.error('RD %j %j', +inGlobStar, abs)
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs, cb)
+
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (!c || c === 'FILE')
+ return cb()
+
+ if (Array.isArray(c))
+ return cb(null, c)
+ }
+
+ var self = this;
+ fs.readdir(abs, readdirCb(this, abs, cb));
+};
+
+function readdirCb (self, abs, cb) {
+ return function (er, entries) {
+ if (er)
+ self._readdirError(abs, er, cb);
+ else
+ self._readdirEntries(abs, entries, cb);
+ }
+}
+
+Glob.prototype._readdirEntries = function (abs, entries, cb) {
+ if (this.aborted)
+ return
+
+ // if we haven't asked to stat everything, then just
+ // assume that everything in there exists, so we can avoid
+ // having to stat it a second time.
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i ++) {
+ var e = entries[i];
+ if (abs === '/')
+ e = abs + e;
+ else
+ e = abs + '/' + e;
+ this.cache[e] = true;
+ }
+ }
+
+ this.cache[abs] = entries;
+ return cb(null, entries)
+};
+
+Glob.prototype._readdirError = function (f, er, cb) {
+ if (this.aborted)
+ return
+
+ // handle errors, and cache the information
+ switch (er.code) {
+ case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
+ case 'ENOTDIR': // totally normal. means it *does* exist.
+ var abs = this._makeAbs(f);
+ this.cache[abs] = 'FILE';
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + ' invalid cwd ' + this.cwd);
+ error.path = this.cwd;
+ error.code = er.code;
+ this.emit('error', error);
+ this.abort();
+ }
+ break
+
+ case 'ENOENT': // not terribly unusual
+ case 'ELOOP':
+ case 'ENAMETOOLONG':
+ case 'UNKNOWN':
+ this.cache[this._makeAbs(f)] = false;
+ break
+
+ default: // some unusual error. Treat as failure.
+ this.cache[this._makeAbs(f)] = false;
+ if (this.strict) {
+ this.emit('error', er);
+ // If the error is handled, then we abort
+ // if not, we threw out of here
+ this.abort();
+ }
+ if (!this.silent)
+ console.error('glob error', er);
+ break
+ }
+
+ return cb()
+};
+
+Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self = this;
+ this._readdir(abs, inGlobStar, function (er, entries) {
+ self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+ });
+};
+
+
+Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+ //console.error('pgs2', prefix, remain[0], entries)
+
+ // no entries means not a dir, so it can never have matches
+ // foo.txt/** doesn't match foo.txt
+ if (!entries)
+ return cb()
+
+ // test without the globstar, and with every child both below
+ // and replacing the globstar.
+ var remainWithoutGlobStar = remain.slice(1);
+ var gspref = prefix ? [ prefix ] : [];
+ var noGlobStar = gspref.concat(remainWithoutGlobStar);
+
+ // the noGlobStar pattern exits the inGlobStar state
+ this._process(noGlobStar, index, false, cb);
+
+ var isSym = this.symlinks[abs];
+ var len = entries.length;
+
+ // If it's a symlink, and we're in a globstar, then stop
+ if (isSym && inGlobStar)
+ return cb()
+
+ for (var i = 0; i < len; i++) {
+ var e = entries[i];
+ if (e.charAt(0) === '.' && !this.dot)
+ continue
+
+ // these two cases enter the inGlobStar state
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+ this._process(instead, index, true, cb);
+
+ var below = gspref.concat(entries[i], remain);
+ this._process(below, index, true, cb);
+ }
+
+ cb();
+};
+
+Glob.prototype._processSimple = function (prefix, index, cb) {
+ // XXX review this. Shouldn't it be doing the mounting etc
+ // before doing stat? kinda weird?
+ var self = this;
+ this._stat(prefix, function (er, exists) {
+ self._processSimple2(prefix, index, er, exists, cb);
+ });
+};
+Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
+
+ //console.error('ps2', prefix, exists)
+
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+
+ // If it doesn't exist, then just mark the lack of results
+ if (!exists)
+ return cb()
+
+ if (prefix && pathIsAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix);
+ if (prefix.charAt(0) === '/') {
+ prefix = path.join(this.root, prefix);
+ } else {
+ prefix = path.resolve(this.root, prefix);
+ if (trail)
+ prefix += '/';
+ }
+ }
+
+ if (process.platform === 'win32')
+ prefix = prefix.replace(/\\/g, '/');
+
+ // Mark this as a match
+ this._emitMatch(index, prefix);
+ cb();
+};
+
+// Returns either 'DIR', 'FILE', or false
+Glob.prototype._stat = function (f, cb) {
+ var abs = this._makeAbs(f);
+ var needDir = f.slice(-1) === '/';
+
+ if (f.length > this.maxLength)
+ return cb()
+
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+
+ if (Array.isArray(c))
+ c = 'DIR';
+
+ // It exists, but maybe not how we need it
+ if (!needDir || c === 'DIR')
+ return cb(null, c)
+
+ if (needDir && c === 'FILE')
+ return cb()
+
+ // otherwise we have to stat, because maybe c=true
+ // if we know it exists, but not what it is.
+ }
+
+ var exists;
+ var stat = this.statCache[abs];
+ if (stat !== undefined) {
+ if (stat === false)
+ return cb(null, stat)
+ else {
+ var type = stat.isDirectory() ? 'DIR' : 'FILE';
+ if (needDir && type === 'FILE')
+ return cb()
+ else
+ return cb(null, type, stat)
+ }
+ }
+
+ var self = this;
+ var statcb = inflight_1('stat\0' + abs, lstatcb_);
+ if (statcb)
+ fs.lstat(abs, statcb);
+
+ function lstatcb_ (er, lstat) {
+ if (lstat && lstat.isSymbolicLink()) {
+ // If it's a symlink, then treat it as the target, unless
+ // the target does not exist, then treat it as a file.
+ return fs.stat(abs, function (er, stat) {
+ if (er)
+ self._stat2(f, abs, null, lstat, cb);
+ else
+ self._stat2(f, abs, er, stat, cb);
+ })
+ } else {
+ self._stat2(f, abs, er, lstat, cb);
+ }
+ }
+};
+
+Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
+ if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+ this.statCache[abs] = false;
+ return cb()
+ }
+
+ var needDir = f.slice(-1) === '/';
+ this.statCache[abs] = stat;
+
+ if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
+ return cb(null, false, stat)
+
+ var c = true;
+ if (stat)
+ c = stat.isDirectory() ? 'DIR' : 'FILE';
+ this.cache[abs] = this.cache[abs] || c;
+
+ if (needDir && c === 'FILE')
+ return cb()
+
+ return cb(null, c, stat)
+};
+
+var pify_1 = createCommonjsModule(function (module) {
+'use strict';
+
+var processFn = function (fn, P, opts) {
+ return function () {
+ var that = this;
+ var args = new Array(arguments.length);
+
+ for (var i = 0; i < arguments.length; i++) {
+ args[i] = arguments[i];
+ }
+
+ return new P(function (resolve, reject) {
+ args.push(function (err, result) {
+ if (err) {
+ reject(err);
+ } else if (opts.multiArgs) {
+ var results = new Array(arguments.length - 1);
+
+ for (var i = 1; i < arguments.length; i++) {
+ results[i - 1] = arguments[i];
+ }
+
+ resolve(results);
+ } else {
+ resolve(result);
+ }
+ });
+
+ fn.apply(that, args);
+ });
+ };
+};
+
+var pify = module.exports = function (obj, P, opts) {
+ if (typeof P !== 'function') {
+ opts = P;
+ P = Promise;
+ }
+
+ opts = opts || {};
+ opts.exclude = opts.exclude || [/.+Sync$/];
+
+ var filter = function (key) {
+ var match = function (pattern) {
+ return typeof pattern === 'string' ? key === pattern : pattern.test(key);
+ };
+
+ return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
+ };
+
+ var ret = typeof obj === 'function' ? function () {
+ if (opts.excludeMain) {
+ return obj.apply(this, arguments);
+ }
+
+ return processFn(obj, P, opts).apply(this, arguments);
+ } : {};
+
+ return Object.keys(obj).reduce(function (ret, key) {
+ var x = obj[key];
+
+ ret[key] = typeof x === 'function' && filter(key) ? processFn(x, P, opts) : x;
+
+ return ret;
+ }, ret);
+};
+
+pify.all = pify;
+});
+
+var globP = pify_1(glob_1, pinkiePromise).bind(glob_1);
+
+function isNegative(pattern) {
+ return pattern[0] === '!';
+}
+
+function isString(value) {
+ return typeof value === 'string';
+}
+
+function assertPatternsInput(patterns) {
+ if (!patterns.every(isString)) {
+ throw new TypeError('patterns must be a string or an array of strings');
+ }
+}
+
+function generateGlobTasks(patterns, opts) {
+ patterns = [].concat(patterns);
+ assertPatternsInput(patterns);
+
+ var globTasks = [];
+
+ opts = objectAssign({
+ cache: Object.create(null),
+ statCache: Object.create(null),
+ realpathCache: Object.create(null),
+ symlinks: Object.create(null),
+ ignore: []
+ }, opts);
+
+ patterns.forEach(function (pattern, i) {
+ if (isNegative(pattern)) {
+ return;
+ }
+
+ var ignore = patterns.slice(i).filter(isNegative).map(function (pattern) {
+ return pattern.slice(1);
+ });
+
+ globTasks.push({
+ pattern: pattern,
+ opts: objectAssign({}, opts, {
+ ignore: opts.ignore.concat(ignore)
+ })
+ });
+ });
+
+ return globTasks;
+}
+
+var globby = function (patterns, opts) {
+ var globTasks;
+
+ try {
+ globTasks = generateGlobTasks(patterns, opts);
+ } catch (err) {
+ return pinkiePromise.reject(err);
+ }
+
+ return pinkiePromise.all(globTasks.map(function (task) {
+ return globP(task.pattern, task.opts);
+ })).then(function (paths) {
+ return arrayUnion.apply(null, paths);
+ });
+};
+
+var sync$3 = function (patterns, opts) {
+ var globTasks = generateGlobTasks(patterns, opts);
+
+ return globTasks.reduce(function (matches, task) {
+ return arrayUnion(matches, glob_1.sync(task.pattern, task.opts));
+ }, []);
+};
+
+var generateGlobTasks_1 = generateGlobTasks;
+
+var hasMagic = function (patterns, opts) {
+ return [].concat(patterns).some(function (pattern) {
+ return glob_1.hasMagic(pattern, opts);
+ });
+};
+
+globby.sync = sync$3;
+globby.generateGlobTasks = generateGlobTasks_1;
+globby.hasMagic = hasMagic;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var ignore = function () {
+ return new IgnoreBase();
+};
+
+// A simple implementation of make-array
+function make_array(subject) {
+ return Array.isArray(subject) ? subject : [subject];
+}
+
+var REGEX_BLANK_LINE = /^\s+$/;
+var REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\\!/;
+var REGEX_LEADING_EXCAPED_HASH = /^\\#/;
+var SLASH = '/';
+var KEY_IGNORE = typeof Symbol !== 'undefined' ? Symbol.for('node-ignore')
+/* istanbul ignore next */
+: 'node-ignore';
+
+var IgnoreBase = function () {
+ function IgnoreBase() {
+ _classCallCheck(this, IgnoreBase);
+
+ this._rules = [];
+ this[KEY_IGNORE] = true;
+ this._initCache();
+ }
+
+ _createClass(IgnoreBase, [{
+ key: '_initCache',
+ value: function _initCache() {
+ this._cache = {};
+ }
+
+ // @param {Array.|string|Ignore} pattern
+
+ }, {
+ key: 'add',
+ value: function add(pattern) {
+ this._added = false;
+
+ if (typeof pattern === 'string') {
+ pattern = pattern.split(/\r?\n/g);
+ }
+
+ make_array(pattern).forEach(this._addPattern, this);
+
+ // Some rules have just added to the ignore,
+ // making the behavior changed.
+ if (this._added) {
+ this._initCache();
+ }
+
+ return this;
+ }
+
+ // legacy
+
+ }, {
+ key: 'addPattern',
+ value: function addPattern(pattern) {
+ return this.add(pattern);
+ }
+ }, {
+ key: '_addPattern',
+ value: function _addPattern(pattern) {
+ // #32
+ if (pattern && pattern[KEY_IGNORE]) {
+ this._rules = this._rules.concat(pattern._rules);
+ this._added = true;
+ return;
+ }
+
+ if (this._checkPattern(pattern)) {
+ var rule = this._createRule(pattern);
+ this._added = true;
+ this._rules.push(rule);
+ }
+ }
+ }, {
+ key: '_checkPattern',
+ value: function _checkPattern(pattern) {
+ // > A blank line matches no files, so it can serve as a separator for readability.
+ return pattern && typeof pattern === 'string' && !REGEX_BLANK_LINE.test(pattern)
+
+ // > A line starting with # serves as a comment.
+ && pattern.indexOf('#') !== 0;
+ }
+ }, {
+ key: 'filter',
+ value: function filter(paths) {
+ var _this = this;
+
+ return make_array(paths).filter(function (path$$1) {
+ return _this._filter(path$$1);
+ });
+ }
+ }, {
+ key: 'createFilter',
+ value: function createFilter() {
+ var _this2 = this;
+
+ return function (path$$1) {
+ return _this2._filter(path$$1);
+ };
+ }
+ }, {
+ key: 'ignores',
+ value: function ignores(path$$1) {
+ return !this._filter(path$$1);
+ }
+ }, {
+ key: '_createRule',
+ value: function _createRule(pattern) {
+ var origin = pattern;
+ var negative = false;
+
+ // > An optional prefix "!" which negates the pattern;
+ if (pattern.indexOf('!') === 0) {
+ negative = true;
+ pattern = pattern.substr(1);
+ }
+
+ pattern = pattern
+ // > Put a backslash ("\") in front of the first "!" for patterns that begin with a literal "!", for example, `"\!important!.txt"`.
+ .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!')
+ // > Put a backslash ("\") in front of the first hash for patterns that begin with a hash.
+ .replace(REGEX_LEADING_EXCAPED_HASH, '#');
+
+ var regex = make_regex(pattern, negative);
+
+ return {
+ origin: origin,
+ pattern: pattern,
+ negative: negative,
+ regex: regex
+ };
+ }
+
+ // @returns `Boolean` true if the `path` is NOT ignored
+
+ }, {
+ key: '_filter',
+ value: function _filter(path$$1, slices) {
+ if (!path$$1) {
+ return false;
+ }
+
+ if (path$$1 in this._cache) {
+ return this._cache[path$$1];
+ }
+
+ if (!slices) {
+ // path/to/a.js
+ // ['path', 'to', 'a.js']
+ slices = path$$1.split(SLASH);
+ }
+
+ slices.pop();
+
+ return this._cache[path$$1] = slices.length
+ // > It is not possible to re-include a file if a parent directory of that file is excluded.
+ // If the path contains a parent directory, check the parent first
+ ? this._filter(slices.join(SLASH) + SLASH, slices) && this._test(path$$1)
+
+ // Or only test the path
+ : this._test(path$$1);
+ }
+
+ // @returns {Boolean} true if a file is NOT ignored
+
+ }, {
+ key: '_test',
+ value: function _test(path$$1) {
+ // Explicitly define variable type by setting matched to `0`
+ var matched = 0;
+
+ this._rules.forEach(function (rule) {
+ // if matched = true, then we only test negative rules
+ // if matched = false, then we test non-negative rules
+ if (!(matched ^ rule.negative)) {
+ matched = rule.negative ^ rule.regex.test(path$$1);
+ }
+ });
+
+ return !matched;
+ }
+ }]);
+
+ return IgnoreBase;
+}();
+
+// > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// > (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+// you could use option `mark: true` with `glob`
+
+// '`foo/`' should not continue with the '`..`'
+
+
+var DEFAULT_REPLACER_PREFIX = [
+
+// > Trailing spaces are ignored unless they are quoted with backslash ("\")
+[
+// (a\ ) -> (a )
+// (a ) -> (a)
+// (a \ ) -> (a )
+/\\?\s+$/, function (match) {
+ return match.indexOf('\\') === 0 ? ' ' : '';
+}],
+
+// replace (\ ) with ' '
+[/\\\s/g, function () {
+ return ' ';
+}],
+
+// Escape metacharacters
+// which is written down by users but means special for regular expressions.
+
+// > There are 12 characters with special meanings:
+// > - the backslash \,
+// > - the caret ^,
+// > - the dollar sign $,
+// > - the period or dot .,
+// > - the vertical bar or pipe symbol |,
+// > - the question mark ?,
+// > - the asterisk or star *,
+// > - the plus sign +,
+// > - the opening parenthesis (,
+// > - the closing parenthesis ),
+// > - and the opening square bracket [,
+// > - the opening curly brace {,
+// > These special characters are often called "metacharacters".
+[/[\\\^$.|?*+()\[{]/g, function (match) {
+ return '\\' + match;
+}],
+
+// leading slash
+[
+
+// > A leading slash matches the beginning of the pathname.
+// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+// A leading slash matches the beginning of the pathname
+/^\//, function () {
+ return '^';
+}],
+
+// replace special metacharacter slash after the leading slash
+[/\//g, function () {
+ return '\\/';
+}], [
+// > A leading "**" followed by a slash means match in all directories.
+// > For example, "**/foo" matches file or directory "foo" anywhere,
+// > the same as pattern "foo".
+// > "**/foo/bar" matches file or directory "bar" anywhere that is directly under directory "foo".
+// Notice that the '*'s have been replaced as '\\*'
+/^\^*\\\*\\\*\\\//,
+
+// '**/foo' <-> 'foo'
+function () {
+ return '^(?:.*\\/)?';
+}]];
+
+var DEFAULT_REPLACER_SUFFIX = [
+// starting
+[
+// there will be no leading '/' (which has been replaced by section "leading slash")
+// If starts with '**', adding a '^' to the regular expression also works
+/^(?=[^\^])/, function () {
+ return !/\/(?!$)/.test(this)
+ // > If the pattern does not contain a slash /, Git treats it as a shell glob pattern
+ // Actually, if there is only a trailing slash, git also treats it as a shell glob pattern
+ ? '(?:^|\\/)'
+
+ // > Otherwise, Git treats the pattern as a shell glob suitable for consumption by fnmatch(3)
+ : '^';
+}],
+
+// two globstars
+[
+// Use lookahead assertions so that we could match more than one `'/**'`
+/\\\/\\\*\\\*(?=\\\/|$)/g,
+
+// Zero, one or several directories
+// should not use '*', or it will be replaced by the next replacer
+
+// Check if it is not the last `'/**'`
+function (match, index, str) {
+ return index + 6 < str.length
+
+ // case: /**/
+ // > A slash followed by two consecutive asterisks then a slash matches zero or more directories.
+ // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+ // '/**/'
+ ? '(?:\\/[^\\/]+)*'
+
+ // case: /**
+ // > A trailing `"/**"` matches everything inside.
+
+ // #21: everything inside but it should not include the current folder
+ : '\\/.+';
+}],
+
+// intermediate wildcards
+[
+// Never replace escaped '*'
+// ignore rule '\*' will match the path '*'
+
+// 'abc.*/' -> go
+// 'abc.*' -> skip this rule
+/(^|[^\\]+)\\\*(?=.+)/g,
+
+// '*.js' matches '.js'
+// '*.js' doesn't match 'abc'
+function (match, p1) {
+ return p1 + '[^\\/]*';
+}],
+
+// trailing wildcard
+[/(\^|\\\/)?\\\*$/, function (match, p1) {
+ return (p1
+ // '\^':
+ // '/*' does not match ''
+ // '/*' does not match everything
+
+ // '\\\/':
+ // 'abc/*' does not match 'abc/'
+ ? p1 + '[^/]+'
+
+ // 'a*' matches 'a'
+ // 'a*' matches 'aa'
+ : '[^/]*') + '(?=$|\\/$)';
+}], [
+// unescape
+/\\\\\\/g, function () {
+ return '\\';
+}]];
+
+var POSITIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [
+
+// 'f'
+// matches
+// - /f(end)
+// - /f/
+// - (start)f(end)
+// - (start)f/
+// doesn't match
+// - oof
+// - foo
+// pseudo:
+// -> (^|/)f(/|$)
+
+// ending
+[
+// 'js' will not match 'js.'
+// 'ab' will not match 'abc'
+/(?:[^*\/])$/,
+
+// 'js*' will not match 'a.js'
+// 'js/' will not match 'a.js'
+// 'js' will match 'a.js' and 'a.js/'
+function (match) {
+ return match + '(?=$|\\/)';
+}]], DEFAULT_REPLACER_SUFFIX);
+
+var NEGATIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [
+
+// #24
+// The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)
+// A negative pattern without a trailing wildcard should not
+// re-include the things inside that directory.
+
+// eg:
+// ['node_modules/*', '!node_modules']
+// should ignore `node_modules/a.js`
+[/(?:[^*\/])$/, function (match) {
+ return match + '(?=$|\\/$)';
+}]], DEFAULT_REPLACER_SUFFIX);
+
+// A simple cache, because an ignore rule only has only one certain meaning
+var cache = {};
+
+// @param {pattern}
+function make_regex(pattern, negative) {
+ var r = cache[pattern];
+ if (r) {
+ return r;
+ }
+
+ var replacers = negative ? NEGATIVE_REPLACERS : POSITIVE_REPLACERS;
+
+ var source = replacers.reduce(function (prev, current) {
+ return prev.replace(current[0], current[1].bind(pattern));
+ }, pattern);
+
+ return cache[pattern] = new RegExp(source, 'i');
+}
+
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore if */
+if (
+// Detect `process` so that it can run in browsers.
+typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) {
+
+ var filter$1 = IgnoreBase.prototype._filter;
+ var make_posix = function make_posix(str) {
+ return (/^\\\\\?\\/.test(str) || /[^\x00-\x80]+/.test(str) ? str : str.replace(/\\/g, '/')
+ );
+ };
+
+ IgnoreBase.prototype._filter = function (path$$1, slices) {
+ path$$1 = make_posix(path$$1);
+ return filter$1.call(this, path$$1, slices);
+ };
+}
+
+var ansiStyles$3 = createCommonjsModule(function (module) {
+'use strict';
+
+
+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],
+
+ // Bright color
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 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],
+
+ // Bright color
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 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] = {
+ open: `\u001B[${style[0]}m`,
+ close: `\u001B[${style[1]}m`
+ };
+
+ group[styleName] = styles[styleName];
+ });
+
+ 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
+});
+});
+
+var hasFlag$3 = function (flag, argv) {
+ argv = argv || process.argv;
+
+ var terminatorPos = argv.indexOf('--');
+ var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+ var pos = argv.indexOf(prefix + flag);
+
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};
+
+var supportsColor$3 = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+const env = process.env;
+
+const support = level => {
+ if (level === 0) {
+ return false;
+ }
+
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+};
+
+let supportLevel = (() => {
+ if (hasFlag$3('no-color') ||
+ hasFlag$3('no-colors') ||
+ hasFlag$3('color=false')) {
+ return 0;
+ }
+
+ if (hasFlag$3('color=16m') ||
+ hasFlag$3('color=full') ||
+ hasFlag$3('color=truecolor')) {
+ return 3;
+ }
+
+ if (hasFlag$3('color=256')) {
+ return 2;
+ }
+
+ if (hasFlag$3('color') ||
+ hasFlag$3('colors') ||
+ hasFlag$3('color=true') ||
+ hasFlag$3('color=always')) {
+ return 1;
+ }
+
+ if (process.stdout && !process.stdout.isTTY) {
+ return 0;
+ }
+
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+ // release that supports 256 colors.
+ const osRelease = os.release().split('.');
+ if (
+ Number(process.version.split('.')[0]) >= 8 &&
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return 2;
+ }
+
+ return 1;
+ }
+
+ if ('CI' in env) {
+ if ('TRAVIS' in env || env.CI === 'Travis' || 'CIRCLECI' in env) {
+ return 1;
+ }
+
+ return 0;
+ }
+
+ if ('TEAMCITY_VERSION' in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
+
+ if ('TERM_PROGRAM' in env) {
+ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Hyper':
+ return 3;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
+
+ if (/^(screen|xterm)-256(?:color)?/.test(env.TERM)) {
+ return 2;
+ }
+
+ if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
+
+ if ('COLORTERM' in env) {
+ return 1;
+ }
+
+ if (env.TERM === 'dumb') {
+ return 0;
+ }
+
+ return 0;
+})();
+
+if ('FORCE_COLOR' in env) {
+ supportLevel = parseInt(env.FORCE_COLOR, 10) === 0 ? 0 : (supportLevel || 1);
+}
+
+module.exports = process && support(supportLevel);
+});
+
+var templates$2 = createCommonjsModule(function (module) {
+'use strict';
+const TEMPLATE_REGEX = /(?:\\(u[a-f0-9]{4}|x[a-f0-9]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[0-9a-f]{4}|x[0-9a-f]{2}|.)|([^\\])/gi;
+
+const ESCAPES = {
+ n: '\n',
+ r: '\r',
+ t: '\t',
+ b: '\b',
+ f: '\f',
+ v: '\v',
+ 0: '\0',
+ '\\': '\\',
+ e: '\u001b',
+ a: '\u0007'
+};
+
+function unescape(c) {
+ if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
+ }
+
+ return ESCAPES[c] || c;
+}
+
+function parseArguments(name, args) {
+ const results = [];
+ const chunks = args.trim().split(/\s*,\s*/g);
+ let matches;
+
+ for (const chunk of chunks) {
+ if (!isNaN(chunk)) {
+ results.push(Number(chunk));
+ } else if ((matches = chunk.match(STRING_REGEX))) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
+
+ return results;
+}
+
+function parseStyle(style) {
+ STYLE_REGEX.lastIndex = 0;
+
+ const results = [];
+ let matches;
+
+ while ((matches = STYLE_REGEX.exec(style)) !== null) {
+ const name = matches[1];
+
+ if (matches[2]) {
+ const args = parseArguments(name, matches[2]);
+ results.push([name].concat(args));
+ } else {
+ results.push([name]);
+ }
+ }
+
+ return results;
+}
+
+function buildStyle(chalk, styles) {
+ const enabled = {};
+
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
+
+ let current = chalk;
+ for (const styleName of Object.keys(enabled)) {
+ if (Array.isArray(enabled[styleName])) {
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
+
+ if (enabled[styleName].length > 0) {
+ current = current[styleName].apply(current, enabled[styleName]);
+ } else {
+ current = current[styleName];
+ }
+ }
+ }
+
+ return current;
+}
+
+module.exports = (chalk, tmp) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
+
+ // eslint-disable-next-line max-params
+ tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+ if (escapeChar) {
+ chunk.push(unescape(escapeChar));
+ } else if (style) {
+ const str = chunk.join('');
+ chunk = [];
+ chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+ styles.push({inverse, styles: parseStyle(style)});
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error('Found extraneous } in Chalk template literal');
+ }
+
+ chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(chr);
+ }
+ });
+
+ chunks.push(chunk.join(''));
+
+ if (styles.length > 0) {
+ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+ throw new Error(errMsg);
+ }
+
+ return chunks.join('');
+};
+});
+
+const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+
+// `color-convert` models to exclude from the Chalk API due to conflicts and such
+const skipModels = new Set(['gray']);
+
+const styles = Object.create(null);
+
+function applyOptions(obj, options) {
+ options = options || {};
+
+ // Detect level if not set manually
+ const scLevel = supportsColor$3 ? supportsColor$3.level : 0;
+ obj.level = options.level === undefined ? scLevel : options.level;
+ obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
+}
+
+function Chalk(options) {
+ // We check for this.template here since calling `chalk.constructor()`
+ // by itself will have a `this` of a previously constructed chalk object
+ if (!this || !(this instanceof Chalk) || this.template) {
+ const chalk = {};
+ applyOptions(chalk, options);
+
+ chalk.template = function () {
+ const args = [].slice.call(arguments);
+ return chalkTag.apply(null, [chalk.template].concat(args));
+ };
+
+ Object.setPrototypeOf(chalk, Chalk.prototype);
+ Object.setPrototypeOf(chalk.template, chalk);
+
+ chalk.template.constructor = Chalk;
+
+ return chalk.template;
+ }
+
+ applyOptions(this, options);
+}
+
+// Use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+ ansiStyles$3.blue.open = '\u001B[94m';
+}
+
+for (const key of Object.keys(ansiStyles$3)) {
+ ansiStyles$3[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles$3[key].close), 'g');
+
+ styles[key] = {
+ get() {
+ const codes = ansiStyles$3[key];
+ return build$1.call(this, this._styles ? this._styles.concat(codes) : [codes], key);
+ }
+ };
+}
+
+ansiStyles$3.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles$3.color.close), 'g');
+for (const model of Object.keys(ansiStyles$3.color.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
+
+ styles[model] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles$3.color[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles$3.color.close,
+ closeRe: ansiStyles$3.color.closeRe
+ };
+ return build$1.call(this, this._styles ? this._styles.concat(codes) : [codes], model);
+ };
+ }
+ };
+}
+
+ansiStyles$3.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles$3.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles$3.bgColor.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
+
+ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles$3.bgColor[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles$3.bgColor.close,
+ closeRe: ansiStyles$3.bgColor.closeRe
+ };
+ return build$1.call(this, this._styles ? this._styles.concat(codes) : [codes], model);
+ };
+ }
+ };
+}
+
+const proto = Object.defineProperties(() => {}, styles);
+
+function build$1(_styles, key) {
+ const builder = function () {
+ return applyStyle.apply(builder, arguments);
+ };
+
+ builder._styles = _styles;
+
+ const self = this;
+
+ Object.defineProperty(builder, 'level', {
+ enumerable: true,
+ get() {
+ return self.level;
+ },
+ set(level) {
+ self.level = level;
+ }
+ });
+
+ Object.defineProperty(builder, 'enabled', {
+ enumerable: true,
+ get() {
+ return self.enabled;
+ },
+ set(enabled) {
+ self.enabled = enabled;
+ }
+ });
+
+ // See below for fix regarding invisible grey/dim combination on Windows
+ builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+
+ // `__proto__` is used because we must return a function, but there is
+ // no way to create a function with a different prototype
+ builder.__proto__ = proto; // eslint-disable-line no-proto
+
+ return builder;
+}
+
+function applyStyle() {
+ // Support varags, but simply cast to string in case there's only one arg
+ const args = arguments;
+ const argsLen = args.length;
+ let str = String(arguments[0]);
+
+ if (argsLen === 0) {
+ return '';
+ }
+
+ if (argsLen > 1) {
+ // Don't slice `arguments`, it prevents V8 optimizations
+ for (let a = 1; a < argsLen; a++) {
+ str += ' ' + args[a];
+ }
+ }
+
+ if (!this.enabled || this.level <= 0 || !str) {
+ return str;
+ }
+
+ // 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.
+ const originalDim = ansiStyles$3.dim.open;
+ if (isSimpleWindowsTerm && this.hasGrey) {
+ ansiStyles$3.dim.open = '';
+ }
+
+ for (const code of this._styles.slice().reverse()) {
+ // 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;
+
+ // Close the styling before a linebreak and reopen
+ // after next line to fix a bleed issue on macOS
+ // https://github.com/chalk/chalk/pull/92
+ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+ }
+
+ // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
+ ansiStyles$3.dim.open = originalDim;
+
+ return str;
+}
+
+function chalkTag(chalk, strings) {
+ if (!Array.isArray(strings)) {
+ // If chalk() was called by itself or with a string,
+ // return the string itself as a string.
+ return [].slice.call(arguments, 1).join(' ');
+ }
+
+ const args = [].slice.call(arguments, 2);
+ const parts = [strings.raw[0]];
+
+ for (let i = 1; i < strings.length; i++) {
+ parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+ parts.push(String(strings.raw[i]));
+ }
+
+ return templates$2(chalk, parts.join(''));
+}
+
+Object.defineProperties(Chalk.prototype, styles);
+
+var chalk$2 = Chalk(); // eslint-disable-line new-cap
+var supportsColor_1 = supportsColor$3;
+
+chalk$2.supportsColor = supportsColor_1;
+
+var minimist = function (args, opts) {
+ if (!opts) opts = {};
+
+ var flags = { bools : {}, strings : {}, unknownFn: null };
+
+ if (typeof opts['unknown'] === 'function') {
+ flags.unknownFn = opts['unknown'];
+ }
+
+ if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+ flags.allBools = true;
+ } else {
+ [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+ flags.bools[key] = true;
+ });
+ }
+
+ var aliases = {};
+ Object.keys(opts.alias || {}).forEach(function (key) {
+ aliases[key] = [].concat(opts.alias[key]);
+ aliases[key].forEach(function (x) {
+ aliases[x] = [key].concat(aliases[key].filter(function (y) {
+ return x !== y;
+ }));
+ });
+ });
+
+ [].concat(opts.string).filter(Boolean).forEach(function (key) {
+ flags.strings[key] = true;
+ if (aliases[key]) {
+ flags.strings[aliases[key]] = true;
+ }
+ });
+
+ var defaults = opts['default'] || {};
+
+ var argv = { _ : [] };
+ Object.keys(flags.bools).forEach(function (key) {
+ setArg(key, defaults[key] === undefined ? false : defaults[key]);
+ });
+
+ var notFlags = [];
+
+ if (args.indexOf('--') !== -1) {
+ notFlags = args.slice(args.indexOf('--')+1);
+ args = args.slice(0, args.indexOf('--'));
+ }
+
+ function argDefined(key, arg) {
+ return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+ flags.strings[key] || flags.bools[key] || aliases[key];
+ }
+
+ function setArg (key, val, arg) {
+ if (arg && flags.unknownFn && !argDefined(key, arg)) {
+ if (flags.unknownFn(arg) === false) return;
+ }
+
+ var value = !flags.strings[key] && isNumber(val)
+ ? Number(val) : val;
+ setKey(argv, key.split('.'), value);
+
+ (aliases[key] || []).forEach(function (x) {
+ setKey(argv, x.split('.'), value);
+ });
+ }
+
+ function setKey (obj, keys, value) {
+ var o = obj;
+ keys.slice(0,-1).forEach(function (key) {
+ if (o[key] === undefined) o[key] = {};
+ o = o[key];
+ });
+
+ var key = keys[keys.length - 1];
+ if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+ o[key] = value;
+ }
+ else if (Array.isArray(o[key])) {
+ o[key].push(value);
+ }
+ else {
+ o[key] = [ o[key], value ];
+ }
+ }
+
+ function aliasIsBoolean(key) {
+ return aliases[key].some(function (x) {
+ return flags.bools[x];
+ });
+ }
+
+ for (var i = 0; i < args.length; i++) {
+ var arg = args[i];
+
+ if (/^--.+=/.test(arg)) {
+ // Using [\s\S] instead of . because js doesn't support the
+ // 'dotall' regex modifier. See:
+ // http://stackoverflow.com/a/1068308/13216
+ var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+ var key = m[1];
+ var value = m[2];
+ if (flags.bools[key]) {
+ value = value !== 'false';
+ }
+ setArg(key, value, arg);
+ }
+ else if (/^--no-.+/.test(arg)) {
+ var key = arg.match(/^--no-(.+)/)[1];
+ setArg(key, false, arg);
+ }
+ else if (/^--.+/.test(arg)) {
+ var key = arg.match(/^--(.+)/)[1];
+ var next = args[i + 1];
+ if (next !== undefined && !/^-/.test(next)
+ && !flags.bools[key]
+ && !flags.allBools
+ && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+ setArg(key, next, arg);
+ i++;
+ }
+ else if (/^(true|false)$/.test(next)) {
+ setArg(key, next === 'true', arg);
+ i++;
+ }
+ else {
+ setArg(key, flags.strings[key] ? '' : true, arg);
+ }
+ }
+ else if (/^-[^-]+/.test(arg)) {
+ var letters = arg.slice(1,-1).split('');
+
+ var broken = false;
+ for (var j = 0; j < letters.length; j++) {
+ var next = arg.slice(j+2);
+
+ if (next === '-') {
+ setArg(letters[j], next, arg);
+ continue;
+ }
+
+ if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+ setArg(letters[j], next.split('=')[1], arg);
+ broken = true;
+ break;
+ }
+
+ if (/[A-Za-z]/.test(letters[j])
+ && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+ setArg(letters[j], next, arg);
+ broken = true;
+ break;
+ }
+
+ if (letters[j+1] && letters[j+1].match(/\W/)) {
+ setArg(letters[j], arg.slice(j+2), arg);
+ broken = true;
+ break;
+ }
+ else {
+ setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+ }
+ }
+
+ var key = arg.slice(-1)[0];
+ if (!broken && key !== '-') {
+ if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+ && !flags.bools[key]
+ && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+ setArg(key, args[i+1], arg);
+ i++;
+ }
+ else if (args[i+1] && /true|false/.test(args[i+1])) {
+ setArg(key, args[i+1] === 'true', arg);
+ i++;
+ }
+ else {
+ setArg(key, flags.strings[key] ? '' : true, arg);
+ }
+ }
+ }
+ else {
+ if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+ argv._.push(
+ flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+ );
+ }
+ if (opts.stopEarly) {
+ argv._.push.apply(argv._, args.slice(i + 1));
+ break;
+ }
+ }
+ }
+
+ Object.keys(defaults).forEach(function (key) {
+ if (!hasKey(argv, key.split('.'))) {
+ setKey(argv, key.split('.'), defaults[key]);
+
+ (aliases[key] || []).forEach(function (x) {
+ setKey(argv, x.split('.'), defaults[key]);
+ });
+ }
+ });
+
+ if (opts['--']) {
+ argv['--'] = new Array();
+ notFlags.forEach(function(key) {
+ argv['--'].push(key);
+ });
+ }
+ else {
+ notFlags.forEach(function(key) {
+ argv._.push(key);
+ });
+ }
+
+ return argv;
+};
+
+function hasKey (obj, keys) {
+ var o = obj;
+ keys.slice(0,-1).forEach(function (key) {
+ o = (o[key] || {});
+ });
+
+ var key = keys[keys.length - 1];
+ return key in o;
+}
+
+function isNumber (x) {
+ if (typeof x === 'number') return true;
+ if (/^0x[0-9a-f]+$/i.test(x)) return true;
+ return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+const PLACEHOLDER = null;
+
+/**
+ * unspecified boolean flag without default value is parsed as `undefined` instead of `false`
+ */
+var minimist_1 = function(args, options) {
+ const boolean = options.boolean || [];
+ const defaults = options.default || {};
+
+ const booleanWithoutDefault = boolean.filter(key => !(key in defaults));
+ const newDefaults = Object.assign(
+ {},
+ defaults,
+ booleanWithoutDefault.reduce(
+ (reduced, key) => Object.assign(reduced, { [key]: PLACEHOLDER }),
+ {}
+ )
+ );
+
+ const parsed = minimist(
+ args,
+ Object.assign({}, options, { default: newDefaults })
+ );
+
+ return Object.keys(parsed).reduce((reduced, key) => {
+ if (parsed[key] !== PLACEHOLDER) {
+ reduced[key] = parsed[key];
+ }
+ return reduced;
+ }, {});
+};
+
+function cleanAST$1(ast, options) {
+ return JSON.stringify(massageAST(ast, options), null, 2);
+}
+
+function massageAST(ast, options, parent) {
+ if (Array.isArray(ast)) {
+ return ast.map(e => massageAST(e, options, parent)).filter(e => e);
+ }
+
+ if (!ast || typeof ast !== "object") {
+ return ast;
+ }
+
+ const newObj = {};
+ for (const key in ast) {
+ if (typeof ast[key] !== "function") {
+ newObj[key] = massageAST(ast[key], options, ast);
+ }
+ }
+
+ [
+ "loc",
+ "range",
+ "raw",
+ "comments",
+ "leadingComments",
+ "trailingComments",
+ "extra",
+ "start",
+ "end",
+ "tokens",
+ "flags",
+ "raws",
+ "sourceIndex",
+ "id",
+ "source",
+ "before",
+ "after",
+ "trailingComma",
+ "parent",
+ "prev",
+ "position"
+ ].forEach(name => {
+ delete newObj[name];
+ });
+
+ if (options.printer.massageAstNode) {
+ const result = options.printer.massageAstNode(ast, newObj, parent);
+ if (result === null) {
+ return undefined;
+ }
+ if (result) {
+ return result;
+ }
+ }
+
+ return newObj;
+}
+
+var cleanAst = { cleanAST: cleanAST$1, massageAST };
+
+var base = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports['default'] = /*istanbul ignore end*/Diff;
+function Diff() {}
+
+Diff.prototype = { /*istanbul ignore start*/
+ /*istanbul ignore end*/diff: function diff(oldString, newString) {
+ /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+ var callback = options.callback;
+ if (typeof options === 'function') {
+ callback = options;
+ options = {};
+ }
+ this.options = options;
+
+ var self = this;
+
+ function done(value) {
+ if (callback) {
+ setTimeout(function () {
+ callback(undefined, value);
+ }, 0);
+ return true;
+ } else {
+ return value;
+ }
+ }
+
+ // Allow subclasses to massage the input prior to running
+ oldString = this.castInput(oldString);
+ newString = this.castInput(newString);
+
+ oldString = this.removeEmpty(this.tokenize(oldString));
+ newString = this.removeEmpty(this.tokenize(newString));
+
+ var newLen = newString.length,
+ oldLen = oldString.length;
+ var editLength = 1;
+ var maxEditLength = newLen + oldLen;
+ var bestPath = [{ newPos: -1, components: [] }];
+
+ // Seed editLength = 0, i.e. the content starts with the same values
+ var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+ if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
+ // Identity per the equality and tokenizer
+ return done([{ value: this.join(newString), count: newString.length }]);
+ }
+
+ // Main worker method. checks all permutations of a given edit length for acceptance.
+ function execEditLength() {
+ for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
+ var basePath = /*istanbul ignore start*/void 0;
+ var addPath = bestPath[diagonalPath - 1],
+ removePath = bestPath[diagonalPath + 1],
+ _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+ if (addPath) {
+ // No one else is going to attempt to use this value, clear it
+ bestPath[diagonalPath - 1] = undefined;
+ }
+
+ var canAdd = addPath && addPath.newPos + 1 < newLen,
+ canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
+ if (!canAdd && !canRemove) {
+ // If this path is a terminal then prune
+ bestPath[diagonalPath] = undefined;
+ continue;
+ }
+
+ // Select the diagonal that we want to branch from. We select the prior
+ // path whose position in the new string is the farthest from the origin
+ // and does not pass the bounds of the diff graph
+ if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
+ basePath = clonePath(removePath);
+ self.pushComponent(basePath.components, undefined, true);
+ } else {
+ basePath = addPath; // No need to clone, we've pulled it from the list
+ basePath.newPos++;
+ self.pushComponent(basePath.components, true, undefined);
+ }
+
+ _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
+
+ // If we have hit the end of both strings, then we are done
+ if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
+ return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
+ } else {
+ // Otherwise track this path as a potential candidate and continue.
+ bestPath[diagonalPath] = basePath;
+ }
+ }
+
+ editLength++;
+ }
+
+ // Performs the length of edit iteration. Is a bit fugly as this has to support the
+ // sync and async mode which is never fun. Loops over execEditLength until a value
+ // is produced.
+ if (callback) {
+ (function exec() {
+ setTimeout(function () {
+ // This should not happen, but we want to be safe.
+ /* istanbul ignore next */
+ if (editLength > maxEditLength) {
+ return callback();
+ }
+
+ if (!execEditLength()) {
+ exec();
+ }
+ }, 0);
+ })();
+ } else {
+ while (editLength <= maxEditLength) {
+ var ret = execEditLength();
+ if (ret) {
+ return ret;
+ }
+ }
+ }
+ },
+ /*istanbul ignore start*/ /*istanbul ignore end*/pushComponent: function pushComponent(components, added, removed) {
+ var last = components[components.length - 1];
+ if (last && last.added === added && last.removed === removed) {
+ // We need to clone here as the component clone operation is just
+ // as shallow array clone
+ components[components.length - 1] = { count: last.count + 1, added: added, removed: removed };
+ } else {
+ components.push({ count: 1, added: added, removed: removed });
+ }
+ },
+ /*istanbul ignore start*/ /*istanbul ignore end*/extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
+ var newLen = newString.length,
+ oldLen = oldString.length,
+ newPos = basePath.newPos,
+ oldPos = newPos - diagonalPath,
+ commonCount = 0;
+ while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+ newPos++;
+ oldPos++;
+ commonCount++;
+ }
+
+ if (commonCount) {
+ basePath.components.push({ count: commonCount });
+ }
+
+ basePath.newPos = newPos;
+ return oldPos;
+ },
+ /*istanbul ignore start*/ /*istanbul ignore end*/equals: function equals(left, right) {
+ return left === right;
+ },
+ /*istanbul ignore start*/ /*istanbul ignore end*/removeEmpty: function removeEmpty(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ if (array[i]) {
+ ret.push(array[i]);
+ }
+ }
+ return ret;
+ },
+ /*istanbul ignore start*/ /*istanbul ignore end*/castInput: function castInput(value) {
+ return value;
+ },
+ /*istanbul ignore start*/ /*istanbul ignore end*/tokenize: function tokenize(value) {
+ return value.split('');
+ },
+ /*istanbul ignore start*/ /*istanbul ignore end*/join: function join(chars) {
+ return chars.join('');
+ }
+};
+
+function buildValues(diff, components, newString, oldString, useLongestToken) {
+ var componentPos = 0,
+ componentLen = components.length,
+ newPos = 0,
+ oldPos = 0;
+
+ for (; componentPos < componentLen; componentPos++) {
+ var component = components[componentPos];
+ if (!component.removed) {
+ if (!component.added && useLongestToken) {
+ var value = newString.slice(newPos, newPos + component.count);
+ value = value.map(function (value, i) {
+ var oldValue = oldString[oldPos + i];
+ return oldValue.length > value.length ? oldValue : value;
+ });
+
+ component.value = diff.join(value);
+ } else {
+ component.value = diff.join(newString.slice(newPos, newPos + component.count));
+ }
+ newPos += component.count;
+
+ // Common case
+ if (!component.added) {
+ oldPos += component.count;
+ }
+ } else {
+ component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
+ oldPos += component.count;
+
+ // Reverse add and remove so removes are output first to match common convention
+ // The diffing algorithm is tied to add then remove output and this is the simplest
+ // route to get the desired output with minimal overhead.
+ if (componentPos && components[componentPos - 1].added) {
+ var tmp = components[componentPos - 1];
+ components[componentPos - 1] = components[componentPos];
+ components[componentPos] = tmp;
+ }
+ }
+ }
+
+ // Special case handle for when one terminal is ignored. For this case we merge the
+ // terminal into the prior string and drop the change.
+ var lastComponent = components[componentLen - 1];
+ if (componentLen > 1 && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
+ components[componentLen - 2].value += lastComponent.value;
+ components.pop();
+ }
+
+ return components;
+}
+
+function clonePath(path$$1) {
+ return { newPos: path$$1.newPos, components: path$$1.components.slice(0) };
+}
+
+});
+
+unwrapExports(base);
+
+var character = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports.characterDiff = undefined;
+exports. /*istanbul ignore end*/diffChars = diffChars;
+
+
+
+/*istanbul ignore start*/
+var _base2 = _interopRequireDefault(base);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+/*istanbul ignore end*/var characterDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/characterDiff = new /*istanbul ignore start*/_base2['default']();
+function diffChars(oldStr, newStr, callback) {
+ return characterDiff.diff(oldStr, newStr, callback);
+}
+
+});
+
+unwrapExports(character);
+
+var params = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports. /*istanbul ignore end*/generateOptions = generateOptions;
+function generateOptions(options, defaults) {
+ if (typeof options === 'function') {
+ defaults.callback = options;
+ } else if (options) {
+ for (var name in options) {
+ /* istanbul ignore else */
+ if (options.hasOwnProperty(name)) {
+ defaults[name] = options[name];
+ }
+ }
+ }
+ return defaults;
+}
+
+});
+
+unwrapExports(params);
+
+var word$1 = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports.wordDiff = undefined;
+exports. /*istanbul ignore end*/diffWords = diffWords;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = diffWordsWithSpace;
+
+
+
+/*istanbul ignore start*/
+var _base2 = _interopRequireDefault(base);
+
+/*istanbul ignore end*/
+
+
+/*istanbul ignore start*/
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+/*istanbul ignore end*/
+
+// Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode
+//
+// Ranges and exceptions:
+// Latin-1 Supplement, 0080–00FF
+// - U+00D7 × Multiplication sign
+// - U+00F7 ÷ Division sign
+// Latin Extended-A, 0100–017F
+// Latin Extended-B, 0180–024F
+// IPA Extensions, 0250–02AF
+// Spacing Modifier Letters, 02B0–02FF
+// - U+02C7 ˇ ˇ Caron
+// - U+02D8 ˘ ˘ Breve
+// - U+02D9 ˙ ˙ Dot Above
+// - U+02DA ˚ ˚ Ring Above
+// - U+02DB ˛ ˛ Ogonek
+// - U+02DC ˜ ˜ Small Tilde
+// - U+02DD ˝ ˝ Double Acute Accent
+// Latin Extended Additional, 1E00–1EFF
+var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
+
+var reWhitespace = /\S/;
+
+var wordDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/wordDiff = new /*istanbul ignore start*/_base2['default']();
+wordDiff.equals = function (left, right) {
+ return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
+};
+wordDiff.tokenize = function (value) {
+ var tokens = value.split(/(\s+|\b)/);
+
+ // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set.
+ for (var i = 0; i < tokens.length - 1; i++) {
+ // If we have an empty string in the next field and we have only word chars before and after, merge
+ if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
+ tokens[i] += tokens[i + 2];
+ tokens.splice(i + 1, 2);
+ i--;
+ }
+ }
+
+ return tokens;
+};
+
+function diffWords(oldStr, newStr, callback) {
+ var options = /*istanbul ignore start*/(0, params.generateOptions) /*istanbul ignore end*/(callback, { ignoreWhitespace: true });
+ return wordDiff.diff(oldStr, newStr, options);
+}
+function diffWordsWithSpace(oldStr, newStr, callback) {
+ return wordDiff.diff(oldStr, newStr, callback);
+}
+
+});
+
+unwrapExports(word$1);
+
+var line$7 = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports.lineDiff = undefined;
+exports. /*istanbul ignore end*/diffLines = diffLines;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = diffTrimmedLines;
+
+
+
+/*istanbul ignore start*/
+var _base2 = _interopRequireDefault(base);
+
+/*istanbul ignore end*/
+
+
+/*istanbul ignore start*/
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+/*istanbul ignore end*/var lineDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/lineDiff = new /*istanbul ignore start*/_base2['default']();
+lineDiff.tokenize = function (value) {
+ var retLines = [],
+ linesAndNewlines = value.split(/(\n|\r\n)/);
+
+ // Ignore the final empty token that occurs if the string ends with a new line
+ if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+ linesAndNewlines.pop();
+ }
+
+ // Merge the content and line separators into single tokens
+ for (var i = 0; i < linesAndNewlines.length; i++) {
+ var line = linesAndNewlines[i];
+
+ if (i % 2 && !this.options.newlineIsToken) {
+ retLines[retLines.length - 1] += line;
+ } else {
+ if (this.options.ignoreWhitespace) {
+ line = line.trim();
+ }
+ retLines.push(line);
+ }
+ }
+
+ return retLines;
+};
+
+function diffLines(oldStr, newStr, callback) {
+ return lineDiff.diff(oldStr, newStr, callback);
+}
+function diffTrimmedLines(oldStr, newStr, callback) {
+ var options = /*istanbul ignore start*/(0, params.generateOptions) /*istanbul ignore end*/(callback, { ignoreWhitespace: true });
+ return lineDiff.diff(oldStr, newStr, options);
+}
+
+});
+
+unwrapExports(line$7);
+
+var sentence = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports.sentenceDiff = undefined;
+exports. /*istanbul ignore end*/diffSentences = diffSentences;
+
+
+
+/*istanbul ignore start*/
+var _base2 = _interopRequireDefault(base);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+/*istanbul ignore end*/var sentenceDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/sentenceDiff = new /*istanbul ignore start*/_base2['default']();
+sentenceDiff.tokenize = function (value) {
+ return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+};
+
+function diffSentences(oldStr, newStr, callback) {
+ return sentenceDiff.diff(oldStr, newStr, callback);
+}
+
+});
+
+unwrapExports(sentence);
+
+var css = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports.cssDiff = undefined;
+exports. /*istanbul ignore end*/diffCss = diffCss;
+
+
+
+/*istanbul ignore start*/
+var _base2 = _interopRequireDefault(base);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+/*istanbul ignore end*/var cssDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/cssDiff = new /*istanbul ignore start*/_base2['default']();
+cssDiff.tokenize = function (value) {
+ return value.split(/([{}:;,]|\s+)/);
+};
+
+function diffCss(oldStr, newStr, callback) {
+ return cssDiff.diff(oldStr, newStr, callback);
+}
+
+});
+
+unwrapExports(css);
+
+var json$1 = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports.jsonDiff = undefined;
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+exports. /*istanbul ignore end*/diffJson = diffJson;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = canonicalize;
+
+
+
+/*istanbul ignore start*/
+var _base2 = _interopRequireDefault(base);
+
+/*istanbul ignore end*/
+
+
+/*istanbul ignore start*/
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+/*istanbul ignore end*/
+
+var objectPrototypeToString = Object.prototype.toString;
+
+var jsonDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/jsonDiff = new /*istanbul ignore start*/_base2['default']();
+// Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
+// dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
+jsonDiff.useLongestToken = true;
+
+jsonDiff.tokenize = /*istanbul ignore start*/line$7.lineDiff. /*istanbul ignore end*/tokenize;
+jsonDiff.castInput = function (value) {
+ /*istanbul ignore start*/var /*istanbul ignore end*/undefinedReplacement = this.options.undefinedReplacement;
+
+
+ return typeof value === 'string' ? value : JSON.stringify(canonicalize(value), function (k, v) {
+ if (typeof v === 'undefined') {
+ return undefinedReplacement;
+ }
+
+ return v;
+ }, ' ');
+};
+jsonDiff.equals = function (left, right) {
+ return (/*istanbul ignore start*/_base2['default']. /*istanbul ignore end*/prototype.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'))
+ );
+};
+
+function diffJson(oldObj, newObj, options) {
+ return jsonDiff.diff(oldObj, newObj, options);
+}
+
+// This function handles the presence of circular references by bailing out when encountering an
+// object that is already on the "stack" of items being processed.
+function canonicalize(obj, stack, replacementStack) {
+ stack = stack || [];
+ replacementStack = replacementStack || [];
+
+ var i = /*istanbul ignore start*/void 0;
+
+ for (i = 0; i < stack.length; i += 1) {
+ if (stack[i] === obj) {
+ return replacementStack[i];
+ }
+ }
+
+ var canonicalizedObj = /*istanbul ignore start*/void 0;
+
+ if ('[object Array]' === objectPrototypeToString.call(obj)) {
+ stack.push(obj);
+ canonicalizedObj = new Array(obj.length);
+ replacementStack.push(canonicalizedObj);
+ for (i = 0; i < obj.length; i += 1) {
+ canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack);
+ }
+ stack.pop();
+ replacementStack.pop();
+ return canonicalizedObj;
+ }
+
+ if (obj && obj.toJSON) {
+ obj = obj.toJSON();
+ }
+
+ if ( /*istanbul ignore start*/(typeof /*istanbul ignore end*/obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && obj !== null) {
+ stack.push(obj);
+ canonicalizedObj = {};
+ replacementStack.push(canonicalizedObj);
+ var sortedKeys = [],
+ key = /*istanbul ignore start*/void 0;
+ for (key in obj) {
+ /* istanbul ignore else */
+ if (obj.hasOwnProperty(key)) {
+ sortedKeys.push(key);
+ }
+ }
+ sortedKeys.sort();
+ for (i = 0; i < sortedKeys.length; i += 1) {
+ key = sortedKeys[i];
+ canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack);
+ }
+ stack.pop();
+ replacementStack.pop();
+ } else {
+ canonicalizedObj = obj;
+ }
+ return canonicalizedObj;
+}
+
+});
+
+unwrapExports(json$1);
+
+var array$1 = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports.arrayDiff = undefined;
+exports. /*istanbul ignore end*/diffArrays = diffArrays;
+
+
+
+/*istanbul ignore start*/
+var _base2 = _interopRequireDefault(base);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+/*istanbul ignore end*/var arrayDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/arrayDiff = new /*istanbul ignore start*/_base2['default']();
+arrayDiff.tokenize = arrayDiff.join = function (value) {
+ return value.slice();
+};
+
+function diffArrays(oldArr, newArr, callback) {
+ return arrayDiff.diff(oldArr, newArr, callback);
+}
+
+});
+
+unwrapExports(array$1);
+
+var parse$8 = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports. /*istanbul ignore end*/parsePatch = parsePatch;
+function parsePatch(uniDiff) {
+ /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+ var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/),
+ delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [],
+ list = [],
+ i = 0;
+
+ function parseIndex() {
+ var index = {};
+ list.push(index);
+
+ // Parse diff metadata
+ while (i < diffstr.length) {
+ var line = diffstr[i];
+
+ // File header found, end parsing diff metadata
+ if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
+ break;
+ }
+
+ // Diff index
+ var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
+ if (header) {
+ index.index = header[1];
+ }
+
+ i++;
+ }
+
+ // Parse file headers if they are defined. Unified diff requires them, but
+ // there's no technical issues to have an isolated hunk without file header
+ parseFileHeader(index);
+ parseFileHeader(index);
+
+ // Parse hunks
+ index.hunks = [];
+
+ while (i < diffstr.length) {
+ var _line = diffstr[i];
+
+ if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) {
+ break;
+ } else if (/^@@/.test(_line)) {
+ index.hunks.push(parseHunk());
+ } else if (_line && options.strict) {
+ // Ignore unexpected content unless in strict mode
+ throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line));
+ } else {
+ i++;
+ }
+ }
+ }
+
+ // Parses the --- and +++ headers, if none are found, no lines
+ // are consumed.
+ function parseFileHeader(index) {
+ var headerPattern = /^(---|\+\+\+)\s+([\S ]*)(?:\t(.*?)\s*)?$/;
+ var fileHeader = headerPattern.exec(diffstr[i]);
+ if (fileHeader) {
+ var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';
+ index[keyPrefix + 'FileName'] = fileHeader[2];
+ index[keyPrefix + 'Header'] = fileHeader[3];
+
+ i++;
+ }
+ }
+
+ // Parses a hunk
+ // This assumes that we are at the start of a hunk.
+ function parseHunk() {
+ var chunkHeaderIndex = i,
+ chunkHeaderLine = diffstr[i++],
+ chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+
+ var hunk = {
+ oldStart: +chunkHeader[1],
+ oldLines: +chunkHeader[2] || 1,
+ newStart: +chunkHeader[3],
+ newLines: +chunkHeader[4] || 1,
+ lines: [],
+ linedelimiters: []
+ };
+
+ var addCount = 0,
+ removeCount = 0;
+ for (; i < diffstr.length; i++) {
+ // Lines starting with '---' could be mistaken for the "remove line" operation
+ // But they could be the header for the next file. Therefore prune such cases out.
+ if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) {
+ break;
+ }
+ var operation = diffstr[i][0];
+
+ if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') {
+ hunk.lines.push(diffstr[i]);
+ hunk.linedelimiters.push(delimiters[i] || '\n');
+
+ if (operation === '+') {
+ addCount++;
+ } else if (operation === '-') {
+ removeCount++;
+ } else if (operation === ' ') {
+ addCount++;
+ removeCount++;
+ }
+ } else {
+ break;
+ }
+ }
+
+ // Handle the empty block count case
+ if (!addCount && hunk.newLines === 1) {
+ hunk.newLines = 0;
+ }
+ if (!removeCount && hunk.oldLines === 1) {
+ hunk.oldLines = 0;
+ }
+
+ // Perform optional sanity checking
+ if (options.strict) {
+ if (addCount !== hunk.newLines) {
+ throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
+ }
+ if (removeCount !== hunk.oldLines) {
+ throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
+ }
+ }
+
+ return hunk;
+ }
+
+ while (i < diffstr.length) {
+ parseIndex();
+ }
+
+ return list;
+}
+
+});
+
+unwrapExports(parse$8);
+
+var distanceIterator = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/"use strict";
+
+exports.__esModule = true;
+
+exports["default"] = /*istanbul ignore end*/function (start, minLine, maxLine) {
+ var wantForward = true,
+ backwardExhausted = false,
+ forwardExhausted = false,
+ localOffset = 1;
+
+ return function iterator() {
+ if (wantForward && !forwardExhausted) {
+ if (backwardExhausted) {
+ localOffset++;
+ } else {
+ wantForward = false;
+ }
+
+ // Check if trying to fit beyond text length, and if not, check it fits
+ // after offset location (or desired location on first iteration)
+ if (start + localOffset <= maxLine) {
+ return localOffset;
+ }
+
+ forwardExhausted = true;
+ }
+
+ if (!backwardExhausted) {
+ if (!forwardExhausted) {
+ wantForward = true;
+ }
+
+ // Check if trying to fit before text beginning, and if not, check it fits
+ // before offset location
+ if (minLine <= start - localOffset) {
+ return -localOffset++;
+ }
+
+ backwardExhausted = true;
+ return iterator();
+ }
+
+ // We tried to fit hunk before text beginning and beyond text lenght, then
+ // hunk can't fit on the text. Return undefined
+ };
+};
+
+});
+
+unwrapExports(distanceIterator);
+
+var apply = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports. /*istanbul ignore end*/applyPatch = applyPatch;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = applyPatches;
+
+
+
+
+
+/*istanbul ignore start*/
+var _distanceIterator2 = _interopRequireDefault(distanceIterator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+/*istanbul ignore end*/function applyPatch(source, uniDiff) {
+ /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+ if (typeof uniDiff === 'string') {
+ uniDiff = /*istanbul ignore start*/(0, parse$8.parsePatch) /*istanbul ignore end*/(uniDiff);
+ }
+
+ if (Array.isArray(uniDiff)) {
+ if (uniDiff.length > 1) {
+ throw new Error('applyPatch only works with a single input.');
+ }
+
+ uniDiff = uniDiff[0];
+ }
+
+ // Apply the diff to the input
+ var lines = source.split(/\r\n|[\n\v\f\r\x85]/),
+ delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [],
+ hunks = uniDiff.hunks,
+ compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) /*istanbul ignore start*/{
+ return (/*istanbul ignore end*/line === patchContent
+ );
+ },
+ errorCount = 0,
+ fuzzFactor = options.fuzzFactor || 0,
+ minLine = 0,
+ offset = 0,
+ removeEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/,
+ addEOFNL = /*istanbul ignore start*/void 0;
+
+ /**
+ * Checks if the hunk exactly fits on the provided location
+ */
+ function hunkFits(hunk, toPos) {
+ for (var j = 0; j < hunk.lines.length; j++) {
+ var line = hunk.lines[j],
+ operation = line[0],
+ content = line.substr(1);
+
+ if (operation === ' ' || operation === '-') {
+ // Context sanity check
+ if (!compareLine(toPos + 1, lines[toPos], operation, content)) {
+ errorCount++;
+
+ if (errorCount > fuzzFactor) {
+ return false;
+ }
+ }
+ toPos++;
+ }
+ }
+
+ return true;
+ }
+
+ // Search best fit offsets for each hunk based on the previous ones
+ for (var i = 0; i < hunks.length; i++) {
+ var hunk = hunks[i],
+ maxLine = lines.length - hunk.oldLines,
+ localOffset = 0,
+ toPos = offset + hunk.oldStart - 1;
+
+ var iterator = /*istanbul ignore start*/(0, _distanceIterator2['default']) /*istanbul ignore end*/(toPos, minLine, maxLine);
+
+ for (; localOffset !== undefined; localOffset = iterator()) {
+ if (hunkFits(hunk, toPos + localOffset)) {
+ hunk.offset = offset += localOffset;
+ break;
+ }
+ }
+
+ if (localOffset === undefined) {
+ return false;
+ }
+
+ // Set lower text limit to end of the current hunk, so next ones don't try
+ // to fit over already patched text
+ minLine = hunk.offset + hunk.oldStart + hunk.oldLines;
+ }
+
+ // Apply patch hunks
+ for (var _i = 0; _i < hunks.length; _i++) {
+ var _hunk = hunks[_i],
+ _toPos = _hunk.offset + _hunk.newStart - 1;
+ if (_hunk.newLines == 0) {
+ _toPos++;
+ }
+
+ for (var j = 0; j < _hunk.lines.length; j++) {
+ var line = _hunk.lines[j],
+ operation = line[0],
+ content = line.substr(1),
+ delimiter = _hunk.linedelimiters[j];
+
+ if (operation === ' ') {
+ _toPos++;
+ } else if (operation === '-') {
+ lines.splice(_toPos, 1);
+ delimiters.splice(_toPos, 1);
+ /* istanbul ignore else */
+ } else if (operation === '+') {
+ lines.splice(_toPos, 0, content);
+ delimiters.splice(_toPos, 0, delimiter);
+ _toPos++;
+ } else if (operation === '\\') {
+ var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null;
+ if (previousOperation === '+') {
+ removeEOFNL = true;
+ } else if (previousOperation === '-') {
+ addEOFNL = true;
+ }
+ }
+ }
+ }
+
+ // Handle EOFNL insertion/removal
+ if (removeEOFNL) {
+ while (!lines[lines.length - 1]) {
+ lines.pop();
+ delimiters.pop();
+ }
+ } else if (addEOFNL) {
+ lines.push('');
+ delimiters.push('\n');
+ }
+ for (var _k = 0; _k < lines.length - 1; _k++) {
+ lines[_k] = lines[_k] + delimiters[_k];
+ }
+ return lines.join('');
+}
+
+// Wrapper that supports multiple file patches via callbacks.
+function applyPatches(uniDiff, options) {
+ if (typeof uniDiff === 'string') {
+ uniDiff = /*istanbul ignore start*/(0, parse$8.parsePatch) /*istanbul ignore end*/(uniDiff);
+ }
+
+ var currentIndex = 0;
+ function processIndex() {
+ var index = uniDiff[currentIndex++];
+ if (!index) {
+ return options.complete();
+ }
+
+ options.loadFile(index, function (err, data) {
+ if (err) {
+ return options.complete(err);
+ }
+
+ var updatedContent = applyPatch(data, index, options);
+ options.patched(index, updatedContent, function (err) {
+ if (err) {
+ return options.complete(err);
+ }
+
+ processIndex();
+ });
+ });
+ }
+ processIndex();
+}
+
+});
+
+unwrapExports(apply);
+
+var create = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports. /*istanbul ignore end*/structuredPatch = structuredPatch;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = createTwoFilesPatch;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = createPatch;
+
+
+
+/*istanbul ignore start*/
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+/*istanbul ignore end*/function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+ if (!options) {
+ options = {};
+ }
+ if (typeof options.context === 'undefined') {
+ options.context = 4;
+ }
+
+ var diff = /*istanbul ignore start*/(0, line$7.diffLines) /*istanbul ignore end*/(oldStr, newStr, options);
+ diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier
+
+ function contextLines(lines) {
+ return lines.map(function (entry) {
+ return ' ' + entry;
+ });
+ }
+
+ var hunks = [];
+ var oldRangeStart = 0,
+ newRangeStart = 0,
+ curRange = [],
+ oldLine = 1,
+ newLine = 1;
+ /*istanbul ignore start*/
+ var _loop = function _loop( /*istanbul ignore end*/i) {
+ var current = diff[i],
+ lines = current.lines || current.value.replace(/\n$/, '').split('\n');
+ current.lines = lines;
+
+ if (current.added || current.removed) {
+ /*istanbul ignore start*/
+ var _curRange;
+
+ /*istanbul ignore end*/
+ // If we have previous context, start with that
+ if (!oldRangeStart) {
+ var prev = diff[i - 1];
+ oldRangeStart = oldLine;
+ newRangeStart = newLine;
+
+ if (prev) {
+ curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
+ oldRangeStart -= curRange.length;
+ newRangeStart -= curRange.length;
+ }
+ }
+
+ // Output our changes
+ /*istanbul ignore start*/(_curRange = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/lines.map(function (entry) {
+ return (current.added ? '+' : '-') + entry;
+ })));
+
+ // Track the updated file position
+ if (current.added) {
+ newLine += lines.length;
+ } else {
+ oldLine += lines.length;
+ }
+ } else {
+ // Identical context lines. Track line changes
+ if (oldRangeStart) {
+ // Close out any changes that have been output (or join overlapping)
+ if (lines.length <= options.context * 2 && i < diff.length - 2) {
+ /*istanbul ignore start*/
+ var _curRange2;
+
+ /*istanbul ignore end*/
+ // Overlapping
+ /*istanbul ignore start*/(_curRange2 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange2 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines)));
+ } else {
+ /*istanbul ignore start*/
+ var _curRange3;
+
+ /*istanbul ignore end*/
+ // end the range and output
+ var contextSize = Math.min(lines.length, options.context);
+ /*istanbul ignore start*/(_curRange3 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange3 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines.slice(0, contextSize))));
+
+ var hunk = {
+ oldStart: oldRangeStart,
+ oldLines: oldLine - oldRangeStart + contextSize,
+ newStart: newRangeStart,
+ newLines: newLine - newRangeStart + contextSize,
+ lines: curRange
+ };
+ if (i >= diff.length - 2 && lines.length <= options.context) {
+ // EOF is inside this hunk
+ var oldEOFNewline = /\n$/.test(oldStr);
+ var newEOFNewline = /\n$/.test(newStr);
+ if (lines.length == 0 && !oldEOFNewline) {
+ // special case: old has no eol and no trailing context; no-nl can end up before adds
+ curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file');
+ } else if (!oldEOFNewline || !newEOFNewline) {
+ curRange.push('\\ No newline at end of file');
+ }
+ }
+ hunks.push(hunk);
+
+ oldRangeStart = 0;
+ newRangeStart = 0;
+ curRange = [];
+ }
+ }
+ oldLine += lines.length;
+ newLine += lines.length;
+ }
+ };
+
+ for (var i = 0; i < diff.length; i++) {
+ /*istanbul ignore start*/
+ _loop( /*istanbul ignore end*/i);
+ }
+
+ return {
+ oldFileName: oldFileName, newFileName: newFileName,
+ oldHeader: oldHeader, newHeader: newHeader,
+ hunks: hunks
+ };
+}
+
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+ var diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+
+ var ret = [];
+ if (oldFileName == newFileName) {
+ ret.push('Index: ' + oldFileName);
+ }
+ ret.push('===================================================================');
+ ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader));
+ ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader));
+
+ for (var i = 0; i < diff.hunks.length; i++) {
+ var hunk = diff.hunks[i];
+ ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@');
+ ret.push.apply(ret, hunk.lines);
+ }
+
+ return ret.join('\n') + '\n';
+}
+
+function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
+ return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
+}
+
+});
+
+unwrapExports(create);
+
+var dmp = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/"use strict";
+
+exports.__esModule = true;
+exports. /*istanbul ignore end*/convertChangesToDMP = convertChangesToDMP;
+// See: http://code.google.com/p/google-diff-match-patch/wiki/API
+function convertChangesToDMP(changes) {
+ var ret = [],
+ change = /*istanbul ignore start*/void 0 /*istanbul ignore end*/,
+ operation = /*istanbul ignore start*/void 0;
+ for (var i = 0; i < changes.length; i++) {
+ change = changes[i];
+ if (change.added) {
+ operation = 1;
+ } else if (change.removed) {
+ operation = -1;
+ } else {
+ operation = 0;
+ }
+
+ ret.push([operation, change.value]);
+ }
+ return ret;
+}
+
+});
+
+unwrapExports(dmp);
+
+var xml = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports. /*istanbul ignore end*/convertChangesToXML = convertChangesToXML;
+function convertChangesToXML(changes) {
+ var ret = [];
+ for (var i = 0; i < changes.length; i++) {
+ var change = changes[i];
+ if (change.added) {
+ ret.push('');
+ } else if (change.removed) {
+ ret.push('');
+ }
+
+ ret.push(escapeHTML(change.value));
+
+ if (change.added) {
+ ret.push('');
+ } else if (change.removed) {
+ ret.push('');
+ }
+ }
+ return ret.join('');
+}
+
+function escapeHTML(s) {
+ var n = s;
+ n = n.replace(/&/g, '&');
+ n = n.replace(//g, '>');
+ n = n.replace(/"/g, '"');
+
+ return n;
+}
+
+});
+
+unwrapExports(xml);
+
+var lib$6 = createCommonjsModule(function (module, exports) {
+/*istanbul ignore start*/'use strict';
+
+exports.__esModule = true;
+exports.canonicalize = exports.convertChangesToXML = exports.convertChangesToDMP = exports.parsePatch = exports.applyPatches = exports.applyPatch = exports.createPatch = exports.createTwoFilesPatch = exports.structuredPatch = exports.diffArrays = exports.diffJson = exports.diffCss = exports.diffSentences = exports.diffTrimmedLines = exports.diffLines = exports.diffWordsWithSpace = exports.diffWords = exports.diffChars = exports.Diff = undefined;
+/*istanbul ignore end*/
+
+
+/*istanbul ignore start*/
+var _base2 = _interopRequireDefault(base);
+
+/*istanbul ignore end*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*istanbul ignore start*/
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+exports. /*istanbul ignore end*/Diff = _base2['default'];
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffChars = character.diffChars;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffWords = word$1.diffWords;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = word$1.diffWordsWithSpace;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffLines = line$7.diffLines;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = line$7.diffTrimmedLines;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffSentences = sentence.diffSentences;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffCss = css.diffCss;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffJson = json$1.diffJson;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/diffArrays = array$1.diffArrays;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/structuredPatch = create.structuredPatch;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = create.createTwoFilesPatch;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = create.createPatch;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatch = apply.applyPatch;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = apply.applyPatches;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/parsePatch = parse$8.parsePatch;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToDMP = dmp.convertChangesToDMP;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToXML = xml.convertChangesToXML;
+/*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = json$1.canonicalize; /* See LICENSE file for terms of use */
+
+/*
+ * Text diff implementation.
+ *
+ * This library supports the following APIS:
+ * JsDiff.diffChars: Character by character diff
+ * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
+ * JsDiff.diffLines: Line based diff
+ *
+ * JsDiff.diffCss: Diff targeted at CSS content
+ *
+ * These methods are based on the implementation proposed in
+ * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
+ * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
+ */
+
+});
+
+unwrapExports(lib$6);
+
+const cleanAST = cleanAst.cleanAST;
+
+
+
+
+
+
+const getSupportInfo$3 = support.getSupportInfo;
+
+
+const OPTION_USAGE_THRESHOLD = 25;
+const CHOICE_USAGE_MARGIN = 3;
+const CHOICE_USAGE_INDENTATION = 2;
+
+function getOptions(argv, detailedOptions) {
+ return detailedOptions.filter(option => option.forwardToApi).reduce(
+ (current, option) =>
+ Object.assign(current, {
+ [option.forwardToApi]: argv[option.name]
+ }),
+ {}
+ );
+}
+
+function cliifyOptions(object, apiDetailedOptionMap) {
+ return Object.keys(object || {}).reduce((output, key) => {
+ const apiOption = apiDetailedOptionMap[key];
+ const cliKey = apiOption ? apiOption.name : key;
+
+ output[dashify(cliKey)] = object[key];
+ return output;
+ }, {});
+}
+
+function diff(a, b) {
+ return lib$6.createTwoFilesPatch("", "", a, b, "", "", {
+ context: 2
+ });
+}
+
+function handleError(context, filename, error) {
+ const isParseError = Boolean(error && error.loc);
+ const isValidationError = /Validation Error/.test(error && error.message);
+
+ // For parse errors and validation errors, we only want to show the error
+ // message formatted in a nice way. `String(error)` takes care of that. Other
+ // (unexpected) errors are passed as-is as a separate argument to
+ // `console.error`. That includes the stack trace (if any), and shows a nice
+ // `util.inspect` of throws things that aren't `Error` objects. (The Flow
+ // parser has mistakenly thrown arrays sometimes.)
+ if (isParseError) {
+ context.logger.error(`${filename}: ${String(error)}`);
+ } else if (isValidationError || error instanceof errors.ConfigError) {
+ context.logger.error(String(error));
+ // If validation fails for one file, it will fail for all of them.
+ process.exit(1);
+ } else if (error instanceof errors.DebugError) {
+ context.logger.error(`${filename}: ${error.message}`);
+ } else {
+ context.logger.error(filename + ": " + (error.stack || error));
+ }
+
+ // Don't exit the process if one file failed
+ process.exitCode = 2;
+}
+
+function logResolvedConfigPathOrDie(context, filePath) {
+ const configFile = resolveConfig_1.resolveConfigFile.sync(filePath);
+ if (configFile) {
+ context.logger.log(path.relative(process.cwd(), configFile));
+ } else {
+ process.exit(1);
+ }
+}
+
+function writeOutput(result, options) {
+ // Don't use `console.log` here since it adds an extra newline at the end.
+ process.stdout.write(result.formatted);
+
+ if (options.cursorOffset >= 0) {
+ process.stderr.write(result.cursorOffset + "\n");
+ }
+}
+
+function listDifferent(context, input, options, filename) {
+ if (!context.argv["list-different"]) {
+ return;
+ }
+
+ options = Object.assign({}, options, { filepath: filename });
+
+ if (!prettier$2.check(input, options)) {
+ if (!context.argv["write"]) {
+ context.logger.log(filename);
+ }
+ process.exitCode = 1;
+ }
+
+ return true;
+}
+
+function format$1(context, input, opt) {
+ if (context.argv["debug-print-doc"]) {
+ const doc = prettier$2.__debug.printToDoc(input, opt);
+ return { formatted: prettier$2.__debug.formatDoc(doc) };
+ }
+
+ if (context.argv["debug-check"]) {
+ const pp = prettier$2.format(input, opt);
+ const pppp = prettier$2.format(pp, opt);
+ if (pp !== pppp) {
+ throw new errors.DebugError(
+ "prettier(input) !== prettier(prettier(input))\n" + diff(pp, pppp)
+ );
+ } else {
+ const normalizedOpts = options$12.normalize(opt);
+ const ast = cleanAST(
+ prettier$2.__debug.parse(input, opt).ast,
+ normalizedOpts
+ );
+ const past = cleanAST(
+ prettier$2.__debug.parse(pp, opt).ast,
+ normalizedOpts
+ );
+
+ if (ast !== past) {
+ const MAX_AST_SIZE = 2097152; // 2MB
+ const astDiff =
+ ast.length > MAX_AST_SIZE || past.length > MAX_AST_SIZE
+ ? "AST diff too large to render"
+ : diff(ast, past);
+ throw new errors.DebugError(
+ "ast(input) !== ast(prettier(input))\n" +
+ astDiff +
+ "\n" +
+ diff(input, pp)
+ );
+ }
+ }
+ return { formatted: opt.filepath || "(stdin)\n" };
+ }
+
+ return prettier$2.formatWithCursor(input, opt);
+}
+
+function getOptionsOrDie(context, filePath) {
+ try {
+ if (context.argv["config"] === false) {
+ context.logger.debug(
+ "'--no-config' option found, skip loading config file."
+ );
+ return null;
+ }
+
+ context.logger.debug(
+ context.argv["config"]
+ ? `load config file from '${context.argv["config"]}'`
+ : `resolve config from '${filePath}'`
+ );
+
+ const options = resolveConfig_1.resolveConfig.sync(filePath, {
+ editorconfig: context.argv["editorconfig"],
+ config: context.argv["config"]
+ });
+
+ context.logger.debug("loaded options `" + JSON.stringify(options) + "`");
+ return options;
+ } catch (error) {
+ context.logger.error("Invalid configuration file: " + error.message);
+ process.exit(2);
+ }
+}
+
+function getOptionsForFile(context, filepath) {
+ const options = getOptionsOrDie(context, filepath);
+
+ const hasPlugins = options && options.plugins;
+ if (hasPlugins) {
+ pushContextPlugins(context, options.plugins);
+ }
+
+ const appliedOptions = Object.assign(
+ { filepath },
+ applyConfigPrecedence(
+ context,
+ options &&
+ optionsNormalizer.normalizeApiOptions(options, context.supportOptions, {
+ logger: context.logger
+ })
+ )
+ );
+
+ context.logger.debug(
+ `applied config-precedence (${context.argv["config-precedence"]}): ` +
+ `${JSON.stringify(appliedOptions)}`
+ );
+
+ if (hasPlugins) {
+ popContextPlugins(context);
+ }
+
+ return appliedOptions;
+}
+
+function parseArgsToOptions(context, overrideDefaults) {
+ const minimistOptions = createMinimistOptions(context.detailedOptions);
+ const apiDetailedOptionMap = createApiDetailedOptionMap(
+ context.detailedOptions
+ );
+ return getOptions(
+ optionsNormalizer.normalizeCliOptions(
+ minimist_1(
+ context.args,
+ Object.assign({
+ string: minimistOptions.string,
+ boolean: minimistOptions.boolean,
+ default: cliifyOptions(overrideDefaults, apiDetailedOptionMap)
+ })
+ ),
+ context.detailedOptions,
+ { logger: false }
+ ),
+ context.detailedOptions
+ );
+}
+
+function applyConfigPrecedence(context, options) {
+ try {
+ switch (context.argv["config-precedence"]) {
+ case "cli-override":
+ return parseArgsToOptions(context, options);
+ case "file-override":
+ return Object.assign({}, parseArgsToOptions(context), options);
+ case "prefer-file":
+ return options || parseArgsToOptions(context);
+ }
+ } catch (error) {
+ context.logger.error(error.toString());
+ process.exit(2);
+ }
+}
+
+function formatStdin(context) {
+ const filepath = context.argv["stdin-filepath"]
+ ? path.resolve(process.cwd(), context.argv["stdin-filepath"])
+ : process.cwd();
+
+ const ignorer = createIgnorer(context);
+ const relativeFilepath = path.relative(process.cwd(), filepath);
+
+ thirdParty$1.getStream(process.stdin).then(input => {
+ if (relativeFilepath && ignorer.filter([relativeFilepath]).length === 0) {
+ writeOutput({ formatted: input }, {});
+ return;
+ }
+
+ const options = getOptionsForFile(context, filepath);
+
+ if (listDifferent(context, input, options, "(stdin)")) {
+ return;
+ }
+
+ try {
+ writeOutput(format$1(context, input, options), options);
+ } catch (error) {
+ handleError(context, "stdin", error);
+ }
+ });
+}
+
+function createIgnorer(context) {
+ const ignoreFilePath = path.resolve(context.argv["ignore-path"]);
+ let ignoreText = "";
+
+ try {
+ ignoreText = fs.readFileSync(ignoreFilePath, "utf8");
+ } catch (readError) {
+ if (readError.code !== "ENOENT") {
+ context.logger.error(
+ `Unable to read ${ignoreFilePath}: ` + readError.message
+ );
+ process.exit(2);
+ }
+ }
+
+ return ignore().add(ignoreText);
+}
+
+function eachFilename(context, patterns, callback) {
+ const ignoreNodeModules = context.argv["with-node-modules"] !== true;
+ if (ignoreNodeModules) {
+ patterns = patterns.concat(["!**/node_modules/**", "!./node_modules/**"]);
+ }
+
+ try {
+ const filePaths = globby
+ .sync(patterns, { dot: true, nodir: true })
+ .map(filePath => path.relative(process.cwd(), filePath));
+
+ if (filePaths.length === 0) {
+ context.logger.error(
+ `No matching files. Patterns tried: ${patterns.join(" ")}`
+ );
+ process.exitCode = 2;
+ return;
+ }
+ filePaths.forEach(filePath =>
+ callback(filePath, getOptionsForFile(context, filePath))
+ );
+ } catch (error) {
+ context.logger.error(
+ `Unable to expand glob patterns: ${patterns.join(" ")}\n${error.message}`
+ );
+ // Don't exit the process if one pattern failed
+ process.exitCode = 2;
+ }
+}
+
+function formatFiles(context) {
+ // The ignorer will be used to filter file paths after the glob is checked,
+ // before any files are actually written
+ const ignorer = createIgnorer(context);
+
+ eachFilename(context, context.filePatterns, (filename, options) => {
+ const fileIgnored = ignorer.filter([filename]).length === 0;
+ if (
+ fileIgnored &&
+ (context.argv["debug-check"] ||
+ context.argv["write"] ||
+ context.argv["list-different"])
+ ) {
+ return;
+ }
+
+ if (context.argv["write"] && process.stdout.isTTY) {
+ // Don't use `console.log` here since we need to replace this line.
+ context.logger.log(filename, { newline: false });
+ }
+
+ let input;
+ try {
+ input = fs.readFileSync(filename, "utf8");
+ } catch (error) {
+ // Add newline to split errors from filename line.
+ context.logger.log("");
+
+ context.logger.error(
+ `Unable to read file: ${filename}\n${error.message}`
+ );
+ // Don't exit the process if one file failed
+ process.exitCode = 2;
+ return;
+ }
+
+ if (fileIgnored) {
+ writeOutput({ formatted: input }, options);
+ return;
+ }
+
+ listDifferent(context, input, options, filename);
+
+ const start = Date.now();
+
+ let result;
+ let output;
+
+ try {
+ result = format$1(
+ context,
+ input,
+ Object.assign({}, options, { filepath: filename })
+ );
+ output = result.formatted;
+ } catch (error) {
+ // Add newline to split errors from filename line.
+ process.stdout.write("\n");
+
+ handleError(context, filename, error);
+ return;
+ }
+
+ if (context.argv["write"]) {
+ if (process.stdout.isTTY) {
+ // Remove previously printed filename to log it with duration.
+ readline.clearLine(process.stdout, 0);
+ readline.cursorTo(process.stdout, 0, null);
+ }
+
+ // Don't write the file if it won't change in order not to invalidate
+ // mtime based caches.
+ if (output === input) {
+ if (!context.argv["list-different"]) {
+ context.logger.log(`${chalk$2.grey(filename)} ${Date.now() - start}ms`);
+ }
+ } else {
+ if (context.argv["list-different"]) {
+ context.logger.log(filename);
+ } else {
+ context.logger.log(`${filename} ${Date.now() - start}ms`);
+ }
+
+ try {
+ fs.writeFileSync(filename, output, "utf8");
+ } catch (error) {
+ context.logger.error(
+ `Unable to write file: ${filename}\n${error.message}`
+ );
+ // Don't exit the process if one file failed
+ process.exitCode = 2;
+ }
+ }
+ } else if (context.argv["debug-check"]) {
+ if (output) {
+ context.logger.log(output);
+ } else {
+ process.exitCode = 2;
+ }
+ } else if (!context.argv["list-different"]) {
+ writeOutput(result, options);
+ }
+ });
+}
+
+function getOptionsWithOpposites(options) {
+ // Add --no-foo after --foo.
+ const optionsWithOpposites = options.map(option => [
+ option.description ? option : null,
+ option.oppositeDescription
+ ? Object.assign({}, option, {
+ name: `no-${option.name}`,
+ type: "boolean",
+ description: option.oppositeDescription
+ })
+ : null
+ ]);
+ return flattenArray(optionsWithOpposites).filter(Boolean);
+}
+
+function createUsage(context) {
+ const options = getOptionsWithOpposites(context.detailedOptions).filter(
+ // remove unnecessary option (e.g. `semi`, `color`, etc.), which is only used for --help
+ option =>
+ !(
+ option.type === "boolean" &&
+ option.oppositeDescription &&
+ !option.name.startsWith("no-")
+ )
+ );
+
+ const groupedOptions = groupBy(options, option => option.category);
+
+ const firstCategories = constant.categoryOrder.slice(0, -1);
+ const lastCategories = constant.categoryOrder.slice(-1);
+ const restCategories = Object.keys(groupedOptions).filter(
+ category =>
+ firstCategories.indexOf(category) === -1 &&
+ lastCategories.indexOf(category) === -1
+ );
+ const allCategories = firstCategories.concat(restCategories, lastCategories);
+
+ const optionsUsage = allCategories.map(category => {
+ const categoryOptions = groupedOptions[category]
+ .map(option => createOptionUsage(context, option, OPTION_USAGE_THRESHOLD))
+ .join("\n");
+ return `${category} options:\n\n${indent$9(categoryOptions, 2)}`;
+ });
+
+ return [constant.usageSummary].concat(optionsUsage, [""]).join("\n\n");
+}
+
+function createOptionUsage(context, option, threshold) {
+ const header = createOptionUsageHeader(option);
+ const optionDefaultValue = getOptionDefaultValue(context, option.name);
+ return createOptionUsageRow(
+ header,
+ `${option.description}${
+ optionDefaultValue === undefined
+ ? ""
+ : `\nDefaults to ${createDefaultValueDisplay(optionDefaultValue)}.`
+ }`,
+ threshold
+ );
+}
+
+function createDefaultValueDisplay(value) {
+ return Array.isArray(value)
+ ? `[${value.map(createDefaultValueDisplay).join(", ")}]`
+ : value;
+}
+
+function createOptionUsageHeader(option) {
+ const name = `--${option.name}`;
+ const alias = option.alias ? `-${option.alias},` : null;
+ const type = createOptionUsageType(option);
+ return [alias, name, type].filter(Boolean).join(" ");
+}
+
+function createOptionUsageRow(header, content, threshold) {
+ const separator =
+ header.length >= threshold
+ ? `\n${" ".repeat(threshold)}`
+ : " ".repeat(threshold - header.length);
+
+ const description = content.replace(/\n/g, `\n${" ".repeat(threshold)}`);
+
+ return `${header}${separator}${description}`;
+}
+
+function createOptionUsageType(option) {
+ switch (option.type) {
+ case "boolean":
+ return null;
+ case "choice":
+ return `<${option.choices
+ .filter(choice => !choice.deprecated)
+ .map(choice => choice.value)
+ .join("|")}>`;
+ default:
+ return `<${option.type}>`;
+ }
+}
+
+function flattenArray(array) {
+ return [].concat.apply([], array);
+}
+
+function getOptionWithLevenSuggestion(context, options, optionName) {
+ // support aliases
+ const optionNameContainers = flattenArray(
+ options.map((option, index) => [
+ { value: option.name, index },
+ option.alias ? { value: option.alias, index } : null
+ ])
+ ).filter(Boolean);
+
+ const optionNameContainer = optionNameContainers.find(
+ optionNameContainer => optionNameContainer.value === optionName
+ );
+
+ if (optionNameContainer !== undefined) {
+ return options[optionNameContainer.index];
+ }
+
+ const suggestedOptionNameContainer = optionNameContainers.find(
+ optionNameContainer => leven(optionNameContainer.value, optionName) < 3
+ );
+
+ if (suggestedOptionNameContainer !== undefined) {
+ const suggestedOptionName = suggestedOptionNameContainer.value;
+ context.logger.warn(
+ `Unknown option name "${optionName}", did you mean "${suggestedOptionName}"?`
+ );
+
+ return options[suggestedOptionNameContainer.index];
+ }
+
+ context.logger.warn(`Unknown option name "${optionName}"`);
+ return options.find(option => option.name === "help");
+}
+
+function createChoiceUsages(choices, margin, indentation) {
+ const activeChoices = choices.filter(choice => !choice.deprecated);
+ const threshold =
+ activeChoices
+ .map(choice => choice.value.length)
+ .reduce((current, length) => Math.max(current, length), 0) + margin;
+ return activeChoices.map(choice =>
+ indent$9(
+ createOptionUsageRow(choice.value, choice.description, threshold),
+ indentation
+ )
+ );
+}
+
+function createDetailedUsage(context, optionName) {
+ const option = getOptionWithLevenSuggestion(
+ context,
+ getOptionsWithOpposites(context.detailedOptions),
+ optionName
+ );
+
+ const header = createOptionUsageHeader(option);
+ const description = `\n\n${indent$9(option.description, 2)}`;
+
+ const choices =
+ option.type !== "choice"
+ ? ""
+ : `\n\nValid options:\n\n${createChoiceUsages(
+ option.choices,
+ CHOICE_USAGE_MARGIN,
+ CHOICE_USAGE_INDENTATION
+ ).join("\n")}`;
+
+ const optionDefaultValue = getOptionDefaultValue(context, option.name);
+ const defaults =
+ optionDefaultValue !== undefined
+ ? `\n\nDefault: ${createDefaultValueDisplay(optionDefaultValue)}`
+ : "";
+
+ const pluginDefaults =
+ option.pluginDefaults && Object.keys(option.pluginDefaults).length
+ ? `\nPlugin defaults:${Object.keys(option.pluginDefaults).map(
+ key =>
+ `\n* ${key}: ${createDefaultValueDisplay(
+ option.pluginDefaults[key]
+ )}`
+ )}`
+ : "";
+ return `${header}${description}${choices}${defaults}${pluginDefaults}`;
+}
+
+function getOptionDefaultValue(context, optionName) {
+ // --no-option
+ if (!(optionName in context.detailedOptionMap)) {
+ return undefined;
+ }
+
+ const option = context.detailedOptionMap[optionName];
+
+ if (option.default !== undefined) {
+ return option.default;
+ }
+
+ const optionCamelName = camelcase(optionName);
+ if (optionCamelName in context.apiDefaultOptions) {
+ return context.apiDefaultOptions[optionCamelName];
+ }
+
+ return undefined;
+}
+
+function indent$9(str, spaces) {
+ return str.replace(/^/gm, " ".repeat(spaces));
+}
+
+function groupBy(array, getKey) {
+ return array.reduce((obj, item) => {
+ const key = getKey(item);
+ const previousItems = key in obj ? obj[key] : [];
+ return Object.assign({}, obj, { [key]: previousItems.concat(item) });
+ }, Object.create(null));
+}
+
+function pick(object, keys) {
+ return !keys
+ ? object
+ : keys.reduce(
+ (reduced, key) => Object.assign(reduced, { [key]: object[key] }),
+ {}
+ );
+}
+
+function createLogger(logLevel) {
+ return {
+ warn: createLogFunc("warn", "yellow"),
+ error: createLogFunc("error", "red"),
+ debug: createLogFunc("debug", "blue"),
+ log: createLogFunc("log")
+ };
+
+ function createLogFunc(loggerName, color) {
+ if (!shouldLog(loggerName)) {
+ return () => {};
+ }
+
+ const prefix = color ? `[${chalk$2[color](loggerName)}] ` : "";
+ return function(message, opts) {
+ opts = Object.assign({ newline: true }, opts);
+ const stream = process[loggerName === "log" ? "stdout" : "stderr"];
+ stream.write(message.replace(/^/gm, prefix) + (opts.newline ? "\n" : ""));
+ };
+ }
+
+ function shouldLog(loggerName) {
+ switch (logLevel) {
+ case "silent":
+ return false;
+ default:
+ return true;
+ case "debug":
+ if (loggerName === "debug") {
+ return true;
+ }
+ // fall through
+ case "log":
+ if (loggerName === "log") {
+ return true;
+ }
+ // fall through
+ case "warn":
+ if (loggerName === "warn") {
+ return true;
+ }
+ // fall through
+ case "error":
+ return loggerName === "error";
+ }
+ }
+}
+
+function normalizeDetailedOption(name, option) {
+ return Object.assign({ category: constant.CATEGORY_OTHER }, option, {
+ choices:
+ option.choices &&
+ option.choices.map(choice => {
+ const newChoice = Object.assign(
+ { description: "", deprecated: false },
+ typeof choice === "object" ? choice : { value: choice }
+ );
+ if (newChoice.value === true) {
+ newChoice.value = ""; // backward compability for original boolean option
+ }
+ return newChoice;
+ })
+ });
+}
+
+function normalizeDetailedOptionMap(detailedOptionMap) {
+ return Object.keys(detailedOptionMap)
+ .sort()
+ .reduce((normalized, name) => {
+ const option = detailedOptionMap[name];
+ return Object.assign(normalized, {
+ [name]: normalizeDetailedOption(name, option)
+ });
+ }, {});
+}
+
+function createMinimistOptions(detailedOptions) {
+ return {
+ boolean: detailedOptions
+ .filter(option => option.type === "boolean")
+ .map(option => option.name),
+ string: detailedOptions
+ .filter(option => option.type !== "boolean")
+ .map(option => option.name),
+ default: detailedOptions
+ .filter(option => !option.deprecated)
+ .filter(option => !option.forwardToApi || option.name === "plugin")
+ .filter(option => option.default !== undefined)
+ .reduce(
+ (current, option) =>
+ Object.assign({ [option.name]: option.default }, current),
+ {}
+ ),
+ alias: detailedOptions
+ .filter(option => option.alias !== undefined)
+ .reduce(
+ (current, option) =>
+ Object.assign({ [option.name]: option.alias }, current),
+ {}
+ )
+ };
+}
+
+function createApiDetailedOptionMap(detailedOptions) {
+ return detailedOptions.reduce(
+ (current, option) =>
+ option.forwardToApi && option.forwardToApi !== option.name
+ ? Object.assign(current, { [option.forwardToApi]: option })
+ : current,
+ {}
+ );
+}
+
+function createDetailedOptionMap(supportOptions) {
+ return supportOptions.reduce((reduced, option) => {
+ const newOption = Object.assign({}, option, {
+ name: option.cliName || dashify(option.name),
+ description: option.cliDescription || option.description,
+ category: option.cliCategory || constant.CATEGORY_FORMAT,
+ forwardToApi: option.name
+ });
+
+ if (option.deprecated) {
+ delete newOption.forwardToApi;
+ delete newOption.description;
+ delete newOption.oppositeDescription;
+ newOption.deprecated = true;
+ }
+
+ return Object.assign(reduced, { [newOption.name]: newOption });
+ }, {});
+}
+
+//-----------------------------context-util-start-------------------------------
+/**
+ * @typedef {Object} Context
+ * @property logger
+ * @property args
+ * @property argv
+ * @property filePatterns
+ * @property supportOptions
+ * @property detailedOptions
+ * @property detailedOptionMap
+ * @property apiDefaultOptions
+ */
+function createContext(args) {
+ const context = { args };
+
+ updateContextArgv(context);
+ normalizeContextArgv(context, ["loglevel", "plugin"]);
+
+ context.logger = createLogger(context.argv["loglevel"]);
+
+ updateContextArgv(context, context.argv["plugin"]);
+
+ return context;
+}
+
+function initContext(context) {
+ // split into 2 step so that we could wrap this in a `try..catch` in cli/index.js
+ normalizeContextArgv(context);
+}
+
+function updateContextOptions(context, plugins) {
+ const supportOptions = getSupportInfo$3(null, {
+ showDeprecated: true,
+ showUnreleased: true,
+ showInternal: true,
+ plugins
+ }).options;
+
+ const detailedOptionMap = normalizeDetailedOptionMap(
+ Object.assign({}, createDetailedOptionMap(supportOptions), constant.options)
+ );
+
+ const detailedOptions = util$1.arrayify(detailedOptionMap, "name");
+
+ const apiDefaultOptions = supportOptions
+ .filter(optionInfo => !optionInfo.deprecated)
+ .reduce(
+ (reduced, optionInfo) =>
+ Object.assign(reduced, { [optionInfo.name]: optionInfo.default }),
+ Object.assign({}, options$12.hiddenDefaults)
+ );
+
+ context.supportOptions = supportOptions;
+ context.detailedOptions = detailedOptions;
+ context.detailedOptionMap = detailedOptionMap;
+ context.apiDefaultOptions = apiDefaultOptions;
+}
+
+function pushContextPlugins(context, plugins) {
+ context._supportOptions = context.supportOptions;
+ context._detailedOptions = context.detailedOptions;
+ context._detailedOptionMap = context.detailedOptionMap;
+ context._apiDefaultOptions = context.apiDefaultOptions;
+ updateContextOptions(context, plugins);
+}
+
+function popContextPlugins(context) {
+ context.supportOptions = context._supportOptions;
+ context.detailedOptions = context._detailedOptions;
+ context.detailedOptionMap = context._detailedOptionMap;
+ context.apiDefaultOptions = context._apiDefaultOptions;
+}
+
+function updateContextArgv(context, plugins) {
+ pushContextPlugins(context, plugins);
+
+ const minimistOptions = createMinimistOptions(context.detailedOptions);
+ const argv = minimist_1(context.args, minimistOptions);
+
+ context.argv = argv;
+ context.filePatterns = argv["_"];
+}
+
+function normalizeContextArgv(context, keys) {
+ const detailedOptions = !keys
+ ? context.detailedOptions
+ : context.detailedOptions.filter(
+ option => keys.indexOf(option.name) !== -1
+ );
+ const argv = !keys ? context.argv : pick(context.argv, keys);
+
+ context.argv = optionsNormalizer.normalizeCliOptions(argv, detailedOptions, {
+ logger: context.logger
+ });
+}
+//------------------------------context-util-end--------------------------------
+
+var util_1 = {
+ createContext,
+ createDetailedOptionMap,
+ createDetailedUsage,
+ createUsage,
+ format: format$1,
+ formatFiles,
+ formatStdin,
+ initContext,
+ logResolvedConfigPathOrDie,
+ normalizeDetailedOptionMap
+};
+
+function run(args) {
+ const context = util_1.createContext(args);
+
+ try {
+ util_1.initContext(context);
+
+ context.logger.debug(`normalized argv: ${JSON.stringify(context.argv)}`);
+
+ if (context.argv["write"] && context.argv["debug-check"]) {
+ context.logger.error("Cannot use --write and --debug-check together.");
+ process.exit(1);
+ }
+
+ if (context.argv["find-config-path"] && context.filePatterns.length) {
+ context.logger.error("Cannot use --find-config-path with multiple files");
+ process.exit(1);
+ }
+
+ if (context.argv["version"]) {
+ context.logger.log(prettier$2.version);
+ process.exit(0);
+ }
+
+ if (context.argv["help"] !== undefined) {
+ context.logger.log(
+ typeof context.argv["help"] === "string" && context.argv["help"] !== ""
+ ? util_1.createDetailedUsage(context, context.argv["help"])
+ : util_1.createUsage(context)
+ );
+ process.exit(0);
+ }
+
+ if (context.argv["support-info"]) {
+ context.logger.log(
+ prettier$2.format(jsonStableStringify(prettier$2.getSupportInfo()), {
+ parser: "json"
+ })
+ );
+ process.exit(0);
+ }
+
+ const hasFilePatterns = context.filePatterns.length !== 0;
+ const useStdin =
+ context.argv["stdin"] || (!hasFilePatterns && !process.stdin.isTTY);
+
+ if (context.argv["find-config-path"]) {
+ util_1.logResolvedConfigPathOrDie(
+ context,
+ context.argv["find-config-path"]
+ );
+ } else if (useStdin) {
+ util_1.formatStdin(context);
+ } else if (hasFilePatterns) {
+ util_1.formatFiles(context);
+ } else {
+ context.logger.log(util_1.createUsage(context));
+ process.exit(1);
+ }
+ } catch (error) {
+ context.logger.error(error.message);
+ process.exit(1);
+ }
+}
+
+var cli = {
+ run
+};
+
+cli.run(process.argv.slice(2));
+
+var prettier = {
+
+};
+
+module.exports = prettier;
diff --git a/Colorui-UniApp/node_modules/prettier/index.js b/Colorui-UniApp/node_modules/prettier/index.js
new file mode 100644
index 0000000..b6233b2
--- /dev/null
+++ b/Colorui-UniApp/node_modules/prettier/index.js
@@ -0,0 +1,29708 @@
+'use strict';
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var fs = _interopDefault(require('fs'));
+var path = _interopDefault(require('path'));
+var util = _interopDefault(require('util'));
+var url = _interopDefault(require('url'));
+var assert = _interopDefault(require('assert'));
+var os = _interopDefault(require('os'));
+var thirdParty = require('./third-party');
+var thirdParty__default = thirdParty['default'];
+
+var name = "prettier";
+var version$1 = "1.12.1";
+var description = "Prettier is an opinionated code formatter";
+var bin = {"prettier":"./bin/prettier.js"};
+var repository = "prettier/prettier";
+var homepage = "https://prettier.io";
+var author = "James Long";
+var license = "MIT";
+var main = "./index.js";
+var engines = {"node":">=4"};
+var dependencies = {"@babel/code-frame":"7.0.0-beta.40","@glimmer/syntax":"0.30.3","babylon":"7.0.0-beta.34","camelcase":"4.1.0","chalk":"2.1.0","cjk-regex":"1.0.2","cosmiconfig":"3.1.0","dashify":"0.2.2","dedent":"0.7.0","diff":"3.2.0","editorconfig":"0.15.0","editorconfig-to-prettier":"0.0.6","emoji-regex":"6.5.1","escape-string-regexp":"1.0.5","esutils":"2.0.2","find-project-root":"1.1.1","flow-parser":"0.69","get-stream":"3.0.0","globby":"6.1.0","graphql":"0.13.2","gray-matter":"3.1.1","html-tag-names":"1.1.2","ignore":"3.3.7","jest-docblock":"22.2.2","json-stable-stringify":"1.0.1","leven":"2.1.0","mem":"1.1.0","minimatch":"3.0.4","minimist":"1.2.0","parse5":"3.0.3","postcss-less":"1.1.5","postcss-media-query-parser":"0.2.3","postcss-scss":"1.0.5","postcss-selector-parser":"2.2.3","postcss-values-parser":"1.5.0","read-pkg-up":"3.0.0","remark-frontmatter":"1.1.0","remark-parse":"5.0.0","resolve":"1.5.0","semver":"5.4.1","string-width":"2.1.1","typescript":"2.8.0-rc","typescript-eslint-parser":"14.0.0","unicode-regex":"1.0.1","unified":"6.1.6"};
+var devDependencies = {"babel-cli":"6.24.1","babel-preset-es2015":"6.24.1","codecov":"2.2.0","cross-env":"5.0.5","eslint":"4.18.2","eslint-config-prettier":"2.9.0","eslint-friendly-formatter":"3.0.0","eslint-plugin-import":"2.9.0","eslint-plugin-prettier":"2.6.0","eslint-plugin-react":"7.7.0","jest":"21.1.0","mkdirp":"0.5.1","prettier":"1.12.0","prettylint":"1.0.0","rimraf":"2.6.2","rollup":"0.47.6","rollup-plugin-commonjs":"8.2.6","rollup-plugin-json":"2.1.1","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.2.1","shelljs":"0.8.1","snapshot-diff":"0.2.2","strip-ansi":"4.0.0","tempy":"0.2.1","uglify-es":"3.3.9","webpack":"2.6.1"};
+var scripts = {"prepublishOnly":"echo \"Error: must publish from dist/\" && exit 1","prepare-release":"yarn && yarn build && yarn test:dist","test":"jest","test:dist":"node ./scripts/test-dist.js","test-integration":"jest tests_integration","lint":"cross-env EFF_NO_LINK_RULES=true eslint . --format node_modules/eslint-friendly-formatter","lint-docs":"prettylint {.,docs,website,website/blog}/*.md","build":"node ./scripts/build/build.js","build-docs":"node ./scripts/build/build-docs.js","check-deps":"node ./scripts/check-deps.js"};
+var _package = {
+ name: name,
+ version: version$1,
+ description: description,
+ bin: bin,
+ repository: repository,
+ homepage: homepage,
+ author: author,
+ license: license,
+ main: main,
+ engines: engines,
+ dependencies: dependencies,
+ devDependencies: devDependencies,
+ scripts: scripts
+};
+
+var _package$1 = Object.freeze({
+ name: name,
+ version: version$1,
+ description: description,
+ bin: bin,
+ repository: repository,
+ homepage: homepage,
+ author: author,
+ license: license,
+ main: main,
+ engines: engines,
+ dependencies: dependencies,
+ devDependencies: devDependencies,
+ scripts: scripts,
+ default: _package
+});
+
+var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function commonjsRequire () {
+ throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
+}
+
+function unwrapExports (x) {
+ return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, module) {
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var ansiRegex = createCommonjsModule(function (module) {
+'use strict';
+
+module.exports = () => {
+ const pattern = [
+ '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)',
+ '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))'
+ ].join('|');
+
+ return new RegExp(pattern, 'g');
+};
+});
+
+var stripAnsi = input => typeof input === 'string' ? input.replace(ansiRegex(), '') : input;
+
+var isFullwidthCodePoint = createCommonjsModule(function (module) {
+'use strict';
+/* eslint-disable yoda */
+module.exports = x => {
+ if (Number.isNaN(x)) {
+ return false;
+ }
+
+ // code points are derived from:
+ // http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt
+ if (
+ x >= 0x1100 && (
+ x <= 0x115f || // Hangul Jamo
+ x === 0x2329 || // LEFT-POINTING ANGLE BRACKET
+ x === 0x232a || // RIGHT-POINTING ANGLE BRACKET
+ // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+ (0x2e80 <= x && x <= 0x3247 && x !== 0x303f) ||
+ // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+ (0x3250 <= x && x <= 0x4dbf) ||
+ // CJK Unified Ideographs .. Yi Radicals
+ (0x4e00 <= x && x <= 0xa4c6) ||
+ // Hangul Jamo Extended-A
+ (0xa960 <= x && x <= 0xa97c) ||
+ // Hangul Syllables
+ (0xac00 <= x && x <= 0xd7a3) ||
+ // CJK Compatibility Ideographs
+ (0xf900 <= x && x <= 0xfaff) ||
+ // Vertical Forms
+ (0xfe10 <= x && x <= 0xfe19) ||
+ // CJK Compatibility Forms .. Small Form Variants
+ (0xfe30 <= x && x <= 0xfe6b) ||
+ // Halfwidth and Fullwidth Forms
+ (0xff01 <= x && x <= 0xff60) ||
+ (0xffe0 <= x && x <= 0xffe6) ||
+ // Kana Supplement
+ (0x1b000 <= x && x <= 0x1b001) ||
+ // Enclosed Ideographic Supplement
+ (0x1f200 <= x && x <= 0x1f251) ||
+ // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+ (0x20000 <= x && x <= 0x3fffd)
+ )
+ ) {
+ return true;
+ }
+
+ return false;
+};
+});
+
+var stringWidth = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+module.exports = str => {
+ if (typeof str !== 'string' || str.length === 0) {
+ return 0;
+ }
+
+ str = stripAnsi(str);
+
+ let width = 0;
+
+ for (let i = 0; i < str.length; i++) {
+ const code = str.codePointAt(i);
+
+ // Ignore control characters
+ if (code <= 0x1F || (code >= 0x7F && code <= 0x9F)) {
+ continue;
+ }
+
+ // Ignore combining characters
+ if (code >= 0x300 && code <= 0x36F) {
+ continue;
+ }
+
+ // Surrogates
+ if (code > 0xFFFF) {
+ i++;
+ }
+
+ width += isFullwidthCodePoint(code) ? 2 : 1;
+ }
+
+ return width;
+};
+});
+
+var emojiRegex$1 = function () {
+ // https://mathiasbynens.be/notes/es-unicode-property-escapes#emoji
+ return (/\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74)\uDB40\uDC7F|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC68(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92])|(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2695\u2696\u2708]\uFE0F|(?:\uD83C[\uDFFB-\uDFFF])\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]))|\uD83D\uDC69\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2695\u2696\u2708]|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83D\uDC69\u200D[\u2695\u2696\u2708])\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC68(?:\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C[\uDFFB-\uDFFF])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92])|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDD1-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC69\uDC6E\uDC70-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD18-\uDD1C\uDD1E\uDD1F\uDD26\uDD30-\uDD39\uDD3D\uDD3E\uDDD1-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])?|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDEEB\uDEEC\uDEF4-\uDEF8]|\uD83E[\uDD10-\uDD3A\uDD3C-\uDD3E\uDD40-\uDD45\uDD47-\uDD4C\uDD50-\uDD6B\uDD80-\uDD97\uDDC0\uDDD0-\uDDE6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u2660\u2663\u2665\u2666\u2668\u267B\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEF8]|\uD83E[\uDD10-\uDD3A\uDD3C-\uDD3E\uDD40-\uDD45\uDD47-\uDD4C\uDD50-\uDD6B\uDD80-\uDD97\uDDC0\uDDD0-\uDDE6])\uFE0F/g
+ );
+};
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+
+var escapeStringRegexp = function (str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+
+ return str.replace(matchOperatorsRe, '\\$&');
+};
+
+var punctuation_ranges = [
+ // http://www.unicode.org/charts/PDF/U3000.pdf CJK Symbols and Punctuation
+ [0x3000, 0x303f],
+ // http://www.unicode.org/charts/PDF/UAC00.pdf Hangul Syllables
+ [0xac00, 0xd7af],
+ // http://www.unicode.org/charts/PDF/UFE10.pdf Vertical Forms
+ [0xfe10, 0xfe1f],
+ // http://www.unicode.org/charts/PDF/UFE30.pdf CJK Compatibility Forms
+ // http://www.unicode.org/charts/PDF/UFE50.pdf Small Form Variants
+ [0xfe30, 0xfe6f],
+ // http://www.unicode.org/charts/PDF/UFF00.pdf Halfwidth and Fullwidth Forms
+ [0xff00, 0xff60],
+ [0xffe0, 0xffef],
+];
+var character_ranges = [
+ // http://www.unicode.org/charts/PDF/U1100.pdf Hangul Jamo
+ [0x1100, 0x11ff],
+ // http://www.unicode.org/charts/PDF/U2E80.pdf CJK Radicals Supplement
+ // http://www.unicode.org/charts/PDF/U2F00.pdf Kangxi Radicals
+ [0x2e80, 0x2fdf],
+ // http://www.unicode.org/charts/PDF/U3040.pdf Hiragana
+ // http://www.unicode.org/charts/PDF/U30A0.pdf Katakana
+ // http://www.unicode.org/charts/PDF/U3100.pdf Bopomofo
+ // http://www.unicode.org/charts/PDF/U3130.pdf Hangul Compatibility Jamo
+ [0x3040, 0x318f],
+ // http://www.unicode.org/charts/PDF/U3200.pdf Enclosed CJK Letters and Months
+ // http://www.unicode.org/charts/PDF/U3300.pdf CJK Compatibility
+ // http://www.unicode.org/charts/PDF/U3400.pdf CJK Unified Ideographs Extension A
+ [0x3200, 0x4dbf],
+ // http://www.unicode.org/charts/PDF/U4E00.pdf CJK Unified Ideographs (Han)
+ [0x4e00, 0x9fff],
+ // http://www.unicode.org/charts/PDF/UA960.pdf Hangul Jamo Extended-A
+ [0xa960, 0xa97f],
+ // http://www.unicode.org/charts/PDF/UF900.pdf CJK Compatibility Ideographs
+ [0xf900, 0xfaff],
+];
+function get_regex() {
+ return create_regex(character_ranges.concat(punctuation_ranges));
+}
+// istanbul ignore next
+// tslint:disable-next-line:no-namespace
+(function (get_regex) {
+ function punctuations() {
+ return create_regex(punctuation_ranges);
+ }
+ get_regex.punctuations = punctuations;
+ function characters() {
+ return create_regex(character_ranges);
+ }
+ get_regex.characters = characters;
+})(get_regex || (get_regex = {}));
+function create_regex(ranges) {
+ return new RegExp("[" + ranges.map(get_bracket_content).reduce(function (a, b) { return a + b; }) + "]", 'g');
+}
+function get_bracket_content(range) {
+ return get_escaped_unicode(range[0]) + "-" + get_escaped_unicode(range[1]);
+}
+function get_escaped_unicode(num) {
+ return "\\u" + num.toString(16);
+}
+var lib = get_regex;
+
+var data_generated = createCommonjsModule(function (module, exports) {
+"use strict";
+exports.__esModule = true;
+exports.get_data = function () { return ({ "Pc": [[95, 95], [8255, 8256], [8276, 8276], [65075, 65076], [65101, 65103], [65343, 65343]], "Pe": [[41, 41], [93, 93], [125, 125], [3899, 3899], [3901, 3901], [5788, 5788], [8262, 8262], [8318, 8318], [8334, 8334], [8969, 8969], [8971, 8971], [9002, 9002], [10089, 10089], [10091, 10091], [10093, 10093], [10095, 10095], [10097, 10097], [10099, 10099], [10101, 10101], [10182, 10182], [10215, 10215], [10217, 10217], [10219, 10219], [10221, 10221], [10223, 10223], [10628, 10628], [10630, 10630], [10632, 10632], [10634, 10634], [10636, 10636], [10638, 10638], [10640, 10640], [10642, 10642], [10644, 10644], [10646, 10646], [10648, 10648], [10713, 10713], [10715, 10715], [10749, 10749], [11811, 11811], [11813, 11813], [11815, 11815], [11817, 11817], [12297, 12297], [12299, 12299], [12301, 12301], [12303, 12303], [12305, 12305], [12309, 12309], [12311, 12311], [12313, 12313], [12315, 12315], [12318, 12319], [64830, 64830], [65048, 65048], [65078, 65078], [65080, 65080], [65082, 65082], [65084, 65084], [65086, 65086], [65088, 65088], [65090, 65090], [65092, 65092], [65096, 65096], [65114, 65114], [65116, 65116], [65118, 65118], [65289, 65289], [65341, 65341], [65373, 65373], [65376, 65376], [65379, 65379]], "Ps": [[40, 40], [91, 91], [123, 123], [3898, 3898], [3900, 3900], [5787, 5787], [8218, 8218], [8222, 8222], [8261, 8261], [8317, 8317], [8333, 8333], [8968, 8968], [8970, 8970], [9001, 9001], [10088, 10088], [10090, 10090], [10092, 10092], [10094, 10094], [10096, 10096], [10098, 10098], [10100, 10100], [10181, 10181], [10214, 10214], [10216, 10216], [10218, 10218], [10220, 10220], [10222, 10222], [10627, 10627], [10629, 10629], [10631, 10631], [10633, 10633], [10635, 10635], [10637, 10637], [10639, 10639], [10641, 10641], [10643, 10643], [10645, 10645], [10647, 10647], [10712, 10712], [10714, 10714], [10748, 10748], [11810, 11810], [11812, 11812], [11814, 11814], [11816, 11816], [11842, 11842], [12296, 12296], [12298, 12298], [12300, 12300], [12302, 12302], [12304, 12304], [12308, 12308], [12310, 12310], [12312, 12312], [12314, 12314], [12317, 12317], [64831, 64831], [65047, 65047], [65077, 65077], [65079, 65079], [65081, 65081], [65083, 65083], [65085, 65085], [65087, 65087], [65089, 65089], [65091, 65091], [65095, 65095], [65113, 65113], [65115, 65115], [65117, 65117], [65288, 65288], [65339, 65339], [65371, 65371], [65375, 65375], [65378, 65378]], "Lm": [[688, 705], [710, 721], [736, 740], [748, 748], [750, 750], [884, 884], [890, 890], [1369, 1369], [1600, 1600], [1765, 1766], [2036, 2037], [2042, 2042], [2074, 2074], [2084, 2084], [2088, 2088], [2417, 2417], [3654, 3654], [3782, 3782], [4348, 4348], [6103, 6103], [6211, 6211], [6823, 6823], [7288, 7293], [7468, 7530], [7544, 7544], [7579, 7615], [8305, 8305], [8319, 8319], [8336, 8348], [11388, 11389], [11631, 11631], [11823, 11823], [12293, 12293], [12337, 12341], [12347, 12347], [12445, 12446], [12540, 12542], [40981, 40981], [42232, 42237], [42508, 42508], [42623, 42623], [42652, 42653], [42775, 42783], [42864, 42864], [42888, 42888], [43000, 43001], [43471, 43471], [43494, 43494], [43632, 43632], [43741, 43741], [43763, 43764], [43868, 43871], [65392, 65392], [65438, 65439]], "Mc": [[2307, 2307], [2363, 2363], [2366, 2368], [2377, 2380], [2382, 2383], [2434, 2435], [2494, 2496], [2503, 2504], [2507, 2508], [2519, 2519], [2563, 2563], [2622, 2624], [2691, 2691], [2750, 2752], [2761, 2761], [2763, 2764], [2818, 2819], [2878, 2878], [2880, 2880], [2887, 2888], [2891, 2892], [2903, 2903], [3006, 3007], [3009, 3010], [3014, 3016], [3018, 3020], [3031, 3031], [3073, 3075], [3137, 3140], [3202, 3203], [3262, 3262], [3264, 3268], [3271, 3272], [3274, 3275], [3285, 3286], [3330, 3331], [3390, 3392], [3398, 3400], [3402, 3404], [3415, 3415], [3458, 3459], [3535, 3537], [3544, 3551], [3570, 3571], [3902, 3903], [3967, 3967], [4139, 4140], [4145, 4145], [4152, 4152], [4155, 4156], [4182, 4183], [4194, 4196], [4199, 4205], [4227, 4228], [4231, 4236], [4239, 4239], [4250, 4252], [6070, 6070], [6078, 6085], [6087, 6088], [6435, 6438], [6441, 6443], [6448, 6449], [6451, 6456], [6681, 6682], [6741, 6741], [6743, 6743], [6753, 6753], [6755, 6756], [6765, 6770], [6916, 6916], [6965, 6965], [6971, 6971], [6973, 6977], [6979, 6980], [7042, 7042], [7073, 7073], [7078, 7079], [7082, 7082], [7143, 7143], [7146, 7148], [7150, 7150], [7154, 7155], [7204, 7211], [7220, 7221], [7393, 7393], [7410, 7411], [7415, 7415], [12334, 12335], [43043, 43044], [43047, 43047], [43136, 43137], [43188, 43203], [43346, 43347], [43395, 43395], [43444, 43445], [43450, 43451], [43453, 43456], [43567, 43568], [43571, 43572], [43597, 43597], [43643, 43643], [43645, 43645], [43755, 43755], [43758, 43759], [43765, 43765], [44003, 44004], [44006, 44007], [44009, 44010], [44012, 44012]], "Zp": [[8233, 8233]], "Sc": [[36, 36], [162, 165], [1423, 1423], [1547, 1547], [2546, 2547], [2555, 2555], [2801, 2801], [3065, 3065], [3647, 3647], [6107, 6107], [8352, 8383], [43064, 43064], [65020, 65020], [65129, 65129], [65284, 65284], [65504, 65505], [65509, 65510]], "Me": [[1160, 1161], [6846, 6846], [8413, 8416], [8418, 8420], [42608, 42610]], "Sk": [[94, 94], [96, 96], [168, 168], [175, 175], [180, 180], [184, 184], [706, 709], [722, 735], [741, 747], [749, 749], [751, 767], [885, 885], [900, 901], [8125, 8125], [8127, 8129], [8141, 8143], [8157, 8159], [8173, 8175], [8189, 8190], [12443, 12444], [42752, 42774], [42784, 42785], [42889, 42890], [43867, 43867], [64434, 64449], [65342, 65342], [65344, 65344], [65507, 65507]], "Cs": [[55296, 55296], [56191, 56192], [56319, 56320], [57343, 57343]], "Nl": [[5870, 5872], [8544, 8578], [8581, 8584], [12295, 12295], [12321, 12329], [12344, 12346], [42726, 42735]], "So": [[166, 166], [169, 169], [174, 174], [176, 176], [1154, 1154], [1421, 1422], [1550, 1551], [1758, 1758], [1769, 1769], [1789, 1790], [2038, 2038], [2554, 2554], [2928, 2928], [3059, 3064], [3066, 3066], [3199, 3199], [3407, 3407], [3449, 3449], [3841, 3843], [3859, 3859], [3861, 3863], [3866, 3871], [3892, 3892], [3894, 3894], [3896, 3896], [4030, 4037], [4039, 4044], [4046, 4047], [4053, 4056], [4254, 4255], [5008, 5017], [6464, 6464], [6622, 6655], [7009, 7018], [7028, 7036], [8448, 8449], [8451, 8454], [8456, 8457], [8468, 8468], [8470, 8471], [8478, 8483], [8485, 8485], [8487, 8487], [8489, 8489], [8494, 8494], [8506, 8507], [8522, 8522], [8524, 8525], [8527, 8527], [8586, 8587], [8597, 8601], [8604, 8607], [8609, 8610], [8612, 8613], [8615, 8621], [8623, 8653], [8656, 8657], [8659, 8659], [8661, 8691], [8960, 8967], [8972, 8991], [8994, 9000], [9003, 9083], [9085, 9114], [9140, 9179], [9186, 9254], [9280, 9290], [9372, 9449], [9472, 9654], [9656, 9664], [9666, 9719], [9728, 9838], [9840, 10087], [10132, 10175], [10240, 10495], [11008, 11055], [11077, 11078], [11085, 11123], [11126, 11157], [11160, 11193], [11197, 11208], [11210, 11218], [11244, 11247], [11493, 11498], [11904, 11929], [11931, 12019], [12032, 12245], [12272, 12283], [12292, 12292], [12306, 12307], [12320, 12320], [12342, 12343], [12350, 12351], [12688, 12689], [12694, 12703], [12736, 12771], [12800, 12830], [12842, 12871], [12880, 12880], [12896, 12927], [12938, 12976], [12992, 13054], [13056, 13311], [19904, 19967], [42128, 42182], [43048, 43051], [43062, 43063], [43065, 43065], [43639, 43641], [65021, 65021], [65508, 65508], [65512, 65512], [65517, 65518], [65532, 65533]], "Lt": [[453, 453], [456, 456], [459, 459], [498, 498], [8072, 8079], [8088, 8095], [8104, 8111], [8124, 8124], [8140, 8140], [8188, 8188]], "Zl": [[8232, 8232]], "Lo": [[170, 170], [186, 186], [443, 443], [448, 451], [660, 660], [1488, 1514], [1520, 1522], [1568, 1599], [1601, 1610], [1646, 1647], [1649, 1747], [1749, 1749], [1774, 1775], [1786, 1788], [1791, 1791], [1808, 1808], [1810, 1839], [1869, 1957], [1969, 1969], [1994, 2026], [2048, 2069], [2112, 2136], [2144, 2154], [2208, 2228], [2230, 2237], [2308, 2361], [2365, 2365], [2384, 2384], [2392, 2401], [2418, 2432], [2437, 2444], [2447, 2448], [2451, 2472], [2474, 2480], [2482, 2482], [2486, 2489], [2493, 2493], [2510, 2510], [2524, 2525], [2527, 2529], [2544, 2545], [2556, 2556], [2565, 2570], [2575, 2576], [2579, 2600], [2602, 2608], [2610, 2611], [2613, 2614], [2616, 2617], [2649, 2652], [2654, 2654], [2674, 2676], [2693, 2701], [2703, 2705], [2707, 2728], [2730, 2736], [2738, 2739], [2741, 2745], [2749, 2749], [2768, 2768], [2784, 2785], [2809, 2809], [2821, 2828], [2831, 2832], [2835, 2856], [2858, 2864], [2866, 2867], [2869, 2873], [2877, 2877], [2908, 2909], [2911, 2913], [2929, 2929], [2947, 2947], [2949, 2954], [2958, 2960], [2962, 2965], [2969, 2970], [2972, 2972], [2974, 2975], [2979, 2980], [2984, 2986], [2990, 3001], [3024, 3024], [3077, 3084], [3086, 3088], [3090, 3112], [3114, 3129], [3133, 3133], [3160, 3162], [3168, 3169], [3200, 3200], [3205, 3212], [3214, 3216], [3218, 3240], [3242, 3251], [3253, 3257], [3261, 3261], [3294, 3294], [3296, 3297], [3313, 3314], [3333, 3340], [3342, 3344], [3346, 3386], [3389, 3389], [3406, 3406], [3412, 3414], [3423, 3425], [3450, 3455], [3461, 3478], [3482, 3505], [3507, 3515], [3517, 3517], [3520, 3526], [3585, 3632], [3634, 3635], [3648, 3653], [3713, 3714], [3716, 3716], [3719, 3720], [3722, 3722], [3725, 3725], [3732, 3735], [3737, 3743], [3745, 3747], [3749, 3749], [3751, 3751], [3754, 3755], [3757, 3760], [3762, 3763], [3773, 3773], [3776, 3780], [3804, 3807], [3840, 3840], [3904, 3911], [3913, 3948], [3976, 3980], [4096, 4138], [4159, 4159], [4176, 4181], [4186, 4189], [4193, 4193], [4197, 4198], [4206, 4208], [4213, 4225], [4238, 4238], [4304, 4346], [4349, 4680], [4682, 4685], [4688, 4694], [4696, 4696], [4698, 4701], [4704, 4744], [4746, 4749], [4752, 4784], [4786, 4789], [4792, 4798], [4800, 4800], [4802, 4805], [4808, 4822], [4824, 4880], [4882, 4885], [4888, 4954], [4992, 5007], [5121, 5740], [5743, 5759], [5761, 5786], [5792, 5866], [5873, 5880], [5888, 5900], [5902, 5905], [5920, 5937], [5952, 5969], [5984, 5996], [5998, 6000], [6016, 6067], [6108, 6108], [6176, 6210], [6212, 6263], [6272, 6276], [6279, 6312], [6314, 6314], [6320, 6389], [6400, 6430], [6480, 6509], [6512, 6516], [6528, 6571], [6576, 6601], [6656, 6678], [6688, 6740], [6917, 6963], [6981, 6987], [7043, 7072], [7086, 7087], [7098, 7141], [7168, 7203], [7245, 7247], [7258, 7287], [7401, 7404], [7406, 7409], [7413, 7414], [8501, 8504], [11568, 11623], [11648, 11670], [11680, 11686], [11688, 11694], [11696, 11702], [11704, 11710], [11712, 11718], [11720, 11726], [11728, 11734], [11736, 11742], [12294, 12294], [12348, 12348], [12353, 12438], [12447, 12447], [12449, 12538], [12543, 12543], [12549, 12590], [12593, 12686], [12704, 12730], [12784, 12799], [13312, 13312], [19893, 19893], [19968, 19968], [40938, 40938], [40960, 40980], [40982, 42124], [42192, 42231], [42240, 42507], [42512, 42527], [42538, 42539], [42606, 42606], [42656, 42725], [42895, 42895], [42999, 42999], [43003, 43009], [43011, 43013], [43015, 43018], [43020, 43042], [43072, 43123], [43138, 43187], [43250, 43255], [43259, 43259], [43261, 43261], [43274, 43301], [43312, 43334], [43360, 43388], [43396, 43442], [43488, 43492], [43495, 43503], [43514, 43518], [43520, 43560], [43584, 43586], [43588, 43595], [43616, 43631], [43633, 43638], [43642, 43642], [43646, 43695], [43697, 43697], [43701, 43702], [43705, 43709], [43712, 43712], [43714, 43714], [43739, 43740], [43744, 43754], [43762, 43762], [43777, 43782], [43785, 43790], [43793, 43798], [43808, 43814], [43816, 43822], [43968, 44002], [44032, 44032], [55203, 55203], [55216, 55238], [55243, 55291], [63744, 64109], [64112, 64217], [64285, 64285], [64287, 64296], [64298, 64310], [64312, 64316], [64318, 64318], [64320, 64321], [64323, 64324], [64326, 64433], [64467, 64829], [64848, 64911], [64914, 64967], [65008, 65019], [65136, 65140], [65142, 65276], [65382, 65391], [65393, 65437], [65440, 65470], [65474, 65479], [65482, 65487], [65490, 65495], [65498, 65500]], "Mn": [[768, 879], [1155, 1159], [1425, 1469], [1471, 1471], [1473, 1474], [1476, 1477], [1479, 1479], [1552, 1562], [1611, 1631], [1648, 1648], [1750, 1756], [1759, 1764], [1767, 1768], [1770, 1773], [1809, 1809], [1840, 1866], [1958, 1968], [2027, 2035], [2070, 2073], [2075, 2083], [2085, 2087], [2089, 2093], [2137, 2139], [2260, 2273], [2275, 2306], [2362, 2362], [2364, 2364], [2369, 2376], [2381, 2381], [2385, 2391], [2402, 2403], [2433, 2433], [2492, 2492], [2497, 2500], [2509, 2509], [2530, 2531], [2561, 2562], [2620, 2620], [2625, 2626], [2631, 2632], [2635, 2637], [2641, 2641], [2672, 2673], [2677, 2677], [2689, 2690], [2748, 2748], [2753, 2757], [2759, 2760], [2765, 2765], [2786, 2787], [2810, 2815], [2817, 2817], [2876, 2876], [2879, 2879], [2881, 2884], [2893, 2893], [2902, 2902], [2914, 2915], [2946, 2946], [3008, 3008], [3021, 3021], [3072, 3072], [3134, 3136], [3142, 3144], [3146, 3149], [3157, 3158], [3170, 3171], [3201, 3201], [3260, 3260], [3263, 3263], [3270, 3270], [3276, 3277], [3298, 3299], [3328, 3329], [3387, 3388], [3393, 3396], [3405, 3405], [3426, 3427], [3530, 3530], [3538, 3540], [3542, 3542], [3633, 3633], [3636, 3642], [3655, 3662], [3761, 3761], [3764, 3769], [3771, 3772], [3784, 3789], [3864, 3865], [3893, 3893], [3895, 3895], [3897, 3897], [3953, 3966], [3968, 3972], [3974, 3975], [3981, 3991], [3993, 4028], [4038, 4038], [4141, 4144], [4146, 4151], [4153, 4154], [4157, 4158], [4184, 4185], [4190, 4192], [4209, 4212], [4226, 4226], [4229, 4230], [4237, 4237], [4253, 4253], [4957, 4959], [5906, 5908], [5938, 5940], [5970, 5971], [6002, 6003], [6068, 6069], [6071, 6077], [6086, 6086], [6089, 6099], [6109, 6109], [6155, 6157], [6277, 6278], [6313, 6313], [6432, 6434], [6439, 6440], [6450, 6450], [6457, 6459], [6679, 6680], [6683, 6683], [6742, 6742], [6744, 6750], [6752, 6752], [6754, 6754], [6757, 6764], [6771, 6780], [6783, 6783], [6832, 6845], [6912, 6915], [6964, 6964], [6966, 6970], [6972, 6972], [6978, 6978], [7019, 7027], [7040, 7041], [7074, 7077], [7080, 7081], [7083, 7085], [7142, 7142], [7144, 7145], [7149, 7149], [7151, 7153], [7212, 7219], [7222, 7223], [7376, 7378], [7380, 7392], [7394, 7400], [7405, 7405], [7412, 7412], [7416, 7417], [7616, 7673], [7675, 7679], [8400, 8412], [8417, 8417], [8421, 8432], [11503, 11505], [11647, 11647], [11744, 11775], [12330, 12333], [12441, 12442], [42607, 42607], [42612, 42621], [42654, 42655], [42736, 42737], [43010, 43010], [43014, 43014], [43019, 43019], [43045, 43046], [43204, 43205], [43232, 43249], [43302, 43309], [43335, 43345], [43392, 43394], [43443, 43443], [43446, 43449], [43452, 43452], [43493, 43493], [43561, 43566], [43569, 43570], [43573, 43574], [43587, 43587], [43596, 43596], [43644, 43644], [43696, 43696], [43698, 43700], [43703, 43704], [43710, 43711], [43713, 43713], [43756, 43757], [43766, 43766], [44005, 44005], [44008, 44008], [44013, 44013], [64286, 64286], [65024, 65039], [65056, 65071]], "Po": [[33, 35], [37, 39], [42, 42], [44, 44], [46, 47], [58, 59], [63, 64], [92, 92], [161, 161], [167, 167], [182, 183], [191, 191], [894, 894], [903, 903], [1370, 1375], [1417, 1417], [1472, 1472], [1475, 1475], [1478, 1478], [1523, 1524], [1545, 1546], [1548, 1549], [1563, 1563], [1566, 1567], [1642, 1645], [1748, 1748], [1792, 1805], [2039, 2041], [2096, 2110], [2142, 2142], [2404, 2405], [2416, 2416], [2557, 2557], [2800, 2800], [3572, 3572], [3663, 3663], [3674, 3675], [3844, 3858], [3860, 3860], [3973, 3973], [4048, 4052], [4057, 4058], [4170, 4175], [4347, 4347], [4960, 4968], [5741, 5742], [5867, 5869], [5941, 5942], [6100, 6102], [6104, 6106], [6144, 6149], [6151, 6154], [6468, 6469], [6686, 6687], [6816, 6822], [6824, 6829], [7002, 7008], [7164, 7167], [7227, 7231], [7294, 7295], [7360, 7367], [7379, 7379], [8214, 8215], [8224, 8231], [8240, 8248], [8251, 8254], [8257, 8259], [8263, 8273], [8275, 8275], [8277, 8286], [11513, 11516], [11518, 11519], [11632, 11632], [11776, 11777], [11782, 11784], [11787, 11787], [11790, 11798], [11800, 11801], [11803, 11803], [11806, 11807], [11818, 11822], [11824, 11833], [11836, 11839], [11841, 11841], [11843, 11849], [12289, 12291], [12349, 12349], [12539, 12539], [42238, 42239], [42509, 42511], [42611, 42611], [42622, 42622], [42738, 42743], [43124, 43127], [43214, 43215], [43256, 43258], [43260, 43260], [43310, 43311], [43359, 43359], [43457, 43469], [43486, 43487], [43612, 43615], [43742, 43743], [43760, 43761], [44011, 44011], [65040, 65046], [65049, 65049], [65072, 65072], [65093, 65094], [65097, 65100], [65104, 65106], [65108, 65111], [65119, 65121], [65128, 65128], [65130, 65131], [65281, 65283], [65285, 65287], [65290, 65290], [65292, 65292], [65294, 65295], [65306, 65307], [65311, 65312], [65340, 65340], [65377, 65377], [65380, 65381]], "Co": [[57344, 57344], [63743, 63743]], "Sm": [[43, 43], [60, 62], [124, 124], [126, 126], [172, 172], [177, 177], [215, 215], [247, 247], [1014, 1014], [1542, 1544], [8260, 8260], [8274, 8274], [8314, 8316], [8330, 8332], [8472, 8472], [8512, 8516], [8523, 8523], [8592, 8596], [8602, 8603], [8608, 8608], [8611, 8611], [8614, 8614], [8622, 8622], [8654, 8655], [8658, 8658], [8660, 8660], [8692, 8959], [8992, 8993], [9084, 9084], [9115, 9139], [9180, 9185], [9655, 9655], [9665, 9665], [9720, 9727], [9839, 9839], [10176, 10180], [10183, 10213], [10224, 10239], [10496, 10626], [10649, 10711], [10716, 10747], [10750, 11007], [11056, 11076], [11079, 11084], [64297, 64297], [65122, 65122], [65124, 65126], [65291, 65291], [65308, 65310], [65372, 65372], [65374, 65374], [65506, 65506], [65513, 65516]], "Pf": [[187, 187], [8217, 8217], [8221, 8221], [8250, 8250], [11779, 11779], [11781, 11781], [11786, 11786], [11789, 11789], [11805, 11805], [11809, 11809]], "Cc": [[0, 31], [127, 159]], "Pi": [[171, 171], [8216, 8216], [8219, 8220], [8223, 8223], [8249, 8249], [11778, 11778], [11780, 11780], [11785, 11785], [11788, 11788], [11804, 11804], [11808, 11808]], "Lu": [[65, 90], [192, 214], [216, 222], [256, 256], [258, 258], [260, 260], [262, 262], [264, 264], [266, 266], [268, 268], [270, 270], [272, 272], [274, 274], [276, 276], [278, 278], [280, 280], [282, 282], [284, 284], [286, 286], [288, 288], [290, 290], [292, 292], [294, 294], [296, 296], [298, 298], [300, 300], [302, 302], [304, 304], [306, 306], [308, 308], [310, 310], [313, 313], [315, 315], [317, 317], [319, 319], [321, 321], [323, 323], [325, 325], [327, 327], [330, 330], [332, 332], [334, 334], [336, 336], [338, 338], [340, 340], [342, 342], [344, 344], [346, 346], [348, 348], [350, 350], [352, 352], [354, 354], [356, 356], [358, 358], [360, 360], [362, 362], [364, 364], [366, 366], [368, 368], [370, 370], [372, 372], [374, 374], [376, 377], [379, 379], [381, 381], [385, 386], [388, 388], [390, 391], [393, 395], [398, 401], [403, 404], [406, 408], [412, 413], [415, 416], [418, 418], [420, 420], [422, 423], [425, 425], [428, 428], [430, 431], [433, 435], [437, 437], [439, 440], [444, 444], [452, 452], [455, 455], [458, 458], [461, 461], [463, 463], [465, 465], [467, 467], [469, 469], [471, 471], [473, 473], [475, 475], [478, 478], [480, 480], [482, 482], [484, 484], [486, 486], [488, 488], [490, 490], [492, 492], [494, 494], [497, 497], [500, 500], [502, 504], [506, 506], [508, 508], [510, 510], [512, 512], [514, 514], [516, 516], [518, 518], [520, 520], [522, 522], [524, 524], [526, 526], [528, 528], [530, 530], [532, 532], [534, 534], [536, 536], [538, 538], [540, 540], [542, 542], [544, 544], [546, 546], [548, 548], [550, 550], [552, 552], [554, 554], [556, 556], [558, 558], [560, 560], [562, 562], [570, 571], [573, 574], [577, 577], [579, 582], [584, 584], [586, 586], [588, 588], [590, 590], [880, 880], [882, 882], [886, 886], [895, 895], [902, 902], [904, 906], [908, 908], [910, 911], [913, 929], [931, 939], [975, 975], [978, 980], [984, 984], [986, 986], [988, 988], [990, 990], [992, 992], [994, 994], [996, 996], [998, 998], [1000, 1000], [1002, 1002], [1004, 1004], [1006, 1006], [1012, 1012], [1015, 1015], [1017, 1018], [1021, 1071], [1120, 1120], [1122, 1122], [1124, 1124], [1126, 1126], [1128, 1128], [1130, 1130], [1132, 1132], [1134, 1134], [1136, 1136], [1138, 1138], [1140, 1140], [1142, 1142], [1144, 1144], [1146, 1146], [1148, 1148], [1150, 1150], [1152, 1152], [1162, 1162], [1164, 1164], [1166, 1166], [1168, 1168], [1170, 1170], [1172, 1172], [1174, 1174], [1176, 1176], [1178, 1178], [1180, 1180], [1182, 1182], [1184, 1184], [1186, 1186], [1188, 1188], [1190, 1190], [1192, 1192], [1194, 1194], [1196, 1196], [1198, 1198], [1200, 1200], [1202, 1202], [1204, 1204], [1206, 1206], [1208, 1208], [1210, 1210], [1212, 1212], [1214, 1214], [1216, 1217], [1219, 1219], [1221, 1221], [1223, 1223], [1225, 1225], [1227, 1227], [1229, 1229], [1232, 1232], [1234, 1234], [1236, 1236], [1238, 1238], [1240, 1240], [1242, 1242], [1244, 1244], [1246, 1246], [1248, 1248], [1250, 1250], [1252, 1252], [1254, 1254], [1256, 1256], [1258, 1258], [1260, 1260], [1262, 1262], [1264, 1264], [1266, 1266], [1268, 1268], [1270, 1270], [1272, 1272], [1274, 1274], [1276, 1276], [1278, 1278], [1280, 1280], [1282, 1282], [1284, 1284], [1286, 1286], [1288, 1288], [1290, 1290], [1292, 1292], [1294, 1294], [1296, 1296], [1298, 1298], [1300, 1300], [1302, 1302], [1304, 1304], [1306, 1306], [1308, 1308], [1310, 1310], [1312, 1312], [1314, 1314], [1316, 1316], [1318, 1318], [1320, 1320], [1322, 1322], [1324, 1324], [1326, 1326], [1329, 1366], [4256, 4293], [4295, 4295], [4301, 4301], [5024, 5109], [7680, 7680], [7682, 7682], [7684, 7684], [7686, 7686], [7688, 7688], [7690, 7690], [7692, 7692], [7694, 7694], [7696, 7696], [7698, 7698], [7700, 7700], [7702, 7702], [7704, 7704], [7706, 7706], [7708, 7708], [7710, 7710], [7712, 7712], [7714, 7714], [7716, 7716], [7718, 7718], [7720, 7720], [7722, 7722], [7724, 7724], [7726, 7726], [7728, 7728], [7730, 7730], [7732, 7732], [7734, 7734], [7736, 7736], [7738, 7738], [7740, 7740], [7742, 7742], [7744, 7744], [7746, 7746], [7748, 7748], [7750, 7750], [7752, 7752], [7754, 7754], [7756, 7756], [7758, 7758], [7760, 7760], [7762, 7762], [7764, 7764], [7766, 7766], [7768, 7768], [7770, 7770], [7772, 7772], [7774, 7774], [7776, 7776], [7778, 7778], [7780, 7780], [7782, 7782], [7784, 7784], [7786, 7786], [7788, 7788], [7790, 7790], [7792, 7792], [7794, 7794], [7796, 7796], [7798, 7798], [7800, 7800], [7802, 7802], [7804, 7804], [7806, 7806], [7808, 7808], [7810, 7810], [7812, 7812], [7814, 7814], [7816, 7816], [7818, 7818], [7820, 7820], [7822, 7822], [7824, 7824], [7826, 7826], [7828, 7828], [7838, 7838], [7840, 7840], [7842, 7842], [7844, 7844], [7846, 7846], [7848, 7848], [7850, 7850], [7852, 7852], [7854, 7854], [7856, 7856], [7858, 7858], [7860, 7860], [7862, 7862], [7864, 7864], [7866, 7866], [7868, 7868], [7870, 7870], [7872, 7872], [7874, 7874], [7876, 7876], [7878, 7878], [7880, 7880], [7882, 7882], [7884, 7884], [7886, 7886], [7888, 7888], [7890, 7890], [7892, 7892], [7894, 7894], [7896, 7896], [7898, 7898], [7900, 7900], [7902, 7902], [7904, 7904], [7906, 7906], [7908, 7908], [7910, 7910], [7912, 7912], [7914, 7914], [7916, 7916], [7918, 7918], [7920, 7920], [7922, 7922], [7924, 7924], [7926, 7926], [7928, 7928], [7930, 7930], [7932, 7932], [7934, 7934], [7944, 7951], [7960, 7965], [7976, 7983], [7992, 7999], [8008, 8013], [8025, 8025], [8027, 8027], [8029, 8029], [8031, 8031], [8040, 8047], [8120, 8123], [8136, 8139], [8152, 8155], [8168, 8172], [8184, 8187], [8450, 8450], [8455, 8455], [8459, 8461], [8464, 8466], [8469, 8469], [8473, 8477], [8484, 8484], [8486, 8486], [8488, 8488], [8490, 8493], [8496, 8499], [8510, 8511], [8517, 8517], [8579, 8579], [11264, 11310], [11360, 11360], [11362, 11364], [11367, 11367], [11369, 11369], [11371, 11371], [11373, 11376], [11378, 11378], [11381, 11381], [11390, 11392], [11394, 11394], [11396, 11396], [11398, 11398], [11400, 11400], [11402, 11402], [11404, 11404], [11406, 11406], [11408, 11408], [11410, 11410], [11412, 11412], [11414, 11414], [11416, 11416], [11418, 11418], [11420, 11420], [11422, 11422], [11424, 11424], [11426, 11426], [11428, 11428], [11430, 11430], [11432, 11432], [11434, 11434], [11436, 11436], [11438, 11438], [11440, 11440], [11442, 11442], [11444, 11444], [11446, 11446], [11448, 11448], [11450, 11450], [11452, 11452], [11454, 11454], [11456, 11456], [11458, 11458], [11460, 11460], [11462, 11462], [11464, 11464], [11466, 11466], [11468, 11468], [11470, 11470], [11472, 11472], [11474, 11474], [11476, 11476], [11478, 11478], [11480, 11480], [11482, 11482], [11484, 11484], [11486, 11486], [11488, 11488], [11490, 11490], [11499, 11499], [11501, 11501], [11506, 11506], [42560, 42560], [42562, 42562], [42564, 42564], [42566, 42566], [42568, 42568], [42570, 42570], [42572, 42572], [42574, 42574], [42576, 42576], [42578, 42578], [42580, 42580], [42582, 42582], [42584, 42584], [42586, 42586], [42588, 42588], [42590, 42590], [42592, 42592], [42594, 42594], [42596, 42596], [42598, 42598], [42600, 42600], [42602, 42602], [42604, 42604], [42624, 42624], [42626, 42626], [42628, 42628], [42630, 42630], [42632, 42632], [42634, 42634], [42636, 42636], [42638, 42638], [42640, 42640], [42642, 42642], [42644, 42644], [42646, 42646], [42648, 42648], [42650, 42650], [42786, 42786], [42788, 42788], [42790, 42790], [42792, 42792], [42794, 42794], [42796, 42796], [42798, 42798], [42802, 42802], [42804, 42804], [42806, 42806], [42808, 42808], [42810, 42810], [42812, 42812], [42814, 42814], [42816, 42816], [42818, 42818], [42820, 42820], [42822, 42822], [42824, 42824], [42826, 42826], [42828, 42828], [42830, 42830], [42832, 42832], [42834, 42834], [42836, 42836], [42838, 42838], [42840, 42840], [42842, 42842], [42844, 42844], [42846, 42846], [42848, 42848], [42850, 42850], [42852, 42852], [42854, 42854], [42856, 42856], [42858, 42858], [42860, 42860], [42862, 42862], [42873, 42873], [42875, 42875], [42877, 42878], [42880, 42880], [42882, 42882], [42884, 42884], [42886, 42886], [42891, 42891], [42893, 42893], [42896, 42896], [42898, 42898], [42902, 42902], [42904, 42904], [42906, 42906], [42908, 42908], [42910, 42910], [42912, 42912], [42914, 42914], [42916, 42916], [42918, 42918], [42920, 42920], [42922, 42926], [42928, 42932], [42934, 42934], [65313, 65338]], "Pd": [[45, 45], [1418, 1418], [1470, 1470], [5120, 5120], [6150, 6150], [8208, 8213], [11799, 11799], [11802, 11802], [11834, 11835], [11840, 11840], [12316, 12316], [12336, 12336], [12448, 12448], [65073, 65074], [65112, 65112], [65123, 65123], [65293, 65293]], "Cf": [[173, 173], [1536, 1541], [1564, 1564], [1757, 1757], [1807, 1807], [2274, 2274], [6158, 6158], [8203, 8207], [8234, 8238], [8288, 8292], [8294, 8303], [65279, 65279], [65529, 65531]], "Nd": [[48, 57], [1632, 1641], [1776, 1785], [1984, 1993], [2406, 2415], [2534, 2543], [2662, 2671], [2790, 2799], [2918, 2927], [3046, 3055], [3174, 3183], [3302, 3311], [3430, 3439], [3558, 3567], [3664, 3673], [3792, 3801], [3872, 3881], [4160, 4169], [4240, 4249], [6112, 6121], [6160, 6169], [6470, 6479], [6608, 6617], [6784, 6793], [6800, 6809], [6992, 7001], [7088, 7097], [7232, 7241], [7248, 7257], [42528, 42537], [43216, 43225], [43264, 43273], [43472, 43481], [43504, 43513], [43600, 43609], [44016, 44025], [65296, 65305]], "Ll": [[97, 122], [181, 181], [223, 246], [248, 255], [257, 257], [259, 259], [261, 261], [263, 263], [265, 265], [267, 267], [269, 269], [271, 271], [273, 273], [275, 275], [277, 277], [279, 279], [281, 281], [283, 283], [285, 285], [287, 287], [289, 289], [291, 291], [293, 293], [295, 295], [297, 297], [299, 299], [301, 301], [303, 303], [305, 305], [307, 307], [309, 309], [311, 312], [314, 314], [316, 316], [318, 318], [320, 320], [322, 322], [324, 324], [326, 326], [328, 329], [331, 331], [333, 333], [335, 335], [337, 337], [339, 339], [341, 341], [343, 343], [345, 345], [347, 347], [349, 349], [351, 351], [353, 353], [355, 355], [357, 357], [359, 359], [361, 361], [363, 363], [365, 365], [367, 367], [369, 369], [371, 371], [373, 373], [375, 375], [378, 378], [380, 380], [382, 384], [387, 387], [389, 389], [392, 392], [396, 397], [402, 402], [405, 405], [409, 411], [414, 414], [417, 417], [419, 419], [421, 421], [424, 424], [426, 427], [429, 429], [432, 432], [436, 436], [438, 438], [441, 442], [445, 447], [454, 454], [457, 457], [460, 460], [462, 462], [464, 464], [466, 466], [468, 468], [470, 470], [472, 472], [474, 474], [476, 477], [479, 479], [481, 481], [483, 483], [485, 485], [487, 487], [489, 489], [491, 491], [493, 493], [495, 496], [499, 499], [501, 501], [505, 505], [507, 507], [509, 509], [511, 511], [513, 513], [515, 515], [517, 517], [519, 519], [521, 521], [523, 523], [525, 525], [527, 527], [529, 529], [531, 531], [533, 533], [535, 535], [537, 537], [539, 539], [541, 541], [543, 543], [545, 545], [547, 547], [549, 549], [551, 551], [553, 553], [555, 555], [557, 557], [559, 559], [561, 561], [563, 569], [572, 572], [575, 576], [578, 578], [583, 583], [585, 585], [587, 587], [589, 589], [591, 659], [661, 687], [881, 881], [883, 883], [887, 887], [891, 893], [912, 912], [940, 974], [976, 977], [981, 983], [985, 985], [987, 987], [989, 989], [991, 991], [993, 993], [995, 995], [997, 997], [999, 999], [1001, 1001], [1003, 1003], [1005, 1005], [1007, 1011], [1013, 1013], [1016, 1016], [1019, 1020], [1072, 1119], [1121, 1121], [1123, 1123], [1125, 1125], [1127, 1127], [1129, 1129], [1131, 1131], [1133, 1133], [1135, 1135], [1137, 1137], [1139, 1139], [1141, 1141], [1143, 1143], [1145, 1145], [1147, 1147], [1149, 1149], [1151, 1151], [1153, 1153], [1163, 1163], [1165, 1165], [1167, 1167], [1169, 1169], [1171, 1171], [1173, 1173], [1175, 1175], [1177, 1177], [1179, 1179], [1181, 1181], [1183, 1183], [1185, 1185], [1187, 1187], [1189, 1189], [1191, 1191], [1193, 1193], [1195, 1195], [1197, 1197], [1199, 1199], [1201, 1201], [1203, 1203], [1205, 1205], [1207, 1207], [1209, 1209], [1211, 1211], [1213, 1213], [1215, 1215], [1218, 1218], [1220, 1220], [1222, 1222], [1224, 1224], [1226, 1226], [1228, 1228], [1230, 1231], [1233, 1233], [1235, 1235], [1237, 1237], [1239, 1239], [1241, 1241], [1243, 1243], [1245, 1245], [1247, 1247], [1249, 1249], [1251, 1251], [1253, 1253], [1255, 1255], [1257, 1257], [1259, 1259], [1261, 1261], [1263, 1263], [1265, 1265], [1267, 1267], [1269, 1269], [1271, 1271], [1273, 1273], [1275, 1275], [1277, 1277], [1279, 1279], [1281, 1281], [1283, 1283], [1285, 1285], [1287, 1287], [1289, 1289], [1291, 1291], [1293, 1293], [1295, 1295], [1297, 1297], [1299, 1299], [1301, 1301], [1303, 1303], [1305, 1305], [1307, 1307], [1309, 1309], [1311, 1311], [1313, 1313], [1315, 1315], [1317, 1317], [1319, 1319], [1321, 1321], [1323, 1323], [1325, 1325], [1327, 1327], [1377, 1415], [5112, 5117], [7296, 7304], [7424, 7467], [7531, 7543], [7545, 7578], [7681, 7681], [7683, 7683], [7685, 7685], [7687, 7687], [7689, 7689], [7691, 7691], [7693, 7693], [7695, 7695], [7697, 7697], [7699, 7699], [7701, 7701], [7703, 7703], [7705, 7705], [7707, 7707], [7709, 7709], [7711, 7711], [7713, 7713], [7715, 7715], [7717, 7717], [7719, 7719], [7721, 7721], [7723, 7723], [7725, 7725], [7727, 7727], [7729, 7729], [7731, 7731], [7733, 7733], [7735, 7735], [7737, 7737], [7739, 7739], [7741, 7741], [7743, 7743], [7745, 7745], [7747, 7747], [7749, 7749], [7751, 7751], [7753, 7753], [7755, 7755], [7757, 7757], [7759, 7759], [7761, 7761], [7763, 7763], [7765, 7765], [7767, 7767], [7769, 7769], [7771, 7771], [7773, 7773], [7775, 7775], [7777, 7777], [7779, 7779], [7781, 7781], [7783, 7783], [7785, 7785], [7787, 7787], [7789, 7789], [7791, 7791], [7793, 7793], [7795, 7795], [7797, 7797], [7799, 7799], [7801, 7801], [7803, 7803], [7805, 7805], [7807, 7807], [7809, 7809], [7811, 7811], [7813, 7813], [7815, 7815], [7817, 7817], [7819, 7819], [7821, 7821], [7823, 7823], [7825, 7825], [7827, 7827], [7829, 7837], [7839, 7839], [7841, 7841], [7843, 7843], [7845, 7845], [7847, 7847], [7849, 7849], [7851, 7851], [7853, 7853], [7855, 7855], [7857, 7857], [7859, 7859], [7861, 7861], [7863, 7863], [7865, 7865], [7867, 7867], [7869, 7869], [7871, 7871], [7873, 7873], [7875, 7875], [7877, 7877], [7879, 7879], [7881, 7881], [7883, 7883], [7885, 7885], [7887, 7887], [7889, 7889], [7891, 7891], [7893, 7893], [7895, 7895], [7897, 7897], [7899, 7899], [7901, 7901], [7903, 7903], [7905, 7905], [7907, 7907], [7909, 7909], [7911, 7911], [7913, 7913], [7915, 7915], [7917, 7917], [7919, 7919], [7921, 7921], [7923, 7923], [7925, 7925], [7927, 7927], [7929, 7929], [7931, 7931], [7933, 7933], [7935, 7943], [7952, 7957], [7968, 7975], [7984, 7991], [8000, 8005], [8016, 8023], [8032, 8039], [8048, 8061], [8064, 8071], [8080, 8087], [8096, 8103], [8112, 8116], [8118, 8119], [8126, 8126], [8130, 8132], [8134, 8135], [8144, 8147], [8150, 8151], [8160, 8167], [8178, 8180], [8182, 8183], [8458, 8458], [8462, 8463], [8467, 8467], [8495, 8495], [8500, 8500], [8505, 8505], [8508, 8509], [8518, 8521], [8526, 8526], [8580, 8580], [11312, 11358], [11361, 11361], [11365, 11366], [11368, 11368], [11370, 11370], [11372, 11372], [11377, 11377], [11379, 11380], [11382, 11387], [11393, 11393], [11395, 11395], [11397, 11397], [11399, 11399], [11401, 11401], [11403, 11403], [11405, 11405], [11407, 11407], [11409, 11409], [11411, 11411], [11413, 11413], [11415, 11415], [11417, 11417], [11419, 11419], [11421, 11421], [11423, 11423], [11425, 11425], [11427, 11427], [11429, 11429], [11431, 11431], [11433, 11433], [11435, 11435], [11437, 11437], [11439, 11439], [11441, 11441], [11443, 11443], [11445, 11445], [11447, 11447], [11449, 11449], [11451, 11451], [11453, 11453], [11455, 11455], [11457, 11457], [11459, 11459], [11461, 11461], [11463, 11463], [11465, 11465], [11467, 11467], [11469, 11469], [11471, 11471], [11473, 11473], [11475, 11475], [11477, 11477], [11479, 11479], [11481, 11481], [11483, 11483], [11485, 11485], [11487, 11487], [11489, 11489], [11491, 11492], [11500, 11500], [11502, 11502], [11507, 11507], [11520, 11557], [11559, 11559], [11565, 11565], [42561, 42561], [42563, 42563], [42565, 42565], [42567, 42567], [42569, 42569], [42571, 42571], [42573, 42573], [42575, 42575], [42577, 42577], [42579, 42579], [42581, 42581], [42583, 42583], [42585, 42585], [42587, 42587], [42589, 42589], [42591, 42591], [42593, 42593], [42595, 42595], [42597, 42597], [42599, 42599], [42601, 42601], [42603, 42603], [42605, 42605], [42625, 42625], [42627, 42627], [42629, 42629], [42631, 42631], [42633, 42633], [42635, 42635], [42637, 42637], [42639, 42639], [42641, 42641], [42643, 42643], [42645, 42645], [42647, 42647], [42649, 42649], [42651, 42651], [42787, 42787], [42789, 42789], [42791, 42791], [42793, 42793], [42795, 42795], [42797, 42797], [42799, 42801], [42803, 42803], [42805, 42805], [42807, 42807], [42809, 42809], [42811, 42811], [42813, 42813], [42815, 42815], [42817, 42817], [42819, 42819], [42821, 42821], [42823, 42823], [42825, 42825], [42827, 42827], [42829, 42829], [42831, 42831], [42833, 42833], [42835, 42835], [42837, 42837], [42839, 42839], [42841, 42841], [42843, 42843], [42845, 42845], [42847, 42847], [42849, 42849], [42851, 42851], [42853, 42853], [42855, 42855], [42857, 42857], [42859, 42859], [42861, 42861], [42863, 42863], [42865, 42872], [42874, 42874], [42876, 42876], [42879, 42879], [42881, 42881], [42883, 42883], [42885, 42885], [42887, 42887], [42892, 42892], [42894, 42894], [42897, 42897], [42899, 42901], [42903, 42903], [42905, 42905], [42907, 42907], [42909, 42909], [42911, 42911], [42913, 42913], [42915, 42915], [42917, 42917], [42919, 42919], [42921, 42921], [42933, 42933], [42935, 42935], [43002, 43002], [43824, 43866], [43872, 43877], [43888, 43967], [64256, 64262], [64275, 64279], [65345, 65370]], "No": [[178, 179], [185, 185], [188, 190], [2548, 2553], [2930, 2935], [3056, 3058], [3192, 3198], [3416, 3422], [3440, 3448], [3882, 3891], [4969, 4988], [6128, 6137], [6618, 6618], [8304, 8304], [8308, 8313], [8320, 8329], [8528, 8543], [8585, 8585], [9312, 9371], [9450, 9471], [10102, 10131], [11517, 11517], [12690, 12693], [12832, 12841], [12872, 12879], [12881, 12895], [12928, 12937], [12977, 12991], [43056, 43061]], "Zs": [[32, 32], [160, 160], [5760, 5760], [8192, 8202], [8239, 8239], [8287, 8287], [12288, 12288]] }); };
+});
+
+unwrapExports(data_generated);
+
+var utils = createCommonjsModule(function (module, exports) {
+"use strict";
+exports.__esModule = true;
+function normalize_ranges(ranges) {
+ return ranges
+ .sort(function (_a, _b) {
+ var start1 = _a[0];
+ var start2 = _b[0];
+ return start1 - start2;
+ })
+ .reduce(function (current, tuple, index) {
+ if (index === 0) {
+ return [tuple];
+ }
+ var _a = current[current.length - 1], last_start = _a[0], last_end = _a[1];
+ var start = tuple[0], end = tuple[1];
+ return last_end + 1 === start
+ ? current.slice(0, -1).concat([[last_start, end]]) : current.concat([tuple]);
+ }, []);
+}
+exports.normalize_ranges = normalize_ranges;
+function build_regex(ranges, flag) {
+ var pattern = ranges
+ .map(function (_a) {
+ var start = _a[0], end = _a[1];
+ return start === end
+ ? "\\u" + get_hex(start)
+ : "\\u" + get_hex(start) + "-\\u" + get_hex(end);
+ })
+ .join('');
+ return new RegExp("[" + pattern + "]", flag);
+}
+exports.build_regex = build_regex;
+function get_hex(char_code) {
+ var hex = char_code.toString(16);
+ while (hex.length < 4) {
+ hex = "0" + hex;
+ }
+ return hex;
+}
+});
+
+unwrapExports(utils);
+
+var lib$2 = function (categories, flag) {
+ var data = data_generated.get_data();
+ var ranges = categories.reduce(function (current, category) { return current.concat(data[category]); }, []);
+ return utils.build_regex(utils.normalize_ranges(ranges), flag);
+};
+
+const emojiRegex = emojiRegex$1();
+
+
+
+
+const cjkPattern = lib().source;
+
+// http://spec.commonmark.org/0.25/#ascii-punctuation-character
+const asciiPunctuationCharRange = escapeStringRegexp(
+ "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+);
+
+// http://spec.commonmark.org/0.25/#punctuation-character
+const punctuationCharRange = `${asciiPunctuationCharRange}${lib$2([
+ "Pc",
+ "Pd",
+ "Pe",
+ "Pf",
+ "Pi",
+ "Po",
+ "Ps"
+]).source.slice(1, -1)}`; // remove bracket expression `[` and `]`
+
+const punctuationRegex = new RegExp(`[${punctuationCharRange}]`);
+
+function isExportDeclaration(node) {
+ if (node) {
+ switch (node.type) {
+ case "ExportDefaultDeclaration":
+ case "ExportDefaultSpecifier":
+ case "DeclareExportDeclaration":
+ case "ExportNamedDeclaration":
+ case "ExportAllDeclaration":
+ return true;
+ }
+ }
+
+ return false;
+}
+
+function getParentExportDeclaration(path$$1) {
+ const parentNode = path$$1.getParentNode();
+ if (path$$1.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, locStart) {
+ let idx = locStart(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 isNextLineEmptyAfterIndex(text, index) {
+ let oldIdx = null;
+ let idx = index;
+ 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 isNextLineEmpty(text, node, locEnd) {
+ return isNextLineEmptyAfterIndex(text, locEnd(node));
+}
+
+function getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd) {
+ let oldIdx = null;
+ let idx = locEnd(node);
+ while (idx !== oldIdx) {
+ oldIdx = idx;
+ idx = skipSpaces(text, idx);
+ idx = skipInlineComment(text, idx);
+ idx = skipTrailingComment(text, idx);
+ idx = skipNewline(text, idx);
+ }
+ return idx;
+}
+
+function getNextNonSpaceNonCommentCharacter(text, node, locEnd) {
+ return text.charAt(
+ getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd)
+ );
+}
+
+function hasSpaces(text, index, opts) {
+ opts = opts || {};
+ const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts);
+ return idx !== index;
+}
+
+// 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];
+}
+
+const equalityOperators = {
+ "==": true,
+ "!=": true,
+ "===": true,
+ "!==": true
+};
+const multiplicativeOperators = {
+ "*": true,
+ "/": true,
+ "%": true
+};
+const bitshiftOperators = {
+ ">>": true,
+ ">>>": true,
+ "<<": true
+};
+
+function shouldFlatten(parentOp, nodeOp) {
+ if (getPrecedence(nodeOp) !== getPrecedence(parentOp)) {
+ return false;
+ }
+
+ // ** is right-associative
+ // x ** y ** z --> x ** (y ** z)
+ if (parentOp === "**") {
+ return false;
+ }
+
+ // x == y == z --> (x == y) == z
+ if (equalityOperators[parentOp] && equalityOperators[nodeOp]) {
+ return false;
+ }
+
+ // x * y % z --> (x * y) % z
+ if (
+ (nodeOp === "%" && multiplicativeOperators[parentOp]) ||
+ (parentOp === "%" && multiplicativeOperators[nodeOp])
+ ) {
+ return false;
+ }
+
+ // x << y << z --> (x << y) << z
+ if (bitshiftOperators[parentOp] && bitshiftOperators[nodeOp]) {
+ return false;
+ }
+
+ return true;
+}
+
+function isBitwiseOperator(operator) {
+ return (
+ !!bitshiftOperators[operator] ||
+ operator === "|" ||
+ operator === "^" ||
+ operator === "&"
+ );
+}
+
+// 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) {
+ // Hack. Remove after https://github.com/eslint/typescript-eslint-parser/issues/331
+ case "ObjectPattern":
+ return !forbidFunctionAndClass;
+ 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
+ );
+ case "TSAsExpression":
+ return startsWithNoLookaheadToken(
+ node.expression,
+ forbidFunctionAndClass
+ );
+ default:
+ return false;
+ }
+}
+
+function getLeftMost(node) {
+ if (node.left) {
+ return getLeftMost(node.left);
+ }
+ return node;
+}
+
+function hasBlockComments(node) {
+ return node.comments && node.comments.some(isBlockComment);
+}
+
+function isBlockComment(comment) {
+ return comment.type === "Block" || comment.type === "CommentBlock";
+}
+
+function hasClosureCompilerTypeCastComment(text, node, locEnd) {
+ // https://github.com/google/closure-compiler/wiki/Annotating-Types#type-casts
+ // Syntax example: var x = /** @type {string} */ (fruit);
+ return (
+ node.comments &&
+ node.comments.some(
+ comment =>
+ comment.leading &&
+ isBlockComment(comment) &&
+ comment.value.match(/^\*\s*@type\s*{[^}]+}\s*$/) &&
+ getNextNonSpaceNonCommentCharacter(text, comment, locEnd) === "("
+ )
+ );
+}
+
+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;
+}
+
+function getIndentSize(value, tabWidth) {
+ const lastNewlineIndex = value.lastIndexOf("\n");
+ if (lastNewlineIndex === -1) {
+ return 0;
+ }
+
+ return getAlignmentSize(
+ // All the leading whitespaces
+ value.slice(lastNewlineIndex + 1).match(/^[ \t]*/)[0],
+ tabWidth
+ );
+}
+
+function printString(raw, options, isDirectiveLiteral) {
+ // `rawContent` is the string exactly like it appeared in the input source
+ // code, without its enclosing quotes.
+ 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;
+ 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 =
+ options.parser === "json"
+ ? double.quote
+ : 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;
+ }
+ return raw;
+ }
+
+ // It might sound unnecessary to use `makeString` even if the string already
+ // is enclosed with `enclosingQuote`, but it isn't. The string 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,
+ !(
+ options.parser === "css" ||
+ options.parser === "less" ||
+ options.parser === "scss"
+ )
+ );
+}
+
+function makeString(rawContent, enclosingQuote, unescapeUnnecessaryEscapes) {
+ 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 unescapeUnnecessaryEscapes &&
+ /^[^\\nrvtbfux\r\n\u2028\u2029"'0-7]$/.test(escaped)
+ ? escaped
+ : "\\" + escaped;
+ });
+
+ return enclosingQuote + newContent + enclosingQuote;
+}
+
+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(/^([+-])?\./, "$10.")
+ // Remove extraneous trailing decimal zeroes.
+ .replace(/(\.\d+?)0+(?=e|$)/, "$1")
+ // Remove trailing dot.
+ .replace(/\.(?=e|$)/, "")
+ );
+}
+
+function getMaxContinuousCount(str, target) {
+ const results = str.match(
+ new RegExp(`(${escapeStringRegexp(target)})+`, "g")
+ );
+
+ if (results === null) {
+ return 0;
+ }
+
+ return results.reduce(
+ (maxCount, result) => Math.max(maxCount, result.length / target.length),
+ 0
+ );
+}
+
+/**
+ * split text into whitespaces and words
+ * @param {string} text
+ * @return {Array<{ type: "whitespace", value: " " | "\n" | "" } | { type: "word", value: string }>}
+ */
+function splitText(text) {
+ const KIND_NON_CJK = "non-cjk";
+ const KIND_CJK_CHARACTER = "cjk-character";
+ const KIND_CJK_PUNCTUATION = "cjk-punctuation";
+
+ const nodes = [];
+
+ text
+ .replace(new RegExp(`(${cjkPattern})\n(${cjkPattern})`, "g"), "$1$2")
+ .split(/([ \t\n]+)/)
+ .forEach((token, index, tokens) => {
+ // whitespace
+ if (index % 2 === 1) {
+ nodes.push({
+ type: "whitespace",
+ value: /\n/.test(token) ? "\n" : " "
+ });
+ return;
+ }
+
+ // word separated by whitespace
+
+ if ((index === 0 || index === tokens.length - 1) && token === "") {
+ return;
+ }
+
+ token
+ .split(new RegExp(`(${cjkPattern})`))
+ .forEach((innerToken, innerIndex, innerTokens) => {
+ if (
+ (innerIndex === 0 || innerIndex === innerTokens.length - 1) &&
+ innerToken === ""
+ ) {
+ return;
+ }
+
+ // non-CJK word
+ if (innerIndex % 2 === 0) {
+ if (innerToken !== "") {
+ appendNode({
+ type: "word",
+ value: innerToken,
+ kind: KIND_NON_CJK,
+ hasLeadingPunctuation: punctuationRegex.test(innerToken[0]),
+ hasTrailingPunctuation: punctuationRegex.test(
+ getLast(innerToken)
+ )
+ });
+ }
+ return;
+ }
+
+ // CJK character
+ appendNode(
+ punctuationRegex.test(innerToken)
+ ? {
+ type: "word",
+ value: innerToken,
+ kind: KIND_CJK_PUNCTUATION,
+ hasLeadingPunctuation: true,
+ hasTrailingPunctuation: true
+ }
+ : {
+ type: "word",
+ value: innerToken,
+ kind: KIND_CJK_CHARACTER,
+ hasLeadingPunctuation: false,
+ hasTrailingPunctuation: false
+ }
+ );
+ });
+ });
+
+ return nodes;
+
+ function appendNode(node) {
+ const lastNode = getLast(nodes);
+ if (lastNode && lastNode.type === "word") {
+ if (
+ (lastNode.kind === KIND_NON_CJK &&
+ node.kind === KIND_CJK_CHARACTER &&
+ !lastNode.hasTrailingPunctuation) ||
+ (lastNode.kind === KIND_CJK_CHARACTER &&
+ node.kind === KIND_NON_CJK &&
+ !node.hasLeadingPunctuation)
+ ) {
+ nodes.push({ type: "whitespace", value: " " });
+ } else if (
+ !isBetween(KIND_NON_CJK, KIND_CJK_PUNCTUATION) &&
+ // disallow leading/trailing full-width whitespace
+ ![lastNode.value, node.value].some(value => /\u3000/.test(value))
+ ) {
+ nodes.push({ type: "whitespace", value: "" });
+ }
+ }
+ nodes.push(node);
+
+ function isBetween(kind1, kind2) {
+ return (
+ (lastNode.kind === kind1 && node.kind === kind2) ||
+ (lastNode.kind === kind2 && node.kind === kind1)
+ );
+ }
+ }
+}
+
+function getStringWidth(text) {
+ if (!text) {
+ return 0;
+ }
+
+ // emojis are considered 2-char width for consistency
+ // see https://github.com/sindresorhus/string-width/issues/11
+ // for the reason why not implemented in `string-width`
+ return stringWidth(text.replace(emojiRegex, " "));
+}
+
+function hasIgnoreComment(path$$1) {
+ const node = path$$1.getValue();
+ return hasNodeIgnoreComment(node);
+}
+
+function hasNodeIgnoreComment(node) {
+ return (
+ node &&
+ node.comments &&
+ node.comments.length > 0 &&
+ node.comments.some(comment => comment.value.trim() === "prettier-ignore")
+ );
+}
+
+function arrayify(object, keyName) {
+ return Object.keys(object).reduce(
+ (array, key) =>
+ array.concat(Object.assign({ [keyName]: key }, object[key])),
+ []
+ );
+}
+
+function addCommentHelper(node, comment) {
+ const comments = node.comments || (node.comments = []);
+ comments.push(comment);
+ comment.printed = false;
+
+ // For some reason, TypeScript parses `// x` inside of JSXText as a comment
+ // We already "print" it via the raw text, we don't need to re-print it as a
+ // comment
+ if (node.type === "JSXText") {
+ comment.printed = true;
+ }
+}
+
+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);
+}
+
+var util$1 = {
+ arrayify,
+ punctuationRegex,
+ punctuationCharRange,
+ getStringWidth,
+ splitText,
+ getMaxContinuousCount,
+ getPrecedence,
+ shouldFlatten,
+ isBitwiseOperator,
+ isExportDeclaration,
+ getParentExportDeclaration,
+ getPenultimate,
+ getLast,
+ getNextNonSpaceNonCommentCharacterIndex,
+ getNextNonSpaceNonCommentCharacter,
+ skipWhitespace,
+ skipSpaces,
+ skipNewline,
+ isNextLineEmptyAfterIndex,
+ isNextLineEmpty,
+ isPreviousLineEmpty,
+ hasNewline,
+ hasNewlineInRange,
+ hasSpaces,
+ setLocStart,
+ setLocEnd,
+ startsWithNoLookaheadToken,
+ hasBlockComments,
+ isBlockComment,
+ hasClosureCompilerTypeCastComment,
+ getAlignmentSize,
+ getIndentSize,
+ printString,
+ printNumber,
+ hasIgnoreComment,
+ hasNodeIgnoreComment,
+ lineColumnToIndex,
+ makeString,
+ addLeadingComment,
+ addDanglingComment,
+ addTrailingComment
+};
+
+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, cb) {
+ if (doc.type === "concat" || doc.type === "fill") {
+ const parts = doc.parts.map(part => mapDoc(part, cb));
+ return cb(Object.assign({}, doc, { parts }));
+ } else if (doc.type === "if-break") {
+ const breakContents = doc.breakContents && mapDoc(doc.breakContents, cb);
+ const flatContents = doc.flatContents && mapDoc(doc.flatContents, cb);
+ return cb(Object.assign({}, doc, { breakContents, flatContents }));
+ } else if (doc.contents) {
+ const contents = mapDoc(doc.contents, cb);
+ return cb(Object.assign({}, doc, { contents }));
+ }
+ return cb(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(n) {
+ return typeof n === "string" && n.length === 0;
+}
+
+function isLineNext(doc) {
+ return findInDoc(
+ doc,
+ doc => {
+ if (typeof doc === "string") {
+ return false;
+ }
+ if (doc.type === "line") {
+ return true;
+ }
+ },
+ false
+ );
+}
+
+function willBreak(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
+ );
+}
+
+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 mapDoc(doc, d => {
+ if (d.type === "line" && !d.hard) {
+ return d.soft ? "" : " ";
+ } else if (d.type === "if-break") {
+ return d.flatContents || "";
+ }
+ return d;
+ });
+}
+
+function stripTrailingHardline(doc) {
+ // HACK remove ending hardline, original PR: #1984
+ if (
+ doc.type === "concat" &&
+ doc.parts.length === 2 &&
+ doc.parts[1].type === "concat" &&
+ doc.parts[1].parts.length === 2 &&
+ doc.parts[1].parts[0].hard &&
+ doc.parts[1].parts[1].type === "break-parent"
+ ) {
+ return doc.parts[0];
+ }
+ return doc;
+}
+
+var docUtils = {
+ isEmpty,
+ willBreak,
+ isLineNext,
+ traverseDoc,
+ mapDoc,
+ propagateBreaks,
+ removeLines,
+ stripTrailingHardline
+};
+
+function isNextLineEmpty$1(text, node, options) {
+ return util$1.isNextLineEmpty(text, node, options.locEnd);
+}
+
+function getNextNonSpaceNonCommentCharacterIndex$1(text, node, options) {
+ return util$1.getNextNonSpaceNonCommentCharacterIndex(
+ text,
+ node,
+ options.locEnd
+ );
+}
+
+var utilShared = {
+ isNextLineEmpty: isNextLineEmpty$1,
+ isNextLineEmptyAfterIndex: util$1.isNextLineEmptyAfterIndex,
+ getNextNonSpaceNonCommentCharacterIndex: getNextNonSpaceNonCommentCharacterIndex$1,
+ mapDoc: docUtils.mapDoc, // TODO: remove in 2.0, we already exposed it in docUtils
+ makeString: util$1.makeString,
+ addLeadingComment: util$1.addLeadingComment,
+ addDanglingComment: util$1.addDanglingComment,
+ addTrailingComment: util$1.addTrailingComment
+};
+
+var dedent_1 = createCommonjsModule(function (module) {
+"use strict";
+
+function dedent(strings) {
+
+ var raw = void 0;
+ if (typeof strings === "string") {
+ // dedent can be used as a plain function
+ raw = [strings];
+ } else {
+ raw = strings.raw;
+ }
+
+ // first, perform interpolation
+ var result = "";
+ for (var i = 0; i < raw.length; i++) {
+ result += raw[i].
+ // join lines when there is a suppressed newline
+ replace(/\\\n[ \t]*/g, "").
+
+ // handle escaped backticks
+ replace(/\\`/g, "`");
+
+ if (i < (arguments.length <= 1 ? 0 : arguments.length - 1)) {
+ result += arguments.length <= i + 1 ? undefined : arguments[i + 1];
+ }
+ }
+
+ // now strip indentation
+ var lines = result.split("\n");
+ var mindent = null;
+ lines.forEach(function (l) {
+ var m = l.match(/^(\s+)\S+/);
+ if (m) {
+ var indent = m[1].length;
+ if (!mindent) {
+ // this is the first indented line
+ mindent = indent;
+ } else {
+ mindent = Math.min(mindent, indent);
+ }
+ }
+ });
+
+ if (mindent !== null) {
+ result = lines.map(function (l) {
+ return l[0] === " " ? l.slice(mindent) : l;
+ }).join("\n");
+ }
+
+ // dedent eats leading and trailing whitespace too
+ result = result.trim();
+
+ // handle escaped newlines at the end to ensure they don't get stripped too
+ return result.replace(/\\n/g, "\n");
+}
+
+{
+ module.exports = dedent;
+}
+});
+
+var semver = createCommonjsModule(function (module, exports) {
+exports = module.exports = SemVer;
+
+// The debug function is excluded entirely from the minified version.
+/* nomin */ var debug;
+/* nomin */ if (typeof process === 'object' &&
+ /* nomin */ process.env &&
+ /* nomin */ process.env.NODE_DEBUG &&
+ /* nomin */ /\bsemver\b/i.test(process.env.NODE_DEBUG))
+ /* nomin */ debug = function() {
+ /* nomin */ var args = Array.prototype.slice.call(arguments, 0);
+ /* nomin */ args.unshift('SEMVER');
+ /* nomin */ console.log.apply(console, args);
+ /* nomin */ };
+/* nomin */ else
+ /* nomin */ debug = function() {};
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0';
+
+var MAX_LENGTH = 256;
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+
+// The actual regexps go on exports.re
+var re = exports.re = [];
+var src = exports.src = [];
+var R = 0;
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+var NUMERICIDENTIFIER = R++;
+src[NUMERICIDENTIFIER] = '0|[1-9]\\d*';
+var NUMERICIDENTIFIERLOOSE = R++;
+src[NUMERICIDENTIFIERLOOSE] = '[0-9]+';
+
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+var NONNUMERICIDENTIFIER = R++;
+src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*';
+
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+var MAINVERSION = R++;
+src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')';
+
+var MAINVERSIONLOOSE = R++;
+src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')';
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+var PRERELEASEIDENTIFIER = R++;
+src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+var PRERELEASEIDENTIFIERLOOSE = R++;
+src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+var PRERELEASE = R++;
+src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))';
+
+var PRERELEASELOOSE = R++;
+src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))';
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+var BUILDIDENTIFIER = R++;
+src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+';
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+var BUILD = R++;
+src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
+ '(?:\\.' + src[BUILDIDENTIFIER] + ')*))';
+
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups. The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+var FULL = R++;
+var FULLPLAIN = 'v?' + src[MAINVERSION] +
+ src[PRERELEASE] + '?' +
+ src[BUILD] + '?';
+
+src[FULL] = '^' + FULLPLAIN + '$';
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
+ src[PRERELEASELOOSE] + '?' +
+ src[BUILD] + '?';
+
+var LOOSE = R++;
+src[LOOSE] = '^' + LOOSEPLAIN + '$';
+
+var GTLT = R++;
+src[GTLT] = '((?:<|>)?=?)';
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+var XRANGEIDENTIFIERLOOSE = R++;
+src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
+var XRANGEIDENTIFIER = R++;
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*';
+
+var XRANGEPLAIN = R++;
+src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:' + src[PRERELEASE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?';
+
+var XRANGEPLAINLOOSE = R++;
+src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:' + src[PRERELEASELOOSE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?';
+
+var XRANGE = R++;
+src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$';
+var XRANGELOOSE = R++;
+src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$';
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+var LONETILDE = R++;
+src[LONETILDE] = '(?:~>?)';
+
+var TILDETRIM = R++;
+src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+';
+re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g');
+var tildeTrimReplace = '$1~';
+
+var TILDE = R++;
+src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$';
+var TILDELOOSE = R++;
+src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$';
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+var LONECARET = R++;
+src[LONECARET] = '(?:\\^)';
+
+var CARETTRIM = R++;
+src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+';
+re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g');
+var caretTrimReplace = '$1^';
+
+var CARET = R++;
+src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$';
+var CARETLOOSE = R++;
+src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$';
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+var COMPARATORLOOSE = R++;
+src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$';
+var COMPARATOR = R++;
+src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$';
+
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+var COMPARATORTRIM = R++;
+src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
+ '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';
+
+// this one has to use the /g flag
+re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g');
+var comparatorTrimReplace = '$1$2$3';
+
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+var HYPHENRANGE = R++;
+src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAIN] + ')' +
+ '\\s*$';
+
+var HYPHENRANGELOOSE = R++;
+src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s*$';
+
+// Star ranges basically just allow anything at all.
+var STAR = R++;
+src[STAR] = '(<|>)?=?\\s*\\*';
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+ debug(i, src[i]);
+ if (!re[i])
+ re[i] = new RegExp(src[i]);
+}
+
+exports.parse = parse;
+function parse(version, loose) {
+ if (version instanceof SemVer)
+ return version;
+
+ if (typeof version !== 'string')
+ return null;
+
+ if (version.length > MAX_LENGTH)
+ return null;
+
+ var r = loose ? re[LOOSE] : re[FULL];
+ if (!r.test(version))
+ return null;
+
+ try {
+ return new SemVer(version, loose);
+ } catch (er) {
+ return null;
+ }
+}
+
+exports.valid = valid;
+function valid(version, loose) {
+ var v = parse(version, loose);
+ return v ? v.version : null;
+}
+
+
+exports.clean = clean;
+function clean(version, loose) {
+ var s = parse(version.trim().replace(/^[=v]+/, ''), loose);
+ return s ? s.version : null;
+}
+
+exports.SemVer = SemVer;
+
+function SemVer(version, loose) {
+ if (version instanceof SemVer) {
+ if (version.loose === loose)
+ return version;
+ else
+ version = version.version;
+ } else if (typeof version !== 'string') {
+ throw new TypeError('Invalid Version: ' + version);
+ }
+
+ if (version.length > MAX_LENGTH)
+ throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
+
+ if (!(this instanceof SemVer))
+ return new SemVer(version, loose);
+
+ debug('SemVer', version, loose);
+ this.loose = loose;
+ var m = version.trim().match(loose ? re[LOOSE] : re[FULL]);
+
+ if (!m)
+ throw new TypeError('Invalid Version: ' + version);
+
+ this.raw = version;
+
+ // these are actually numbers
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
+
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0)
+ throw new TypeError('Invalid major version')
+
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0)
+ throw new TypeError('Invalid minor version')
+
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0)
+ throw new TypeError('Invalid patch version')
+
+ // numberify any prerelease numeric ids
+ if (!m[4])
+ this.prerelease = [];
+ else
+ this.prerelease = m[4].split('.').map(function(id) {
+ if (/^[0-9]+$/.test(id)) {
+ var num = +id;
+ if (num >= 0 && num < MAX_SAFE_INTEGER)
+ return num;
+ }
+ return id;
+ });
+
+ this.build = m[5] ? m[5].split('.') : [];
+ this.format();
+}
+
+SemVer.prototype.format = function() {
+ this.version = this.major + '.' + this.minor + '.' + this.patch;
+ if (this.prerelease.length)
+ this.version += '-' + this.prerelease.join('.');
+ return this.version;
+};
+
+SemVer.prototype.toString = function() {
+ return this.version;
+};
+
+SemVer.prototype.compare = function(other) {
+ debug('SemVer.compare', this.version, this.loose, other);
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ return this.compareMain(other) || this.comparePre(other);
+};
+
+SemVer.prototype.compareMain = function(other) {
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ return compareIdentifiers(this.major, other.major) ||
+ compareIdentifiers(this.minor, other.minor) ||
+ compareIdentifiers(this.patch, other.patch);
+};
+
+SemVer.prototype.comparePre = function(other) {
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ // NOT having a prerelease is > having one
+ if (this.prerelease.length && !other.prerelease.length)
+ return -1;
+ else if (!this.prerelease.length && other.prerelease.length)
+ return 1;
+ else if (!this.prerelease.length && !other.prerelease.length)
+ return 0;
+
+ var i = 0;
+ do {
+ var a = this.prerelease[i];
+ var b = other.prerelease[i];
+ debug('prerelease compare', i, a, b);
+ if (a === undefined && b === undefined)
+ return 0;
+ else if (b === undefined)
+ return 1;
+ else if (a === undefined)
+ return -1;
+ else if (a === b)
+ continue;
+ else
+ return compareIdentifiers(a, b);
+ } while (++i);
+};
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function(release, identifier) {
+ switch (release) {
+ case 'premajor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc('pre', identifier);
+ break;
+ case 'preminor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc('pre', identifier);
+ break;
+ case 'prepatch':
+ // If this is already a prerelease, it will bump to the next version
+ // drop any prereleases that might already exist, since they are not
+ // relevant at this point.
+ this.prerelease.length = 0;
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break;
+ // If the input is a non-prerelease version, this acts the same as
+ // prepatch.
+ case 'prerelease':
+ if (this.prerelease.length === 0)
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break;
+
+ case 'major':
+ // If this is a pre-major version, bump up to the same major version.
+ // Otherwise increment major.
+ // 1.0.0-5 bumps to 1.0.0
+ // 1.1.0 bumps to 2.0.0
+ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0)
+ this.major++;
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case 'minor':
+ // If this is a pre-minor version, bump up to the same minor version.
+ // Otherwise increment minor.
+ // 1.2.0-5 bumps to 1.2.0
+ // 1.2.1 bumps to 1.3.0
+ if (this.patch !== 0 || this.prerelease.length === 0)
+ this.minor++;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case 'patch':
+ // If this is not a pre-release version, it will increment the patch.
+ // If it is a pre-release it will bump up to the same patch version.
+ // 1.2.0-5 patches to 1.2.0
+ // 1.2.0 patches to 1.2.1
+ if (this.prerelease.length === 0)
+ this.patch++;
+ this.prerelease = [];
+ break;
+ // This probably shouldn't be used publicly.
+ // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
+ case 'pre':
+ if (this.prerelease.length === 0)
+ this.prerelease = [0];
+ else {
+ var i = this.prerelease.length;
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === 'number') {
+ this.prerelease[i]++;
+ i = -2;
+ }
+ }
+ if (i === -1) // didn't increment anything
+ this.prerelease.push(0);
+ }
+ if (identifier) {
+ // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+ if (this.prerelease[0] === identifier) {
+ if (isNaN(this.prerelease[1]))
+ this.prerelease = [identifier, 0];
+ } else
+ this.prerelease = [identifier, 0];
+ }
+ break;
+
+ default:
+ throw new Error('invalid increment argument: ' + release);
+ }
+ this.format();
+ this.raw = this.version;
+ return this;
+};
+
+exports.inc = inc;
+function inc(version, release, loose, identifier) {
+ if (typeof(loose) === 'string') {
+ identifier = loose;
+ loose = undefined;
+ }
+
+ try {
+ return new SemVer(version, loose).inc(release, identifier).version;
+ } catch (er) {
+ return null;
+ }
+}
+
+exports.diff = diff;
+function diff(version1, version2) {
+ if (eq(version1, version2)) {
+ return null;
+ } else {
+ var v1 = parse(version1);
+ var v2 = parse(version2);
+ if (v1.prerelease.length || v2.prerelease.length) {
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return 'pre'+key;
+ }
+ }
+ }
+ return 'prerelease';
+ }
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return key;
+ }
+ }
+ }
+ }
+}
+
+exports.compareIdentifiers = compareIdentifiers;
+
+var numeric = /^[0-9]+$/;
+function compareIdentifiers(a, b) {
+ var anum = numeric.test(a);
+ var bnum = numeric.test(b);
+
+ if (anum && bnum) {
+ a = +a;
+ b = +b;
+ }
+
+ return (anum && !bnum) ? -1 :
+ (bnum && !anum) ? 1 :
+ a < b ? -1 :
+ a > b ? 1 :
+ 0;
+}
+
+exports.rcompareIdentifiers = rcompareIdentifiers;
+function rcompareIdentifiers(a, b) {
+ return compareIdentifiers(b, a);
+}
+
+exports.major = major;
+function major(a, loose) {
+ return new SemVer(a, loose).major;
+}
+
+exports.minor = minor;
+function minor(a, loose) {
+ return new SemVer(a, loose).minor;
+}
+
+exports.patch = patch;
+function patch(a, loose) {
+ return new SemVer(a, loose).patch;
+}
+
+exports.compare = compare;
+function compare(a, b, loose) {
+ return new SemVer(a, loose).compare(new SemVer(b, loose));
+}
+
+exports.compareLoose = compareLoose;
+function compareLoose(a, b) {
+ return compare(a, b, true);
+}
+
+exports.rcompare = rcompare;
+function rcompare(a, b, loose) {
+ return compare(b, a, loose);
+}
+
+exports.sort = sort;
+function sort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports.compare(a, b, loose);
+ });
+}
+
+exports.rsort = rsort;
+function rsort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports.rcompare(a, b, loose);
+ });
+}
+
+exports.gt = gt;
+function gt(a, b, loose) {
+ return compare(a, b, loose) > 0;
+}
+
+exports.lt = lt;
+function lt(a, b, loose) {
+ return compare(a, b, loose) < 0;
+}
+
+exports.eq = eq;
+function eq(a, b, loose) {
+ return compare(a, b, loose) === 0;
+}
+
+exports.neq = neq;
+function neq(a, b, loose) {
+ return compare(a, b, loose) !== 0;
+}
+
+exports.gte = gte;
+function gte(a, b, loose) {
+ return compare(a, b, loose) >= 0;
+}
+
+exports.lte = lte;
+function lte(a, b, loose) {
+ return compare(a, b, loose) <= 0;
+}
+
+exports.cmp = cmp;
+function cmp(a, op, b, loose) {
+ var ret;
+ switch (op) {
+ case '===':
+ if (typeof a === 'object') a = a.version;
+ if (typeof b === 'object') b = b.version;
+ ret = a === b;
+ break;
+ case '!==':
+ if (typeof a === 'object') a = a.version;
+ if (typeof b === 'object') b = b.version;
+ ret = a !== b;
+ break;
+ case '': case '=': case '==': ret = eq(a, b, loose); break;
+ case '!=': ret = neq(a, b, loose); break;
+ case '>': ret = gt(a, b, loose); break;
+ case '>=': ret = gte(a, b, loose); break;
+ case '<': ret = lt(a, b, loose); break;
+ case '<=': ret = lte(a, b, loose); break;
+ default: throw new TypeError('Invalid operator: ' + op);
+ }
+ return ret;
+}
+
+exports.Comparator = Comparator;
+function Comparator(comp, loose) {
+ if (comp instanceof Comparator) {
+ if (comp.loose === loose)
+ return comp;
+ else
+ comp = comp.value;
+ }
+
+ if (!(this instanceof Comparator))
+ return new Comparator(comp, loose);
+
+ debug('comparator', comp, loose);
+ this.loose = loose;
+ this.parse(comp);
+
+ if (this.semver === ANY)
+ this.value = '';
+ else
+ this.value = this.operator + this.semver.version;
+
+ debug('comp', this);
+}
+
+var ANY = {};
+Comparator.prototype.parse = function(comp) {
+ var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+ var m = comp.match(r);
+
+ if (!m)
+ throw new TypeError('Invalid comparator: ' + comp);
+
+ this.operator = m[1];
+ if (this.operator === '=')
+ this.operator = '';
+
+ // if it literally is just '>' or '' then allow anything.
+ if (!m[2])
+ this.semver = ANY;
+ else
+ this.semver = new SemVer(m[2], this.loose);
+};
+
+Comparator.prototype.toString = function() {
+ return this.value;
+};
+
+Comparator.prototype.test = function(version) {
+ debug('Comparator.test', version, this.loose);
+
+ if (this.semver === ANY)
+ return true;
+
+ if (typeof version === 'string')
+ version = new SemVer(version, this.loose);
+
+ return cmp(version, this.operator, this.semver, this.loose);
+};
+
+Comparator.prototype.intersects = function(comp, loose) {
+ if (!(comp instanceof Comparator)) {
+ throw new TypeError('a Comparator is required');
+ }
+
+ var rangeTmp;
+
+ if (this.operator === '') {
+ rangeTmp = new Range(comp.value, loose);
+ return satisfies(this.value, rangeTmp, loose);
+ } else if (comp.operator === '') {
+ rangeTmp = new Range(this.value, loose);
+ return satisfies(comp.semver, rangeTmp, loose);
+ }
+
+ var sameDirectionIncreasing =
+ (this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '>=' || comp.operator === '>');
+ var sameDirectionDecreasing =
+ (this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '<=' || comp.operator === '<');
+ var sameSemVer = this.semver.version === comp.semver.version;
+ var differentDirectionsInclusive =
+ (this.operator === '>=' || this.operator === '<=') &&
+ (comp.operator === '>=' || comp.operator === '<=');
+ var oppositeDirectionsLessThan =
+ cmp(this.semver, '<', comp.semver, loose) &&
+ ((this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '<=' || comp.operator === '<'));
+ var oppositeDirectionsGreaterThan =
+ cmp(this.semver, '>', comp.semver, loose) &&
+ ((this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '>=' || comp.operator === '>'));
+
+ return sameDirectionIncreasing || sameDirectionDecreasing ||
+ (sameSemVer && differentDirectionsInclusive) ||
+ oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+};
+
+
+exports.Range = Range;
+function Range(range, loose) {
+ if (range instanceof Range) {
+ if (range.loose === loose) {
+ return range;
+ } else {
+ return new Range(range.raw, loose);
+ }
+ }
+
+ if (range instanceof Comparator) {
+ return new Range(range.value, loose);
+ }
+
+ if (!(this instanceof Range))
+ return new Range(range, loose);
+
+ this.loose = loose;
+
+ // First, split based on boolean or ||
+ this.raw = range;
+ this.set = range.split(/\s*\|\|\s*/).map(function(range) {
+ return this.parseRange(range.trim());
+ }, this).filter(function(c) {
+ // throw out any that are not relevant for whatever reason
+ return c.length;
+ });
+
+ if (!this.set.length) {
+ throw new TypeError('Invalid SemVer Range: ' + range);
+ }
+
+ this.format();
+}
+
+Range.prototype.format = function() {
+ this.range = this.set.map(function(comps) {
+ return comps.join(' ').trim();
+ }).join('||').trim();
+ return this.range;
+};
+
+Range.prototype.toString = function() {
+ return this.range;
+};
+
+Range.prototype.parseRange = function(range) {
+ var loose = this.loose;
+ range = range.trim();
+ debug('range', range, loose);
+ // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+ var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace);
+ debug('hyphen replace', range);
+ // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+ range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace);
+ debug('comparator trim', range, re[COMPARATORTRIM]);
+
+ // `~ 1.2.3` => `~1.2.3`
+ range = range.replace(re[TILDETRIM], tildeTrimReplace);
+
+ // `^ 1.2.3` => `^1.2.3`
+ range = range.replace(re[CARETTRIM], caretTrimReplace);
+
+ // normalize spaces
+ range = range.split(/\s+/).join(' ');
+
+ // At this point, the range is completely trimmed and
+ // ready to be split into comparators.
+
+ var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+ var set = range.split(' ').map(function(comp) {
+ return parseComparator(comp, loose);
+ }).join(' ').split(/\s+/);
+ if (this.loose) {
+ // in loose mode, throw out any that are not valid comparators
+ set = set.filter(function(comp) {
+ return !!comp.match(compRe);
+ });
+ }
+ set = set.map(function(comp) {
+ return new Comparator(comp, loose);
+ });
+
+ return set;
+};
+
+Range.prototype.intersects = function(range, loose) {
+ if (!(range instanceof Range)) {
+ throw new TypeError('a Range is required');
+ }
+
+ return this.set.some(function(thisComparators) {
+ return thisComparators.every(function(thisComparator) {
+ return range.set.some(function(rangeComparators) {
+ return rangeComparators.every(function(rangeComparator) {
+ return thisComparator.intersects(rangeComparator, loose);
+ });
+ });
+ });
+ });
+};
+
+// Mostly just for testing and legacy API reasons
+exports.toComparators = toComparators;
+function toComparators(range, loose) {
+ return new Range(range, loose).set.map(function(comp) {
+ return comp.map(function(c) {
+ return c.value;
+ }).join(' ').trim().split(' ');
+ });
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+function parseComparator(comp, loose) {
+ debug('comp', comp);
+ comp = replaceCarets(comp, loose);
+ debug('caret', comp);
+ comp = replaceTildes(comp, loose);
+ debug('tildes', comp);
+ comp = replaceXRanges(comp, loose);
+ debug('xrange', comp);
+ comp = replaceStars(comp, loose);
+ debug('stars', comp);
+ return comp;
+}
+
+function isX(id) {
+ return !id || id.toLowerCase() === 'x' || id === '*';
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes(comp, loose) {
+ return comp.trim().split(/\s+/).map(function(comp) {
+ return replaceTilde(comp, loose);
+ }).join(' ');
+}
+
+function replaceTilde(comp, loose) {
+ var r = loose ? re[TILDELOOSE] : re[TILDE];
+ return comp.replace(r, function(_, M, m, p, pr) {
+ debug('tilde', comp, _, M, m, p, pr);
+ var ret;
+
+ if (isX(M))
+ ret = '';
+ else if (isX(m))
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ else if (isX(p))
+ // ~1.2 == >=1.2.0 <1.3.0
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ else if (pr) {
+ debug('replaceTilde pr', pr);
+ if (pr.charAt(0) !== '-')
+ pr = '-' + pr;
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ // ~1.2.3 == >=1.2.3 <1.3.0
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0';
+
+ debug('tilde return', ret);
+ return ret;
+ });
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets(comp, loose) {
+ return comp.trim().split(/\s+/).map(function(comp) {
+ return replaceCaret(comp, loose);
+ }).join(' ');
+}
+
+function replaceCaret(comp, loose) {
+ debug('caret', comp, loose);
+ var r = loose ? re[CARETLOOSE] : re[CARET];
+ return comp.replace(r, function(_, M, m, p, pr) {
+ debug('caret', comp, _, M, m, p, pr);
+ var ret;
+
+ if (isX(M))
+ ret = '';
+ else if (isX(m))
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ else if (isX(p)) {
+ if (M === '0')
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ else
+ ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';
+ } else if (pr) {
+ debug('replaceCaret pr', pr);
+ if (pr.charAt(0) !== '-')
+ pr = '-' + pr;
+ if (M === '0') {
+ if (m === '0')
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + m + '.' + (+p + 1);
+ else
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + (+M + 1) + '.0.0';
+ } else {
+ debug('no pr');
+ if (M === '0') {
+ if (m === '0')
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + m + '.' + (+p + 1);
+ else
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + (+M + 1) + '.0.0';
+ }
+
+ debug('caret return', ret);
+ return ret;
+ });
+}
+
+function replaceXRanges(comp, loose) {
+ debug('replaceXRanges', comp, loose);
+ return comp.split(/\s+/).map(function(comp) {
+ return replaceXRange(comp, loose);
+ }).join(' ');
+}
+
+function replaceXRange(comp, loose) {
+ comp = comp.trim();
+ var r = loose ? re[XRANGELOOSE] : re[XRANGE];
+ return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
+ debug('xRange', comp, ret, gtlt, M, m, p, pr);
+ var xM = isX(M);
+ var xm = xM || isX(m);
+ var xp = xm || isX(p);
+ var anyX = xp;
+
+ if (gtlt === '=' && anyX)
+ gtlt = '';
+
+ if (xM) {
+ if (gtlt === '>' || gtlt === '<') {
+ // nothing is allowed
+ ret = '<0.0.0';
+ } else {
+ // nothing is forbidden
+ ret = '*';
+ }
+ } else if (gtlt && anyX) {
+ // replace X with 0
+ if (xm)
+ m = 0;
+ if (xp)
+ p = 0;
+
+ if (gtlt === '>') {
+ // >1 => >=2.0.0
+ // >1.2 => >=1.3.0
+ // >1.2.3 => >= 1.2.4
+ gtlt = '>=';
+ if (xm) {
+ M = +M + 1;
+ m = 0;
+ p = 0;
+ } else if (xp) {
+ m = +m + 1;
+ p = 0;
+ }
+ } else if (gtlt === '<=') {
+ // <=0.7.x is actually <0.8.0, since any 0.7.x should
+ // pass. Similarly, <=7.x is actually <8.0.0, etc.
+ gtlt = '<';
+ if (xm)
+ M = +M + 1;
+ else
+ m = +m + 1;
+ }
+
+ ret = gtlt + M + '.' + m + '.' + p;
+ } else if (xm) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ } else if (xp) {
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ }
+
+ debug('xRange return', ret);
+
+ return ret;
+ });
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars(comp, loose) {
+ debug('replaceStars', comp, loose);
+ // Looseness is ignored here. star is always as loose as it gets!
+ return comp.trim().replace(re[STAR], '');
+}
+
+// This function is passed to string.replace(re[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0
+function hyphenReplace($0,
+ from, fM, fm, fp, fpr, fb,
+ to, tM, tm, tp, tpr, tb) {
+
+ if (isX(fM))
+ from = '';
+ else if (isX(fm))
+ from = '>=' + fM + '.0.0';
+ else if (isX(fp))
+ from = '>=' + fM + '.' + fm + '.0';
+ else
+ from = '>=' + from;
+
+ if (isX(tM))
+ to = '';
+ else if (isX(tm))
+ to = '<' + (+tM + 1) + '.0.0';
+ else if (isX(tp))
+ to = '<' + tM + '.' + (+tm + 1) + '.0';
+ else if (tpr)
+ to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;
+ else
+ to = '<=' + to;
+
+ return (from + ' ' + to).trim();
+}
+
+
+// if ANY of the sets match ALL of its comparators, then pass
+Range.prototype.test = function(version) {
+ if (!version)
+ return false;
+
+ if (typeof version === 'string')
+ version = new SemVer(version, this.loose);
+
+ for (var i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version))
+ return true;
+ }
+ return false;
+};
+
+function testSet(set, version) {
+ for (var i = 0; i < set.length; i++) {
+ if (!set[i].test(version))
+ return false;
+ }
+
+ if (version.prerelease.length) {
+ // Find the set of versions that are allowed to have prereleases
+ // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+ // That should allow `1.2.3-pr.2` to pass.
+ // However, `1.2.4-alpha.notready` should NOT be allowed,
+ // even though it's within the range set by the comparators.
+ for (var i = 0; i < set.length; i++) {
+ debug(set[i].semver);
+ if (set[i].semver === ANY)
+ continue;
+
+ if (set[i].semver.prerelease.length > 0) {
+ var allowed = set[i].semver;
+ if (allowed.major === version.major &&
+ allowed.minor === version.minor &&
+ allowed.patch === version.patch)
+ return true;
+ }
+ }
+
+ // Version has a -pre, but it's not one of the ones we like.
+ return false;
+ }
+
+ return true;
+}
+
+exports.satisfies = satisfies;
+function satisfies(version, range, loose) {
+ try {
+ range = new Range(range, loose);
+ } catch (er) {
+ return false;
+ }
+ return range.test(version);
+}
+
+exports.maxSatisfying = maxSatisfying;
+function maxSatisfying(versions, range, loose) {
+ var max = null;
+ var maxSV = null;
+ try {
+ var rangeObj = new Range(range, loose);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) { // satisfies(v, range, loose)
+ if (!max || maxSV.compare(v) === -1) { // compare(max, v, true)
+ max = v;
+ maxSV = new SemVer(max, loose);
+ }
+ }
+ });
+ return max;
+}
+
+exports.minSatisfying = minSatisfying;
+function minSatisfying(versions, range, loose) {
+ var min = null;
+ var minSV = null;
+ try {
+ var rangeObj = new Range(range, loose);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) { // satisfies(v, range, loose)
+ if (!min || minSV.compare(v) === 1) { // compare(min, v, true)
+ min = v;
+ minSV = new SemVer(min, loose);
+ }
+ }
+ });
+ return min;
+}
+
+exports.validRange = validRange;
+function validRange(range, loose) {
+ try {
+ // Return '*' instead of '' so that truthiness works.
+ // This will throw if it's invalid anyway
+ return new Range(range, loose).range || '*';
+ } catch (er) {
+ return null;
+ }
+}
+
+// Determine if version is less than all the versions possible in the range
+exports.ltr = ltr;
+function ltr(version, range, loose) {
+ return outside(version, range, '<', loose);
+}
+
+// Determine if version is greater than all the versions possible in the range.
+exports.gtr = gtr;
+function gtr(version, range, loose) {
+ return outside(version, range, '>', loose);
+}
+
+exports.outside = outside;
+function outside(version, range, hilo, loose) {
+ version = new SemVer(version, loose);
+ range = new Range(range, loose);
+
+ var gtfn, ltefn, ltfn, comp, ecomp;
+ switch (hilo) {
+ case '>':
+ gtfn = gt;
+ ltefn = lte;
+ ltfn = lt;
+ comp = '>';
+ ecomp = '>=';
+ break;
+ case '<':
+ gtfn = lt;
+ ltefn = gte;
+ ltfn = gt;
+ comp = '<';
+ ecomp = '<=';
+ break;
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+
+ // If it satisifes the range it is not outside
+ if (satisfies(version, range, loose)) {
+ return false;
+ }
+
+ // From now on, variable terms are as if we're in "gtr" mode.
+ // but note that everything is flipped for the "ltr" function.
+
+ for (var i = 0; i < range.set.length; ++i) {
+ var comparators = range.set[i];
+
+ var high = null;
+ var low = null;
+
+ comparators.forEach(function(comparator) {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator('>=0.0.0');
+ }
+ high = high || comparator;
+ low = low || comparator;
+ if (gtfn(comparator.semver, high.semver, loose)) {
+ high = comparator;
+ } else if (ltfn(comparator.semver, low.semver, loose)) {
+ low = comparator;
+ }
+ });
+
+ // If the edge version comparator has a operator then our version
+ // isn't outside it
+ if (high.operator === comp || high.operator === ecomp) {
+ return false;
+ }
+
+ // If the lowest version comparator has an operator and our version
+ // is less than it then it isn't higher than the range
+ if ((!low.operator || low.operator === comp) &&
+ ltefn(version, low.semver)) {
+ return false;
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+exports.prerelease = prerelease;
+function prerelease(version, loose) {
+ var parsed = parse(version, loose);
+ return (parsed && parsed.prerelease.length) ? parsed.prerelease : null;
+}
+
+exports.intersects = intersects;
+function intersects(r1, r2, loose) {
+ r1 = new Range(r1, loose);
+ r2 = new Range(r2, loose);
+ return r1.intersects(r2)
+}
+});
+
+var assert$1 = true;
+var buffer_ieee754 = "< 0.9.7";
+var buffer = true;
+var child_process = true;
+var cluster = true;
+var console$1 = true;
+var constants = true;
+var crypto = true;
+var _debugger = "< 8";
+var dgram = true;
+var dns = true;
+var domain = true;
+var events = true;
+var freelist = "< 6";
+var fs$1 = true;
+var http = true;
+var http2 = ">= 8.8";
+var https = true;
+var _http_server = ">= 0.11";
+var _linklist = "< 8";
+var module$1 = true;
+var net = true;
+var os$1 = true;
+var path$1 = true;
+var perf_hooks = ">= 8.5";
+var process$1 = ">= 1";
+var punycode = true;
+var querystring = true;
+var readline = true;
+var repl = true;
+var stream = true;
+var string_decoder = true;
+var sys = true;
+var timers = true;
+var tls = true;
+var tty = true;
+var url$1 = true;
+var util$3 = true;
+var v8 = ">= 1";
+var vm = true;
+var zlib = true;
+var core$1 = {
+ assert: assert$1,
+ buffer_ieee754: buffer_ieee754,
+ buffer: buffer,
+ child_process: child_process,
+ cluster: cluster,
+ console: console$1,
+ constants: constants,
+ crypto: crypto,
+ _debugger: _debugger,
+ dgram: dgram,
+ dns: dns,
+ domain: domain,
+ events: events,
+ freelist: freelist,
+ fs: fs$1,
+ http: http,
+ http2: http2,
+ https: https,
+ _http_server: _http_server,
+ _linklist: _linklist,
+ module: module$1,
+ net: net,
+ os: os$1,
+ path: path$1,
+ perf_hooks: perf_hooks,
+ process: process$1,
+ punycode: punycode,
+ querystring: querystring,
+ readline: readline,
+ repl: repl,
+ stream: stream,
+ string_decoder: string_decoder,
+ sys: sys,
+ timers: timers,
+ tls: tls,
+ tty: tty,
+ url: url$1,
+ util: util$3,
+ v8: v8,
+ vm: vm,
+ zlib: zlib
+};
+
+var core$2 = Object.freeze({
+ assert: assert$1,
+ buffer_ieee754: buffer_ieee754,
+ buffer: buffer,
+ child_process: child_process,
+ cluster: cluster,
+ console: console$1,
+ constants: constants,
+ crypto: crypto,
+ _debugger: _debugger,
+ dgram: dgram,
+ dns: dns,
+ domain: domain,
+ events: events,
+ freelist: freelist,
+ fs: fs$1,
+ http: http,
+ http2: http2,
+ https: https,
+ _http_server: _http_server,
+ _linklist: _linklist,
+ module: module$1,
+ net: net,
+ os: os$1,
+ path: path$1,
+ perf_hooks: perf_hooks,
+ process: process$1,
+ punycode: punycode,
+ querystring: querystring,
+ readline: readline,
+ repl: repl,
+ stream: stream,
+ string_decoder: string_decoder,
+ sys: sys,
+ timers: timers,
+ tls: tls,
+ tty: tty,
+ url: url$1,
+ util: util$3,
+ v8: v8,
+ vm: vm,
+ zlib: zlib,
+ default: core$1
+});
+
+var data = ( core$2 && core$1 ) || core$2;
+
+var current = (process.versions && process.versions.node && process.versions.node.split('.')) || [];
+
+function versionIncluded(specifier) {
+ if (specifier === true) { return true; }
+ var parts = specifier.split(' ');
+ var op = parts[0];
+ var versionParts = parts[1].split('.');
+
+ for (var i = 0; i < 3; ++i) {
+ var cur = Number(current[i] || 0);
+ var ver = Number(versionParts[i] || 0);
+ if (cur === ver) {
+ continue; // eslint-disable-line no-restricted-syntax, no-continue
+ }
+ if (op === '<') {
+ return cur < ver;
+ } else if (op === '>=') {
+ return cur >= ver;
+ } else {
+ return false;
+ }
+ }
+ return false;
+}
+
+
+
+var core = {};
+for (var mod in data) { // eslint-disable-line no-restricted-syntax
+ if (Object.prototype.hasOwnProperty.call(data, mod)) {
+ core[mod] = versionIncluded(data[mod]);
+ }
+}
+var core_1 = core;
+
+var caller = function () {
+ // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+ var origPrepareStackTrace = Error.prepareStackTrace;
+ Error.prepareStackTrace = function (_, stack) { return stack; };
+ var stack = (new Error()).stack;
+ Error.prepareStackTrace = origPrepareStackTrace;
+ return stack[2].getFileName();
+};
+
+var pathParse = createCommonjsModule(function (module) {
+'use strict';
+
+var isWindows = process.platform === 'win32';
+
+// Regex to split a windows path into three parts: [*, device, slash,
+// tail] windows-only
+var splitDeviceRe =
+ /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+
+// Regex to split the tail part of the above into [*, dir, basename, ext]
+var splitTailRe =
+ /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+
+var win32 = {};
+
+// Function to split a filename into [root, dir, basename, ext]
+function win32SplitPath(filename) {
+ // Separate device+slash from tail
+ var result = splitDeviceRe.exec(filename),
+ device = (result[1] || '') + (result[2] || ''),
+ tail = result[3] || '';
+ // Split the tail into dir, basename and extension
+ var result2 = splitTailRe.exec(tail),
+ dir = result2[1],
+ basename = result2[2],
+ ext = result2[3];
+ return [device, dir, basename, ext];
+}
+
+win32.parse = function(pathString) {
+ if (typeof pathString !== 'string') {
+ throw new TypeError(
+ "Parameter 'pathString' must be a string, not " + typeof pathString
+ );
+ }
+ var allParts = win32SplitPath(pathString);
+ if (!allParts || allParts.length !== 4) {
+ throw new TypeError("Invalid path '" + pathString + "'");
+ }
+ return {
+ root: allParts[0],
+ dir: allParts[0] + allParts[1].slice(0, -1),
+ base: allParts[2],
+ ext: allParts[3],
+ name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
+ };
+};
+
+
+
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe =
+ /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+var posix = {};
+
+
+function posixSplitPath(filename) {
+ return splitPathRe.exec(filename).slice(1);
+}
+
+
+posix.parse = function(pathString) {
+ if (typeof pathString !== 'string') {
+ throw new TypeError(
+ "Parameter 'pathString' must be a string, not " + typeof pathString
+ );
+ }
+ var allParts = posixSplitPath(pathString);
+ if (!allParts || allParts.length !== 4) {
+ throw new TypeError("Invalid path '" + pathString + "'");
+ }
+ allParts[1] = allParts[1] || '';
+ allParts[2] = allParts[2] || '';
+ allParts[3] = allParts[3] || '';
+
+ return {
+ root: allParts[0],
+ dir: allParts[0] + allParts[1].slice(0, -1),
+ base: allParts[2],
+ ext: allParts[3],
+ name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
+ };
+};
+
+
+if (isWindows)
+ module.exports = win32.parse;
+else /* posix */
+ module.exports = posix.parse;
+
+module.exports.posix = posix.parse;
+module.exports.win32 = win32.parse;
+});
+
+var parse = path.parse || pathParse;
+
+var nodeModulesPaths = function nodeModulesPaths(start, opts) {
+ var modules = opts && opts.moduleDirectory
+ ? [].concat(opts.moduleDirectory)
+ : ['node_modules'];
+
+ // ensure that `start` is an absolute path at this point,
+ // resolving against the process' current working directory
+ var absoluteStart = path.resolve(start);
+
+ if (opts && opts.preserveSymlinks === false) {
+ try {
+ absoluteStart = fs.realpathSync(absoluteStart);
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ throw err;
+ }
+ }
+ }
+
+ var prefix = '/';
+ if (/^([A-Za-z]:)/.test(absoluteStart)) {
+ prefix = '';
+ } else if (/^\\\\/.test(absoluteStart)) {
+ prefix = '\\\\';
+ }
+
+ var paths = [absoluteStart];
+ var parsed = parse(absoluteStart);
+ while (parsed.dir !== paths[paths.length - 1]) {
+ paths.push(parsed.dir);
+ parsed = parse(parsed.dir);
+ }
+
+ var dirs = paths.reduce(function (dirs, aPath) {
+ return dirs.concat(modules.map(function (moduleDir) {
+ return path.join(prefix, aPath, moduleDir);
+ }));
+ }, []);
+
+ return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+};
+
+var async = function resolve(x, options, callback) {
+ var cb = callback;
+ var opts = options || {};
+ if (typeof opts === 'function') {
+ cb = opts;
+ opts = {};
+ }
+ if (typeof x !== 'string') {
+ var err = new TypeError('Path must be a string.');
+ return process.nextTick(function () {
+ cb(err);
+ });
+ }
+
+ var isFile = opts.isFile || function (file, cb) {
+ fs.stat(file, function (err, stat) {
+ if (!err) {
+ return cb(null, stat.isFile() || stat.isFIFO());
+ }
+ if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+ return cb(err);
+ });
+ };
+ var readFile = opts.readFile || fs.readFile;
+
+ var extensions = opts.extensions || ['.js'];
+ var y = opts.basedir || path.dirname(caller());
+
+ opts.paths = opts.paths || [];
+
+ if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x)) {
+ var res = path.resolve(y, x);
+ if (x === '..' || x.slice(-1) === '/') res += '/';
+ if (/\/$/.test(x) && res === y) {
+ loadAsDirectory(res, opts.package, onfile);
+ } else loadAsFile(res, opts.package, onfile);
+ } else loadNodeModules(x, y, function (err, n, pkg) {
+ if (err) cb(err);
+ else if (n) cb(null, n, pkg);
+ else if (core_1[x]) return cb(null, x);
+ else {
+ var moduleError = new Error("Cannot find module '" + x + "' from '" + y + "'");
+ moduleError.code = 'MODULE_NOT_FOUND';
+ cb(moduleError);
+ }
+ });
+
+ function onfile(err, m, pkg) {
+ if (err) cb(err);
+ else if (m) cb(null, m, pkg);
+ else loadAsDirectory(res, function (err, d, pkg) {
+ if (err) cb(err);
+ else if (d) cb(null, d, pkg);
+ else {
+ var moduleError = new Error("Cannot find module '" + x + "' from '" + y + "'");
+ moduleError.code = 'MODULE_NOT_FOUND';
+ cb(moduleError);
+ }
+ });
+ }
+
+ function loadAsFile(x, thePackage, callback) {
+ var loadAsFilePackage = thePackage;
+ var cb = callback;
+ if (typeof loadAsFilePackage === 'function') {
+ cb = loadAsFilePackage;
+ loadAsFilePackage = undefined;
+ }
+
+ var exts = [''].concat(extensions);
+ load(exts, x, loadAsFilePackage);
+
+ function load(exts, x, loadPackage) {
+ if (exts.length === 0) return cb(null, undefined, loadPackage);
+ var file = x + exts[0];
+
+ var pkg = loadPackage;
+ if (pkg) onpkg(null, pkg);
+ else loadpkg(path.dirname(file), onpkg);
+
+ function onpkg(err, pkg_, dir) {
+ pkg = pkg_;
+ if (err) return cb(err);
+ if (dir && pkg && opts.pathFilter) {
+ var rfile = path.relative(dir, file);
+ var rel = rfile.slice(0, rfile.length - exts[0].length);
+ var r = opts.pathFilter(pkg, x, rel);
+ if (r) return load(
+ [''].concat(extensions.slice()),
+ path.resolve(dir, r),
+ pkg
+ );
+ }
+ isFile(file, onex);
+ }
+ function onex(err, ex) {
+ if (err) return cb(err);
+ if (ex) return cb(null, file, pkg);
+ load(exts.slice(1), x, pkg);
+ }
+ }
+ }
+
+ function loadpkg(dir, cb) {
+ if (dir === '' || dir === '/') return cb(null);
+ if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
+ return cb(null);
+ }
+ if (/[/\\]node_modules[/\\]*$/.test(dir)) return cb(null);
+
+ var pkgfile = path.join(dir, 'package.json');
+ isFile(pkgfile, function (err, ex) {
+ // on err, ex is false
+ if (!ex) return loadpkg(path.dirname(dir), cb);
+
+ readFile(pkgfile, function (err, body) {
+ if (err) cb(err);
+ try { var pkg = JSON.parse(body); } catch (jsonErr) {}
+
+ if (pkg && opts.packageFilter) {
+ pkg = opts.packageFilter(pkg, pkgfile);
+ }
+ cb(null, pkg, dir);
+ });
+ });
+ }
+
+ function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+ var cb = callback;
+ var fpkg = loadAsDirectoryPackage;
+ if (typeof fpkg === 'function') {
+ cb = fpkg;
+ fpkg = opts.package;
+ }
+
+ var pkgfile = path.join(x, 'package.json');
+ isFile(pkgfile, function (err, ex) {
+ if (err) return cb(err);
+ if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
+
+ readFile(pkgfile, function (err, body) {
+ if (err) return cb(err);
+ try {
+ var pkg = JSON.parse(body);
+ } catch (jsonErr) {}
+
+ if (opts.packageFilter) {
+ pkg = opts.packageFilter(pkg, pkgfile);
+ }
+
+ if (pkg.main) {
+ if (pkg.main === '.' || pkg.main === './') {
+ pkg.main = 'index';
+ }
+ loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+ if (err) return cb(err);
+ if (m) return cb(null, m, pkg);
+ if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+
+ var dir = path.resolve(x, pkg.main);
+ loadAsDirectory(dir, pkg, function (err, n, pkg) {
+ if (err) return cb(err);
+ if (n) return cb(null, n, pkg);
+ loadAsFile(path.join(x, 'index'), pkg, cb);
+ });
+ });
+ return;
+ }
+
+ loadAsFile(path.join(x, '/index'), pkg, cb);
+ });
+ });
+ }
+
+ function processDirs(cb, dirs) {
+ if (dirs.length === 0) return cb(null, undefined);
+ var dir = dirs[0];
+
+ var file = path.join(dir, x);
+ loadAsFile(file, undefined, onfile);
+
+ function onfile(err, m, pkg) {
+ if (err) return cb(err);
+ if (m) return cb(null, m, pkg);
+ loadAsDirectory(path.join(dir, x), undefined, ondir);
+ }
+
+ function ondir(err, n, pkg) {
+ if (err) return cb(err);
+ if (n) return cb(null, n, pkg);
+ processDirs(cb, dirs.slice(1));
+ }
+ }
+ function loadNodeModules(x, start, cb) {
+ processDirs(cb, nodeModulesPaths(start, opts));
+ }
+};
+
+var sync = function (x, options) {
+ if (typeof x !== 'string') {
+ throw new TypeError('Path must be a string.');
+ }
+ var opts = options || {};
+ var isFile = opts.isFile || function (file) {
+ try {
+ var stat = fs.statSync(file);
+ } catch (e) {
+ if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+ throw e;
+ }
+ return stat.isFile() || stat.isFIFO();
+ };
+ var readFileSync = opts.readFileSync || fs.readFileSync;
+
+ var extensions = opts.extensions || ['.js'];
+ var y = opts.basedir || path.dirname(caller());
+
+ opts.paths = opts.paths || [];
+
+ if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x)) {
+ var res = path.resolve(y, x);
+ if (x === '..' || x.slice(-1) === '/') res += '/';
+ var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+ if (m) return m;
+ } else {
+ var n = loadNodeModulesSync(x, y);
+ if (n) return n;
+ }
+
+ if (core_1[x]) return x;
+
+ var err = new Error("Cannot find module '" + x + "' from '" + y + "'");
+ err.code = 'MODULE_NOT_FOUND';
+ throw err;
+
+ function loadAsFileSync(x) {
+ if (isFile(x)) {
+ return x;
+ }
+
+ for (var i = 0; i < extensions.length; i++) {
+ var file = x + extensions[i];
+ if (isFile(file)) {
+ return file;
+ }
+ }
+ }
+
+ function loadAsDirectorySync(x) {
+ var pkgfile = path.join(x, '/package.json');
+ if (isFile(pkgfile)) {
+ try {
+ var body = readFileSync(pkgfile, 'UTF8');
+ var pkg = JSON.parse(body);
+
+ if (opts.packageFilter) {
+ pkg = opts.packageFilter(pkg, x);
+ }
+
+ if (pkg.main) {
+ if (pkg.main === '.' || pkg.main === './') {
+ pkg.main = 'index';
+ }
+ var m = loadAsFileSync(path.resolve(x, pkg.main));
+ if (m) return m;
+ var n = loadAsDirectorySync(path.resolve(x, pkg.main));
+ if (n) return n;
+ }
+ } catch (e) {}
+ }
+
+ return loadAsFileSync(path.join(x, '/index'));
+ }
+
+ function loadNodeModulesSync(x, start) {
+ var dirs = nodeModulesPaths(start, opts);
+ for (var i = 0; i < dirs.length; i++) {
+ var dir = dirs[i];
+ var m = loadAsFileSync(path.join(dir, '/', x));
+ if (m) return m;
+ var n = loadAsDirectorySync(path.join(dir, '/', x));
+ if (n) return n;
+ }
+ }
+};
+
+var resolve = createCommonjsModule(function (module, exports) {
+async.core = core_1;
+async.isCore = function isCore(x) { return core_1[x]; };
+async.sync = sync;
+
+exports = async;
+module.exports = async;
+});
+
+var pathExists = createCommonjsModule(function (module) {
+'use strict';
+
+
+module.exports = fp => new Promise(resolve => {
+ fs.access(fp, err => {
+ resolve(!err);
+ });
+});
+
+module.exports.sync = fp => {
+ try {
+ fs.accessSync(fp);
+ return true;
+ } catch (err) {
+ return false;
+ }
+};
+});
+
+var pLimit = createCommonjsModule(function (module) {
+'use strict';
+module.exports = concurrency => {
+ if (concurrency < 1) {
+ throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+ }
+
+ const queue = [];
+ let activeCount = 0;
+
+ const next = () => {
+ activeCount--;
+
+ if (queue.length > 0) {
+ queue.shift()();
+ }
+ };
+
+ return fn => new Promise((resolve, reject) => {
+ const run = () => {
+ activeCount++;
+
+ fn().then(
+ val => {
+ resolve(val);
+ next();
+ },
+ err => {
+ reject(err);
+ next();
+ }
+ );
+ };
+
+ if (activeCount < concurrency) {
+ run();
+ } else {
+ queue.push(run);
+ }
+ });
+};
+});
+
+var pLocate = createCommonjsModule(function (module) {
+'use strict';
+
+
+class EndError extends Error {
+ constructor(value) {
+ super();
+ this.value = value;
+ }
+}
+
+// the input can also be a promise, so we `Promise.all()` them both
+const finder = el => Promise.all(el).then(val => val[1] === true && Promise.reject(new EndError(val[0])));
+
+module.exports = (iterable, tester, opts) => {
+ opts = Object.assign({
+ concurrency: Infinity,
+ preserveOrder: true
+ }, opts);
+
+ const limit = pLimit(opts.concurrency);
+
+ // start all the promises concurrently with optional limit
+ const items = Array.from(iterable).map(el => [el, limit(() => Promise.resolve(el).then(tester))]);
+
+ // check the promises either serially or concurrently
+ const checkLimit = pLimit(opts.preserveOrder ? 1 : Infinity);
+
+ return Promise.all(items.map(el => checkLimit(() => finder(el))))
+ .then(() => {})
+ .catch(err => err instanceof EndError ? err.value : Promise.reject(err));
+};
+});
+
+var locatePath = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+
+module.exports = (iterable, opts) => {
+ opts = Object.assign({
+ cwd: process.cwd()
+ }, opts);
+
+ return pLocate(iterable, el => pathExists(path.resolve(opts.cwd, el)), opts);
+};
+
+module.exports.sync = (iterable, opts) => {
+ opts = Object.assign({
+ cwd: process.cwd()
+ }, opts);
+
+ for (const el of iterable) {
+ if (pathExists.sync(path.resolve(opts.cwd, el))) {
+ return el;
+ }
+ }
+};
+});
+
+var findUp = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+module.exports = (filename, opts) => {
+ opts = opts || {};
+
+ const startDir = path.resolve(opts.cwd || '');
+ const root = path.parse(startDir).root;
+
+ const filenames = [].concat(filename);
+
+ return new Promise(resolve => {
+ (function find(dir) {
+ locatePath(filenames, {cwd: dir}).then(file => {
+ if (file) {
+ resolve(path.join(dir, file));
+ } else if (dir === root) {
+ resolve(null);
+ } else {
+ find(path.dirname(dir));
+ }
+ });
+ })(startDir);
+ });
+};
+
+module.exports.sync = (filename, opts) => {
+ opts = opts || {};
+
+ let dir = path.resolve(opts.cwd || '');
+ const root = path.parse(dir).root;
+
+ const filenames = [].concat(filename);
+
+ // eslint-disable-next-line no-constant-condition
+ while (true) {
+ const file = locatePath.sync(filenames, {cwd: dir});
+
+ if (file) {
+ return path.join(dir, file);
+ } else if (dir === root) {
+ return null;
+ }
+
+ dir = path.dirname(dir);
+ }
+};
+});
+
+var stripBom = createCommonjsModule(function (module) {
+'use strict';
+module.exports = x => {
+ if (typeof x !== 'string') {
+ throw new TypeError('Expected a string, got ' + typeof x);
+ }
+
+ // Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+ // conversion translates it to FEFF (UTF-16 BOM)
+ if (x.charCodeAt(0) === 0xFEFF) {
+ return x.slice(1);
+ }
+
+ return x;
+};
+});
+
+var isArrayish = function isArrayish(obj) {
+ if (!obj) {
+ return false;
+ }
+
+ return obj instanceof Array || Array.isArray(obj) ||
+ (obj.length >= 0 && obj.splice instanceof Function);
+};
+
+var errorEx = function errorEx(name, properties) {
+ if (!name || name.constructor !== String) {
+ properties = name || {};
+ name = Error.name;
+ }
+
+ var errorExError = function ErrorEXError(message) {
+ if (!this) {
+ return new ErrorEXError(message);
+ }
+
+ message = message instanceof Error
+ ? message.message
+ : (message || this.message);
+
+ Error.call(this, message);
+ Error.captureStackTrace(this, errorExError);
+
+ this.name = name;
+
+ Object.defineProperty(this, 'message', {
+ configurable: true,
+ enumerable: false,
+ get: function () {
+ var newMessage = message.split(/\r?\n/g);
+
+ for (var key in properties) {
+ if (!properties.hasOwnProperty(key)) {
+ continue;
+ }
+
+ var modifier = properties[key];
+
+ if ('message' in modifier) {
+ newMessage = modifier.message(this[key], newMessage) || newMessage;
+ if (!isArrayish(newMessage)) {
+ newMessage = [newMessage];
+ }
+ }
+ }
+
+ return newMessage.join('\n');
+ },
+ set: function (v) {
+ message = v;
+ }
+ });
+
+ var stackDescriptor = Object.getOwnPropertyDescriptor(this, 'stack');
+ var stackGetter = stackDescriptor.get;
+ var stackValue = stackDescriptor.value;
+ delete stackDescriptor.value;
+ delete stackDescriptor.writable;
+
+ stackDescriptor.get = function () {
+ var stack = (stackGetter)
+ ? stackGetter.call(this).split(/\r?\n+/g)
+ : stackValue.split(/\r?\n+/g);
+
+ // starting in Node 7, the stack builder caches the message.
+ // just replace it.
+ stack[0] = this.name + ': ' + this.message;
+
+ var lineCount = 1;
+ for (var key in properties) {
+ if (!properties.hasOwnProperty(key)) {
+ continue;
+ }
+
+ var modifier = properties[key];
+
+ if ('line' in modifier) {
+ var line = modifier.line(this[key]);
+ if (line) {
+ stack.splice(lineCount++, 0, ' ' + line);
+ }
+ }
+
+ if ('stack' in modifier) {
+ modifier.stack(this[key], stack);
+ }
+ }
+
+ return stack.join('\n');
+ };
+
+ Object.defineProperty(this, 'stack', stackDescriptor);
+ };
+
+ if (Object.setPrototypeOf) {
+ Object.setPrototypeOf(errorExError.prototype, Error.prototype);
+ Object.setPrototypeOf(errorExError, Error);
+ } else {
+ util.inherits(errorExError, Error);
+ }
+
+ return errorExError;
+};
+
+errorEx.append = function (str, def) {
+ return {
+ message: function (v, message) {
+ v = v || def;
+
+ if (v) {
+ message[0] += ' ' + str.replace('%s', v.toString());
+ }
+
+ return message;
+ }
+ };
+};
+
+errorEx.line = function (str, def) {
+ return {
+ line: function (v) {
+ v = v || def;
+
+ if (v) {
+ return str.replace('%s', v.toString());
+ }
+
+ return null;
+ }
+ };
+};
+
+var errorEx_1 = errorEx;
+
+var jsonParseBetterErrors = parseJson$2;
+function parseJson$2 (txt, reviver, context) {
+ context = context || 20;
+ try {
+ return JSON.parse(txt, reviver)
+ } catch (e) {
+ const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i);
+ const errIdx = syntaxErr
+ ? +syntaxErr[1]
+ : e.message.match(/^Unexpected end of JSON.*/i)
+ ? txt.length - 1
+ : null;
+ if (errIdx != null) {
+ const start = errIdx <= context
+ ? 0
+ : errIdx - context;
+ const end = errIdx + context >= txt.length
+ ? txt.length
+ : errIdx + context;
+ e.message += ` while parsing near '${
+ start === 0 ? '' : '...'
+ }${txt.slice(start, end)}${
+ end === txt.length ? '' : '...'
+ }'`;
+ } else {
+ e.message += ` while parsing '${txt.slice(0, context * 2)}'`;
+ }
+ throw e
+ }
+}
+
+var parseJson = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+const JSONError = errorEx_1('JSONError', {
+ fileName: errorEx_1.append('in %s')
+});
+
+module.exports = (input, reviver, filename) => {
+ if (typeof reviver === 'string') {
+ filename = reviver;
+ reviver = null;
+ }
+
+ try {
+ try {
+ return JSON.parse(input, reviver);
+ } catch (err) {
+ jsonParseBetterErrors(input, reviver);
+
+ throw err;
+ }
+ } catch (err) {
+ err.message = err.message.replace(/\n/g, '');
+
+ const jsonErr = new JSONError(err);
+ if (filename) {
+ jsonErr.fileName = filename;
+ }
+
+ throw jsonErr;
+ }
+};
+});
+
+var pify = createCommonjsModule(function (module) {
+'use strict';
+
+const processFn = (fn, opts) => function () {
+ const P = opts.promiseModule;
+ const args = new Array(arguments.length);
+
+ for (let i = 0; i < arguments.length; i++) {
+ args[i] = arguments[i];
+ }
+
+ return new P((resolve, reject) => {
+ if (opts.errorFirst) {
+ args.push(function (err, result) {
+ if (opts.multiArgs) {
+ const results = new Array(arguments.length - 1);
+
+ for (let i = 1; i < arguments.length; i++) {
+ results[i - 1] = arguments[i];
+ }
+
+ if (err) {
+ results.unshift(err);
+ reject(results);
+ } else {
+ resolve(results);
+ }
+ } else if (err) {
+ reject(err);
+ } else {
+ resolve(result);
+ }
+ });
+ } else {
+ args.push(function (result) {
+ if (opts.multiArgs) {
+ const results = new Array(arguments.length - 1);
+
+ for (let i = 0; i < arguments.length; i++) {
+ results[i] = arguments[i];
+ }
+
+ resolve(results);
+ } else {
+ resolve(result);
+ }
+ });
+ }
+
+ fn.apply(this, args);
+ });
+};
+
+module.exports = (obj, opts) => {
+ opts = Object.assign({
+ exclude: [/.+(Sync|Stream)$/],
+ errorFirst: true,
+ promiseModule: Promise
+ }, opts);
+
+ const filter = key => {
+ const match = pattern => typeof pattern === 'string' ? key === pattern : pattern.test(key);
+ return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
+ };
+
+ let ret;
+ if (typeof obj === 'function') {
+ ret = function () {
+ if (opts.excludeMain) {
+ return obj.apply(this, arguments);
+ }
+
+ return processFn(obj, opts).apply(this, arguments);
+ };
+ } else {
+ ret = Object.create(Object.getPrototypeOf(obj));
+ }
+
+ for (const key in obj) { // eslint-disable-line guard-for-in
+ const x = obj[key];
+ ret[key] = typeof x === 'function' && filter(key) ? processFn(x, opts) : x;
+ }
+
+ return ret;
+};
+});
+
+const parse$1 = (data, fp) => parseJson(stripBom(data), path.relative('.', fp));
+
+var loadJsonFile = fp => pify(fs.readFile)(fp, 'utf8').then(data => parse$1(data, fp));
+var sync$2 = fp => parse$1(fs.readFileSync(fp, 'utf8'), fp);
+
+loadJsonFile.sync = sync$2;
+
+var pify$3 = createCommonjsModule(function (module) {
+'use strict';
+
+const processFn = (fn, opts) => function () {
+ const P = opts.promiseModule;
+ const args = new Array(arguments.length);
+
+ for (let i = 0; i < arguments.length; i++) {
+ args[i] = arguments[i];
+ }
+
+ return new P((resolve, reject) => {
+ if (opts.errorFirst) {
+ args.push(function (err, result) {
+ if (opts.multiArgs) {
+ const results = new Array(arguments.length - 1);
+
+ for (let i = 1; i < arguments.length; i++) {
+ results[i - 1] = arguments[i];
+ }
+
+ if (err) {
+ results.unshift(err);
+ reject(results);
+ } else {
+ resolve(results);
+ }
+ } else if (err) {
+ reject(err);
+ } else {
+ resolve(result);
+ }
+ });
+ } else {
+ args.push(function (result) {
+ if (opts.multiArgs) {
+ const results = new Array(arguments.length - 1);
+
+ for (let i = 0; i < arguments.length; i++) {
+ results[i] = arguments[i];
+ }
+
+ resolve(results);
+ } else {
+ resolve(result);
+ }
+ });
+ }
+
+ fn.apply(this, args);
+ });
+};
+
+module.exports = (obj, opts) => {
+ opts = Object.assign({
+ exclude: [/.+(Sync|Stream)$/],
+ errorFirst: true,
+ promiseModule: Promise
+ }, opts);
+
+ const filter = key => {
+ const match = pattern => typeof pattern === 'string' ? key === pattern : pattern.test(key);
+ return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
+ };
+
+ let ret;
+ if (typeof obj === 'function') {
+ ret = function () {
+ if (opts.excludeMain) {
+ return obj.apply(this, arguments);
+ }
+
+ return processFn(obj, opts).apply(this, arguments);
+ };
+ } else {
+ ret = Object.create(Object.getPrototypeOf(obj));
+ }
+
+ for (const key in obj) { // eslint-disable-line guard-for-in
+ const x = obj[key];
+ ret[key] = typeof x === 'function' && filter(key) ? processFn(x, opts) : x;
+ }
+
+ return ret;
+};
+});
+
+function type(fn, fn2, fp) {
+ if (typeof fp !== 'string') {
+ return Promise.reject(new TypeError(`Expected a string, got ${typeof fp}`));
+ }
+
+ return pify$3(fs[fn])(fp)
+ .then(stats => stats[fn2]())
+ .catch(err => {
+ if (err.code === 'ENOENT') {
+ return false;
+ }
+
+ throw err;
+ });
+}
+
+function typeSync(fn, fn2, fp) {
+ if (typeof fp !== 'string') {
+ throw new TypeError(`Expected a string, got ${typeof fp}`);
+ }
+
+ try {
+ return fs[fn](fp)[fn2]();
+ } catch (err) {
+ if (err.code === 'ENOENT') {
+ return false;
+ }
+
+ throw err;
+ }
+}
+
+var file = type.bind(null, 'stat', 'isFile');
+var dir = type.bind(null, 'stat', 'isDirectory');
+var symlink = type.bind(null, 'lstat', 'isSymbolicLink');
+var fileSync = typeSync.bind(null, 'statSync', 'isFile');
+var dirSync = typeSync.bind(null, 'statSync', 'isDirectory');
+var symlinkSync = typeSync.bind(null, 'lstatSync', 'isSymbolicLink');
+
+var pathType = {
+ file: file,
+ dir: dir,
+ symlink: symlink,
+ fileSync: fileSync,
+ dirSync: dirSync,
+ symlinkSync: symlinkSync
+};
+
+var parser$1 = createCommonjsModule(function (module, exports) {
+/* parser generated by jison 0.4.17 */
+/*
+ Returns a Parser object of the following structure:
+
+ Parser: {
+ yy: {}
+ }
+
+ Parser.prototype: {
+ yy: {},
+ trace: function(),
+ symbols_: {associative list: name ==> number},
+ terminals_: {associative list: number ==> name},
+ productions_: [...],
+ performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
+ table: [...],
+ defaultActions: {...},
+ parseError: function(str, hash),
+ parse: function(input),
+
+ lexer: {
+ EOF: 1,
+ parseError: function(str, hash),
+ setInput: function(input),
+ input: function(),
+ unput: function(str),
+ more: function(),
+ less: function(n),
+ pastInput: function(),
+ upcomingInput: function(),
+ showPosition: function(),
+ test_match: function(regex_match_array, rule_index),
+ next: function(),
+ lex: function(),
+ begin: function(condition),
+ popState: function(),
+ _currentRules: function(),
+ topState: function(),
+ pushState: function(condition),
+
+ options: {
+ ranges: boolean (optional: true ==> token location info will include a .range[] member)
+ flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
+ backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
+ },
+
+ performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
+ rules: [...],
+ conditions: {associative list: name ==> set},
+ }
+ }
+
+
+ token location info (@$, _$, etc.): {
+ first_line: n,
+ last_line: n,
+ first_column: n,
+ last_column: n,
+ range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based)
+ }
+
+
+ the parseError function receives a 'hash' object with these members for lexer and parser errors: {
+ text: (matched text)
+ token: (the produced terminal token, if any)
+ line: (yylineno)
+ }
+ while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
+ loc: (yylloc)
+ expected: (string describing the set of expected tokens)
+ recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
+ }
+*/
+var spdxparse = (function(){
+var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,5],$V1=[1,6],$V2=[1,7],$V3=[1,4],$V4=[1,9],$V5=[1,10],$V6=[5,14,15,17],$V7=[5,12,14,15,17];
+var parser = {trace: function trace() { },
+yy: {},
+symbols_: {"error":2,"start":3,"expression":4,"EOS":5,"simpleExpression":6,"LICENSE":7,"PLUS":8,"LICENSEREF":9,"DOCUMENTREF":10,"COLON":11,"WITH":12,"EXCEPTION":13,"AND":14,"OR":15,"OPEN":16,"CLOSE":17,"$accept":0,"$end":1},
+terminals_: {2:"error",5:"EOS",7:"LICENSE",8:"PLUS",9:"LICENSEREF",10:"DOCUMENTREF",11:"COLON",12:"WITH",13:"EXCEPTION",14:"AND",15:"OR",16:"OPEN",17:"CLOSE"},
+productions_: [0,[3,2],[6,1],[6,2],[6,1],[6,3],[4,1],[4,3],[4,3],[4,3],[4,3]],
+performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
+/* this == yyval */
+
+var $0 = $$.length - 1;
+switch (yystate) {
+case 1:
+return this.$ = $$[$0-1]
+break;
+case 2: case 4: case 5:
+this.$ = {license: yytext};
+break;
+case 3:
+this.$ = {license: $$[$0-1], plus: true};
+break;
+case 6:
+this.$ = $$[$0];
+break;
+case 7:
+this.$ = {exception: $$[$0]};
+this.$.license = $$[$0-2].license;
+if ($$[$0-2].hasOwnProperty('plus')) {
+ this.$.plus = $$[$0-2].plus;
+}
+break;
+case 8:
+this.$ = {conjunction: 'and', left: $$[$0-2], right: $$[$0]};
+break;
+case 9:
+this.$ = {conjunction: 'or', left: $$[$0-2], right: $$[$0]};
+break;
+case 10:
+this.$ = $$[$0-1];
+break;
+}
+},
+table: [{3:1,4:2,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{1:[3]},{5:[1,8],14:$V4,15:$V5},o($V6,[2,6],{12:[1,11]}),{4:12,6:3,7:$V0,9:$V1,10:$V2,16:$V3},o($V7,[2,2],{8:[1,13]}),o($V7,[2,4]),{11:[1,14]},{1:[2,1]},{4:15,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{4:16,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{13:[1,17]},{14:$V4,15:$V5,17:[1,18]},o($V7,[2,3]),{9:[1,19]},o($V6,[2,8]),o([5,15,17],[2,9],{14:$V4}),o($V6,[2,7]),o($V6,[2,10]),o($V7,[2,5])],
+defaultActions: {8:[2,1]},
+parseError: function parseError(str, hash) {
+ if (hash.recoverable) {
+ this.trace(str);
+ } else {
+ function _parseError (msg, hash) {
+ this.message = msg;
+ this.hash = hash;
+ }
+ _parseError.prototype = Error;
+
+ throw new _parseError(str, hash);
+ }
+},
+parse: function parse(input) {
+ var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+ var args = lstack.slice.call(arguments, 1);
+ var lexer = Object.create(this.lexer);
+ var sharedState = { yy: {} };
+ for (var k in this.yy) {
+ if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
+ sharedState.yy[k] = this.yy[k];
+ }
+ }
+ lexer.setInput(input, sharedState.yy);
+ sharedState.yy.lexer = lexer;
+ sharedState.yy.parser = this;
+ if (typeof lexer.yylloc == 'undefined') {
+ lexer.yylloc = {};
+ }
+ var yyloc = lexer.yylloc;
+ lstack.push(yyloc);
+ var ranges = lexer.options && lexer.options.ranges;
+ if (typeof sharedState.yy.parseError === 'function') {
+ this.parseError = sharedState.yy.parseError;
+ } else {
+ this.parseError = Object.getPrototypeOf(this).parseError;
+ }
+ _token_stack:
+ var lex = function () {
+ var token;
+ token = lexer.lex() || EOF;
+ if (typeof token !== 'number') {
+ token = self.symbols_[token] || token;
+ }
+ return token;
+ };
+ var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
+ while (true) {
+ state = stack[stack.length - 1];
+ if (this.defaultActions[state]) {
+ action = this.defaultActions[state];
+ } else {
+ if (symbol === null || typeof symbol == 'undefined') {
+ symbol = lex();
+ }
+ action = table[state] && table[state][symbol];
+ }
+ if (typeof action === 'undefined' || !action.length || !action[0]) {
+ var errStr = '';
+ expected = [];
+ for (p in table[state]) {
+ if (this.terminals_[p] && p > TERROR) {
+ expected.push('\'' + this.terminals_[p] + '\'');
+ }
+ }
+ if (lexer.showPosition) {
+ errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
+ } else {
+ errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
+ }
+ this.parseError(errStr, {
+ text: lexer.match,
+ token: this.terminals_[symbol] || symbol,
+ line: lexer.yylineno,
+ loc: yyloc,
+ expected: expected
+ });
+ }
+ if (action[0] instanceof Array && action.length > 1) {
+ throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
+ }
+ switch (action[0]) {
+ case 1:
+ stack.push(symbol);
+ vstack.push(lexer.yytext);
+ lstack.push(lexer.yylloc);
+ stack.push(action[1]);
+ symbol = null;
+ if (!preErrorSymbol) {
+ yyleng = lexer.yyleng;
+ yytext = lexer.yytext;
+ yylineno = lexer.yylineno;
+ yyloc = lexer.yylloc;
+ if (recovering > 0) {
+ recovering--;
+ }
+ } else {
+ symbol = preErrorSymbol;
+ preErrorSymbol = null;
+ }
+ break;
+ case 2:
+ len = this.productions_[action[1]][1];
+ yyval.$ = vstack[vstack.length - len];
+ yyval._$ = {
+ first_line: lstack[lstack.length - (len || 1)].first_line,
+ last_line: lstack[lstack.length - 1].last_line,
+ first_column: lstack[lstack.length - (len || 1)].first_column,
+ last_column: lstack[lstack.length - 1].last_column
+ };
+ if (ranges) {
+ yyval._$.range = [
+ lstack[lstack.length - (len || 1)].range[0],
+ lstack[lstack.length - 1].range[1]
+ ];
+ }
+ r = this.performAction.apply(yyval, [
+ yytext,
+ yyleng,
+ yylineno,
+ sharedState.yy,
+ action[1],
+ vstack,
+ lstack
+ ].concat(args));
+ if (typeof r !== 'undefined') {
+ return r;
+ }
+ if (len) {
+ stack = stack.slice(0, -1 * len * 2);
+ vstack = vstack.slice(0, -1 * len);
+ lstack = lstack.slice(0, -1 * len);
+ }
+ stack.push(this.productions_[action[1]][0]);
+ vstack.push(yyval.$);
+ lstack.push(yyval._$);
+ newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+ stack.push(newState);
+ break;
+ case 3:
+ return true;
+ }
+ }
+ return true;
+}};
+/* generated by jison-lex 0.3.4 */
+var lexer = (function(){
+var lexer = ({
+
+EOF:1,
+
+parseError:function parseError(str, hash) {
+ if (this.yy.parser) {
+ this.yy.parser.parseError(str, hash);
+ } else {
+ throw new Error(str);
+ }
+ },
+
+// resets the lexer, sets new input
+setInput:function (input, yy) {
+ this.yy = yy || this.yy || {};
+ this._input = input;
+ this._more = this._backtrack = this.done = false;
+ this.yylineno = this.yyleng = 0;
+ this.yytext = this.matched = this.match = '';
+ this.conditionStack = ['INITIAL'];
+ this.yylloc = {
+ first_line: 1,
+ first_column: 0,
+ last_line: 1,
+ last_column: 0
+ };
+ if (this.options.ranges) {
+ this.yylloc.range = [0,0];
+ }
+ this.offset = 0;
+ return this;
+ },
+
+// consumes and returns one char from the input
+input:function () {
+ var ch = this._input[0];
+ this.yytext += ch;
+ this.yyleng++;
+ this.offset++;
+ this.match += ch;
+ this.matched += ch;
+ var lines = ch.match(/(?:\r\n?|\n).*/g);
+ if (lines) {
+ this.yylineno++;
+ this.yylloc.last_line++;
+ } else {
+ this.yylloc.last_column++;
+ }
+ if (this.options.ranges) {
+ this.yylloc.range[1]++;
+ }
+
+ this._input = this._input.slice(1);
+ return ch;
+ },
+
+// unshifts one char (or a string) into the input
+unput:function (ch) {
+ var len = ch.length;
+ var lines = ch.split(/(?:\r\n?|\n)/g);
+
+ this._input = ch + this._input;
+ this.yytext = this.yytext.substr(0, this.yytext.length - len);
+ //this.yyleng -= len;
+ this.offset -= len;
+ var oldLines = this.match.split(/(?:\r\n?|\n)/g);
+ this.match = this.match.substr(0, this.match.length - 1);
+ this.matched = this.matched.substr(0, this.matched.length - 1);
+
+ if (lines.length - 1) {
+ this.yylineno -= lines.length - 1;
+ }
+ var r = this.yylloc.range;
+
+ this.yylloc = {
+ first_line: this.yylloc.first_line,
+ last_line: this.yylineno + 1,
+ first_column: this.yylloc.first_column,
+ last_column: lines ?
+ (lines.length === oldLines.length ? this.yylloc.first_column : 0)
+ + oldLines[oldLines.length - lines.length].length - lines[0].length :
+ this.yylloc.first_column - len
+ };
+
+ if (this.options.ranges) {
+ this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+ }
+ this.yyleng = this.yytext.length;
+ return this;
+ },
+
+// When called from action, caches matched text and appends it on next action
+more:function () {
+ this._more = true;
+ return this;
+ },
+
+// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+reject:function () {
+ if (this.options.backtrack_lexer) {
+ this._backtrack = true;
+ } else {
+ return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
+ text: "",
+ token: null,
+ line: this.yylineno
+ });
+
+ }
+ return this;
+ },
+
+// retain first n characters of the match
+less:function (n) {
+ this.unput(this.match.slice(n));
+ },
+
+// displays already matched input, i.e. for error messages
+pastInput:function () {
+ var past = this.matched.substr(0, this.matched.length - this.match.length);
+ return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
+ },
+
+// displays upcoming input, i.e. for error messages
+upcomingInput:function () {
+ var next = this.match;
+ if (next.length < 20) {
+ next += this._input.substr(0, 20-next.length);
+ }
+ return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
+ },
+
+// displays the character position where the lexing error occurred, i.e. for error messages
+showPosition:function () {
+ var pre = this.pastInput();
+ var c = new Array(pre.length + 1).join("-");
+ return pre + this.upcomingInput() + "\n" + c + "^";
+ },
+
+// test the lexed token: return FALSE when not a match, otherwise return token
+test_match:function (match, indexed_rule) {
+ var token,
+ lines,
+ backup;
+
+ if (this.options.backtrack_lexer) {
+ // save context
+ backup = {
+ yylineno: this.yylineno,
+ yylloc: {
+ first_line: this.yylloc.first_line,
+ last_line: this.last_line,
+ first_column: this.yylloc.first_column,
+ last_column: this.yylloc.last_column
+ },
+ yytext: this.yytext,
+ match: this.match,
+ matches: this.matches,
+ matched: this.matched,
+ yyleng: this.yyleng,
+ offset: this.offset,
+ _more: this._more,
+ _input: this._input,
+ yy: this.yy,
+ conditionStack: this.conditionStack.slice(0),
+ done: this.done
+ };
+ if (this.options.ranges) {
+ backup.yylloc.range = this.yylloc.range.slice(0);
+ }
+ }
+
+ lines = match[0].match(/(?:\r\n?|\n).*/g);
+ if (lines) {
+ this.yylineno += lines.length;
+ }
+ this.yylloc = {
+ first_line: this.yylloc.last_line,
+ last_line: this.yylineno + 1,
+ first_column: this.yylloc.last_column,
+ last_column: lines ?
+ lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
+ this.yylloc.last_column + match[0].length
+ };
+ this.yytext += match[0];
+ this.match += match[0];
+ this.matches = match;
+ this.yyleng = this.yytext.length;
+ if (this.options.ranges) {
+ this.yylloc.range = [this.offset, this.offset += this.yyleng];
+ }
+ this._more = false;
+ this._backtrack = false;
+ this._input = this._input.slice(match[0].length);
+ this.matched += match[0];
+ token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
+ if (this.done && this._input) {
+ this.done = false;
+ }
+ if (token) {
+ return token;
+ } else if (this._backtrack) {
+ // recover context
+ for (var k in backup) {
+ this[k] = backup[k];
+ }
+ return false; // rule action called reject() implying the next rule should be tested instead.
+ }
+ return false;
+ },
+
+// return next match in input
+next:function () {
+ if (this.done) {
+ return this.EOF;
+ }
+ if (!this._input) {
+ this.done = true;
+ }
+
+ var token,
+ match,
+ tempMatch,
+ index;
+ if (!this._more) {
+ this.yytext = '';
+ this.match = '';
+ }
+ var rules = this._currentRules();
+ for (var i = 0; i < rules.length; i++) {
+ tempMatch = this._input.match(this.rules[rules[i]]);
+ if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+ match = tempMatch;
+ index = i;
+ if (this.options.backtrack_lexer) {
+ token = this.test_match(tempMatch, rules[i]);
+ if (token !== false) {
+ return token;
+ } else if (this._backtrack) {
+ match = false;
+ continue; // rule action called reject() implying a rule MISmatch.
+ } else {
+ // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
+ return false;
+ }
+ } else if (!this.options.flex) {
+ break;
+ }
+ }
+ }
+ if (match) {
+ token = this.test_match(match, rules[index]);
+ if (token !== false) {
+ return token;
+ }
+ // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
+ return false;
+ }
+ if (this._input === "") {
+ return this.EOF;
+ } else {
+ return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
+ text: "",
+ token: null,
+ line: this.yylineno
+ });
+ }
+ },
+
+// return next match that has a token
+lex:function lex() {
+ var r = this.next();
+ if (r) {
+ return r;
+ } else {
+ return this.lex();
+ }
+ },
+
+// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+begin:function begin(condition) {
+ this.conditionStack.push(condition);
+ },
+
+// pop the previously active lexer condition state off the condition stack
+popState:function popState() {
+ var n = this.conditionStack.length - 1;
+ if (n > 0) {
+ return this.conditionStack.pop();
+ } else {
+ return this.conditionStack[0];
+ }
+ },
+
+// produce the lexer rule set which is active for the currently active lexer condition state
+_currentRules:function _currentRules() {
+ if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
+ return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
+ } else {
+ return this.conditions["INITIAL"].rules;
+ }
+ },
+
+// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+topState:function topState(n) {
+ n = this.conditionStack.length - 1 - Math.abs(n || 0);
+ if (n >= 0) {
+ return this.conditionStack[n];
+ } else {
+ return "INITIAL";
+ }
+ },
+
+// alias for begin(condition)
+pushState:function pushState(condition) {
+ this.begin(condition);
+ },
+
+// return the number of states currently on the stack
+stateStackSize:function stateStackSize() {
+ return this.conditionStack.length;
+ },
+options: {},
+performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
+var YYSTATE=YY_START;
+switch($avoiding_name_collisions) {
+case 0:return 5
+break;
+case 1:/* skip whitespace */
+break;
+case 2:return 8
+break;
+case 3:return 16
+break;
+case 4:return 17
+break;
+case 5:return 11
+break;
+case 6:return 10
+break;
+case 7:return 9
+break;
+case 8:return 14
+break;
+case 9:return 15
+break;
+case 10:return 12
+break;
+case 11:return 7
+break;
+case 12:return 7
+break;
+case 13:return 7
+break;
+case 14:return 7
+break;
+case 15:return 7
+break;
+case 16:return 7
+break;
+case 17:return 7
+break;
+case 18:return 7
+break;
+case 19:return 7
+break;
+case 20:return 7
+break;
+case 21:return 7
+break;
+case 22:return 7
+break;
+case 23:return 7
+break;
+case 24:return 13
+break;
+case 25:return 13
+break;
+case 26:return 13
+break;
+case 27:return 13
+break;
+case 28:return 13
+break;
+case 29:return 13
+break;
+case 30:return 13
+break;
+case 31:return 13
+break;
+case 32:return 7
+break;
+case 33:return 13
+break;
+case 34:return 7
+break;
+case 35:return 13
+break;
+case 36:return 7
+break;
+case 37:return 13
+break;
+case 38:return 13
+break;
+case 39:return 7
+break;
+case 40:return 13
+break;
+case 41:return 13
+break;
+case 42:return 13
+break;
+case 43:return 13
+break;
+case 44:return 13
+break;
+case 45:return 7
+break;
+case 46:return 13
+break;
+case 47:return 7
+break;
+case 48:return 7
+break;
+case 49:return 7
+break;
+case 50:return 7
+break;
+case 51:return 7
+break;
+case 52:return 7
+break;
+case 53:return 7
+break;
+case 54:return 7
+break;
+case 55:return 7
+break;
+case 56:return 7
+break;
+case 57:return 7
+break;
+case 58:return 7
+break;
+case 59:return 7
+break;
+case 60:return 7
+break;
+case 61:return 7
+break;
+case 62:return 7
+break;
+case 63:return 13
+break;
+case 64:return 7
+break;
+case 65:return 7
+break;
+case 66:return 13
+break;
+case 67:return 7
+break;
+case 68:return 7
+break;
+case 69:return 7
+break;
+case 70:return 7
+break;
+case 71:return 7
+break;
+case 72:return 7
+break;
+case 73:return 13
+break;
+case 74:return 7
+break;
+case 75:return 13
+break;
+case 76:return 7
+break;
+case 77:return 7
+break;
+case 78:return 7
+break;
+case 79:return 7
+break;
+case 80:return 7
+break;
+case 81:return 7
+break;
+case 82:return 7
+break;
+case 83:return 7
+break;
+case 84:return 7
+break;
+case 85:return 7
+break;
+case 86:return 7
+break;
+case 87:return 7
+break;
+case 88:return 7
+break;
+case 89:return 7
+break;
+case 90:return 7
+break;
+case 91:return 7
+break;
+case 92:return 7
+break;
+case 93:return 7
+break;
+case 94:return 7
+break;
+case 95:return 7
+break;
+case 96:return 7
+break;
+case 97:return 7
+break;
+case 98:return 7
+break;
+case 99:return 7
+break;
+case 100:return 7
+break;
+case 101:return 7
+break;
+case 102:return 7
+break;
+case 103:return 7
+break;
+case 104:return 7
+break;
+case 105:return 7
+break;
+case 106:return 7
+break;
+case 107:return 7
+break;
+case 108:return 7
+break;
+case 109:return 7
+break;
+case 110:return 7
+break;
+case 111:return 7
+break;
+case 112:return 7
+break;
+case 113:return 7
+break;
+case 114:return 7
+break;
+case 115:return 7
+break;
+case 116:return 7
+break;
+case 117:return 7
+break;
+case 118:return 7
+break;
+case 119:return 7
+break;
+case 120:return 7
+break;
+case 121:return 7
+break;
+case 122:return 7
+break;
+case 123:return 7
+break;
+case 124:return 7
+break;
+case 125:return 7
+break;
+case 126:return 7
+break;
+case 127:return 7
+break;
+case 128:return 7
+break;
+case 129:return 7
+break;
+case 130:return 7
+break;
+case 131:return 7
+break;
+case 132:return 7
+break;
+case 133:return 7
+break;
+case 134:return 7
+break;
+case 135:return 7
+break;
+case 136:return 7
+break;
+case 137:return 7
+break;
+case 138:return 7
+break;
+case 139:return 7
+break;
+case 140:return 7
+break;
+case 141:return 7
+break;
+case 142:return 7
+break;
+case 143:return 7
+break;
+case 144:return 7
+break;
+case 145:return 7
+break;
+case 146:return 7
+break;
+case 147:return 7
+break;
+case 148:return 7
+break;
+case 149:return 7
+break;
+case 150:return 7
+break;
+case 151:return 7
+break;
+case 152:return 7
+break;
+case 153:return 7
+break;
+case 154:return 7
+break;
+case 155:return 7
+break;
+case 156:return 7
+break;
+case 157:return 7
+break;
+case 158:return 7
+break;
+case 159:return 7
+break;
+case 160:return 7
+break;
+case 161:return 7
+break;
+case 162:return 7
+break;
+case 163:return 7
+break;
+case 164:return 7
+break;
+case 165:return 7
+break;
+case 166:return 7
+break;
+case 167:return 7
+break;
+case 168:return 7
+break;
+case 169:return 7
+break;
+case 170:return 7
+break;
+case 171:return 7
+break;
+case 172:return 7
+break;
+case 173:return 7
+break;
+case 174:return 7
+break;
+case 175:return 7
+break;
+case 176:return 7
+break;
+case 177:return 7
+break;
+case 178:return 7
+break;
+case 179:return 7
+break;
+case 180:return 7
+break;
+case 181:return 7
+break;
+case 182:return 7
+break;
+case 183:return 7
+break;
+case 184:return 7
+break;
+case 185:return 7
+break;
+case 186:return 7
+break;
+case 187:return 7
+break;
+case 188:return 7
+break;
+case 189:return 7
+break;
+case 190:return 7
+break;
+case 191:return 7
+break;
+case 192:return 7
+break;
+case 193:return 7
+break;
+case 194:return 7
+break;
+case 195:return 7
+break;
+case 196:return 7
+break;
+case 197:return 7
+break;
+case 198:return 7
+break;
+case 199:return 7
+break;
+case 200:return 7
+break;
+case 201:return 7
+break;
+case 202:return 7
+break;
+case 203:return 7
+break;
+case 204:return 7
+break;
+case 205:return 7
+break;
+case 206:return 7
+break;
+case 207:return 7
+break;
+case 208:return 7
+break;
+case 209:return 7
+break;
+case 210:return 7
+break;
+case 211:return 7
+break;
+case 212:return 7
+break;
+case 213:return 7
+break;
+case 214:return 7
+break;
+case 215:return 7
+break;
+case 216:return 7
+break;
+case 217:return 7
+break;
+case 218:return 7
+break;
+case 219:return 7
+break;
+case 220:return 7
+break;
+case 221:return 7
+break;
+case 222:return 7
+break;
+case 223:return 7
+break;
+case 224:return 7
+break;
+case 225:return 7
+break;
+case 226:return 7
+break;
+case 227:return 7
+break;
+case 228:return 7
+break;
+case 229:return 7
+break;
+case 230:return 7
+break;
+case 231:return 7
+break;
+case 232:return 7
+break;
+case 233:return 7
+break;
+case 234:return 7
+break;
+case 235:return 7
+break;
+case 236:return 7
+break;
+case 237:return 7
+break;
+case 238:return 7
+break;
+case 239:return 7
+break;
+case 240:return 7
+break;
+case 241:return 7
+break;
+case 242:return 7
+break;
+case 243:return 7
+break;
+case 244:return 7
+break;
+case 245:return 7
+break;
+case 246:return 7
+break;
+case 247:return 7
+break;
+case 248:return 7
+break;
+case 249:return 7
+break;
+case 250:return 7
+break;
+case 251:return 7
+break;
+case 252:return 7
+break;
+case 253:return 7
+break;
+case 254:return 7
+break;
+case 255:return 7
+break;
+case 256:return 7
+break;
+case 257:return 7
+break;
+case 258:return 7
+break;
+case 259:return 7
+break;
+case 260:return 7
+break;
+case 261:return 7
+break;
+case 262:return 7
+break;
+case 263:return 7
+break;
+case 264:return 7
+break;
+case 265:return 7
+break;
+case 266:return 7
+break;
+case 267:return 7
+break;
+case 268:return 7
+break;
+case 269:return 7
+break;
+case 270:return 7
+break;
+case 271:return 7
+break;
+case 272:return 7
+break;
+case 273:return 7
+break;
+case 274:return 7
+break;
+case 275:return 7
+break;
+case 276:return 7
+break;
+case 277:return 7
+break;
+case 278:return 7
+break;
+case 279:return 7
+break;
+case 280:return 7
+break;
+case 281:return 7
+break;
+case 282:return 7
+break;
+case 283:return 7
+break;
+case 284:return 7
+break;
+case 285:return 7
+break;
+case 286:return 7
+break;
+case 287:return 7
+break;
+case 288:return 7
+break;
+case 289:return 7
+break;
+case 290:return 7
+break;
+case 291:return 7
+break;
+case 292:return 7
+break;
+case 293:return 7
+break;
+case 294:return 7
+break;
+case 295:return 7
+break;
+case 296:return 7
+break;
+case 297:return 7
+break;
+case 298:return 7
+break;
+case 299:return 7
+break;
+case 300:return 7
+break;
+case 301:return 7
+break;
+case 302:return 7
+break;
+case 303:return 7
+break;
+case 304:return 7
+break;
+case 305:return 7
+break;
+case 306:return 7
+break;
+case 307:return 7
+break;
+case 308:return 7
+break;
+case 309:return 7
+break;
+case 310:return 7
+break;
+case 311:return 7
+break;
+case 312:return 7
+break;
+case 313:return 7
+break;
+case 314:return 7
+break;
+case 315:return 7
+break;
+case 316:return 7
+break;
+case 317:return 7
+break;
+case 318:return 7
+break;
+case 319:return 7
+break;
+case 320:return 7
+break;
+case 321:return 7
+break;
+case 322:return 7
+break;
+case 323:return 7
+break;
+case 324:return 7
+break;
+case 325:return 7
+break;
+case 326:return 7
+break;
+case 327:return 7
+break;
+case 328:return 7
+break;
+case 329:return 7
+break;
+case 330:return 7
+break;
+case 331:return 7
+break;
+case 332:return 7
+break;
+case 333:return 7
+break;
+case 334:return 7
+break;
+case 335:return 7
+break;
+case 336:return 7
+break;
+case 337:return 7
+break;
+case 338:return 7
+break;
+case 339:return 7
+break;
+case 340:return 7
+break;
+case 341:return 7
+break;
+case 342:return 7
+break;
+case 343:return 7
+break;
+case 344:return 7
+break;
+case 345:return 7
+break;
+case 346:return 7
+break;
+case 347:return 7
+break;
+case 348:return 7
+break;
+case 349:return 7
+break;
+case 350:return 7
+break;
+case 351:return 7
+break;
+case 352:return 7
+break;
+case 353:return 7
+break;
+case 354:return 7
+break;
+case 355:return 7
+break;
+case 356:return 7
+break;
+case 357:return 7
+break;
+case 358:return 7
+break;
+case 359:return 7
+break;
+case 360:return 7
+break;
+case 361:return 7
+break;
+case 362:return 7
+break;
+case 363:return 7
+break;
+case 364:return 7
+break;
+}
+},
+rules: [/^(?:$)/,/^(?:\s+)/,/^(?:\+)/,/^(?:\()/,/^(?:\))/,/^(?::)/,/^(?:DocumentRef-([0-9A-Za-z-+.]+))/,/^(?:LicenseRef-([0-9A-Za-z-+.]+))/,/^(?:AND)/,/^(?:OR)/,/^(?:WITH)/,/^(?:BSD-3-Clause-No-Nuclear-License-2014)/,/^(?:BSD-3-Clause-No-Nuclear-Warranty)/,/^(?:GPL-2\.0-with-classpath-exception)/,/^(?:GPL-3\.0-with-autoconf-exception)/,/^(?:GPL-2\.0-with-autoconf-exception)/,/^(?:BSD-3-Clause-No-Nuclear-License)/,/^(?:MPL-2\.0-no-copyleft-exception)/,/^(?:GPL-2\.0-with-bison-exception)/,/^(?:GPL-2\.0-with-font-exception)/,/^(?:GPL-2\.0-with-GCC-exception)/,/^(?:CNRI-Python-GPL-Compatible)/,/^(?:GPL-3\.0-with-GCC-exception)/,/^(?:BSD-3-Clause-Attribution)/,/^(?:Classpath-exception-2\.0)/,/^(?:WxWindows-exception-3\.1)/,/^(?:freertos-exception-2\.0)/,/^(?:Autoconf-exception-3\.0)/,/^(?:i2p-gpl-java-exception)/,/^(?:gnu-javamail-exception)/,/^(?:Nokia-Qt-exception-1\.1)/,/^(?:Autoconf-exception-2\.0)/,/^(?:BSD-2-Clause-FreeBSD)/,/^(?:u-boot-exception-2\.0)/,/^(?:zlib-acknowledgement)/,/^(?:Bison-exception-2\.2)/,/^(?:BSD-2-Clause-NetBSD)/,/^(?:CLISP-exception-2\.0)/,/^(?:eCos-exception-2\.0)/,/^(?:BSD-3-Clause-Clear)/,/^(?:Font-exception-2\.0)/,/^(?:FLTK-exception-2\.0)/,/^(?:GCC-exception-2\.0)/,/^(?:Qwt-exception-1\.0)/,/^(?:Libtool-exception)/,/^(?:BSD-3-Clause-LBNL)/,/^(?:GCC-exception-3\.1)/,/^(?:Artistic-1\.0-Perl)/,/^(?:Artistic-1\.0-cl8)/,/^(?:CC-BY-NC-SA-2\.5)/,/^(?:MIT-advertising)/,/^(?:BSD-Source-Code)/,/^(?:CC-BY-NC-SA-4\.0)/,/^(?:LiLiQ-Rplus-1\.1)/,/^(?:CC-BY-NC-SA-3\.0)/,/^(?:BSD-4-Clause-UC)/,/^(?:CC-BY-NC-SA-2\.0)/,/^(?:CC-BY-NC-SA-1\.0)/,/^(?:CC-BY-NC-ND-4\.0)/,/^(?:CC-BY-NC-ND-3\.0)/,/^(?:CC-BY-NC-ND-2\.5)/,/^(?:CC-BY-NC-ND-2\.0)/,/^(?:CC-BY-NC-ND-1\.0)/,/^(?:LZMA-exception)/,/^(?:BitTorrent-1\.1)/,/^(?:CrystalStacker)/,/^(?:FLTK-exception)/,/^(?:SugarCRM-1\.1\.3)/,/^(?:BSD-Protection)/,/^(?:BitTorrent-1\.0)/,/^(?:HaskellReport)/,/^(?:Interbase-1\.0)/,/^(?:StandardML-NJ)/,/^(?:mif-exception)/,/^(?:Frameworx-1\.0)/,/^(?:389-exception)/,/^(?:CC-BY-NC-2\.0)/,/^(?:CC-BY-NC-2\.5)/,/^(?:CC-BY-NC-3\.0)/,/^(?:CC-BY-NC-4\.0)/,/^(?:W3C-19980720)/,/^(?:CC-BY-SA-1\.0)/,/^(?:CC-BY-SA-2\.0)/,/^(?:CC-BY-SA-2\.5)/,/^(?:CC-BY-ND-2\.0)/,/^(?:CC-BY-SA-4\.0)/,/^(?:CC-BY-SA-3\.0)/,/^(?:Artistic-1\.0)/,/^(?:Artistic-2\.0)/,/^(?:CC-BY-ND-2\.5)/,/^(?:CC-BY-ND-3\.0)/,/^(?:CC-BY-ND-4\.0)/,/^(?:CC-BY-ND-1\.0)/,/^(?:BSD-4-Clause)/,/^(?:BSD-3-Clause)/,/^(?:BSD-2-Clause)/,/^(?:CC-BY-NC-1\.0)/,/^(?:bzip2-1\.0\.6)/,/^(?:Unicode-TOU)/,/^(?:CNRI-Jython)/,/^(?:ImageMagick)/,/^(?:Adobe-Glyph)/,/^(?:CUA-OPL-1\.0)/,/^(?:OLDAP-2\.2\.2)/,/^(?:LiLiQ-R-1\.1)/,/^(?:bzip2-1\.0\.5)/,/^(?:LiLiQ-P-1\.1)/,/^(?:OLDAP-2\.0\.1)/,/^(?:OLDAP-2\.2\.1)/,/^(?:CNRI-Python)/,/^(?:XFree86-1\.1)/,/^(?:OSET-PL-2\.1)/,/^(?:Apache-2\.0)/,/^(?:Watcom-1\.0)/,/^(?:PostgreSQL)/,/^(?:Python-2\.0)/,/^(?:RHeCos-1\.1)/,/^(?:EUDatagrid)/,/^(?:Spencer-99)/,/^(?:Intel-ACPI)/,/^(?:CECILL-1\.0)/,/^(?:CECILL-1\.1)/,/^(?:JasPer-2\.0)/,/^(?:CECILL-2\.0)/,/^(?:CECILL-2\.1)/,/^(?:gSOAP-1\.3b)/,/^(?:Spencer-94)/,/^(?:Apache-1\.1)/,/^(?:Spencer-86)/,/^(?:Apache-1\.0)/,/^(?:ClArtistic)/,/^(?:TORQUE-1\.1)/,/^(?:CATOSL-1\.1)/,/^(?:Adobe-2006)/,/^(?:Zimbra-1\.4)/,/^(?:Zimbra-1\.3)/,/^(?:Condor-1\.1)/,/^(?:CC-BY-3\.0)/,/^(?:CC-BY-2\.5)/,/^(?:OLDAP-2\.4)/,/^(?:SGI-B-1\.1)/,/^(?:SISSL-1\.2)/,/^(?:SGI-B-1\.0)/,/^(?:OLDAP-2\.3)/,/^(?:CC-BY-4\.0)/,/^(?:Crossword)/,/^(?:SimPL-2\.0)/,/^(?:OLDAP-2\.2)/,/^(?:OLDAP-2\.1)/,/^(?:ErlPL-1\.1)/,/^(?:LPPL-1\.3a)/,/^(?:LPPL-1\.3c)/,/^(?:OLDAP-2\.0)/,/^(?:Leptonica)/,/^(?:CPOL-1\.02)/,/^(?:OLDAP-1\.4)/,/^(?:OLDAP-1\.3)/,/^(?:CC-BY-2\.0)/,/^(?:Unlicense)/,/^(?:OLDAP-2\.8)/,/^(?:OLDAP-1\.2)/,/^(?:MakeIndex)/,/^(?:OLDAP-2\.7)/,/^(?:OLDAP-1\.1)/,/^(?:Sleepycat)/,/^(?:D-FSL-1\.0)/,/^(?:CC-BY-1\.0)/,/^(?:OLDAP-2\.6)/,/^(?:WXwindows)/,/^(?:NPOSL-3\.0)/,/^(?:FreeImage)/,/^(?:SGI-B-2\.0)/,/^(?:OLDAP-2\.5)/,/^(?:Beerware)/,/^(?:Newsletr)/,/^(?:NBPL-1\.0)/,/^(?:NASA-1\.3)/,/^(?:NLOD-1\.0)/,/^(?:AGPL-1\.0)/,/^(?:OCLC-2\.0)/,/^(?:ODbL-1\.0)/,/^(?:PDDL-1\.0)/,/^(?:Motosoto)/,/^(?:Afmparse)/,/^(?:ANTLR-PD)/,/^(?:LPL-1\.02)/,/^(?:Abstyles)/,/^(?:eCos-2\.0)/,/^(?:APSL-1\.0)/,/^(?:LPPL-1\.2)/,/^(?:LPPL-1\.1)/,/^(?:LPPL-1\.0)/,/^(?:APSL-1\.1)/,/^(?:APSL-2\.0)/,/^(?:Info-ZIP)/,/^(?:Zend-2\.0)/,/^(?:IBM-pibs)/,/^(?:LGPL-2\.0)/,/^(?:LGPL-3\.0)/,/^(?:LGPL-2\.1)/,/^(?:GFDL-1\.3)/,/^(?:PHP-3\.01)/,/^(?:GFDL-1\.2)/,/^(?:GFDL-1\.1)/,/^(?:AGPL-3\.0)/,/^(?:Giftware)/,/^(?:EUPL-1\.1)/,/^(?:RPSL-1\.0)/,/^(?:EUPL-1\.0)/,/^(?:MIT-enna)/,/^(?:CECILL-B)/,/^(?:diffmark)/,/^(?:CECILL-C)/,/^(?:CDDL-1\.0)/,/^(?:Sendmail)/,/^(?:CDDL-1\.1)/,/^(?:CPAL-1\.0)/,/^(?:APSL-1\.2)/,/^(?:NPL-1\.1)/,/^(?:AFL-1\.2)/,/^(?:Caldera)/,/^(?:AFL-2\.0)/,/^(?:FSFULLR)/,/^(?:AFL-2\.1)/,/^(?:VSL-1\.0)/,/^(?:VOSTROM)/,/^(?:UPL-1\.0)/,/^(?:Dotseqn)/,/^(?:CPL-1\.0)/,/^(?:dvipdfm)/,/^(?:EPL-1\.0)/,/^(?:OCCT-PL)/,/^(?:ECL-1\.0)/,/^(?:Latex2e)/,/^(?:ECL-2\.0)/,/^(?:GPL-1\.0)/,/^(?:GPL-2\.0)/,/^(?:GPL-3\.0)/,/^(?:AFL-3\.0)/,/^(?:LAL-1\.2)/,/^(?:LAL-1\.3)/,/^(?:EFL-1\.0)/,/^(?:EFL-2\.0)/,/^(?:gnuplot)/,/^(?:Aladdin)/,/^(?:LPL-1\.0)/,/^(?:libtiff)/,/^(?:Entessa)/,/^(?:AMDPLPA)/,/^(?:IPL-1\.0)/,/^(?:OPL-1\.0)/,/^(?:OSL-1\.0)/,/^(?:OSL-1\.1)/,/^(?:OSL-2\.0)/,/^(?:OSL-2\.1)/,/^(?:OSL-3\.0)/,/^(?:OpenSSL)/,/^(?:ZPL-2\.1)/,/^(?:PHP-3\.0)/,/^(?:ZPL-2\.0)/,/^(?:ZPL-1\.1)/,/^(?:CC0-1\.0)/,/^(?:SPL-1\.0)/,/^(?:psutils)/,/^(?:MPL-1\.0)/,/^(?:QPL-1\.0)/,/^(?:MPL-1\.1)/,/^(?:MPL-2\.0)/,/^(?:APL-1\.0)/,/^(?:RPL-1\.1)/,/^(?:RPL-1\.5)/,/^(?:MIT-CMU)/,/^(?:Multics)/,/^(?:Eurosym)/,/^(?:BSL-1\.0)/,/^(?:MIT-feh)/,/^(?:Saxpath)/,/^(?:Borceux)/,/^(?:OFL-1\.1)/,/^(?:OFL-1\.0)/,/^(?:AFL-1\.1)/,/^(?:YPL-1\.1)/,/^(?:YPL-1\.0)/,/^(?:NPL-1\.0)/,/^(?:iMatix)/,/^(?:mpich2)/,/^(?:APAFML)/,/^(?:Bahyph)/,/^(?:RSA-MD)/,/^(?:psfrag)/,/^(?:Plexus)/,/^(?:eGenix)/,/^(?:Glulxe)/,/^(?:SAX-PD)/,/^(?:Imlib2)/,/^(?:Wsuipa)/,/^(?:LGPLLR)/,/^(?:Libpng)/,/^(?:xinetd)/,/^(?:MITNFA)/,/^(?:NetCDF)/,/^(?:Naumen)/,/^(?:SMPPL)/,/^(?:Nunit)/,/^(?:FSFUL)/,/^(?:GL2PS)/,/^(?:SMLNJ)/,/^(?:Rdisc)/,/^(?:Noweb)/,/^(?:Nokia)/,/^(?:SISSL)/,/^(?:Qhull)/,/^(?:Intel)/,/^(?:Glide)/,/^(?:Xerox)/,/^(?:AMPAS)/,/^(?:WTFPL)/,/^(?:MS-PL)/,/^(?:XSkat)/,/^(?:MS-RL)/,/^(?:MirOS)/,/^(?:RSCPL)/,/^(?:TMate)/,/^(?:OGTSL)/,/^(?:FSFAP)/,/^(?:NCSA)/,/^(?:Zlib)/,/^(?:SCEA)/,/^(?:SNIA)/,/^(?:NGPL)/,/^(?:NOSL)/,/^(?:ADSL)/,/^(?:MTLL)/,/^(?:NLPL)/,/^(?:Ruby)/,/^(?:JSON)/,/^(?:Barr)/,/^(?:0BSD)/,/^(?:Xnet)/,/^(?:Cube)/,/^(?:curl)/,/^(?:DSDP)/,/^(?:Fair)/,/^(?:HPND)/,/^(?:TOSL)/,/^(?:IJG)/,/^(?:SWL)/,/^(?:Vim)/,/^(?:FTL)/,/^(?:ICU)/,/^(?:OML)/,/^(?:NRL)/,/^(?:DOC)/,/^(?:TCL)/,/^(?:W3C)/,/^(?:NTP)/,/^(?:IPA)/,/^(?:ISC)/,/^(?:X11)/,/^(?:AAL)/,/^(?:AML)/,/^(?:xpp)/,/^(?:Zed)/,/^(?:MIT)/,/^(?:Mup)/],
+conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364],"inclusive":true}}
+});
+return lexer;
+})();
+parser.lexer = lexer;
+function Parser () {
+ this.yy = {};
+}
+Parser.prototype = parser;parser.Parser = Parser;
+return new Parser;
+})();
+
+
+if (typeof commonjsRequire !== 'undefined' && 'object' !== 'undefined') {
+exports.parser = spdxparse;
+exports.Parser = spdxparse.Parser;
+exports.parse = function () { return spdxparse.parse.apply(spdxparse, arguments); };
+exports.main = function commonjsMain(args) {
+ if (!args[1]) {
+ console.log('Usage: '+args[0]+' FILE');
+ process.exit(1);
+ }
+ var source = fs.readFileSync(path.normalize(args[1]), "utf8");
+ return exports.parser.parse(source);
+};
+if ('object' !== 'undefined' && commonjsRequire.main === module) {
+ exports.main(process.argv.slice(1));
+}
+}
+});
+
+var parser = parser$1.parser;
+
+var spdxExpressionParse = function (argument) {
+ return parser.parse(argument)
+};
+
+var spdxLicenseIds = [
+ "Glide",
+ "Abstyles",
+ "AFL-1.1",
+ "AFL-1.2",
+ "AFL-2.0",
+ "AFL-2.1",
+ "AFL-3.0",
+ "AMPAS",
+ "APL-1.0",
+ "Adobe-Glyph",
+ "APAFML",
+ "Adobe-2006",
+ "AGPL-1.0",
+ "Afmparse",
+ "Aladdin",
+ "ADSL",
+ "AMDPLPA",
+ "ANTLR-PD",
+ "Apache-1.0",
+ "Apache-1.1",
+ "Apache-2.0",
+ "AML",
+ "APSL-1.0",
+ "APSL-1.1",
+ "APSL-1.2",
+ "APSL-2.0",
+ "Artistic-1.0",
+ "Artistic-1.0-Perl",
+ "Artistic-1.0-cl8",
+ "Artistic-2.0",
+ "AAL",
+ "Bahyph",
+ "Barr",
+ "Beerware",
+ "BitTorrent-1.0",
+ "BitTorrent-1.1",
+ "BSL-1.0",
+ "Borceux",
+ "BSD-2-Clause",
+ "BSD-2-Clause-FreeBSD",
+ "BSD-2-Clause-NetBSD",
+ "BSD-3-Clause",
+ "BSD-3-Clause-Clear",
+ "BSD-4-Clause",
+ "BSD-Protection",
+ "BSD-Source-Code",
+ "BSD-3-Clause-Attribution",
+ "0BSD",
+ "BSD-4-Clause-UC",
+ "bzip2-1.0.5",
+ "bzip2-1.0.6",
+ "Caldera",
+ "CECILL-1.0",
+ "CECILL-1.1",
+ "CECILL-2.0",
+ "CECILL-2.1",
+ "CECILL-B",
+ "CECILL-C",
+ "ClArtistic",
+ "MIT-CMU",
+ "CNRI-Jython",
+ "CNRI-Python",
+ "CNRI-Python-GPL-Compatible",
+ "CPOL-1.02",
+ "CDDL-1.0",
+ "CDDL-1.1",
+ "CPAL-1.0",
+ "CPL-1.0",
+ "CATOSL-1.1",
+ "Condor-1.1",
+ "CC-BY-1.0",
+ "CC-BY-2.0",
+ "CC-BY-2.5",
+ "CC-BY-3.0",
+ "CC-BY-4.0",
+ "CC-BY-ND-1.0",
+ "CC-BY-ND-2.0",
+ "CC-BY-ND-2.5",
+ "CC-BY-ND-3.0",
+ "CC-BY-ND-4.0",
+ "CC-BY-NC-1.0",
+ "CC-BY-NC-2.0",
+ "CC-BY-NC-2.5",
+ "CC-BY-NC-3.0",
+ "CC-BY-NC-4.0",
+ "CC-BY-NC-ND-1.0",
+ "CC-BY-NC-ND-2.0",
+ "CC-BY-NC-ND-2.5",
+ "CC-BY-NC-ND-3.0",
+ "CC-BY-NC-ND-4.0",
+ "CC-BY-NC-SA-1.0",
+ "CC-BY-NC-SA-2.0",
+ "CC-BY-NC-SA-2.5",
+ "CC-BY-NC-SA-3.0",
+ "CC-BY-NC-SA-4.0",
+ "CC-BY-SA-1.0",
+ "CC-BY-SA-2.0",
+ "CC-BY-SA-2.5",
+ "CC-BY-SA-3.0",
+ "CC-BY-SA-4.0",
+ "CC0-1.0",
+ "Crossword",
+ "CrystalStacker",
+ "CUA-OPL-1.0",
+ "Cube",
+ "curl",
+ "D-FSL-1.0",
+ "diffmark",
+ "WTFPL",
+ "DOC",
+ "Dotseqn",
+ "DSDP",
+ "dvipdfm",
+ "EPL-1.0",
+ "ECL-1.0",
+ "ECL-2.0",
+ "eGenix",
+ "EFL-1.0",
+ "EFL-2.0",
+ "MIT-advertising",
+ "MIT-enna",
+ "Entessa",
+ "ErlPL-1.1",
+ "EUDatagrid",
+ "EUPL-1.0",
+ "EUPL-1.1",
+ "Eurosym",
+ "Fair",
+ "MIT-feh",
+ "Frameworx-1.0",
+ "FreeImage",
+ "FTL",
+ "FSFAP",
+ "FSFUL",
+ "FSFULLR",
+ "Giftware",
+ "GL2PS",
+ "Glulxe",
+ "AGPL-3.0",
+ "GFDL-1.1",
+ "GFDL-1.2",
+ "GFDL-1.3",
+ "GPL-1.0",
+ "GPL-2.0",
+ "GPL-3.0",
+ "LGPL-2.1",
+ "LGPL-3.0",
+ "LGPL-2.0",
+ "gnuplot",
+ "gSOAP-1.3b",
+ "HaskellReport",
+ "HPND",
+ "IBM-pibs",
+ "IPL-1.0",
+ "ICU",
+ "ImageMagick",
+ "iMatix",
+ "Imlib2",
+ "IJG",
+ "Info-ZIP",
+ "Intel-ACPI",
+ "Intel",
+ "Interbase-1.0",
+ "IPA",
+ "ISC",
+ "JasPer-2.0",
+ "JSON",
+ "LPPL-1.0",
+ "LPPL-1.1",
+ "LPPL-1.2",
+ "LPPL-1.3a",
+ "LPPL-1.3c",
+ "Latex2e",
+ "BSD-3-Clause-LBNL",
+ "Leptonica",
+ "LGPLLR",
+ "Libpng",
+ "libtiff",
+ "LAL-1.2",
+ "LAL-1.3",
+ "LiLiQ-P-1.1",
+ "LiLiQ-Rplus-1.1",
+ "LiLiQ-R-1.1",
+ "LPL-1.02",
+ "LPL-1.0",
+ "MakeIndex",
+ "MTLL",
+ "MS-PL",
+ "MS-RL",
+ "MirOS",
+ "MITNFA",
+ "MIT",
+ "Motosoto",
+ "MPL-1.0",
+ "MPL-1.1",
+ "MPL-2.0",
+ "MPL-2.0-no-copyleft-exception",
+ "mpich2",
+ "Multics",
+ "Mup",
+ "NASA-1.3",
+ "Naumen",
+ "NBPL-1.0",
+ "NetCDF",
+ "NGPL",
+ "NOSL",
+ "NPL-1.0",
+ "NPL-1.1",
+ "Newsletr",
+ "NLPL",
+ "Nokia",
+ "NPOSL-3.0",
+ "NLOD-1.0",
+ "Noweb",
+ "NRL",
+ "NTP",
+ "Nunit",
+ "OCLC-2.0",
+ "ODbL-1.0",
+ "PDDL-1.0",
+ "OCCT-PL",
+ "OGTSL",
+ "OLDAP-2.2.2",
+ "OLDAP-1.1",
+ "OLDAP-1.2",
+ "OLDAP-1.3",
+ "OLDAP-1.4",
+ "OLDAP-2.0",
+ "OLDAP-2.0.1",
+ "OLDAP-2.1",
+ "OLDAP-2.2",
+ "OLDAP-2.2.1",
+ "OLDAP-2.3",
+ "OLDAP-2.4",
+ "OLDAP-2.5",
+ "OLDAP-2.6",
+ "OLDAP-2.7",
+ "OLDAP-2.8",
+ "OML",
+ "OPL-1.0",
+ "OSL-1.0",
+ "OSL-1.1",
+ "OSL-2.0",
+ "OSL-2.1",
+ "OSL-3.0",
+ "OpenSSL",
+ "OSET-PL-2.1",
+ "PHP-3.0",
+ "PHP-3.01",
+ "Plexus",
+ "PostgreSQL",
+ "psfrag",
+ "psutils",
+ "Python-2.0",
+ "QPL-1.0",
+ "Qhull",
+ "Rdisc",
+ "RPSL-1.0",
+ "RPL-1.1",
+ "RPL-1.5",
+ "RHeCos-1.1",
+ "RSCPL",
+ "RSA-MD",
+ "Ruby",
+ "SAX-PD",
+ "Saxpath",
+ "SCEA",
+ "SWL",
+ "SMPPL",
+ "Sendmail",
+ "SGI-B-1.0",
+ "SGI-B-1.1",
+ "SGI-B-2.0",
+ "OFL-1.0",
+ "OFL-1.1",
+ "SimPL-2.0",
+ "Sleepycat",
+ "SNIA",
+ "Spencer-86",
+ "Spencer-94",
+ "Spencer-99",
+ "SMLNJ",
+ "SugarCRM-1.1.3",
+ "SISSL",
+ "SISSL-1.2",
+ "SPL-1.0",
+ "Watcom-1.0",
+ "TCL",
+ "Unlicense",
+ "TMate",
+ "TORQUE-1.1",
+ "TOSL",
+ "Unicode-TOU",
+ "UPL-1.0",
+ "NCSA",
+ "Vim",
+ "VOSTROM",
+ "VSL-1.0",
+ "W3C-19980720",
+ "W3C",
+ "Wsuipa",
+ "Xnet",
+ "X11",
+ "Xerox",
+ "XFree86-1.1",
+ "xinetd",
+ "xpp",
+ "XSkat",
+ "YPL-1.0",
+ "YPL-1.1",
+ "Zed",
+ "Zend-2.0",
+ "Zimbra-1.3",
+ "Zimbra-1.4",
+ "Zlib",
+ "zlib-acknowledgement",
+ "ZPL-1.1",
+ "ZPL-2.0",
+ "ZPL-2.1",
+ "BSD-3-Clause-No-Nuclear-License",
+ "BSD-3-Clause-No-Nuclear-Warranty",
+ "BSD-3-Clause-No-Nuclear-License-2014",
+ "eCos-2.0",
+ "GPL-2.0-with-autoconf-exception",
+ "GPL-2.0-with-bison-exception",
+ "GPL-2.0-with-classpath-exception",
+ "GPL-2.0-with-font-exception",
+ "GPL-2.0-with-GCC-exception",
+ "GPL-3.0-with-autoconf-exception",
+ "GPL-3.0-with-GCC-exception",
+ "StandardML-NJ",
+ "WXwindows"
+]
+;
+
+var spdxLicenseIds$1 = Object.freeze({
+ default: spdxLicenseIds
+});
+
+var licenseIDs = ( spdxLicenseIds$1 && spdxLicenseIds ) || spdxLicenseIds$1;
+
+function valid(string) {
+ return licenseIDs.indexOf(string) > -1;
+}
+
+// Common transpositions of license identifier acronyms
+var transpositions = [
+ ['APGL', 'AGPL'],
+ ['Gpl', 'GPL'],
+ ['GLP', 'GPL'],
+ ['APL', 'Apache'],
+ ['ISD', 'ISC'],
+ ['GLP', 'GPL'],
+ ['IST', 'ISC'],
+ ['Claude', 'Clause'],
+ [' or later', '+'],
+ [' International', ''],
+ ['GNU', 'GPL'],
+ ['GUN', 'GPL'],
+ ['+', ''],
+ ['GNU GPL', 'GPL'],
+ ['GNU/GPL', 'GPL'],
+ ['GNU GLP', 'GPL'],
+ ['GNU General Public License', 'GPL'],
+ ['Gnu public license', 'GPL'],
+ ['GNU Public License', 'GPL'],
+ ['GNU GENERAL PUBLIC LICENSE', 'GPL'],
+ ['MTI', 'MIT'],
+ ['Mozilla Public License', 'MPL'],
+ ['WTH', 'WTF'],
+ ['-License', '']
+];
+
+var TRANSPOSED = 0;
+var CORRECT = 1;
+
+// Simple corrections to nearly valid identifiers.
+var transforms = [
+ // e.g. 'mit'
+ function(argument) {
+ return argument.toUpperCase();
+ },
+ // e.g. 'MIT '
+ function(argument) {
+ return argument.trim();
+ },
+ // e.g. 'M.I.T.'
+ function(argument) {
+ return argument.replace(/\./g, '');
+ },
+ // e.g. 'Apache- 2.0'
+ function(argument) {
+ return argument.replace(/\s+/g, '');
+ },
+ // e.g. 'CC BY 4.0''
+ function(argument) {
+ return argument.replace(/\s+/g, '-');
+ },
+ // e.g. 'LGPLv2.1'
+ function(argument) {
+ return argument.replace('v', '-');
+ },
+ // e.g. 'Apache 2.0'
+ function(argument) {
+ return argument.replace(/,?\s*(\d)/, '-$1');
+ },
+ // e.g. 'GPL 2'
+ function(argument) {
+ return argument.replace(/,?\s*(\d)/, '-$1.0');
+ },
+ // e.g. 'Apache Version 2.0'
+ function(argument) {
+ return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, '-$2');
+ },
+ // e.g. 'Apache Version 2'
+ function(argument) {
+ return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, '-$2.0');
+ },
+ // e.g. 'ZLIB'
+ function(argument) {
+ return argument[0].toUpperCase() + argument.slice(1);
+ },
+ // e.g. 'MPL/2.0'
+ function(argument) {
+ return argument.replace('/', '-');
+ },
+ // e.g. 'Apache 2'
+ function(argument) {
+ return argument
+ .replace(/\s*V\s*(\d)/, '-$1')
+ .replace(/(\d)$/, '$1.0');
+ },
+ // e.g. 'GPL-2.0-'
+ function(argument) {
+ return argument.slice(0, argument.length - 1);
+ },
+ // e.g. 'GPL2'
+ function(argument) {
+ return argument.replace(/(\d)$/, '-$1.0');
+ },
+ // e.g. 'BSD 3'
+ function(argument) {
+ return argument.replace(/(-| )?(\d)$/, '-$2-Clause');
+ },
+ // e.g. 'BSD clause 3'
+ function(argument) {
+ return argument.replace(/(-| )clause(-| )(\d)/, '-$3-Clause');
+ },
+ // e.g. 'BY-NC-4.0'
+ function(argument) {
+ return 'CC-' + argument;
+ },
+ // e.g. 'BY-NC'
+ function(argument) {
+ return 'CC-' + argument + '-4.0';
+ },
+ // e.g. 'Attribution-NonCommercial'
+ function(argument) {
+ return argument
+ .replace('Attribution', 'BY')
+ .replace('NonCommercial', 'NC')
+ .replace('NoDerivatives', 'ND')
+ .replace(/ (\d)/, '-$1')
+ .replace(/ ?International/, '');
+ },
+ // e.g. 'Attribution-NonCommercial'
+ function(argument) {
+ return 'CC-' +
+ argument
+ .replace('Attribution', 'BY')
+ .replace('NonCommercial', 'NC')
+ .replace('NoDerivatives', 'ND')
+ .replace(/ (\d)/, '-$1')
+ .replace(/ ?International/, '') +
+ '-4.0';
+ }
+];
+
+// If all else fails, guess that strings containing certain substrings
+// meant to identify certain licenses.
+var lastResorts = [
+ ['UNLI', 'Unlicense'],
+ ['WTF', 'WTFPL'],
+ ['2 CLAUSE', 'BSD-2-Clause'],
+ ['2-CLAUSE', 'BSD-2-Clause'],
+ ['3 CLAUSE', 'BSD-3-Clause'],
+ ['3-CLAUSE', 'BSD-3-Clause'],
+ ['AFFERO', 'AGPL-3.0'],
+ ['AGPL', 'AGPL-3.0'],
+ ['APACHE', 'Apache-2.0'],
+ ['ARTISTIC', 'Artistic-2.0'],
+ ['Affero', 'AGPL-3.0'],
+ ['BEER', 'Beerware'],
+ ['BOOST', 'BSL-1.0'],
+ ['BSD', 'BSD-2-Clause'],
+ ['ECLIPSE', 'EPL-1.0'],
+ ['FUCK', 'WTFPL'],
+ ['GNU', 'GPL-3.0'],
+ ['LGPL', 'LGPL-3.0'],
+ ['GPL', 'GPL-3.0'],
+ ['MIT', 'MIT'],
+ ['MPL', 'MPL-2.0'],
+ ['X11', 'X11'],
+ ['ZLIB', 'Zlib']
+];
+
+var SUBSTRING = 0;
+var IDENTIFIER = 1;
+
+var validTransformation = function(identifier) {
+ for (var i = 0; i < transforms.length; i++) {
+ var transformed = transforms[i](identifier);
+ if (transformed !== identifier && valid(transformed)) {
+ return transformed;
+ }
+ }
+ return null;
+};
+
+var validLastResort = function(identifier) {
+ var upperCased = identifier.toUpperCase();
+ for (var i = 0; i < lastResorts.length; i++) {
+ var lastResort = lastResorts[i];
+ if (upperCased.indexOf(lastResort[SUBSTRING]) > -1) {
+ return lastResort[IDENTIFIER];
+ }
+ }
+ return null;
+};
+
+var anyCorrection = function(identifier, check) {
+ for (var i = 0; i < transpositions.length; i++) {
+ var transposition = transpositions[i];
+ var transposed = transposition[TRANSPOSED];
+ if (identifier.indexOf(transposed) > -1) {
+ var corrected = identifier.replace(
+ transposed,
+ transposition[CORRECT]
+ );
+ var checked = check(corrected);
+ if (checked !== null) {
+ return checked;
+ }
+ }
+ }
+ return null;
+};
+
+var spdxCorrect = function(identifier) {
+ identifier = identifier.replace(/\+$/, '');
+ if (valid(identifier)) {
+ return identifier;
+ }
+ var transformed = validTransformation(identifier);
+ if (transformed !== null) {
+ return transformed;
+ }
+ transformed = anyCorrection(identifier, function(argument) {
+ if (valid(argument)) {
+ return argument;
+ }
+ return validTransformation(argument);
+ });
+ if (transformed !== null) {
+ return transformed;
+ }
+ transformed = validLastResort(identifier);
+ if (transformed !== null) {
+ return transformed;
+ }
+ transformed = anyCorrection(identifier, validLastResort);
+ if (transformed !== null) {
+ return transformed;
+ }
+ return null;
+};
+
+var genericWarning = (
+ 'license should be ' +
+ 'a valid SPDX license expression (without "LicenseRef"), ' +
+ '"UNLICENSED", or ' +
+ '"SEE LICENSE IN "'
+);
+
+var fileReferenceRE = /^SEE LICEN[CS]E IN (.+)$/;
+
+function startsWith(prefix, string) {
+ return string.slice(0, prefix.length) === prefix;
+}
+
+function usesLicenseRef(ast) {
+ if (ast.hasOwnProperty('license')) {
+ var license = ast.license;
+ return (
+ startsWith('LicenseRef', license) ||
+ startsWith('DocumentRef', license)
+ );
+ } else {
+ return (
+ usesLicenseRef(ast.left) ||
+ usesLicenseRef(ast.right)
+ );
+ }
+}
+
+var validateNpmPackageLicense = function(argument) {
+ var ast;
+
+ try {
+ ast = spdxExpressionParse(argument);
+ } catch (e) {
+ var match;
+ if (
+ argument === 'UNLICENSED' ||
+ argument === 'UNLICENCED'
+ ) {
+ return {
+ validForOldPackages: true,
+ validForNewPackages: true,
+ unlicensed: true
+ };
+ } else if (match = fileReferenceRE.exec(argument)) {
+ return {
+ validForOldPackages: true,
+ validForNewPackages: true,
+ inFile: match[1]
+ };
+ } else {
+ var result = {
+ validForOldPackages: false,
+ validForNewPackages: false,
+ warnings: [genericWarning]
+ };
+ var corrected = spdxCorrect(argument);
+ if (corrected) {
+ result.warnings.push(
+ 'license is similar to the valid expression "' + corrected + '"'
+ );
+ }
+ return result;
+ }
+ }
+
+ if (usesLicenseRef(ast)) {
+ return {
+ validForNewPackages: false,
+ validForOldPackages: false,
+ spdx: true,
+ warnings: [genericWarning]
+ };
+ } else {
+ return {
+ validForNewPackages: true,
+ validForOldPackages: true,
+ spdx: true
+ };
+ }
+};
+
+var gitHostInfo = createCommonjsModule(function (module) {
+'use strict';
+
+var gitHosts = module.exports = {
+ github: {
+ // First two are insecure and generally shouldn't be used any more, but
+ // they are still supported.
+ 'protocols': [ 'git', 'http', 'git+ssh', 'git+https', 'ssh', 'https' ],
+ 'domain': 'github.com',
+ 'treepath': 'tree',
+ 'filetemplate': 'https://{auth@}raw.githubusercontent.com/{user}/{project}/{committish}/{path}',
+ 'bugstemplate': 'https://{domain}/{user}/{project}/issues',
+ 'gittemplate': 'git://{auth@}{domain}/{user}/{project}.git{#committish}',
+ 'tarballtemplate': 'https://{domain}/{user}/{project}/archive/{committish}.tar.gz'
+ },
+ bitbucket: {
+ 'protocols': [ 'git+ssh', 'git+https', 'ssh', 'https' ],
+ 'domain': 'bitbucket.org',
+ 'treepath': 'src',
+ 'tarballtemplate': 'https://{domain}/{user}/{project}/get/{committish}.tar.gz'
+ },
+ gitlab: {
+ 'protocols': [ 'git+ssh', 'git+https', 'ssh', 'https' ],
+ 'domain': 'gitlab.com',
+ 'treepath': 'tree',
+ 'docstemplate': 'https://{domain}/{user}/{project}{/tree/committish}#README',
+ 'bugstemplate': 'https://{domain}/{user}/{project}/issues',
+ 'tarballtemplate': 'https://{domain}/{user}/{project}/repository/archive.tar.gz?ref={committish}'
+ },
+ gist: {
+ 'protocols': [ 'git', 'git+ssh', 'git+https', 'ssh', 'https' ],
+ 'domain': 'gist.github.com',
+ 'pathmatch': /^[/](?:([^/]+)[/])?([a-z0-9]+)(?:[.]git)?$/,
+ 'filetemplate': 'https://gist.githubusercontent.com/{user}/{project}/raw{/committish}/{path}',
+ 'bugstemplate': 'https://{domain}/{project}',
+ 'gittemplate': 'git://{domain}/{project}.git{#committish}',
+ 'sshtemplate': 'git@{domain}:/{project}.git{#committish}',
+ 'sshurltemplate': 'git+ssh://git@{domain}/{project}.git{#committish}',
+ 'browsetemplate': 'https://{domain}/{project}{/committish}',
+ 'docstemplate': 'https://{domain}/{project}{/committish}',
+ 'httpstemplate': 'git+https://{domain}/{project}.git{#committish}',
+ 'shortcuttemplate': '{type}:{project}{#committish}',
+ 'pathtemplate': '{project}{#committish}',
+ 'tarballtemplate': 'https://{domain}/{user}/{project}/archive/{committish}.tar.gz'
+ }
+};
+
+var gitHostDefaults = {
+ 'sshtemplate': 'git@{domain}:{user}/{project}.git{#committish}',
+ 'sshurltemplate': 'git+ssh://git@{domain}/{user}/{project}.git{#committish}',
+ 'browsetemplate': 'https://{domain}/{user}/{project}{/tree/committish}',
+ 'docstemplate': 'https://{domain}/{user}/{project}{/tree/committish}#readme',
+ 'httpstemplate': 'git+https://{auth@}{domain}/{user}/{project}.git{#committish}',
+ 'filetemplate': 'https://{domain}/{user}/{project}/raw/{committish}/{path}',
+ 'shortcuttemplate': '{type}:{user}/{project}{#committish}',
+ 'pathtemplate': '{user}/{project}{#committish}',
+ 'pathmatch': /^[/]([^/]+)[/]([^/]+?)(?:[.]git|[/])?$/
+};
+
+Object.keys(gitHosts).forEach(function (name) {
+ Object.keys(gitHostDefaults).forEach(function (key) {
+ if (gitHosts[name][key]) return
+ gitHosts[name][key] = gitHostDefaults[key];
+ });
+ gitHosts[name].protocols_re = RegExp('^(' +
+ gitHosts[name].protocols.map(function (protocol) {
+ return protocol.replace(/([\\+*{}()[\]$^|])/g, '\\$1')
+ }).join('|') + '):$');
+});
+});
+
+var gitHost = createCommonjsModule(function (module) {
+'use strict';
+
+var extend = Object.assign || util._extend;
+
+var GitHost = module.exports = function (type, user, auth, project, committish, defaultRepresentation, opts) {
+ var gitHostInfo$$1 = this;
+ gitHostInfo$$1.type = type;
+ Object.keys(gitHostInfo[type]).forEach(function (key) {
+ gitHostInfo$$1[key] = gitHostInfo[type][key];
+ });
+ gitHostInfo$$1.user = user;
+ gitHostInfo$$1.auth = auth;
+ gitHostInfo$$1.project = project;
+ gitHostInfo$$1.committish = committish;
+ gitHostInfo$$1.default = defaultRepresentation;
+ gitHostInfo$$1.opts = opts || {};
+};
+GitHost.prototype = {};
+
+GitHost.prototype.hash = function () {
+ return this.committish ? '#' + this.committish : ''
+};
+
+GitHost.prototype._fill = function (template, opts) {
+ if (!template) return
+ var vars = extend({}, opts);
+ opts = extend(extend({}, this.opts), opts);
+ var self = this;
+ Object.keys(this).forEach(function (key) {
+ if (self[key] != null && vars[key] == null) vars[key] = self[key];
+ });
+ var rawAuth = vars.auth;
+ var rawComittish = vars.committish;
+ Object.keys(vars).forEach(function (key) {
+ vars[key] = encodeURIComponent(vars[key]);
+ });
+ vars['auth@'] = rawAuth ? rawAuth + '@' : '';
+ if (opts.noCommittish) {
+ vars['#committish'] = '';
+ vars['/tree/committish'] = '';
+ vars['/comittish'] = '';
+ vars.comittish = '';
+ } else {
+ vars['#committish'] = rawComittish ? '#' + rawComittish : '';
+ vars['/tree/committish'] = vars.committish
+ ? '/' + vars.treepath + '/' + vars.committish
+ : '';
+ vars['/committish'] = vars.committish ? '/' + vars.committish : '';
+ vars.committish = vars.committish || 'master';
+ }
+ var res = template;
+ Object.keys(vars).forEach(function (key) {
+ res = res.replace(new RegExp('[{]' + key + '[}]', 'g'), vars[key]);
+ });
+ if (opts.noGitPlus) {
+ return res.replace(/^git[+]/, '')
+ } else {
+ return res
+ }
+};
+
+GitHost.prototype.ssh = function (opts) {
+ return this._fill(this.sshtemplate, opts)
+};
+
+GitHost.prototype.sshurl = function (opts) {
+ return this._fill(this.sshurltemplate, opts)
+};
+
+GitHost.prototype.browse = function (opts) {
+ return this._fill(this.browsetemplate, opts)
+};
+
+GitHost.prototype.docs = function (opts) {
+ return this._fill(this.docstemplate, opts)
+};
+
+GitHost.prototype.bugs = function (opts) {
+ return this._fill(this.bugstemplate, opts)
+};
+
+GitHost.prototype.https = function (opts) {
+ return this._fill(this.httpstemplate, opts)
+};
+
+GitHost.prototype.git = function (opts) {
+ return this._fill(this.gittemplate, opts)
+};
+
+GitHost.prototype.shortcut = function (opts) {
+ return this._fill(this.shortcuttemplate, opts)
+};
+
+GitHost.prototype.path = function (opts) {
+ return this._fill(this.pathtemplate, opts)
+};
+
+GitHost.prototype.tarball = function (opts) {
+ return this._fill(this.tarballtemplate, opts)
+};
+
+GitHost.prototype.file = function (P, opts) {
+ return this._fill(this.filetemplate, extend({
+ path: P.replace(/^[/]+/g, '')
+ }, opts))
+};
+
+GitHost.prototype.getDefaultRepresentation = function () {
+ return this.default
+};
+
+GitHost.prototype.toString = function (opts) {
+ return (this[this.default] || this.sshurl).call(this, opts)
+};
+});
+
+var hostedGitInfo = createCommonjsModule(function (module) {
+'use strict';
+
+
+var GitHost = module.exports = gitHost;
+
+var protocolToRepresentationMap = {
+ 'git+ssh': 'sshurl',
+ 'git+https': 'https',
+ 'ssh': 'sshurl',
+ 'git': 'git'
+};
+
+function protocolToRepresentation (protocol) {
+ if (protocol.substr(-1) === ':') protocol = protocol.slice(0, -1);
+ return protocolToRepresentationMap[protocol] || protocol
+}
+
+var authProtocols = {
+ 'git:': true,
+ 'https:': true,
+ 'git+https:': true,
+ 'http:': true,
+ 'git+http:': true
+};
+
+module.exports.fromUrl = function (giturl, opts) {
+ if (giturl == null || giturl === '') return
+ var url$$1 = fixupUnqualifiedGist(
+ isGitHubShorthand(giturl) ? 'github:' + giturl : giturl
+ );
+ var parsed = parseGitUrl(url$$1);
+ var shortcutMatch = url$$1.match(new RegExp('^([^:]+):(?:(?:[^@:]+(?:[^@]+)?@)?([^/]*))[/](.+?)(?:[.]git)?($|#)'));
+ var matches = Object.keys(gitHostInfo).map(function (gitHostName) {
+ try {
+ var gitHostInfo$$1 = gitHostInfo[gitHostName];
+ var auth = null;
+ if (parsed.auth && authProtocols[parsed.protocol]) {
+ auth = decodeURIComponent(parsed.auth);
+ }
+ var committish = parsed.hash ? decodeURIComponent(parsed.hash.substr(1)) : null;
+ var user = null;
+ var project = null;
+ var defaultRepresentation = null;
+ if (shortcutMatch && shortcutMatch[1] === gitHostName) {
+ user = shortcutMatch[2] && decodeURIComponent(shortcutMatch[2]);
+ project = decodeURIComponent(shortcutMatch[3]);
+ defaultRepresentation = 'shortcut';
+ } else {
+ if (parsed.host !== gitHostInfo$$1.domain) return
+ if (!gitHostInfo$$1.protocols_re.test(parsed.protocol)) return
+ if (!parsed.path) return
+ var pathmatch = gitHostInfo$$1.pathmatch;
+ var matched = parsed.path.match(pathmatch);
+ if (!matched) return
+ if (matched[1] != null) user = decodeURIComponent(matched[1].replace(/^:/, ''));
+ if (matched[2] != null) project = decodeURIComponent(matched[2]);
+ defaultRepresentation = protocolToRepresentation(parsed.protocol);
+ }
+ return new GitHost(gitHostName, user, auth, project, committish, defaultRepresentation, opts)
+ } catch (ex) {
+ if (!(ex instanceof URIError)) throw ex
+ }
+ }).filter(function (gitHostInfo$$1) { return gitHostInfo$$1 });
+ if (matches.length !== 1) return
+ return matches[0]
+};
+
+function isGitHubShorthand (arg) {
+ // Note: This does not fully test the git ref format.
+ // See https://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
+ //
+ // The only way to do this properly would be to shell out to
+ // git-check-ref-format, and as this is a fast sync function,
+ // we don't want to do that. Just let git fail if it turns
+ // out that the commit-ish is invalid.
+ // GH usernames cannot start with . or -
+ return /^[^:@%/\s.-][^:@%/\s]*[/][^:@\s/%]+(?:#.*)?$/.test(arg)
+}
+
+function fixupUnqualifiedGist (giturl) {
+ // necessary for round-tripping gists
+ var parsed = url.parse(giturl);
+ if (parsed.protocol === 'gist:' && parsed.host && !parsed.path) {
+ return parsed.protocol + '/' + parsed.host
+ } else {
+ return giturl
+ }
+}
+
+function parseGitUrl (giturl) {
+ if (typeof giturl !== 'string') giturl = '' + giturl;
+ var matched = giturl.match(/^([^@]+)@([^:/]+):[/]?((?:[^/]+[/])?[^/]+?)(?:[.]git)?(#.*)?$/);
+ if (!matched) return url.parse(giturl)
+ return {
+ protocol: 'git+ssh:',
+ slashes: true,
+ auth: matched[1],
+ host: matched[2],
+ port: null,
+ hostname: matched[2],
+ hash: matched[4],
+ search: null,
+ query: null,
+ pathname: '/' + matched[3],
+ path: '/' + matched[3],
+ href: 'git+ssh://' + matched[1] + '@' + matched[2] +
+ '/' + matched[3] + (matched[4] || '')
+ }
+}
+});
+
+var blacklist = [
+ 'freelist',
+ 'sys'
+];
+
+var builtinModules = Object.keys(process.binding('natives')).filter(function (el) {
+ return !/^_|^internal|\//.test(el) && blacklist.indexOf(el) === -1;
+}).sort();
+
+var isBuiltinModule = function (str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+
+ return builtinModules.indexOf(str) !== -1;
+};
+
+var extract_description = extractDescription;
+
+// Extracts description from contents of a readme file in markdown format
+function extractDescription (d) {
+ if (!d) return;
+ if (d === "ERROR: No README data found!") return;
+ // the first block of text before the first heading
+ // that isn't the first line heading
+ d = d.trim().split('\n');
+ for (var s = 0; d[s] && d[s].trim().match(/^(#|$)/); s ++);
+ var l = d.length;
+ for (var e = s + 1; e < l && d[e].trim(); e ++);
+ return d.slice(s, e).join(' ').trim()
+}
+
+var topLevel = {"dependancies":"dependencies","dependecies":"dependencies","depdenencies":"dependencies","devEependencies":"devDependencies","depends":"dependencies","dev-dependencies":"devDependencies","devDependences":"devDependencies","devDepenencies":"devDependencies","devdependencies":"devDependencies","repostitory":"repository","repo":"repository","prefereGlobal":"preferGlobal","hompage":"homepage","hampage":"homepage","autohr":"author","autor":"author","contributers":"contributors","publicationConfig":"publishConfig","script":"scripts"};
+var bugs = {"web":"url","name":"url"};
+var script = {"server":"start","tests":"test"};
+var typos = {
+ topLevel: topLevel,
+ bugs: bugs,
+ script: script
+};
+
+var typos$1 = Object.freeze({
+ topLevel: topLevel,
+ bugs: bugs,
+ script: script,
+ default: typos
+});
+
+var typos$2 = ( typos$1 && typos ) || typos$1;
+
+var fixer_1 = createCommonjsModule(function (module) {
+var depTypes = ["dependencies","devDependencies","optionalDependencies"];
+
+
+
+
+var fixer = module.exports = {
+ // default warning function
+ warn: function() {},
+
+ fixRepositoryField: function(data) {
+ if (data.repositories) {
+ this.warn("repositories");
+ data.repository = data.repositories[0];
+ }
+ if (!data.repository) return this.warn("missingRepository")
+ if (typeof data.repository === "string") {
+ data.repository = {
+ type: "git",
+ url: data.repository
+ };
+ }
+ var r = data.repository.url || "";
+ if (r) {
+ var hosted = hostedGitInfo.fromUrl(r);
+ if (hosted) {
+ r = data.repository.url
+ = hosted.getDefaultRepresentation() == "shortcut" ? hosted.https() : hosted.toString();
+ }
+ }
+
+ if (r.match(/github.com\/[^\/]+\/[^\/]+\.git\.git$/)) {
+ this.warn("brokenGitUrl", r);
+ }
+ }
+
+, fixTypos: function(data) {
+ Object.keys(typos$2.topLevel).forEach(function (d) {
+ if (data.hasOwnProperty(d)) {
+ this.warn("typo", d, typos$2.topLevel[d]);
+ }
+ }, this);
+ }
+
+, fixScriptsField: function(data) {
+ if (!data.scripts) return
+ if (typeof data.scripts !== "object") {
+ this.warn("nonObjectScripts");
+ delete data.scripts;
+ return
+ }
+ Object.keys(data.scripts).forEach(function (k) {
+ if (typeof data.scripts[k] !== "string") {
+ this.warn("nonStringScript");
+ delete data.scripts[k];
+ } else if (typos$2.script[k] && !data.scripts[typos$2.script[k]]) {
+ this.warn("typo", k, typos$2.script[k], "scripts");
+ }
+ }, this);
+ }
+
+, fixFilesField: function(data) {
+ var files = data.files;
+ if (files && !Array.isArray(files)) {
+ this.warn("nonArrayFiles");
+ delete data.files;
+ } else if (data.files) {
+ data.files = data.files.filter(function(file) {
+ if (!file || typeof file !== "string") {
+ this.warn("invalidFilename", file);
+ return false
+ } else {
+ return true
+ }
+ }, this);
+ }
+ }
+
+, fixBinField: function(data) {
+ if (!data.bin) return;
+ if (typeof data.bin === "string") {
+ var b = {};
+ var match;
+ if (match = data.name.match(/^@[^/]+[/](.*)$/)) {
+ b[match[1]] = data.bin;
+ } else {
+ b[data.name] = data.bin;
+ }
+ data.bin = b;
+ }
+ }
+
+, fixManField: function(data) {
+ if (!data.man) return;
+ if (typeof data.man === "string") {
+ data.man = [ data.man ];
+ }
+ }
+, fixBundleDependenciesField: function(data) {
+ var bdd = "bundledDependencies";
+ var bd = "bundleDependencies";
+ if (data[bdd] && !data[bd]) {
+ data[bd] = data[bdd];
+ delete data[bdd];
+ }
+ if (data[bd] && !Array.isArray(data[bd])) {
+ this.warn("nonArrayBundleDependencies");
+ delete data[bd];
+ } else if (data[bd]) {
+ data[bd] = data[bd].filter(function(bd) {
+ if (!bd || typeof bd !== 'string') {
+ this.warn("nonStringBundleDependency", bd);
+ return false
+ } else {
+ if (!data.dependencies) {
+ data.dependencies = {};
+ }
+ if (!data.dependencies.hasOwnProperty(bd)) {
+ this.warn("nonDependencyBundleDependency", bd);
+ data.dependencies[bd] = "*";
+ }
+ return true
+ }
+ }, this);
+ }
+ }
+
+, fixDependencies: function(data, strict) {
+ var loose = !strict;
+ objectifyDeps(data, this.warn);
+ addOptionalDepsToDeps(data, this.warn);
+ this.fixBundleDependenciesField(data)
+
+ ;['dependencies','devDependencies'].forEach(function(deps) {
+ if (!(deps in data)) return
+ if (!data[deps] || typeof data[deps] !== "object") {
+ this.warn("nonObjectDependencies", deps);
+ delete data[deps];
+ return
+ }
+ Object.keys(data[deps]).forEach(function (d) {
+ var r = data[deps][d];
+ if (typeof r !== 'string') {
+ this.warn("nonStringDependency", d, JSON.stringify(r));
+ delete data[deps][d];
+ }
+ var hosted = hostedGitInfo.fromUrl(data[deps][d]);
+ if (hosted) data[deps][d] = hosted.toString();
+ }, this);
+ }, this);
+ }
+
+, fixModulesField: function (data) {
+ if (data.modules) {
+ this.warn("deprecatedModules");
+ delete data.modules;
+ }
+ }
+
+, fixKeywordsField: function (data) {
+ if (typeof data.keywords === "string") {
+ data.keywords = data.keywords.split(/,\s+/);
+ }
+ if (data.keywords && !Array.isArray(data.keywords)) {
+ delete data.keywords;
+ this.warn("nonArrayKeywords");
+ } else if (data.keywords) {
+ data.keywords = data.keywords.filter(function(kw) {
+ if (typeof kw !== "string" || !kw) {
+ this.warn("nonStringKeyword");
+ return false
+ } else {
+ return true
+ }
+ }, this);
+ }
+ }
+
+, fixVersionField: function(data, strict) {
+ // allow "loose" semver 1.0 versions in non-strict mode
+ // enforce strict semver 2.0 compliance in strict mode
+ var loose = !strict;
+ if (!data.version) {
+ data.version = "";
+ return true
+ }
+ if (!semver.valid(data.version, loose)) {
+ throw new Error('Invalid version: "'+ data.version + '"')
+ }
+ data.version = semver.clean(data.version, loose);
+ return true
+ }
+
+, fixPeople: function(data) {
+ modifyPeople(data, unParsePerson);
+ modifyPeople(data, parsePerson);
+ }
+
+, fixNameField: function(data, options) {
+ if (typeof options === "boolean") options = {strict: options};
+ else if (typeof options === "undefined") options = {};
+ var strict = options.strict;
+ if (!data.name && !strict) {
+ data.name = "";
+ return
+ }
+ if (typeof data.name !== "string") {
+ throw new Error("name field must be a string.")
+ }
+ if (!strict)
+ data.name = data.name.trim();
+ ensureValidName(data.name, strict, options.allowLegacyCase);
+ if (isBuiltinModule(data.name))
+ this.warn("conflictingName", data.name);
+ }
+
+
+, fixDescriptionField: function (data) {
+ if (data.description && typeof data.description !== 'string') {
+ this.warn("nonStringDescription");
+ delete data.description;
+ }
+ if (data.readme && !data.description)
+ data.description = extract_description(data.readme);
+ if(data.description === undefined) delete data.description;
+ if (!data.description) this.warn("missingDescription");
+ }
+
+, fixReadmeField: function (data) {
+ if (!data.readme) {
+ this.warn("missingReadme");
+ data.readme = "ERROR: No README data found!";
+ }
+ }
+
+, fixBugsField: function(data) {
+ if (!data.bugs && data.repository && data.repository.url) {
+ var hosted = hostedGitInfo.fromUrl(data.repository.url);
+ if(hosted && hosted.bugs()) {
+ data.bugs = {url: hosted.bugs()};
+ }
+ }
+ else if(data.bugs) {
+ var emailRe = /^.+@.*\..+$/;
+ if(typeof data.bugs == "string") {
+ if(emailRe.test(data.bugs))
+ data.bugs = {email:data.bugs};
+ else if(url.parse(data.bugs).protocol)
+ data.bugs = {url: data.bugs};
+ else
+ this.warn("nonEmailUrlBugsString");
+ }
+ else {
+ bugsTypos(data.bugs, this.warn);
+ var oldBugs = data.bugs;
+ data.bugs = {};
+ if(oldBugs.url) {
+ if(typeof(oldBugs.url) == "string" && url.parse(oldBugs.url).protocol)
+ data.bugs.url = oldBugs.url;
+ else
+ this.warn("nonUrlBugsUrlField");
+ }
+ if(oldBugs.email) {
+ if(typeof(oldBugs.email) == "string" && emailRe.test(oldBugs.email))
+ data.bugs.email = oldBugs.email;
+ else
+ this.warn("nonEmailBugsEmailField");
+ }
+ }
+ if(!data.bugs.email && !data.bugs.url) {
+ delete data.bugs;
+ this.warn("emptyNormalizedBugs");
+ }
+ }
+ }
+
+, fixHomepageField: function(data) {
+ if (!data.homepage && data.repository && data.repository.url) {
+ var hosted = hostedGitInfo.fromUrl(data.repository.url);
+ if (hosted && hosted.docs()) data.homepage = hosted.docs();
+ }
+ if (!data.homepage) return
+
+ if(typeof data.homepage !== "string") {
+ this.warn("nonUrlHomepage");
+ return delete data.homepage
+ }
+ if(!url.parse(data.homepage).protocol) {
+ this.warn("missingProtocolHomepage");
+ data.homepage = "http://" + data.homepage;
+ }
+ }
+
+, fixLicenseField: function(data) {
+ if (!data.license) {
+ return this.warn("missingLicense")
+ } else{
+ if (
+ typeof(data.license) !== 'string' ||
+ data.license.length < 1
+ ) {
+ this.warn("invalidLicense");
+ } else {
+ if (!validateNpmPackageLicense(data.license).validForNewPackages)
+ this.warn("invalidLicense");
+ }
+ }
+ }
+};
+
+function isValidScopedPackageName(spec) {
+ if (spec.charAt(0) !== '@') return false
+
+ var rest = spec.slice(1).split('/');
+ if (rest.length !== 2) return false
+
+ return rest[0] && rest[1] &&
+ rest[0] === encodeURIComponent(rest[0]) &&
+ rest[1] === encodeURIComponent(rest[1])
+}
+
+function isCorrectlyEncodedName(spec) {
+ return !spec.match(/[\/@\s\+%:]/) &&
+ spec === encodeURIComponent(spec)
+}
+
+function ensureValidName (name, strict, allowLegacyCase) {
+ if (name.charAt(0) === "." ||
+ !(isValidScopedPackageName(name) || isCorrectlyEncodedName(name)) ||
+ (strict && (!allowLegacyCase) && name !== name.toLowerCase()) ||
+ name.toLowerCase() === "node_modules" ||
+ name.toLowerCase() === "favicon.ico") {
+ throw new Error("Invalid name: " + JSON.stringify(name))
+ }
+}
+
+function modifyPeople (data, fn) {
+ if (data.author) data.author = fn(data.author)
+ ;["maintainers", "contributors"].forEach(function (set) {
+ if (!Array.isArray(data[set])) return;
+ data[set] = data[set].map(fn);
+ });
+ return data
+}
+
+function unParsePerson (person) {
+ if (typeof person === "string") return person
+ var name = person.name || "";
+ var u = person.url || person.web;
+ var url$$1 = u ? (" ("+u+")") : "";
+ var e = person.email || person.mail;
+ var email = e ? (" <"+e+">") : "";
+ return name+email+url$$1
+}
+
+function parsePerson (person) {
+ if (typeof person !== "string") return person
+ var name = person.match(/^([^\(<]+)/);
+ var url$$1 = person.match(/\(([^\)]+)\)/);
+ var email = person.match(/<([^>]+)>/);
+ var obj = {};
+ if (name && name[0].trim()) obj.name = name[0].trim();
+ if (email) obj.email = email[1];
+ if (url$$1) obj.url = url$$1[1];
+ return obj
+}
+
+function addOptionalDepsToDeps (data, warn) {
+ var o = data.optionalDependencies;
+ if (!o) return;
+ var d = data.dependencies || {};
+ Object.keys(o).forEach(function (k) {
+ d[k] = o[k];
+ });
+ data.dependencies = d;
+}
+
+function depObjectify (deps, type, warn) {
+ if (!deps) return {}
+ if (typeof deps === "string") {
+ deps = deps.trim().split(/[\n\r\s\t ,]+/);
+ }
+ if (!Array.isArray(deps)) return deps
+ warn("deprecatedArrayDependencies", type);
+ var o = {};
+ deps.filter(function (d) {
+ return typeof d === "string"
+ }).forEach(function(d) {
+ d = d.trim().split(/(:?[@\s><=])/);
+ var dn = d.shift();
+ var dv = d.join("");
+ dv = dv.trim();
+ dv = dv.replace(/^@/, "");
+ o[dn] = dv;
+ });
+ return o
+}
+
+function objectifyDeps (data, warn) {
+ depTypes.forEach(function (type) {
+ if (!data[type]) return;
+ data[type] = depObjectify(data[type], type, warn);
+ });
+}
+
+function bugsTypos(bugs, warn) {
+ if (!bugs) return
+ Object.keys(bugs).forEach(function (k) {
+ if (typos$2.bugs[k]) {
+ warn("typo", k, typos$2.bugs[k], "bugs");
+ bugs[typos$2.bugs[k]] = bugs[k];
+ delete bugs[k];
+ }
+ });
+}
+});
+
+var repositories = "'repositories' (plural) Not supported. Please pick one as the 'repository' field";
+var missingRepository = "No repository field.";
+var brokenGitUrl = "Probably broken git url: %s";
+var nonObjectScripts = "scripts must be an object";
+var nonStringScript = "script values must be string commands";
+var nonArrayFiles = "Invalid 'files' member";
+var invalidFilename = "Invalid filename in 'files' list: %s";
+var nonArrayBundleDependencies = "Invalid 'bundleDependencies' list. Must be array of package names";
+var nonStringBundleDependency = "Invalid bundleDependencies member: %s";
+var nonDependencyBundleDependency = "Non-dependency in bundleDependencies: %s";
+var nonObjectDependencies = "%s field must be an object";
+var nonStringDependency = "Invalid dependency: %s %s";
+var deprecatedArrayDependencies = "specifying %s as array is deprecated";
+var deprecatedModules = "modules field is deprecated";
+var nonArrayKeywords = "keywords should be an array of strings";
+var nonStringKeyword = "keywords should be an array of strings";
+var conflictingName = "%s is also the name of a node core module.";
+var nonStringDescription = "'description' field should be a string";
+var missingDescription = "No description";
+var missingReadme = "No README data";
+var missingLicense = "No license field.";
+var nonEmailUrlBugsString = "Bug string field must be url, email, or {email,url}";
+var nonUrlBugsUrlField = "bugs.url field must be a string url. Deleted.";
+var nonEmailBugsEmailField = "bugs.email field must be a string email. Deleted.";
+var emptyNormalizedBugs = "Normalized value of bugs field is an empty object. Deleted.";
+var nonUrlHomepage = "homepage field must be a string url. Deleted.";
+var invalidLicense = "license should be a valid SPDX license expression";
+var missingProtocolHomepage = "homepage field must start with a protocol.";
+var typo = "%s should probably be %s.";
+var warning_messages = {
+ repositories: repositories,
+ missingRepository: missingRepository,
+ brokenGitUrl: brokenGitUrl,
+ nonObjectScripts: nonObjectScripts,
+ nonStringScript: nonStringScript,
+ nonArrayFiles: nonArrayFiles,
+ invalidFilename: invalidFilename,
+ nonArrayBundleDependencies: nonArrayBundleDependencies,
+ nonStringBundleDependency: nonStringBundleDependency,
+ nonDependencyBundleDependency: nonDependencyBundleDependency,
+ nonObjectDependencies: nonObjectDependencies,
+ nonStringDependency: nonStringDependency,
+ deprecatedArrayDependencies: deprecatedArrayDependencies,
+ deprecatedModules: deprecatedModules,
+ nonArrayKeywords: nonArrayKeywords,
+ nonStringKeyword: nonStringKeyword,
+ conflictingName: conflictingName,
+ nonStringDescription: nonStringDescription,
+ missingDescription: missingDescription,
+ missingReadme: missingReadme,
+ missingLicense: missingLicense,
+ nonEmailUrlBugsString: nonEmailUrlBugsString,
+ nonUrlBugsUrlField: nonUrlBugsUrlField,
+ nonEmailBugsEmailField: nonEmailBugsEmailField,
+ emptyNormalizedBugs: emptyNormalizedBugs,
+ nonUrlHomepage: nonUrlHomepage,
+ invalidLicense: invalidLicense,
+ missingProtocolHomepage: missingProtocolHomepage,
+ typo: typo
+};
+
+var warning_messages$1 = Object.freeze({
+ repositories: repositories,
+ missingRepository: missingRepository,
+ brokenGitUrl: brokenGitUrl,
+ nonObjectScripts: nonObjectScripts,
+ nonStringScript: nonStringScript,
+ nonArrayFiles: nonArrayFiles,
+ invalidFilename: invalidFilename,
+ nonArrayBundleDependencies: nonArrayBundleDependencies,
+ nonStringBundleDependency: nonStringBundleDependency,
+ nonDependencyBundleDependency: nonDependencyBundleDependency,
+ nonObjectDependencies: nonObjectDependencies,
+ nonStringDependency: nonStringDependency,
+ deprecatedArrayDependencies: deprecatedArrayDependencies,
+ deprecatedModules: deprecatedModules,
+ nonArrayKeywords: nonArrayKeywords,
+ nonStringKeyword: nonStringKeyword,
+ conflictingName: conflictingName,
+ nonStringDescription: nonStringDescription,
+ missingDescription: missingDescription,
+ missingReadme: missingReadme,
+ missingLicense: missingLicense,
+ nonEmailUrlBugsString: nonEmailUrlBugsString,
+ nonUrlBugsUrlField: nonUrlBugsUrlField,
+ nonEmailBugsEmailField: nonEmailBugsEmailField,
+ emptyNormalizedBugs: emptyNormalizedBugs,
+ nonUrlHomepage: nonUrlHomepage,
+ invalidLicense: invalidLicense,
+ missingProtocolHomepage: missingProtocolHomepage,
+ typo: typo,
+ default: warning_messages
+});
+
+var messages = ( warning_messages$1 && warning_messages ) || warning_messages$1;
+
+var make_warning = function() {
+ var args = Array.prototype.slice.call(arguments, 0);
+ var warningName = args.shift();
+ if (warningName == "typo") {
+ return makeTypoWarning.apply(null,args)
+ }
+ else {
+ var msgTemplate = messages[warningName] ? messages[warningName] : warningName + ": '%s'";
+ args.unshift(msgTemplate);
+ return util.format.apply(null, args)
+ }
+};
+
+function makeTypoWarning (providedName, probableName, field) {
+ if (field) {
+ providedName = field + "['" + providedName + "']";
+ probableName = field + "['" + probableName + "']";
+ }
+ return util.format(messages.typo, providedName, probableName)
+}
+
+var normalize_1 = normalize;
+
+
+normalize.fixer = fixer_1;
+
+
+
+var fieldsToFix = ['name','version','description','repository','modules','scripts'
+ ,'files','bin','man','bugs','keywords','readme','homepage','license'];
+var otherThingsToFix = ['dependencies','people', 'typos'];
+
+var thingsToFix = fieldsToFix.map(function(fieldName) {
+ return ucFirst(fieldName) + "Field"
+});
+// two ways to do this in CoffeeScript on only one line, sub-70 chars:
+// thingsToFix = fieldsToFix.map (name) -> ucFirst(name) + "Field"
+// thingsToFix = (ucFirst(name) + "Field" for name in fieldsToFix)
+thingsToFix = thingsToFix.concat(otherThingsToFix);
+
+function normalize (data, warn, strict) {
+ if(warn === true) warn = null, strict = true;
+ if(!strict) strict = false;
+ if(!warn || data.private) warn = function(msg) { /* noop */ };
+
+ if (data.scripts &&
+ data.scripts.install === "node-gyp rebuild" &&
+ !data.scripts.preinstall) {
+ data.gypfile = true;
+ }
+ fixer_1.warn = function() { warn(make_warning.apply(null, arguments)); };
+ thingsToFix.forEach(function(thingName) {
+ fixer_1["fix" + ucFirst(thingName)](data, strict);
+ });
+ data._id = data.name + "@" + data.version;
+}
+
+function ucFirst (string) {
+ return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+var readPkg = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+
+module.exports = (fp, opts) => {
+ if (typeof fp !== 'string') {
+ opts = fp;
+ fp = '.';
+ }
+
+ opts = opts || {};
+
+ return pathType.dir(fp)
+ .then(isDir => {
+ if (isDir) {
+ fp = path.join(fp, 'package.json');
+ }
+
+ return loadJsonFile(fp);
+ })
+ .then(x => {
+ if (opts.normalize !== false) {
+ normalize_1(x);
+ }
+
+ return x;
+ });
+};
+
+module.exports.sync = (fp, opts) => {
+ if (typeof fp !== 'string') {
+ opts = fp;
+ fp = '.';
+ }
+
+ opts = opts || {};
+ fp = pathType.dirSync(fp) ? path.join(fp, 'package.json') : fp;
+
+ const x = loadJsonFile.sync(fp);
+
+ if (opts.normalize !== false) {
+ normalize_1(x);
+ }
+
+ return x;
+};
+});
+
+var readPkgUp = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+module.exports = opts => {
+ return findUp('package.json', opts).then(fp => {
+ if (!fp) {
+ return {};
+ }
+
+ return readPkg(fp, opts).then(pkg => ({pkg, path: fp}));
+ });
+};
+
+module.exports.sync = opts => {
+ const fp = findUp.sync('package.json', opts);
+
+ if (!fp) {
+ return {};
+ }
+
+ return {
+ pkg: readPkg.sync(fp, opts),
+ path: fp
+ };
+};
+});
+
+function concat$2(parts) {
+ return { type: "concat", parts };
+}
+
+function indent$2(contents) {
+ return { type: "indent", contents };
+}
+
+function align$1(n, contents) {
+ return { type: "align", contents, n };
+}
+
+function group$1(contents, opts) {
+ opts = opts || {};
+
+ return {
+ type: "group",
+ contents: contents,
+ break: !!opts.shouldBreak,
+ expandedStates: opts.expandedStates
+ };
+}
+
+function dedentToRoot(contents) {
+ return align$1(-Infinity, contents);
+}
+
+function markAsRoot(contents) {
+ return align$1({ type: "root" }, contents);
+}
+
+function dedent$1(contents) {
+ return align$1(-1, contents);
+}
+
+function conditionalGroup$1(states, opts) {
+ return group$1(
+ states[0],
+ Object.assign(opts || {}, { expandedStates: states })
+ );
+}
+
+function fill$1(parts) {
+ return { type: "fill", parts };
+}
+
+function ifBreak$1(breakContents, flatContents) {
+ return { type: "if-break", breakContents, flatContents };
+}
+
+function lineSuffix$1(contents) {
+ return { type: "line-suffix", contents };
+}
+
+const lineSuffixBoundary$1 = { type: "line-suffix-boundary" };
+const breakParent$2 = { type: "break-parent" };
+const line$1 = { type: "line" };
+const softline$1 = { type: "line", soft: true };
+const hardline$2 = concat$2([{ type: "line", hard: true }, breakParent$2]);
+const literalline$1 = concat$2([
+ { type: "line", hard: true, literal: true },
+ breakParent$2
+]);
+const cursor$1 = { type: "cursor", placeholder: Symbol("cursor") };
+
+function join$2(sep, arr) {
+ const res = [];
+
+ for (let i = 0; i < arr.length; i++) {
+ if (i !== 0) {
+ res.push(sep);
+ }
+
+ res.push(arr[i]);
+ }
+
+ return concat$2(res);
+}
+
+function addAlignmentToDoc$1(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$2(aligned);
+ }
+ // Use align for all the spaces that are needed
+ aligned = align$1(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$1(-Infinity, aligned);
+ }
+ return aligned;
+}
+
+var docBuilders$2 = {
+ concat: concat$2,
+ join: join$2,
+ line: line$1,
+ softline: softline$1,
+ hardline: hardline$2,
+ literalline: literalline$1,
+ group: group$1,
+ conditionalGroup: conditionalGroup$1,
+ fill: fill$1,
+ lineSuffix: lineSuffix$1,
+ lineSuffixBoundary: lineSuffixBoundary$1,
+ cursor: cursor$1,
+ breakParent: breakParent$2,
+ ifBreak: ifBreak$1,
+ indent: indent$2,
+ align: align$1,
+ addAlignmentToDoc: addAlignmentToDoc$1,
+ markAsRoot,
+ dedentToRoot,
+ dedent: dedent$1
+};
+
+const concat$3 = docBuilders$2.concat;
+const fill$2 = docBuilders$2.fill;
+const cursor$2 = docBuilders$2.cursor;
+
+const MODE_BREAK = 1;
+const MODE_FLAT = 2;
+
+function rootIndent() {
+ return { value: "", length: 0, queue: [] };
+}
+
+function makeIndent(ind, options) {
+ return generateInd(ind, { type: "indent" }, options);
+}
+
+function makeAlign(ind, n, options) {
+ return n === -Infinity
+ ? ind.root || rootIndent()
+ : n < 0
+ ? generateInd(ind, { type: "dedent" }, options)
+ : !n
+ ? ind
+ : n.type === "root"
+ ? Object.assign({}, ind, { root: ind })
+ : typeof n === "string"
+ ? generateInd(ind, { type: "stringAlign", n }, options)
+ : generateInd(ind, { type: "numberAlign", n }, options);
+}
+
+function generateInd(ind, newPart, options) {
+ const queue =
+ newPart.type === "dedent"
+ ? ind.queue.slice(0, -1)
+ : ind.queue.concat(newPart);
+
+ let value = "";
+ let length = 0;
+ let lastTabs = 0;
+ let lastSpaces = 0;
+
+ for (const part of queue) {
+ switch (part.type) {
+ case "indent":
+ flush();
+ if (options.useTabs) {
+ addTabs(1);
+ } else {
+ addSpaces(options.tabWidth);
+ }
+ break;
+ case "stringAlign":
+ flush();
+ value += part.n;
+ length += part.n.length;
+ break;
+ case "numberAlign":
+ lastTabs += 1;
+ lastSpaces += part.n;
+ break;
+ /* istanbul ignore next */
+ default:
+ throw new Error(`Unexpected type '${part.type}'`);
+ }
+ }
+
+ flushSpaces();
+
+ return Object.assign({}, ind, { value, length, queue });
+
+ function addTabs(count) {
+ value += "\t".repeat(count);
+ length += options.tabWidth * count;
+ }
+
+ function addSpaces(count) {
+ value += " ".repeat(count);
+ length += count;
+ }
+
+ function flush() {
+ if (options.useTabs) {
+ flushTabs();
+ } else {
+ flushSpaces();
+ }
+ }
+
+ function flushTabs() {
+ if (lastTabs > 0) {
+ addTabs(lastTabs);
+ }
+ resetLast();
+ }
+
+ function flushSpaces() {
+ if (lastSpaces > 0) {
+ addSpaces(lastSpaces);
+ }
+ resetLast();
+ }
+
+ function resetLast() {
+ lastTabs = 0;
+ lastSpaces = 0;
+ }
+}
+
+function fits(next, restCommands, width, options, mustBeFlat) {
+ let restIdx = restCommands.length;
+ const cmds = [next];
+ while (width >= 0) {
+ if (cmds.length === 0) {
+ if (restIdx === 0) {
+ return true;
+ }
+ 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 -= util$1.getStringWidth(doc);
+ } 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, options), mode, doc.contents]);
+
+ break;
+ case "align":
+ cmds.push([makeAlign(ind, doc.n, options), 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 += util$1.getStringWidth(doc);
+ } else {
+ switch (doc.type) {
+ case "cursor":
+ out.push(cursor$2.placeholder);
+
+ break;
+ 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, options), mode, doc.contents]);
+
+ break;
+ case "align":
+ cmds.push([makeAlign(ind, doc.n, options), 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, options)) {
+ 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, options)) {
+ 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, [], rem, options, 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;
+ }
+
+ // At this point we've handled the first pair (context, separator)
+ // and will create a new fill doc for the rest of the content.
+ // Ideally we wouldn't mutate the array here but coping all the
+ // elements to a new array would make this algorithm quadratic,
+ // which is unusable for large arrays (e.g. large texts in JSX).
+ parts.splice(0, 2);
+ const remainingCmd = [ind, mode, fill$2(parts)];
+
+ const secondContent = parts[0];
+
+ const firstAndSecondContentFlatCmd = [
+ ind,
+ MODE_FLAT,
+ concat$3([content, whitespace, secondContent])
+ ];
+ const firstAndSecondContentFits = fits(
+ firstAndSecondContentFlatCmd,
+ [],
+ rem,
+ options,
+ 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) {
+ if (ind.root) {
+ out.push(newLine, ind.root.value);
+ pos = ind.root.length;
+ } else {
+ 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 &&
+ (options.parser !== "markdown" ||
+ // preserve markdown's `break` node (two trailing spaces)
+ !/\S {2}$/.test(out[out.length - 1]))
+ ) {
+ out[out.length - 1] = out[out.length - 1].replace(
+ /[^\S\n]*$/,
+ ""
+ );
+ }
+ }
+
+ out.push(newLine + ind.value);
+ pos = ind.length;
+ }
+ break;
+ }
+ break;
+ default:
+ }
+ }
+ }
+
+ const cursorPlaceholderIndex = out.indexOf(cursor$2.placeholder);
+ if (cursorPlaceholderIndex !== -1) {
+ const beforeCursor = out.slice(0, cursorPlaceholderIndex).join("");
+ const afterCursor = out.slice(cursorPlaceholderIndex + 1).join("");
+
+ return {
+ formatted: beforeCursor + afterCursor,
+ cursor: beforeCursor.length
+ };
+ }
+
+ return { formatted: out.join("") };
+}
+
+var docPrinter = { printDocToString: printDocToString$1 };
+
+function flattenDoc(doc) {
+ if (doc.type === "concat") {
+ const res = [];
+
+ for (let i = 0; i < doc.parts.length; ++i) {
+ const doc2 = doc.parts[i];
+ if (typeof doc2 !== "string" && doc2.type === "concat") {
+ [].push.apply(res, flattenDoc(doc2).parts);
+ } else {
+ const flattened = flattenDoc(doc2);
+ if (flattened !== "") {
+ res.push(flattened);
+ }
+ }
+ }
+
+ return Object.assign({}, doc, { parts: res });
+ } else if (doc.type === "if-break") {
+ return Object.assign({}, doc, {
+ breakContents:
+ doc.breakContents != null ? flattenDoc(doc.breakContents) : null,
+ flatContents:
+ doc.flatContents != null ? flattenDoc(doc.flatContents) : null
+ });
+ } else if (doc.type === "group") {
+ return Object.assign({}, doc, {
+ contents: flattenDoc(doc.contents),
+ expandedStates: doc.expandedStates
+ ? doc.expandedStates.map(flattenDoc)
+ : doc.expandedStates
+ });
+ } else if (doc.contents) {
+ return Object.assign({}, doc, { contents: flattenDoc(doc.contents) });
+ }
+ return doc;
+}
+
+function printDoc(doc) {
+ if (typeof doc === "string") {
+ return JSON.stringify(doc);
+ }
+
+ if (doc.type === "line") {
+ if (doc.literalline) {
+ return "literalline";
+ }
+ if (doc.hard) {
+ return "hardline";
+ }
+ if (doc.soft) {
+ return "softline";
+ }
+ return "line";
+ }
+
+ if (doc.type === "break-parent") {
+ return "breakParent";
+ }
+
+ if (doc.type === "concat") {
+ return "[" + doc.parts.map(printDoc).join(", ") + "]";
+ }
+
+ if (doc.type === "indent") {
+ return "indent(" + printDoc(doc.contents) + ")";
+ }
+
+ if (doc.type === "align") {
+ return doc.n === -Infinity
+ ? "dedentToRoot(" + printDoc(doc.contents) + ")"
+ : doc.n < 0
+ ? "dedent(" + printDoc(doc.contents) + ")"
+ : doc.n.type === "root"
+ ? "markAsRoot(" + printDoc(doc.contents) + ")"
+ : "align(" +
+ JSON.stringify(doc.n) +
+ ", " +
+ printDoc(doc.contents) +
+ ")";
+ }
+
+ if (doc.type === "if-break") {
+ return (
+ "ifBreak(" +
+ printDoc(doc.breakContents) +
+ (doc.flatContents ? ", " + printDoc(doc.flatContents) : "") +
+ ")"
+ );
+ }
+
+ if (doc.type === "group") {
+ if (doc.expandedStates) {
+ return (
+ "conditionalGroup(" +
+ "[" +
+ doc.expandedStates.map(printDoc).join(",") +
+ "])"
+ );
+ }
+
+ return (
+ (doc.break ? "wrappedGroup" : "group") +
+ "(" +
+ printDoc(doc.contents) +
+ ")"
+ );
+ }
+
+ if (doc.type === "fill") {
+ return "fill" + "(" + doc.parts.map(printDoc).join(", ") + ")";
+ }
+
+ if (doc.type === "line-suffix") {
+ return "lineSuffix(" + printDoc(doc.contents) + ")";
+ }
+
+ if (doc.type === "line-suffix-boundary") {
+ return "lineSuffixBoundary";
+ }
+
+ throw new Error("Unknown doc type " + doc.type);
+}
+
+var docDebug = {
+ printDocToDebug: function(doc) {
+ return printDoc(flattenDoc(doc));
+ }
+};
+
+var doc = {
+ builders: docBuilders$2,
+ printer: docPrinter,
+ utils: docUtils,
+ debug: docDebug
+};
+
+const docBuilders$1 = doc.builders;
+const concat$1 = docBuilders$1.concat;
+const hardline$1 = docBuilders$1.hardline;
+const breakParent$1 = docBuilders$1.breakParent;
+const indent$1 = docBuilders$1.indent;
+const lineSuffix = docBuilders$1.lineSuffix;
+const join$1 = docBuilders$1.join;
+const cursor = docBuilders$1.cursor;
+
+
+const childNodesCacheKey = Symbol("child-nodes");
+
+const addLeadingComment$1 = utilShared.addLeadingComment;
+const addTrailingComment$1 = utilShared.addTrailingComment;
+const addDanglingComment$1 = utilShared.addDanglingComment;
+
+function getSortedChildNodes(node, text, options, resultArray) {
+ if (!node) {
+ return;
+ }
+ const printer = options.printer;
+ const locStart = options.locStart;
+ const locEnd = options.locEnd;
+
+ if (resultArray) {
+ if (node && printer.canAttachComment && printer.canAttachComment(node)) {
+ // 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 childNodes;
+
+ if (printer.getCommentChildNodes) {
+ childNodes = printer.getCommentChildNodes(node);
+ } else if (node && typeof node === "object") {
+ childNodes = Object.keys(node)
+ .filter(
+ n =>
+ n !== "enclosingNode" &&
+ n !== "precedingNode" &&
+ n !== "followingNode"
+ )
+ .map(n => node[n]);
+ }
+
+ if (!childNodes) {
+ return;
+ }
+
+ if (!resultArray) {
+ Object.defineProperty(node, childNodesCacheKey, {
+ value: (resultArray = []),
+ enumerable: false
+ });
+ }
+
+ childNodes.forEach(childNode => {
+ getSortedChildNodes(childNode, text, options, 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, options) {
+ const locStart = options.locStart;
+ const locEnd = options.locEnd;
+ const childNodes = getSortedChildNodes(node, text, options);
+ let precedingNode;
+ let followingNode;
+ // Time to dust off the old binary search robes and wizard hat.
+ let left = 0;
+ let 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, options);
+ 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;
+ }
+
+ /* istanbul ignore next */
+ 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,
+ options
+ );
+
+ if (
+ precedingNode &&
+ findExpressionIndexForComment(quasis, precedingNode, options) !==
+ commentIndex
+ ) {
+ precedingNode = null;
+ }
+ if (
+ followingNode &&
+ findExpressionIndexForComment(quasis, followingNode, options) !==
+ commentIndex
+ ) {
+ followingNode = null;
+ }
+ }
+
+ if (precedingNode) {
+ comment.precedingNode = precedingNode;
+ }
+
+ if (followingNode) {
+ comment.followingNode = followingNode;
+ }
+}
+
+function attach(comments, ast, text, options) {
+ if (!Array.isArray(comments)) {
+ return;
+ }
+
+ const tiesToBreak = [];
+ const locStart = options.locStart;
+ const locEnd = options.locEnd;
+
+ comments.forEach((comment, i) => {
+ if (options.parser === "json" && locStart(comment) - locStart(ast) <= 0) {
+ addLeadingComment$1(ast, comment);
+ return;
+ }
+
+ decorateComment(ast, comment, text, options);
+
+ const precedingNode = comment.precedingNode;
+ const enclosingNode = comment.enclosingNode;
+ const followingNode = comment.followingNode;
+
+ const pluginHandleOwnLineComment =
+ options.printer.handleComments && options.printer.handleComments.ownLine
+ ? options.printer.handleComments.ownLine
+ : () => false;
+ const pluginHandleEndOfLineComment =
+ options.printer.handleComments && options.printer.handleComments.endOfLine
+ ? options.printer.handleComments.endOfLine
+ : () => false;
+ const pluginHandleRemainingComment =
+ options.printer.handleComments && options.printer.handleComments.remaining
+ ? options.printer.handleComments.remaining
+ : () => false;
+
+ 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 (
+ pluginHandleOwnLineComment(comment, text, options, ast, isLastComment)
+ ) {
+ // We're good
+ } else if (followingNode) {
+ // Always a leading comment.
+ addLeadingComment$1(followingNode, comment);
+ } else if (precedingNode) {
+ addTrailingComment$1(precedingNode, comment);
+ } else if (enclosingNode) {
+ addDanglingComment$1(enclosingNode, comment);
+ } else {
+ // There are no nodes, let's attach it to the root of the ast
+ /* istanbul ignore next */
+ addDanglingComment$1(ast, comment);
+ }
+ } else if (util$1.hasNewline(text, locEnd(comment))) {
+ if (
+ pluginHandleEndOfLineComment(comment, text, options, ast, isLastComment)
+ ) {
+ // 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$1(precedingNode, comment);
+ } else if (followingNode) {
+ addLeadingComment$1(followingNode, comment);
+ } else if (enclosingNode) {
+ addDanglingComment$1(enclosingNode, comment);
+ } else {
+ // There are no nodes, let's attach it to the root of the ast
+ /* istanbul ignore next */
+ addDanglingComment$1(ast, comment);
+ }
+ } else {
+ if (
+ pluginHandleRemainingComment(comment, text, options, ast, 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, options);
+ }
+ }
+ tiesToBreak.push(comment);
+ } else if (precedingNode) {
+ addTrailingComment$1(precedingNode, comment);
+ } else if (followingNode) {
+ addLeadingComment$1(followingNode, comment);
+ } else if (enclosingNode) {
+ addDanglingComment$1(enclosingNode, comment);
+ } else {
+ // There are no nodes, let's attach it to the root of the ast
+ /* istanbul ignore next */
+ addDanglingComment$1(ast, comment);
+ }
+ }
+ });
+
+ breakTies(tiesToBreak, text, options);
+
+ 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, options) {
+ const tieCount = tiesToBreak.length;
+ if (tieCount === 0) {
+ return;
+ }
+
+ const precedingNode = tiesToBreak[0].precedingNode;
+ const followingNode = tiesToBreak[0].followingNode;
+ let gapEndPos = options.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
+ // gaps (or other comments). Gaps should only contain whitespace or open
+ // parentheses.
+ 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(options.locEnd(comment), gapEndPos).trim();
+ if (gap === "" || /^\(+$/.test(gap)) {
+ gapEndPos = options.locStart(comment);
+ } else {
+ // The gap string contained something other than whitespace or open
+ // parentheses.
+ break;
+ }
+ }
+
+ tiesToBreak.forEach((comment, i) => {
+ if (i < indexOfFirstLeadingComment) {
+ addTrailingComment$1(precedingNode, comment);
+ } else {
+ addLeadingComment$1(followingNode, comment);
+ }
+ });
+
+ tiesToBreak.length = 0;
+}
+
+function printComment$1(commentPath, options) {
+ const comment = commentPath.getValue();
+ comment.printed = true;
+ return options.printer.printComment(commentPath, options);
+}
+
+function findExpressionIndexForComment(quasis, comment, options) {
+ const startPos = options.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.
+ /* istanbul ignore next */
+ 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$1(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$1([
+ contents,
+ util$1.hasNewline(options.originalText, options.locEnd(comment))
+ ? hardline$1
+ : " "
+ ]);
+ }
+
+ return concat$1([contents, hardline$1]);
+}
+
+function printTrailingComment(commentPath, print, options) {
+ const comment = commentPath.getValue();
+ const contents = printComment$1(commentPath, options);
+ if (!contents) {
+ return "";
+ }
+ const isBlock = util$1.isBlockComment(comment);
+
+ // We don't want the line to break
+ // when the parentParentNode is a ClassDeclaration/-Expression
+ // And the parentNode is in the superClass property
+ const parentNode = commentPath.getNode(1);
+ const parentParentNode = commentPath.getNode(2);
+ const isParentSuperClass =
+ parentParentNode &&
+ (parentParentNode.type === "ClassDeclaration" ||
+ parentParentNode.type === "ClassExpression") &&
+ parentParentNode.superClass === parentNode;
+
+ if (
+ util$1.hasNewline(options.originalText, options.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,
+ options.locStart
+ );
+
+ return lineSuffix(
+ concat$1([hardline$1, isLineBeforeEmpty ? hardline$1 : "", contents])
+ );
+ } else if (isBlock || isParentSuperClass) {
+ // Trailing block comments never need a newline
+ return concat$1([" ", contents]);
+ }
+
+ return concat$1([lineSuffix(" " + contents), !isBlock ? breakParent$1 : ""]);
+}
+
+function printDanglingComments(path$$1, options, sameIndent, filter) {
+ const parts = [];
+ const node = path$$1.getValue();
+
+ if (!node || !node.comments) {
+ return "";
+ }
+
+ path$$1.each(commentPath => {
+ const comment = commentPath.getValue();
+ if (
+ comment &&
+ !comment.leading &&
+ !comment.trailing &&
+ (!filter || filter(comment))
+ ) {
+ parts.push(printComment$1(commentPath, options));
+ }
+ }, "comments");
+
+ if (parts.length === 0) {
+ return "";
+ }
+
+ if (sameIndent) {
+ return join$1(hardline$1, parts);
+ }
+ return indent$1(concat$1([hardline$1, join$1(hardline$1, parts)]));
+}
+
+function prependCursorPlaceholder(path$$1, options, printed) {
+ if (path$$1.getNode() === options.cursorNode && path$$1.getValue()) {
+ return concat$1([cursor, printed]);
+ }
+ return printed;
+}
+
+function printComments(path$$1, print, options, needsSemi) {
+ const value = path$$1.getValue();
+ const printed = print(path$$1);
+ const comments = value && value.comments;
+
+ if (!comments || comments.length === 0) {
+ return prependCursorPlaceholder(path$$1, options, printed);
+ }
+
+ const leadingParts = [];
+ const trailingParts = [needsSemi ? ";" : "", printed];
+
+ path$$1.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, options.locEnd(comment))
+ )
+ ) {
+ leadingParts.push(hardline$1);
+ }
+ } else if (trailing) {
+ trailingParts.push(printTrailingComment(commentPath, print, options));
+ }
+ }, "comments");
+
+ return prependCursorPlaceholder(
+ path$$1,
+ options,
+ concat$1(leadingParts.concat(trailingParts))
+ );
+}
+
+var comments = {
+ attach,
+ printComments,
+ printDanglingComments,
+ getSortedChildNodes
+};
+
+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$2 = 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 : */
+});
+
+const doc$2 = doc;
+const docUtils$4 = doc$2.utils;
+const docBuilders$5 = doc$2.builders;
+const indent$3 = docBuilders$5.indent;
+const join$3 = docBuilders$5.join;
+const hardline$3 = docBuilders$5.hardline;
+const softline$2 = docBuilders$5.softline;
+const literalline$2 = docBuilders$5.literalline;
+const concat$4 = docBuilders$5.concat;
+const dedentToRoot$1 = docBuilders$5.dedentToRoot;
+
+function embed(path$$1, print, textToDoc /*, options */) {
+ const node = path$$1.getValue();
+ const parent = path$$1.getParentNode();
+ const parentParent = path$$1.getParentNode(1);
+
+ switch (node.type) {
+ case "TemplateLiteral": {
+ const isCss = [isStyledJsx, isStyledComponents, isCssProp].some(isIt =>
+ isIt(path$$1)
+ );
+
+ if (isCss) {
+ // Get full template literal with expressions replaced by placeholders
+ const rawQuasis = node.quasis.map(q => q.value.raw);
+ let placeholderID = 0;
+ const text = rawQuasis.reduce((prevVal, currVal, idx) => {
+ return idx == 0
+ ? currVal
+ : prevVal +
+ "@prettier-placeholder-" +
+ placeholderID++ +
+ "-id" +
+ currVal;
+ }, "");
+ const doc$$2 = textToDoc(text, { parser: "css" });
+ return transformCssDoc(doc$$2, path$$1, print);
+ }
+
+ /*
+ * react-relay and graphql-tag
+ * graphql`...`
+ * graphql.experimental`...`
+ * gql`...`
+ *
+ * This intentionally excludes Relay Classic tags, as Prettier does not
+ * support Relay Classic formatting.
+ */
+ if (
+ parent &&
+ ((parent.type === "TaggedTemplateExpression" &&
+ ((parent.tag.type === "MemberExpression" &&
+ parent.tag.object.name === "graphql" &&
+ parent.tag.property.name === "experimental") ||
+ (parent.tag.type === "Identifier" &&
+ (parent.tag.name === "gql" || parent.tag.name === "graphql")))) ||
+ (parent.type === "CallExpression" &&
+ parent.callee.type === "Identifier" &&
+ parent.callee.name === "graphql"))
+ ) {
+ const expressionDocs = node.expressions
+ ? path$$1.map(print, "expressions")
+ : [];
+
+ const numQuasis = node.quasis.length;
+
+ if (numQuasis === 1 && node.quasis[0].value.raw.trim() === "") {
+ return "``";
+ }
+
+ const parts = [];
+
+ for (let i = 0; i < numQuasis; i++) {
+ const templateElement = node.quasis[i];
+ const isFirst = i === 0;
+ const isLast = i === numQuasis - 1;
+ const text = templateElement.value.cooked;
+
+ // Bail out if any of the quasis have an invalid escape sequence
+ // (which would make the `cooked` value be `null` or `undefined`)
+ if (typeof text !== "string") {
+ return null;
+ }
+
+ const lines = text.split("\n");
+ const numLines = lines.length;
+ const expressionDoc = expressionDocs[i];
+
+ const startsWithBlankLine =
+ numLines > 2 && lines[0].trim() === "" && lines[1].trim() === "";
+ const endsWithBlankLine =
+ numLines > 2 &&
+ lines[numLines - 1].trim() === "" &&
+ lines[numLines - 2].trim() === "";
+
+ const commentsAndWhitespaceOnly = lines.every(line =>
+ /^\s*(?:#[^\r\n]*)?$/.test(line)
+ );
+
+ // Bail out if an interpolation occurs within a comment.
+ if (!isLast && /#[^\r\n]*$/.test(lines[numLines - 1])) {
+ return null;
+ }
+
+ let doc$$2 = null;
+
+ if (commentsAndWhitespaceOnly) {
+ doc$$2 = printGraphqlComments(lines);
+ } else {
+ try {
+ doc$$2 = docUtils$4.stripTrailingHardline(
+ textToDoc(text, { parser: "graphql" })
+ );
+ } catch (error) {
+ if (process.env.PRETTIER_DEBUG) {
+ throw error;
+ }
+ // Bail if any part fails to parse.
+ return null;
+ }
+ }
+
+ if (doc$$2) {
+ doc$$2 = escapeBackticks(doc$$2);
+ if (!isFirst && startsWithBlankLine) {
+ parts.push("");
+ }
+ parts.push(doc$$2);
+ if (!isLast && endsWithBlankLine) {
+ parts.push("");
+ }
+ } else if (!isFirst && !isLast && startsWithBlankLine) {
+ parts.push("");
+ }
+
+ if (expressionDoc) {
+ parts.push(concat$4(["${", expressionDoc, "}"]));
+ }
+ }
+
+ return concat$4([
+ "`",
+ indent$3(concat$4([hardline$3, join$3(hardline$3, parts)])),
+ hardline$3,
+ "`"
+ ]);
+ }
+
+ break;
+ }
+
+ case "TemplateElement": {
+ /**
+ * md`...`
+ * markdown`...`
+ */
+ if (
+ parentParent &&
+ (parentParent.type === "TaggedTemplateExpression" &&
+ parent.quasis.length === 1 &&
+ (parentParent.tag.type === "Identifier" &&
+ (parentParent.tag.name === "md" ||
+ parentParent.tag.name === "markdown")))
+ ) {
+ const text = parent.quasis[0].value.cooked;
+ const indentation = getIndentation(text);
+ const hasIndent = indentation !== "";
+ return concat$4([
+ hasIndent
+ ? indent$3(
+ concat$4([
+ softline$2,
+ printMarkdown(
+ text.replace(new RegExp(`^${indentation}`, "gm"), "")
+ )
+ ])
+ )
+ : concat$4([literalline$2, dedentToRoot$1(printMarkdown(text))]),
+ softline$2
+ ]);
+ }
+
+ break;
+ }
+ }
+
+ function printMarkdown(text) {
+ const doc$$2 = textToDoc(text, { parser: "markdown", __inJsTemplate: true });
+ return docUtils$4.stripTrailingHardline(escapeBackticks(doc$$2));
+ }
+}
+
+function getIndentation(str) {
+ const firstMatchedIndent = str.match(/^([^\S\n]*)\S/m);
+ return firstMatchedIndent === null ? "" : firstMatchedIndent[1];
+}
+
+function escapeBackticks(doc$$2) {
+ return docUtils$4.mapDoc(doc$$2, currentDoc => {
+ if (!currentDoc.parts) {
+ return currentDoc;
+ }
+
+ const parts = [];
+
+ currentDoc.parts.forEach(part => {
+ if (typeof part === "string") {
+ parts.push(part.replace(/`/g, "\\`"));
+ } else {
+ parts.push(part);
+ }
+ });
+
+ return Object.assign({}, currentDoc, { parts });
+ });
+}
+
+function transformCssDoc(quasisDoc, path$$1, print) {
+ const parentNode = path$$1.getValue();
+
+ const isEmpty =
+ parentNode.quasis.length === 1 && !parentNode.quasis[0].value.raw.trim();
+ if (isEmpty) {
+ return "``";
+ }
+
+ const expressionDocs = parentNode.expressions
+ ? path$$1.map(print, "expressions")
+ : [];
+ const newDoc = replacePlaceholders(quasisDoc, expressionDocs);
+ /* istanbul ignore if */
+ if (!newDoc) {
+ throw new Error("Couldn't insert all the expressions");
+ }
+ return concat$4([
+ "`",
+ indent$3(concat$4([hardline$3, docUtils$4.stripTrailingHardline(newDoc)])),
+ softline$2,
+ "`"
+ ]);
+}
+
+// Search all the placeholders in the quasisDoc tree
+// and replace them with the expression docs one by one
+// returns a new doc with all the placeholders replaced,
+// or null if it couldn't replace any expression
+function replacePlaceholders(quasisDoc, expressionDocs) {
+ if (!expressionDocs || !expressionDocs.length) {
+ return quasisDoc;
+ }
+
+ const expressions = expressionDocs.slice();
+ let replaceCounter = 0;
+ const newDoc = docUtils$4.mapDoc(quasisDoc, doc$$2 => {
+ if (!doc$$2 || !doc$$2.parts || !doc$$2.parts.length) {
+ return doc$$2;
+ }
+ let parts = doc$$2.parts;
+ const atIndex = parts.indexOf("@");
+ const placeholderIndex = atIndex + 1;
+ if (
+ atIndex > -1 &&
+ typeof parts[placeholderIndex] === "string" &&
+ parts[placeholderIndex].startsWith("prettier-placeholder")
+ ) {
+ // If placeholder is split, join it
+ const at = parts[atIndex];
+ const placeholder = parts[placeholderIndex];
+ const rest = parts.slice(placeholderIndex + 1);
+ parts = parts
+ .slice(0, atIndex)
+ .concat([at + placeholder])
+ .concat(rest);
+ }
+ const atPlaceholderIndex = parts.findIndex(
+ part =>
+ typeof part === "string" && part.startsWith("@prettier-placeholder")
+ );
+ if (atPlaceholderIndex > -1) {
+ const placeholder = parts[atPlaceholderIndex];
+ const rest = parts.slice(atPlaceholderIndex + 1);
+ const placeholderMatch = placeholder.match(
+ /@prettier-placeholder-(.+)-id([\s\S]*)/
+ );
+ const placeholderID = placeholderMatch[1];
+ // When the expression has a suffix appended, like:
+ // animation: linear ${time}s ease-out;
+ const suffix = placeholderMatch[2];
+ const expression = expressions[placeholderID];
+
+ replaceCounter++;
+ parts = parts
+ .slice(0, atPlaceholderIndex)
+ .concat(["${", expression, "}" + suffix])
+ .concat(rest);
+ }
+ return Object.assign({}, doc$$2, {
+ parts: parts
+ });
+ });
+
+ return expressions.length === replaceCounter ? newDoc : null;
+}
+
+function printGraphqlComments(lines) {
+ const parts = [];
+ let seenComment = false;
+
+ lines.map(textLine => textLine.trim()).forEach((textLine, i, array) => {
+ // Lines are either whitespace only, or a comment (with poential whitespace
+ // around it). Drop whitespace-only lines.
+ if (textLine === "") {
+ return;
+ }
+
+ if (array[i - 1] === "" && seenComment) {
+ // If a non-first comment is preceded by a blank (whitespace only) line,
+ // add in a blank line.
+ parts.push(concat$4([hardline$3, textLine]));
+ } else {
+ parts.push(textLine);
+ }
+
+ seenComment = true;
+ });
+
+ // If `lines` was whitespace only, return `null`.
+ return parts.length === 0 ? null : join$3(hardline$3, parts);
+}
+
+/**
+ * Template literal in this context:
+ *
+ */
+function isStyledJsx(path$$1) {
+ const node = path$$1.getValue();
+ const parent = path$$1.getParentNode();
+ const parentParent = path$$1.getParentNode(1);
+ return (
+ parentParent &&
+ node.quasis &&
+ parent.type === "JSXExpressionContainer" &&
+ parentParent.type === "JSXElement" &&
+ parentParent.openingElement.name.name === "style" &&
+ parentParent.openingElement.attributes.some(
+ attribute => attribute.name.name === "jsx"
+ )
+ );
+}
+
+/**
+ * styled-components template literals
+ */
+function isStyledComponents(path$$1) {
+ const parent = path$$1.getParentNode();
+
+ if (!parent || parent.type !== "TaggedTemplateExpression") {
+ return false;
+ }
+
+ const tag = parent.tag;
+
+ switch (tag.type) {
+ case "MemberExpression":
+ return (
+ // styled.foo``
+ isStyledIdentifier(tag.object) ||
+ // Component.extend``
+ (/^[A-Z]/.test(tag.object.name) && tag.property.name === "extend")
+ );
+
+ case "CallExpression":
+ return (
+ // styled(Component)``
+ isStyledIdentifier(tag.callee) ||
+ (tag.callee.type === "MemberExpression" &&
+ // styled.foo.attr({})``
+ ((tag.callee.object.type === "MemberExpression" &&
+ isStyledIdentifier(tag.callee.object.object)) ||
+ // styled(Component).attr({})``
+ (tag.callee.object.type === "CallExpression" &&
+ isStyledIdentifier(tag.callee.object.callee))))
+ );
+
+ case "Identifier":
+ // css``
+ return tag.name === "css";
+
+ default:
+ return false;
+ }
+}
+
+/**
+ * JSX element with CSS prop
+ */
+function isCssProp(path$$1) {
+ const parent = path$$1.getParentNode();
+ const parentParent = path$$1.getParentNode(1);
+ return (
+ parentParent &&
+ parent.type === "JSXExpressionContainer" &&
+ parentParent.type === "JSXAttribute" &&
+ parentParent.name.type === "JSXIdentifier" &&
+ parentParent.name.name === "css"
+ );
+}
+
+function isStyledIdentifier(node) {
+ return node.type === "Identifier" && node.name === "styled";
+}
+
+var embed_1 = embed;
+
+function clean(ast, newObj, parent) {
+ // We remove extra `;` and add them when needed
+ if (ast.type === "EmptyStatement") {
+ return null;
+ }
+
+ // We move text around, including whitespaces and add {" "}
+ if (ast.type === "JSXText") {
+ return null;
+ }
+ if (
+ ast.type === "JSXExpressionContainer" &&
+ ast.expression.type === "Literal" &&
+ ast.expression.value === " "
+ ) {
+ return null;
+ }
+
+ // (TypeScript) Ignore `static` in `constructor(static p) {}`
+ // and `export` in `constructor(export p) {}`
+ if (
+ ast.type === "TSParameterProperty" &&
+ ast.accessibility === null &&
+ !ast.readonly
+ ) {
+ return {
+ type: "Identifier",
+ name: ast.parameter.name,
+ typeAnnotation: newObj.parameter.typeAnnotation,
+ decorators: newObj.decorators
+ };
+ }
+
+ // (TypeScript) ignore empty `specifiers` array
+ if (
+ ast.type === "TSNamespaceExportDeclaration" &&
+ ast.specifiers &&
+ ast.specifiers.length === 0
+ ) {
+ delete newObj.specifiers;
+ }
+
+ // (TypeScript) bypass TSParenthesizedType
+ if (
+ ast.type === "TSParenthesizedType" &&
+ ast.typeAnnotation.type === "TSTypeAnnotation"
+ ) {
+ return newObj.typeAnnotation.typeAnnotation;
+ }
+
+ // We convert to
+ if (ast.type === "JSXOpeningElement") {
+ delete newObj.selfClosing;
+ }
+ if (ast.type === "JSXElement") {
+ delete newObj.closingElement;
+ }
+
+ // We change {'key': value} into {key: value}
+ if (
+ (ast.type === "Property" ||
+ ast.type === "MethodDefinition" ||
+ ast.type === "ClassProperty" ||
+ ast.type === "TSPropertySignature" ||
+ ast.type === "ObjectTypeProperty") &&
+ typeof ast.key === "object" &&
+ ast.key &&
+ (ast.key.type === "Literal" || ast.key.type === "Identifier")
+ ) {
+ delete newObj.key;
+ }
+
+ // Remove raw and cooked values from TemplateElement when it's CSS
+ // styled-jsx
+ if (
+ ast.type === "JSXElement" &&
+ ast.openingElement.name.name === "style" &&
+ ast.openingElement.attributes.some(attr => attr.name.name === "jsx")
+ ) {
+ const templateLiterals = newObj.children
+ .filter(
+ child =>
+ child.type === "JSXExpressionContainer" &&
+ child.expression.type === "TemplateLiteral"
+ )
+ .map(container => container.expression);
+
+ const quasis = templateLiterals.reduce(
+ (quasis, templateLiteral) => quasis.concat(templateLiteral.quasis),
+ []
+ );
+
+ quasis.forEach(q => delete q.value);
+ }
+
+ // CSS template literals in css prop
+ if (
+ ast.type === "JSXAttribute" &&
+ ast.name.name === "css" &&
+ ast.value.type === "JSXExpressionContainer" &&
+ ast.value.expression.type === "TemplateLiteral"
+ ) {
+ newObj.value.expression.quasis.forEach(q => delete q.value);
+ }
+
+ // styled-components, graphql, markdown
+ if (
+ ast.type === "TaggedTemplateExpression" &&
+ (ast.tag.type === "MemberExpression" ||
+ (ast.tag.type === "Identifier" &&
+ (ast.tag.name === "gql" ||
+ ast.tag.name === "graphql" ||
+ ast.tag.name === "css" ||
+ ast.tag.name === "md" ||
+ ast.tag.name === "markdown")) ||
+ ast.tag.type === "CallExpression")
+ ) {
+ newObj.quasi.quasis.forEach(quasi => delete quasi.value);
+ }
+ if (
+ ast.type === "TemplateLiteral" &&
+ parent.type === "CallExpression" &&
+ parent.callee.name === "graphql"
+ ) {
+ newObj.quasis.forEach(quasi => delete quasi.value);
+ }
+}
+
+var clean_1 = clean;
+
+var detectNewline = createCommonjsModule(function (module) {
+'use strict';
+module.exports = function (str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+
+ var newlines = (str.match(/(?:\r?\n)/g) || []);
+
+ if (newlines.length === 0) {
+ return null;
+ }
+
+ var crlf = newlines.filter(function (el) {
+ return el === '\r\n';
+ }).length;
+
+ var lf = newlines.length - crlf;
+
+ return crlf > lf ? '\r\n' : '\n';
+};
+
+module.exports.graceful = function (str) {
+ return module.exports(str) || '\n';
+};
+});
+
+var build = createCommonjsModule(function (module, exports) {
+'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extract = extract;exports.
+
+
+
+
+strip = strip;exports.
+
+
+
+
+parse = parse;exports.
+
+
+
+parseWithComments = parseWithComments;exports.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+print = print;var _detectNewline;function _load_detectNewline() {return _detectNewline = _interopRequireDefault(detectNewline);}var _os;function _load_os() {return _os = os;}function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };} /**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ */const commentEndRe = /\*\/$/;const commentStartRe = /^\/\*\*/;const docblockRe = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/;const lineCommentRe = /(^|\s+)\/\/([^\r\n]*)/g;const ltrimRe = /^\s*/;const rtrimRe = /\s*$/;const ltrimNewlineRe = /^(\r?\n)+/;const multilineRe = /(?:^|\r?\n) *(@[^\r\n]*?) *\r?\n *(?![^@\r\n]*\/\/[^]*)([^@\r\n\s][^@\r\n]+?) *\r?\n/g;const propertyRe = /(?:^|\r?\n) *@(\S+) *([^\r\n]*)/g;const stringStartRe = /(\r?\n|^) *\* ?/g;function extract(contents) {const match = contents.match(docblockRe);return match ? match[0].replace(ltrimRe, '') || '' : '';}function strip(contents) {const match = contents.match(docblockRe);return match && match[0] ? contents.substring(match[0].length) : contents;}function parse(docblock) {return parseWithComments(docblock).pragmas;}function parseWithComments(docblock) {const line = (0, (_detectNewline || _load_detectNewline()).default)(docblock) || (_os || _load_os()).EOL;docblock = docblock.replace(commentStartRe, '').replace(commentEndRe, '').replace(stringStartRe, '$1'); // Normalize multi-line directives
+ let prev = '';while (prev !== docblock) {prev = docblock;docblock = docblock.replace(multilineRe, `${line}$1 $2${line}`);}docblock = docblock.replace(ltrimNewlineRe, '').replace(rtrimRe, '');const result = Object.create(null);const comments = docblock.replace(propertyRe, '').replace(ltrimNewlineRe, '').replace(rtrimRe, '');let match;while (match = propertyRe.exec(docblock)) {// strip linecomments from pragmas
+ const nextPragma = match[2].replace(lineCommentRe, '');if (typeof result[match[1]] === 'string' || Array.isArray(result[match[1]])) {result[match[1]] = [].concat(result[match[1]], nextPragma);} else {result[match[1]] = nextPragma;}}return { comments, pragmas: result };}function print(_ref) {var _ref$comments = _ref.comments;let comments = _ref$comments === undefined ? '' : _ref$comments;var _ref$pragmas = _ref.pragmas;let pragmas = _ref$pragmas === undefined ? {} : _ref$pragmas;const line = (0, (_detectNewline || _load_detectNewline()).default)(comments) || (_os || _load_os()).EOL;const head = '/**';
+ const start = ' *';
+ const tail = ' */';
+
+ const keys = Object.keys(pragmas);
+
+ const printedObject = keys.
+ map(key => printKeyValues(key, pragmas[key])).
+ reduce((arr, next) => arr.concat(next), []).
+ map(keyValue => start + ' ' + keyValue + line).
+ join('');
+
+ if (!comments) {
+ if (keys.length === 0) {
+ return '';
+ }
+ if (keys.length === 1 && !Array.isArray(pragmas[keys[0]])) {
+ const value = pragmas[keys[0]];
+ return `${head} ${printKeyValues(keys[0], value)[0]}${tail}`;
+ }
+ }
+
+ const printedComments =
+ comments.
+ split(line).
+ map(textLine => `${start} ${textLine}`).
+ join(line) + line;
+
+ return (
+ head +
+ line + (
+ comments ? printedComments : '') + (
+ comments && keys.length ? start + line : '') +
+ printedObject +
+ tail);
+
+}
+
+function printKeyValues(key, valueOrArray) {
+ return [].concat(valueOrArray).map(value => `@${key} ${value}`.trim());
+}
+});
+
+unwrapExports(build);
+
+function hasPragma$1(text) {
+ const pragmas = Object.keys(build.parse(build.extract(text)));
+ return pragmas.indexOf("prettier") !== -1 || pragmas.indexOf("format") !== -1;
+}
+
+function insertPragma$1(text) {
+ const parsedDocblock = build.parseWithComments(build.extract(text));
+ const pragmas = Object.assign({ format: "" }, parsedDocblock.pragmas);
+ const newDocblock = build.print({
+ pragmas,
+ comments: parsedDocblock.comments.replace(/^(\s+?\r?\n)+/, "") // remove leading newlines
+ });
+ const strippedText = build.strip(text);
+ const separatingNewlines = strippedText.startsWith("\n") ? "\n" : "\n\n";
+ return newDocblock + separatingNewlines + strippedText;
+}
+
+var pragma = {
+ hasPragma: hasPragma$1,
+ insertPragma: insertPragma$1
+};
+
+const addLeadingComment$2 = utilShared.addLeadingComment;
+const addTrailingComment$2 = utilShared.addTrailingComment;
+const addDanglingComment$2 = utilShared.addDanglingComment;
+
+function handleOwnLineComment(comment, text, options, ast, isLastComment) {
+ const precedingNode = comment.precedingNode;
+ const enclosingNode = comment.enclosingNode;
+ const followingNode = comment.followingNode;
+ if (
+ handleLastFunctionArgComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment,
+ options
+ ) ||
+ handleMemberExpressionComments(enclosingNode, followingNode, comment) ||
+ handleIfStatementComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment,
+ options
+ ) ||
+ handleTryStatementComments(enclosingNode, followingNode, comment) ||
+ handleClassComments(enclosingNode, precedingNode, followingNode, comment) ||
+ handleImportSpecifierComments(enclosingNode, comment) ||
+ handleForComments(enclosingNode, precedingNode, comment) ||
+ handleUnionTypeComments(
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+ ) ||
+ handleOnlyComments(enclosingNode, ast, comment, isLastComment) ||
+ handleImportDeclarationComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment,
+ options
+ ) ||
+ handleAssignmentPatternComments(enclosingNode, comment) ||
+ handleMethodNameComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment,
+ options
+ )
+ ) {
+ return true;
+ }
+ return false;
+}
+
+function handleEndOfLineComment(comment, text, options, ast, isLastComment) {
+ const precedingNode = comment.precedingNode;
+ const enclosingNode = comment.enclosingNode;
+ const followingNode = comment.followingNode;
+ if (
+ handleLastFunctionArgComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment,
+ options
+ ) ||
+ handleConditionalExpressionComments(
+ enclosingNode,
+ precedingNode,
+ followingNode,
+ comment,
+ text,
+ options
+ ) ||
+ handleImportSpecifierComments(enclosingNode, comment) ||
+ handleIfStatementComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment,
+ options
+ ) ||
+ handleClassComments(enclosingNode, precedingNode, followingNode, comment) ||
+ handleLabeledStatementComments(enclosingNode, comment) ||
+ handleCallExpressionComments(precedingNode, enclosingNode, comment) ||
+ handlePropertyComments(enclosingNode, comment) ||
+ handleOnlyComments(enclosingNode, ast, comment, isLastComment) ||
+ handleTypeAliasComments(enclosingNode, followingNode, comment) ||
+ handleVariableDeclaratorComments(enclosingNode, followingNode, comment)
+ ) {
+ return true;
+ }
+ return false;
+}
+
+function handleRemainingComment(comment, text, options, ast, isLastComment) {
+ const precedingNode = comment.precedingNode;
+ const enclosingNode = comment.enclosingNode;
+ const followingNode = comment.followingNode;
+ if (
+ handleIfStatementComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment,
+ options
+ ) ||
+ handleObjectPropertyAssignment(enclosingNode, precedingNode, comment) ||
+ handleCommentInEmptyParens(text, enclosingNode, comment, options) ||
+ handleMethodNameComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment,
+ options
+ ) ||
+ handleOnlyComments(enclosingNode, ast, comment, isLastComment) ||
+ handleCommentAfterArrowParams(text, enclosingNode, comment, options) ||
+ handleFunctionNameComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment,
+ options
+ ) ||
+ handleBreakAndContinueStatementComments(enclosingNode, comment)
+ ) {
+ return true;
+ }
+ return false;
+}
+
+function addBlockStatementFirstComment(node, comment) {
+ const body = node.body.filter(n => n.type !== "EmptyStatement");
+ if (body.length === 0) {
+ addDanglingComment$2(node, comment);
+ } else {
+ addLeadingComment$2(body[0], comment);
+ }
+}
+
+function addBlockOrNotComment(node, comment) {
+ if (node.type === "BlockStatement") {
+ addBlockStatementFirstComment(node, comment);
+ } else {
+ addLeadingComment$2(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,
+ options
+) {
+ 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 the condition parenthesis:
+ // if (a /* comment */) {}
+ // The only workaround I found is to look at the next character to see if
+ // it is a ).
+ const nextCharacter = util$1.getNextNonSpaceNonCommentCharacter(
+ text,
+ comment,
+ options.locEnd
+ );
+ if (nextCharacter === ")") {
+ addTrailingComment$2(precedingNode, comment);
+ return true;
+ }
+
+ // Comments before `else`:
+ // - treat as trailing comments of the consequent, if it's a BlockStatement
+ // - treat as a dangling comment otherwise
+ if (
+ precedingNode === enclosingNode.consequent &&
+ followingNode === enclosingNode.alternate
+ ) {
+ if (precedingNode.type === "BlockStatement") {
+ addTrailingComment$2(precedingNode, comment);
+ } else {
+ addDanglingComment$2(enclosingNode, comment);
+ }
+ return true;
+ }
+
+ if (followingNode.type === "BlockStatement") {
+ addBlockStatementFirstComment(followingNode, comment);
+ return true;
+ }
+
+ if (followingNode.type === "IfStatement") {
+ addBlockOrNotComment(followingNode.consequent, comment);
+ return true;
+ }
+
+ // For comments positioned after the condition parenthesis in an if statement
+ // before the consequent with or without brackets on, such as
+ // if (a) /* comment */ {} or if (a) /* comment */ true,
+ // we look at the next character to see if it is a { or if the following node
+ // is the consequent for the if statement
+ if (nextCharacter === "{" || enclosingNode.consequent === followingNode) {
+ addLeadingComment$2(followingNode, 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$2(enclosingNode, comment);
+ return true;
+ }
+
+ return false;
+}
+
+function handleConditionalExpressionComments(
+ enclosingNode,
+ precedingNode,
+ followingNode,
+ comment,
+ text,
+ options
+) {
+ const isSameLineAsPrecedingNode =
+ precedingNode &&
+ !util$1.hasNewlineInRange(
+ text,
+ options.locEnd(precedingNode),
+ options.locStart(comment)
+ );
+
+ if (
+ (!precedingNode || !isSameLineAsPrecedingNode) &&
+ enclosingNode &&
+ enclosingNode.type === "ConditionalExpression" &&
+ followingNode
+ ) {
+ addLeadingComment$2(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$2(enclosingNode.value.left, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleClassComments(
+ enclosingNode,
+ precedingNode,
+ followingNode,
+ comment
+) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "ClassDeclaration" ||
+ enclosingNode.type === "ClassExpression") &&
+ (enclosingNode.decorators && enclosingNode.decorators.length > 0) &&
+ !(followingNode && followingNode.type === "Decorator")
+ ) {
+ if (!enclosingNode.decorators || enclosingNode.decorators.length === 0) {
+ addLeadingComment$2(enclosingNode, comment);
+ } else {
+ addTrailingComment$2(
+ enclosingNode.decorators[enclosingNode.decorators.length - 1],
+ comment
+ );
+ }
+ return true;
+ }
+ return false;
+}
+
+function handleMethodNameComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment,
+ options
+) {
+ // This is only needed for estree parsers (flow, typescript) to attach
+ // after a method name:
+ // obj = { fn /*comment*/() {} };
+ if (
+ enclosingNode &&
+ precedingNode &&
+ (enclosingNode.type === "Property" ||
+ enclosingNode.type === "MethodDefinition") &&
+ precedingNode.type === "Identifier" &&
+ enclosingNode.key === precedingNode &&
+ // special Property case: { key: /*comment*/(value) };
+ // comment should be attached to value instead of key
+ util$1.getNextNonSpaceNonCommentCharacter(
+ text,
+ precedingNode,
+ options.locEnd
+ ) !== ":"
+ ) {
+ addTrailingComment$2(precedingNode, comment);
+ return true;
+ }
+
+ // Print comments between decorators and class methods as a trailing comment
+ // on the decorator node instead of the method node
+ if (
+ precedingNode &&
+ enclosingNode &&
+ precedingNode.type === "Decorator" &&
+ (enclosingNode.type === "ClassMethod" ||
+ enclosingNode.type === "ClassProperty" ||
+ enclosingNode.type === "TSAbstractClassProperty" ||
+ enclosingNode.type === "TSAbstractMethodDefinition" ||
+ enclosingNode.type === "MethodDefinition")
+ ) {
+ addTrailingComment$2(precedingNode, comment);
+ return true;
+ }
+
+ return false;
+}
+
+function handleFunctionNameComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment,
+ options
+) {
+ if (
+ util$1.getNextNonSpaceNonCommentCharacter(
+ text,
+ comment,
+ options.locEnd
+ ) !== "("
+ ) {
+ return false;
+ }
+
+ if (
+ precedingNode &&
+ enclosingNode &&
+ (enclosingNode.type === "FunctionDeclaration" ||
+ enclosingNode.type === "FunctionExpression" ||
+ enclosingNode.type === "ClassMethod" ||
+ enclosingNode.type === "MethodDefinition" ||
+ enclosingNode.type === "ObjectMethod")
+ ) {
+ addTrailingComment$2(precedingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleCommentAfterArrowParams(text, enclosingNode, comment, options) {
+ if (!(enclosingNode && enclosingNode.type === "ArrowFunctionExpression")) {
+ return false;
+ }
+
+ const index = utilShared.getNextNonSpaceNonCommentCharacterIndex(
+ text,
+ comment,
+ options
+ );
+ if (text.substr(index, 2) === "=>") {
+ addDanglingComment$2(enclosingNode, comment);
+ return true;
+ }
+
+ return false;
+}
+
+function handleCommentInEmptyParens(text, enclosingNode, comment, options) {
+ if (
+ util$1.getNextNonSpaceNonCommentCharacter(
+ text,
+ comment,
+ options.locEnd
+ ) !== ")"
+ ) {
+ 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.body.type !== "CallExpression" ||
+ enclosingNode.body.arguments.length === 0)) ||
+ enclosingNode.type === "ClassMethod" ||
+ enclosingNode.type === "ObjectMethod") &&
+ enclosingNode.params.length === 0) ||
+ (enclosingNode.type === "CallExpression" &&
+ enclosingNode.arguments.length === 0))
+ ) {
+ addDanglingComment$2(enclosingNode, comment);
+ return true;
+ }
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "MethodDefinition" &&
+ enclosingNode.value.params.length === 0)
+ ) {
+ addDanglingComment$2(enclosingNode.value, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleLastFunctionArgComments(
+ text,
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment,
+ options
+) {
+ // Type definitions functions
+ if (
+ precedingNode &&
+ precedingNode.type === "FunctionTypeParam" &&
+ enclosingNode &&
+ enclosingNode.type === "FunctionTypeAnnotation" &&
+ followingNode &&
+ followingNode.type !== "FunctionTypeParam"
+ ) {
+ addTrailingComment$2(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") &&
+ util$1.getNextNonSpaceNonCommentCharacter(
+ text,
+ comment,
+ options.locEnd
+ ) === ")"
+ ) {
+ addTrailingComment$2(precedingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleImportSpecifierComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "ImportSpecifier") {
+ addLeadingComment$2(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleLabeledStatementComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "LabeledStatement") {
+ addLeadingComment$2(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleBreakAndContinueStatementComments(enclosingNode, comment) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "ContinueStatement" ||
+ enclosingNode.type === "BreakStatement") &&
+ !enclosingNode.label
+ ) {
+ addTrailingComment$2(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$2(enclosingNode.arguments[0], comment);
+ return true;
+ }
+ return false;
+}
+
+function handleUnionTypeComments(
+ precedingNode,
+ enclosingNode,
+ followingNode,
+ comment
+) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "UnionTypeAnnotation" ||
+ enclosingNode.type === "TSUnionType")
+ ) {
+ addTrailingComment$2(precedingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handlePropertyComments(enclosingNode, comment) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "Property" ||
+ enclosingNode.type === "ObjectProperty")
+ ) {
+ addLeadingComment$2(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$2(ast, comment);
+ } else {
+ addLeadingComment$2(ast, comment);
+ }
+ return true;
+ } else if (
+ enclosingNode &&
+ enclosingNode.type === "Program" &&
+ enclosingNode.body.length === 0 &&
+ enclosingNode.directives &&
+ enclosingNode.directives.length === 0
+ ) {
+ if (isLastComment) {
+ addDanglingComment$2(enclosingNode, comment);
+ } else {
+ addLeadingComment$2(enclosingNode, comment);
+ }
+ return true;
+ }
+ return false;
+}
+
+function handleForComments(enclosingNode, precedingNode, comment) {
+ if (
+ enclosingNode &&
+ (enclosingNode.type === "ForInStatement" ||
+ enclosingNode.type === "ForOfStatement")
+ ) {
+ addLeadingComment$2(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleImportDeclarationComments(
+ text,
+ enclosingNode,
+ precedingNode,
+ comment,
+ options
+) {
+ if (
+ precedingNode &&
+ enclosingNode &&
+ enclosingNode.type === "ImportDeclaration" &&
+ util$1.hasNewline(text, options.locEnd(comment))
+ ) {
+ addTrailingComment$2(precedingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleAssignmentPatternComments(enclosingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "AssignmentPattern") {
+ addLeadingComment$2(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleTypeAliasComments(enclosingNode, followingNode, comment) {
+ if (enclosingNode && enclosingNode.type === "TypeAlias") {
+ addLeadingComment$2(enclosingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+function handleVariableDeclaratorComments(
+ enclosingNode,
+ followingNode,
+ comment
+) {
+ if (
+ enclosingNode &&
+ enclosingNode.type === "VariableDeclarator" &&
+ followingNode &&
+ (followingNode.type === "ObjectExpression" ||
+ followingNode.type === "ArrayExpression")
+ ) {
+ addLeadingComment$2(followingNode, comment);
+ return true;
+ }
+ return false;
+}
+
+var comments$2 = {
+ handleOwnLineComment,
+ handleEndOfLineComment,
+ handleRemainingComment
+};
+
+function needsParens(path$$1, options) {
+ const parent = path$$1.getParentNode();
+ if (!parent) {
+ return false;
+ }
+
+ const name = path$$1.getName();
+ const node = path$$1.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 (path$$1.getValue() !== node) {
+ return false;
+ }
+
+ // Only statements don't need parentheses.
+ if (isStatement(node)) {
+ return false;
+ }
+
+ // Closure compiler requires that type casted expressions to be surrounded by
+ // parentheses.
+ if (
+ util$1.hasClosureCompilerTypeCastComment(
+ options.originalText,
+ node,
+ options.locEnd
+ )
+ ) {
+ return true;
+ }
+
+ // 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 &&
+ node.type !== "SequenceExpression" && // these have parens added anyway
+ util$1.startsWithNoLookaheadToken(
+ node,
+ /* forbidFunctionAndClass */ false
+ )) ||
+ (parent.type === "ExpressionStatement" &&
+ util$1.startsWithNoLookaheadToken(node, /* forbidFunctionAndClass */ true))
+ ) {
+ return true;
+ }
+
+ switch (node.type) {
+ case "CallExpression": {
+ let firstParentNotMemberExpression = parent;
+ let i = 0;
+ while (
+ firstParentNotMemberExpression &&
+ firstParentNotMemberExpression.type === "MemberExpression"
+ ) {
+ firstParentNotMemberExpression = path$$1.getParentNode(++i);
+ }
+
+ if (
+ firstParentNotMemberExpression.type === "NewExpression" &&
+ firstParentNotMemberExpression.callee === path$$1.getParentNode(i - 1)
+ ) {
+ 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";
+
+ case "TSNonNullExpression":
+ return true;
+
+ default:
+ return false;
+ }
+
+ case "BinaryExpression": {
+ if (parent.type === "UpdateExpression") {
+ return true;
+ }
+
+ const isLeftOfAForStatement = node => {
+ let i = 0;
+ while (node) {
+ const parent = path$$1.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 "ConditionalExpression":
+ return node.type === "TSAsExpression";
+
+ case "CallExpression":
+ case "NewExpression":
+ return name === "callee" && parent.callee === node;
+
+ case "ClassDeclaration":
+ case "TSAbstractClassDeclaration":
+ return name === "superClass" && parent.superClass === node;
+ case "TSTypeAssertionExpression":
+ case "TaggedTemplateExpression":
+ case "UnaryExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ case "ExperimentalSpreadProperty":
+ case "BindExpression":
+ case "AwaitExpression":
+ case "TSAsExpression":
+ case "TSNonNullExpression":
+ case "UpdateExpression":
+ return true;
+
+ case "MemberExpression":
+ return name === "object" && parent.object === node;
+
+ case "AssignmentExpression":
+ return (
+ parent.left === node &&
+ (node.type === "TSTypeAssertionExpression" ||
+ node.type === "TSAsExpression")
+ );
+ case "Decorator":
+ return (
+ parent.expression === node &&
+ (node.type === "TSTypeAssertionExpression" ||
+ node.type === "TSAsExpression")
+ );
+
+ case "BinaryExpression":
+ case "LogicalExpression": {
+ if (!node.operator && node.type !== "TSTypeAssertionExpression") {
+ return true;
+ }
+
+ const po = parent.operator;
+ const pp = util$1.getPrecedence(po);
+ const no = node.operator;
+ const np = util$1.getPrecedence(no);
+
+ if (pp > np) {
+ return true;
+ }
+
+ if ((po === "||" || po === "??") && no === "&&") {
+ return true;
+ }
+
+ if (pp === np && name === "right") {
+ assert.strictEqual(parent.right, node);
+ return true;
+ }
+
+ if (pp === np && !util$1.shouldFlatten(po, no)) {
+ return true;
+ }
+
+ // Add parenthesis when working with binary operators
+ // It's not stricly needed but helps with code understanding
+ if (util$1.isBitwiseOperator(po)) {
+ return true;
+ }
+
+ return false;
+ }
+
+ default:
+ return false;
+ }
+
+ case "TSParenthesizedType": {
+ const grandParent = path$$1.getParentNode(1);
+ if (
+ (parent.type === "TSTypeParameter" ||
+ parent.type === "TypeParameter" ||
+ parent.type === "VariableDeclarator" ||
+ parent.type === "TSTypeAnnotation" ||
+ parent.type === "GenericTypeAnnotation" ||
+ parent.type === "TSTypeReference") &&
+ (node.typeAnnotation.type === "TSTypeAnnotation" &&
+ node.typeAnnotation.typeAnnotation.type !== "TSFunctionType" &&
+ grandParent.type !== "TSTypeOperator")
+ ) {
+ return false;
+ }
+ // Delegate to inner TSParenthesizedType
+ if (node.typeAnnotation.type === "TSParenthesizedType") {
+ return false;
+ }
+ return true;
+ }
+
+ 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";
+
+ case "ArrowFunctionExpression":
+ // We do need parentheses, but SequenceExpressions are handled
+ // specially when printing bodies of arrow functions.
+ return name !== "body";
+
+ 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" ||
+ parent.type === "TSAsExpression" ||
+ parent.type === "TSNonNullExpression"
+ ) {
+ return true;
+ }
+ // else fallthrough
+ case "AwaitExpression":
+ switch (parent.type) {
+ case "TaggedTemplateExpression":
+ case "UnaryExpression":
+ case "BinaryExpression":
+ case "LogicalExpression":
+ case "SpreadElement":
+ case "SpreadProperty":
+ case "ExperimentalSpreadProperty":
+ case "TSAsExpression":
+ case "TSNonNullExpression":
+ 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" ||
+ parent.type === "ArrayTypeAnnotation"
+ );
+
+ case "StringLiteral":
+ case "NumericLiteral":
+ case "Literal":
+ if (
+ typeof node.value === "string" &&
+ parent.type === "ExpressionStatement" &&
+ // TypeScript workaround for eslint/typescript-eslint-parser#267
+ // See corresponding workaround in printer.js case: "Literal"
+ ((options.parser !== "typescript" && !parent.directive) ||
+ (options.parser === "typescript" &&
+ options.originalText.substr(options.locStart(node) - 1, 1) === "("))
+ ) {
+ // To avoid becoming a directive
+ const grandParent = path$$1.getParentNode(1);
+
+ return (
+ grandParent.type === "Program" ||
+ grandParent.type === "BlockStatement"
+ );
+ }
+
+ return (
+ parent.type === "MemberExpression" &&
+ typeof node.value === "number" &&
+ name === "object" &&
+ parent.object === node
+ );
+
+ case "AssignmentExpression": {
+ const grandParent = path$$1.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 "ExperimentalSpreadProperty":
+ case "BinaryExpression":
+ case "LogicalExpression":
+ case "ExportDefaultDeclaration":
+ case "AwaitExpression":
+ case "JSXSpreadAttribute":
+ case "TSTypeAssertionExpression":
+ case "TypeCastExpression":
+ 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";
+ }
+
+ 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 === "ClassPrivateProperty" ||
+ 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 === "TypeAlias" ||
+ node.type === "VariableDeclaration" ||
+ node.type === "WhileStatement" ||
+ node.type === "WithStatement"
+ );
+}
+
+var needsParens_1 = needsParens;
+
+// TODO(azz): anything that imports from main shouldn't be in a `language-*` dir.
+
+
+
+const isIdentifierName = utils$2.keyword.isIdentifierNameES6;
+
+
+const insertPragma = pragma.insertPragma;
+
+
+
+
+const docBuilders = doc.builders;
+const concat = docBuilders.concat;
+const join = docBuilders.join;
+const line = docBuilders.line;
+const hardline = docBuilders.hardline;
+const softline = docBuilders.softline;
+const literalline = docBuilders.literalline;
+const group = docBuilders.group;
+const indent = docBuilders.indent;
+const align = docBuilders.align;
+const conditionalGroup = docBuilders.conditionalGroup;
+const fill = docBuilders.fill;
+const ifBreak = docBuilders.ifBreak;
+const breakParent = docBuilders.breakParent;
+const lineSuffixBoundary = docBuilders.lineSuffixBoundary;
+const addAlignmentToDoc = docBuilders.addAlignmentToDoc;
+const dedent = docBuilders.dedent;
+
+const docUtils$3 = doc.utils;
+const willBreak$1 = docUtils$3.willBreak;
+const isLineNext$1 = docUtils$3.isLineNext;
+const isEmpty$1 = docUtils$3.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$$1, options, printPath, args) {
+ const node = path$$1.getValue();
+ let needsParens = false;
+ const linesWithoutParens = printPathNoParens(path$$1, options, printPath, args);
+
+ if (!node || isEmpty$1(linesWithoutParens)) {
+ return linesWithoutParens;
+ }
+
+ const decorators = [];
+ if (
+ node.decorators &&
+ node.decorators.length > 0 &&
+ // If the parent node is an export declaration, it will be
+ // responsible for printing node.decorators.
+ !util$1.getParentExportDeclaration(path$$1)
+ ) {
+ let separator = hardline;
+ path$$1.each(decoratorPath => {
+ let prefix = "@";
+ let decorator = decoratorPath.getValue();
+ if (decorator.expression) {
+ decorator = decorator.expression;
+ prefix = "";
+ }
+
+ if (
+ node.decorators.length === 1 &&
+ node.type !== "ClassDeclaration" &&
+ node.type !== "MethodDefinition" &&
+ node.type !== "ClassMethod" &&
+ (decorator.type === "Identifier" ||
+ decorator.type === "MemberExpression" ||
+ (decorator.type === "CallExpression" &&
+ (decorator.arguments.length === 0 ||
+ (decorator.arguments.length === 1 &&
+ (isStringLiteral(decorator.arguments[0]) ||
+ decorator.arguments[0].type === "Identifier" ||
+ decorator.arguments[0].type === "MemberExpression")))))
+ ) {
+ separator = line;
+ }
+
+ decorators.push(prefix, printPath(decoratorPath), separator);
+ }, "decorators");
+ } else if (
+ util$1.isExportDeclaration(node) &&
+ node.declaration &&
+ node.declaration.decorators
+ ) {
+ // Export declarations are responsible for printing any decorators
+ // that logically apply to node.declaration.
+ path$$1.each(
+ decoratorPath => {
+ const decorator = decoratorPath.getValue();
+ const prefix = decorator.type === "Decorator" ? "" : "@";
+ decorators.push(prefix, printPath(decoratorPath), hardline);
+ },
+ "declaration",
+ "decorators"
+ );
+ } else {
+ // Nodes with decorators can't have parentheses, so we can avoid
+ // computing pathNeedsParens() except in this case.
+ needsParens = needsParens_1(path$$1, options);
+ }
+
+ const parts = [];
+ if (needsParens) {
+ parts.unshift("(");
+ }
+
+ parts.push(linesWithoutParens);
+
+ if (needsParens) {
+ parts.push(")");
+ }
+
+ if (decorators.length > 0) {
+ return group(concat(decorators.concat(parts)));
+ }
+ return concat(parts);
+}
+
+function hasPrettierIgnore(path$$1) {
+ return util$1.hasIgnoreComment(path$$1) || hasJsxIgnoreComment(path$$1);
+}
+
+function hasJsxIgnoreComment(path$$1) {
+ const node = path$$1.getValue();
+ const parent = path$$1.getParentNode();
+ if (!parent || !node || !isJSXNode(node) || !isJSXNode(parent)) {
+ return false;
+ }
+
+ // Lookup the previous sibling, ignoring any empty JSXText elements
+ const index = parent.children.indexOf(node);
+ let prevSibling = null;
+ for (let i = index; i > 0; i--) {
+ const candidate = parent.children[i - 1];
+ if (candidate.type === "JSXText" && !isMeaningfulJSXText(candidate)) {
+ continue;
+ }
+ prevSibling = candidate;
+ break;
+ }
+
+ return (
+ prevSibling &&
+ prevSibling.type === "JSXExpressionContainer" &&
+ prevSibling.expression.type === "JSXEmptyExpression" &&
+ prevSibling.expression.comments &&
+ prevSibling.expression.comments.find(
+ comment => comment.value.trim() === "prettier-ignore"
+ )
+ );
+}
+
+// The following is the shared logic for
+// ternary operators, namely ConditionalExpression
+// and TSConditionalType
+function formatTernaryOperator(path$$1, options, print, operatorOptions) {
+ const n = path$$1.getValue();
+ const parts = [];
+ const operatorOpts = Object.assign(
+ {
+ beforeParts: () => [""],
+ afterParts: () => [""],
+ shouldCheckJsx: true,
+ operatorName: "ConditionalExpression",
+ consequentNode: "consequent",
+ alternateNode: "alternate",
+ testNode: "test",
+ breakNested: true
+ },
+ operatorOptions || {}
+ );
+
+ // We print a ConditionalExpression in either "JSX mode" or "normal mode".
+ // See tests/jsx/conditional-expression.js for more info.
+ let jsxMode = false;
+ const parent = path$$1.getParentNode();
+ let forceNoIndent = parent.type === operatorOpts.operatorName;
+
+ // Find the outermost non-ConditionalExpression parent, and the outermost
+ // ConditionalExpression parent. We'll use these to determine if we should
+ // print in JSX mode.
+ let currentParent;
+ let previousParent;
+ let i = 0;
+ do {
+ previousParent = currentParent || n;
+ currentParent = path$$1.getParentNode(i);
+ i++;
+ } while (currentParent && currentParent.type === operatorOpts.operatorName);
+ const firstNonConditionalParent = currentParent || parent;
+ const lastConditionalParent = previousParent;
+
+ if (
+ (operatorOpts.shouldCheckJsx && isJSXNode(n[operatorOpts.testNode])) ||
+ isJSXNode(n[operatorOpts.consequentNode]) ||
+ isJSXNode(n[operatorOpts.alternateNode]) ||
+ conditionalExpressionChainContainsJSX(lastConditionalParent)
+ ) {
+ jsxMode = true;
+ forceNoIndent = true;
+
+ // Even though they don't need parens, we wrap (almost) everything in
+ // parens when using ?: within JSX, because the parens are analogous to
+ // curly braces in an if statement.
+ const wrap = doc$$1 =>
+ concat([
+ ifBreak("(", ""),
+ indent(concat([softline, doc$$1])),
+ softline,
+ ifBreak(")", "")
+ ]);
+
+ // The only things we don't wrap are:
+ // * Nested conditional expressions in alternates
+ // * null
+ const isNull = node =>
+ node.type === "NullLiteral" ||
+ (node.type === "Literal" && node.value === null);
+
+ parts.push(
+ " ? ",
+ isNull(n[operatorOpts.consequentNode])
+ ? path$$1.call(print, operatorOpts.consequentNode)
+ : wrap(path$$1.call(print, operatorOpts.consequentNode)),
+ " : ",
+ n[operatorOpts.alternateNode].type === operatorOpts.operatorName ||
+ isNull(n[operatorOpts.alternateNode])
+ ? path$$1.call(print, operatorOpts.alternateNode)
+ : wrap(path$$1.call(print, operatorOpts.alternateNode))
+ );
+ } else {
+ // normal mode
+ const part = concat([
+ line,
+ "? ",
+ n[operatorOpts.consequentNode].type === operatorOpts.operatorName
+ ? ifBreak("", "(")
+ : "",
+ align(2, path$$1.call(print, operatorOpts.consequentNode)),
+ n[operatorOpts.consequentNode].type === operatorOpts.operatorName
+ ? ifBreak("", ")")
+ : "",
+ line,
+ ": ",
+ align(2, path$$1.call(print, operatorOpts.alternateNode))
+ ]);
+ parts.push(
+ parent.type === operatorOpts.operatorName
+ ? options.useTabs
+ ? dedent(indent(part))
+ : align(Math.max(0, options.tabWidth - 2), part)
+ : part
+ );
+ }
+
+ // We want a whole chain of ConditionalExpressions to all
+ // break if any of them break. That means we should only group around the
+ // outer-most ConditionalExpression.
+ const maybeGroup = doc$$1 =>
+ operatorOpts.breakNested
+ ? parent === firstNonConditionalParent
+ ? group(doc$$1)
+ : doc$$1
+ : group(doc$$1); // Always group in normal mode.
+
+ // Break the closing paren to keep the chain right after it:
+ // (a
+ // ? b
+ // : c
+ // ).call()
+ const breakClosingParen =
+ !jsxMode && parent.type === "MemberExpression" && !parent.computed;
+
+ return maybeGroup(
+ concat(
+ [].concat(
+ operatorOpts.beforeParts(),
+ forceNoIndent ? concat(parts) : indent(concat(parts)),
+ operatorOpts.afterParts(breakClosingParen)
+ )
+ )
+ );
+}
+
+function getTypeScriptMappedTypeModifier(tokenNode, keyword) {
+ if (tokenNode.type === "TSPlusToken") {
+ return "+" + keyword;
+ } else if (tokenNode.type === "TSMinusToken") {
+ return "-" + keyword;
+ }
+ return keyword;
+}
+
+function printPathNoParens(path$$1, options, print, args) {
+ const n = path$$1.getValue();
+ const semi = options.semi ? ";" : "";
+
+ if (!n) {
+ return "";
+ }
+
+ if (typeof n === "string") {
+ return n;
+ }
+
+ let parts = [];
+ switch (n.type) {
+ case "File":
+ return path$$1.call(print, "program");
+ case "Program":
+ // Babel 6
+ if (n.directives) {
+ path$$1.each(childPath => {
+ parts.push(print(childPath), semi, hardline);
+ if (
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ childPath.getValue(),
+ options
+ )
+ ) {
+ parts.push(hardline);
+ }
+ }, "directives");
+ }
+
+ parts.push(
+ path$$1.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body")
+ );
+
+ parts.push(
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true)
+ );
+
+ // Only force a trailing newline if there were any contents.
+ if (n.body.length || n.comments) {
+ parts.push(hardline);
+ }
+
+ return concat(parts);
+ // Babel extension.
+ case "EmptyStatement":
+ return "";
+ case "ExpressionStatement":
+ // Detect Flow-parsed directives
+ if (n.directive) {
+ return concat([nodeStr(n.expression, options, true), semi]);
+ }
+ // Do not append semicolon after the only JSX element in a program
+ return concat([
+ path$$1.call(print, "expression"),
+ isTheOnlyJSXElementInMarkdown(options, path$$1) ? "" : semi
+ ]); // Babel extension.
+ case "ParenthesizedExpression":
+ return concat(["(", path$$1.call(print, "expression"), ")"]);
+ case "AssignmentExpression":
+ return printAssignment(
+ n.left,
+ path$$1.call(print, "left"),
+ concat([" ", n.operator]),
+ n.right,
+ path$$1.call(print, "right"),
+ options
+ );
+ case "BinaryExpression":
+ case "LogicalExpression": {
+ const parent = path$$1.getParentNode();
+ const parentParent = path$$1.getParentNode(1);
+ const isInsideParenthesis =
+ n !== parent.body &&
+ (parent.type === "IfStatement" ||
+ parent.type === "WhileStatement" ||
+ parent.type === "DoWhileStatement");
+
+ const parts = printBinaryishExpressions(
+ path$$1,
+ 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(parts);
+ }
+
+ // Break between the parens in unaries or in a member expression, i.e.
+ //
+ // (
+ // a &&
+ // b &&
+ // c
+ // ).call()
+ if (
+ parent.type === "UnaryExpression" ||
+ (parent.type === "MemberExpression" && !parent.computed)
+ ) {
+ return group(
+ concat([indent(concat([softline, concat(parts)])), softline])
+ );
+ }
+
+ // Avoid indenting sub-expressions in some cases where the first sub-expression is already
+ // indented accordingly. We should indent sub-expressions where the first case isn't indented.
+ const shouldNotIndent =
+ parent.type === "ReturnStatement" ||
+ (parent.type === "JSXExpressionContainer" &&
+ parentParent.type === "JSXAttribute") ||
+ (n === parent.body && parent.type === "ArrowFunctionExpression") ||
+ (n !== parent.body && parent.type === "ForStatement") ||
+ (parent.type === "ConditionalExpression" &&
+ parentParent.type !== "ReturnStatement");
+
+ const shouldIndentIfInlining =
+ parent.type === "AssignmentExpression" ||
+ parent.type === "VariableDeclarator" ||
+ parent.type === "ClassProperty" ||
+ parent.type === "TSAbstractClassProperty" ||
+ parent.type === "ClassPrivateProperty" ||
+ parent.type === "ObjectProperty" ||
+ parent.type === "Property";
+
+ const samePrecedenceSubExpression =
+ isBinaryish(n.left) &&
+ util$1.shouldFlatten(n.operator, n.left.operator);
+
+ if (
+ shouldNotIndent ||
+ (shouldInlineLogicalExpression(n) && !samePrecedenceSubExpression) ||
+ (!shouldInlineLogicalExpression(n) && shouldIndentIfInlining)
+ ) {
+ return group(concat(parts));
+ }
+
+ const rest = concat(parts.slice(1));
+
+ return group(
+ concat([
+ // 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(rest)
+ ])
+ );
+ }
+ case "AssignmentPattern":
+ return concat([
+ path$$1.call(print, "left"),
+ " = ",
+ path$$1.call(print, "right")
+ ]);
+ case "TSTypeAssertionExpression":
+ return concat([
+ "<",
+ path$$1.call(print, "typeAnnotation"),
+ ">",
+ path$$1.call(print, "expression")
+ ]);
+ case "MemberExpression": {
+ const parent = path$$1.getParentNode();
+ let firstNonMemberParent;
+ let i = 0;
+ do {
+ firstNonMemberParent = path$$1.getParentNode(i);
+ i++;
+ } while (
+ firstNonMemberParent &&
+ (firstNonMemberParent.type === "MemberExpression" ||
+ firstNonMemberParent.type === "TSNonNullExpression")
+ );
+
+ const shouldInline =
+ (firstNonMemberParent &&
+ (firstNonMemberParent.type === "NewExpression" ||
+ (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([
+ path$$1.call(print, "object"),
+ shouldInline
+ ? printMemberLookup(path$$1, options, print)
+ : group(
+ indent(
+ concat([softline, printMemberLookup(path$$1, options, print)])
+ )
+ )
+ ]);
+ }
+ case "MetaProperty":
+ return concat([
+ path$$1.call(print, "meta"),
+ ".",
+ path$$1.call(print, "property")
+ ]);
+ case "BindExpression":
+ if (n.object) {
+ parts.push(path$$1.call(print, "object"));
+ }
+
+ parts.push(printBindExpressionCallee(path$$1, options, print));
+
+ return concat(parts);
+ case "Identifier": {
+ return concat([
+ n.name,
+ printOptionalToken(path$$1),
+ printTypeAnnotation(path$$1, options, print)
+ ]);
+ }
+ case "SpreadElement":
+ case "SpreadElementPattern":
+ case "RestProperty":
+ case "ExperimentalRestProperty":
+ case "ExperimentalSpreadProperty":
+ case "SpreadProperty":
+ case "SpreadPropertyPattern":
+ case "RestElement":
+ case "ObjectTypeSpreadProperty":
+ return concat([
+ "...",
+ path$$1.call(print, "argument"),
+ printTypeAnnotation(path$$1, options, print)
+ ]);
+ case "FunctionDeclaration":
+ case "FunctionExpression":
+ if (isNodeStartingWithDeclare(n, options)) {
+ parts.push("declare ");
+ }
+ parts.push(printFunctionDeclaration(path$$1, print, options));
+ if (!n.body) {
+ parts.push(semi);
+ }
+ return concat(parts);
+ case "ArrowFunctionExpression": {
+ if (n.async) {
+ parts.push("async ");
+ }
+
+ if (shouldPrintParamsWithoutParens(path$$1, options)) {
+ parts.push(path$$1.call(print, "params", 0));
+ } else {
+ parts.push(
+ group(
+ concat([
+ printFunctionParams(
+ path$$1,
+ print,
+ options,
+ /* expandLast */ args &&
+ (args.expandLastArg || args.expandFirstArg),
+ /* printTypeParams */ true
+ ),
+ printReturnType(path$$1, print, options)
+ ])
+ )
+ );
+ }
+
+ const dangling = comments.printDanglingComments(
+ path$$1,
+ options,
+ /* sameIndent */ true,
+ comment => {
+ const nextCharacter = utilShared.getNextNonSpaceNonCommentCharacterIndex(
+ options.originalText,
+ comment,
+ options
+ );
+ return options.originalText.substr(nextCharacter, 2) === "=>";
+ }
+ );
+ if (dangling) {
+ parts.push(" ", dangling);
+ }
+
+ parts.push(" =>");
+
+ const body = path$$1.call(bodyPath => print(bodyPath, args), "body");
+
+ // We want to always keep these types of nodes on the same line
+ // as the arrow.
+ if (
+ !hasLeadingOwnLineComment(options.originalText, n.body, options) &&
+ (n.body.type === "ArrayExpression" ||
+ n.body.type === "ObjectExpression" ||
+ n.body.type === "BlockStatement" ||
+ isJSXNode(n.body) ||
+ isTemplateOnItsOwnLine(n.body, options.originalText, options) ||
+ n.body.type === "ArrowFunctionExpression")
+ ) {
+ return group(concat([concat(parts), " ", body]));
+ }
+
+ // We handle sequence expressions as the body of arrows specially,
+ // so that the required parentheses end up on their own lines.
+ if (n.body.type === "SequenceExpression") {
+ return group(
+ concat([
+ concat(parts),
+ group(
+ concat([" (", indent(concat([softline, body])), softline, ")"])
+ )
+ ])
+ );
+ }
+
+ // 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 (, or if it's inside a JSXExpression (e.g. an attribute)
+ // we should align the expression's closing } with the line with the opening {.
+ const shouldAddSoftLine =
+ ((args && args.expandLastArg) ||
+ path$$1.getParentNode().type === "JSXExpressionContainer") &&
+ !(n.comments && n.comments.length);
+
+ const printTrailingComma =
+ args && args.expandLastArg && shouldPrintComma(options, "all");
+
+ // In order to avoid confusion between
+ // a => a ? a : a
+ // a <= a ? a : a
+ const shouldAddParens =
+ n.body.type === "ConditionalExpression" &&
+ !util$1.startsWithNoLookaheadToken(
+ n.body,
+ /* forbidFunctionAndClass */ false
+ );
+
+ return group(
+ concat([
+ concat(parts),
+ group(
+ concat([
+ indent(
+ concat([
+ line,
+ shouldAddParens ? ifBreak("", "(") : "",
+ body,
+ shouldAddParens ? ifBreak("", ")") : ""
+ ])
+ ),
+ shouldAddSoftLine
+ ? concat([ifBreak(printTrailingComma ? "," : ""), softline])
+ : ""
+ ])
+ )
+ ])
+ );
+ }
+ case "MethodDefinition":
+ case "TSAbstractMethodDefinition":
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.static) {
+ parts.push("static ");
+ }
+ if (n.type === "TSAbstractMethodDefinition") {
+ parts.push("abstract ");
+ }
+
+ parts.push(printMethod(path$$1, options, print));
+
+ return concat(parts);
+ case "YieldExpression":
+ parts.push("yield");
+
+ if (n.delegate) {
+ parts.push("*");
+ }
+ if (n.argument) {
+ parts.push(" ", path$$1.call(print, "argument"));
+ }
+
+ return concat(parts);
+ case "AwaitExpression":
+ return concat(["await ", path$$1.call(print, "argument")]);
+ case "ImportSpecifier":
+ if (n.importKind) {
+ parts.push(path$$1.call(print, "importKind"), " ");
+ }
+
+ parts.push(path$$1.call(print, "imported"));
+
+ if (n.local && n.local.name !== n.imported.name) {
+ parts.push(" as ", path$$1.call(print, "local"));
+ }
+
+ return concat(parts);
+ case "ExportSpecifier":
+ parts.push(path$$1.call(print, "local"));
+
+ if (n.exported && n.exported.name !== n.local.name) {
+ parts.push(" as ", path$$1.call(print, "exported"));
+ }
+
+ return concat(parts);
+ case "ImportNamespaceSpecifier":
+ parts.push("* as ");
+
+ if (n.local) {
+ parts.push(path$$1.call(print, "local"));
+ } else if (n.id) {
+ parts.push(path$$1.call(print, "id"));
+ }
+
+ return concat(parts);
+ case "ImportDefaultSpecifier":
+ if (n.local) {
+ return path$$1.call(print, "local");
+ }
+
+ return path$$1.call(print, "id");
+ case "TSExportAssignment":
+ return concat(["export = ", path$$1.call(print, "expression"), semi]);
+ case "ExportDefaultDeclaration":
+ case "ExportNamedDeclaration":
+ return printExportDeclaration(path$$1, options, print);
+ case "ExportAllDeclaration":
+ parts.push("export ");
+
+ if (n.exportKind === "type") {
+ parts.push("type ");
+ }
+
+ parts.push("* from ", path$$1.call(print, "source"), semi);
+
+ return concat(parts);
+
+ case "ExportNamespaceSpecifier":
+ case "ExportDefaultSpecifier":
+ return path$$1.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$$1.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(", ", standalones));
+ }
+
+ if (standalones.length > 0 && grouped.length > 0) {
+ parts.push(", ");
+ }
+
+ if (
+ grouped.length === 1 &&
+ standalones.length === 0 &&
+ n.specifiers &&
+ !n.specifiers.some(node => node.comments)
+ ) {
+ parts.push(
+ concat([
+ "{",
+ options.bracketSpacing ? " " : "",
+ concat(grouped),
+ options.bracketSpacing ? " " : "",
+ "}"
+ ])
+ );
+ } else if (grouped.length >= 1) {
+ parts.push(
+ group(
+ concat([
+ "{",
+ indent(
+ concat([
+ options.bracketSpacing ? line : softline,
+ join(concat([",", line]), grouped)
+ ])
+ ),
+ ifBreak(shouldPrintComma(options) ? "," : ""),
+ options.bracketSpacing ? line : softline,
+ "}"
+ ])
+ )
+ );
+ }
+
+ parts.push(" from ");
+ } else if (
+ (n.importKind && n.importKind === "type") ||
+ // import {} from 'x'
+ /{\s*}/.test(
+ options.originalText.slice(
+ options.locStart(n),
+ options.locStart(n.source)
+ )
+ )
+ ) {
+ parts.push("{} from ");
+ }
+
+ parts.push(path$$1.call(print, "source"), semi);
+
+ return concat(parts);
+ }
+
+ case "Import":
+ return "import";
+ case "BlockStatement": {
+ const naked = path$$1.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$$1.getParentNode();
+ const parentParent = path$$1.getParentNode(1);
+ if (
+ !hasContent &&
+ !hasDirectives &&
+ !hasDanglingComments(n) &&
+ (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$$1.each(childPath => {
+ parts.push(indent(concat([hardline, print(childPath), semi])));
+ if (
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ childPath.getValue(),
+ options
+ )
+ ) {
+ parts.push(hardline);
+ }
+ }, "directives");
+ }
+
+ if (hasContent) {
+ parts.push(indent(concat([hardline, naked])));
+ }
+
+ parts.push(comments.printDanglingComments(path$$1, options));
+ parts.push(hardline, "}");
+
+ return concat(parts);
+ }
+ case "ReturnStatement":
+ parts.push("return");
+
+ if (n.argument) {
+ if (returnArgumentHasLeadingComment(options, n.argument)) {
+ parts.push(
+ concat([
+ " (",
+ indent(concat([hardline, path$$1.call(print, "argument")])),
+ hardline,
+ ")"
+ ])
+ );
+ } else if (
+ n.argument.type === "LogicalExpression" ||
+ n.argument.type === "BinaryExpression" ||
+ n.argument.type === "SequenceExpression"
+ ) {
+ parts.push(
+ group(
+ concat([
+ ifBreak(" (", " "),
+ indent(concat([softline, path$$1.call(print, "argument")])),
+ softline,
+ ifBreak(")")
+ ])
+ )
+ );
+ } else {
+ parts.push(" ", path$$1.call(print, "argument"));
+ }
+ }
+
+ if (hasDanglingComments(n)) {
+ parts.push(
+ " ",
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true)
+ );
+ }
+
+ parts.push(semi);
+
+ return concat(parts);
+ case "NewExpression":
+ case "CallExpression": {
+ const isNew = n.type === "NewExpression";
+
+ const optional = printOptionalToken(path$$1);
+ if (
+ // We want to keep CommonJS- and AMD-style require calls, and AMD-style
+ // define calls, as a unit.
+ // e.g. `define(["some/lib", (lib) => {`
+ (!isNew &&
+ n.callee.type === "Identifier" &&
+ (n.callee.name === "require" || n.callee.name === "define")) ||
+ n.callee.type === "Import" ||
+ // Template literals as single arguments
+ (n.arguments.length === 1 &&
+ isTemplateOnItsOwnLine(
+ n.arguments[0],
+ options.originalText,
+ options
+ )) ||
+ // Keep test declarations on a single line
+ // e.g. `it('long name', () => {`
+ (!isNew && isTestCall(n, path$$1.getParentNode()))
+ ) {
+ return concat([
+ isNew ? "new " : "",
+ path$$1.call(print, "callee"),
+ optional,
+ path$$1.call(print, "typeParameters"),
+ concat(["(", join(", ", path$$1.map(print, "arguments")), ")"])
+ ]);
+ }
+
+ // We detect calls on member lookups and possibly print them in a
+ // special chain format. See `printMemberChain` for more info.
+ if (!isNew && isMemberish(n.callee)) {
+ return printMemberChain(path$$1, options, print);
+ }
+
+ return concat([
+ isNew ? "new " : "",
+ path$$1.call(print, "callee"),
+ optional,
+ printFunctionTypeParameters(path$$1, options, print),
+ printArgumentsList(path$$1, options, print)
+ ]);
+ }
+ case "TSInterfaceDeclaration":
+ if (isNodeStartingWithDeclare(n, options)) {
+ parts.push("declare ");
+ }
+
+ parts.push(
+ n.abstract ? "abstract " : "",
+ printTypeScriptModifiers(path$$1, options, print),
+ "interface ",
+ path$$1.call(print, "id"),
+ n.typeParameters ? path$$1.call(print, "typeParameters") : "",
+ " "
+ );
+
+ if (n.heritage.length) {
+ parts.push(
+ group(
+ indent(
+ concat([
+ softline,
+ "extends ",
+ indent(join(concat([",", line]), path$$1.map(print, "heritage"))),
+ " "
+ ])
+ )
+ )
+ );
+ }
+
+ parts.push(path$$1.call(print, "body"));
+
+ return concat(parts);
+ case "ObjectExpression":
+ case "ObjectPattern":
+ case "ObjectTypeAnnotation":
+ case "TSInterfaceBody":
+ case "TSTypeLiteral": {
+ const isTypeAnnotation = n.type === "ObjectTypeAnnotation";
+ const parent = path$$1.getParentNode(0);
+ const shouldBreak =
+ n.type === "TSInterfaceBody" ||
+ (n.type === "ObjectPattern" &&
+ parent.type !== "FunctionDeclaration" &&
+ parent.type !== "FunctionExpression" &&
+ parent.type !== "ArrowFunctionExpression" &&
+ parent.type !== "AssignmentPattern" &&
+ n.properties.some(
+ property =>
+ property.value &&
+ (property.value.type === "ObjectPattern" ||
+ property.value.type === "ArrayPattern")
+ )) ||
+ (n.type !== "ObjectPattern" &&
+ util$1.hasNewlineInRange(
+ options.originalText,
+ options.locStart(n),
+ options.locEnd(n)
+ ));
+ const isFlowInterfaceLikeBody =
+ isTypeAnnotation &&
+ parent &&
+ (parent.type === "InterfaceDeclaration" ||
+ parent.type === "DeclareInterface" ||
+ parent.type === "DeclareClass") &&
+ path$$1.getName() === "body";
+ const separator = isFlowInterfaceLikeBody
+ ? ";"
+ : n.type === "TSInterfaceBody" || n.type === "TSTypeLiteral"
+ ? ifBreak(semi, ";")
+ : ",";
+ const fields = [];
+ const leftBrace = n.exact ? "{|" : "{";
+ const rightBrace = n.exact ? "|}" : "}";
+
+ 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$$1.each(childPath => {
+ const node = childPath.getValue();
+ propsAndLoc.push({
+ node: node,
+ printed: print(childPath),
+ loc: options.locStart(node)
+ });
+ }, field);
+ });
+
+ let separatorParts = [];
+ const props = propsAndLoc.sort((a, b) => a.loc - b.loc).map(prop => {
+ const result = concat(separatorParts.concat(group(prop.printed)));
+ separatorParts = [separator, line];
+ if (
+ prop.node.type === "TSPropertySignature" &&
+ util$1.hasNodeIgnoreComment(prop.node)
+ ) {
+ separatorParts.shift();
+ }
+ if (
+ utilShared.isNextLineEmpty(options.originalText, prop.node, options)
+ ) {
+ separatorParts.push(hardline);
+ }
+ return result;
+ });
+
+ const lastElem = util$1.getLast(n[propertiesField]);
+
+ const canHaveTrailingSeparator = !(
+ lastElem &&
+ (lastElem.type === "RestProperty" ||
+ lastElem.type === "RestElement" ||
+ lastElem.type === "ExperimentalRestProperty" ||
+ util$1.hasNodeIgnoreComment(lastElem))
+ );
+
+ let content;
+ if (props.length === 0 && !n.typeAnnotation) {
+ if (!hasDanglingComments(n)) {
+ return concat([leftBrace, rightBrace]);
+ }
+
+ content = group(
+ concat([
+ leftBrace,
+ comments.printDanglingComments(path$$1, options),
+ softline,
+ rightBrace,
+ printOptionalToken(path$$1)
+ ])
+ );
+ } else {
+ content = concat([
+ leftBrace,
+ indent(
+ concat([options.bracketSpacing ? line : softline, concat(props)])
+ ),
+ ifBreak(
+ canHaveTrailingSeparator &&
+ (separator !== "," || shouldPrintComma(options))
+ ? separator
+ : ""
+ ),
+ concat([options.bracketSpacing ? line : softline, rightBrace]),
+ printOptionalToken(path$$1),
+ printTypeAnnotation(path$$1, options, print)
+ ]);
+ }
+
+ // 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$$1.getParentNode(2);
+ if (
+ (n.type === "ObjectPattern" &&
+ parent &&
+ shouldHugArguments(parent) &&
+ parent.params[0] === n) ||
+ (shouldHugType(n) &&
+ parentParentParent &&
+ shouldHugArguments(parentParentParent) &&
+ parentParentParent.params[0].typeAnnotation &&
+ parentParentParent.params[0].typeAnnotation.typeAnnotation === n)
+ ) {
+ return content;
+ }
+
+ return group(content, { shouldBreak });
+ }
+ // Babel 6
+ case "ObjectProperty": // Non-standard AST node type.
+ case "Property":
+ if (n.method || n.kind === "get" || n.kind === "set") {
+ return printMethod(path$$1, options, print);
+ }
+
+ if (n.shorthand) {
+ parts.push(path$$1.call(print, "value"));
+ } else {
+ let printedLeft;
+ if (n.computed) {
+ printedLeft = concat(["[", path$$1.call(print, "key"), "]"]);
+ } else {
+ printedLeft = printPropertyKey(path$$1, options, print);
+ }
+ parts.push(
+ printAssignment(
+ n.key,
+ printedLeft,
+ ":",
+ n.value,
+ path$$1.call(print, "value"),
+ options
+ )
+ );
+ }
+
+ return concat(parts); // Babel 6
+ case "ClassMethod":
+ if (n.static) {
+ parts.push("static ");
+ }
+
+ parts = parts.concat(printObjectMethod(path$$1, options, print));
+
+ return concat(parts); // Babel 6
+ case "ObjectMethod":
+ return printObjectMethod(path$$1, options, print);
+ case "Decorator":
+ return concat(["@", path$$1.call(print, "expression")]);
+ case "ArrayExpression":
+ case "ArrayPattern":
+ if (n.elements.length === 0) {
+ if (!hasDanglingComments(n)) {
+ parts.push("[]");
+ } else {
+ parts.push(
+ group(
+ concat([
+ "[",
+ comments.printDanglingComments(path$$1, options),
+ softline,
+ "]"
+ ])
+ )
+ );
+ }
+ } else {
+ const lastElem = util$1.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 privateUtil.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(
+ concat([
+ "[",
+ indent(
+ concat([
+ softline,
+ printArrayItems(path$$1, options, "elements", print)
+ ])
+ ),
+ needsForcedTrailingComma ? "," : "",
+ ifBreak(
+ canHaveTrailingComma &&
+ !needsForcedTrailingComma &&
+ shouldPrintComma(options)
+ ? ","
+ : ""
+ ),
+ comments.printDanglingComments(
+ path$$1,
+ options,
+ /* sameIndent */ true
+ ),
+ softline,
+ "]"
+ ])
+ )
+ );
+ }
+
+ parts.push(
+ printOptionalToken(path$$1),
+ printTypeAnnotation(path$$1, options, print)
+ );
+
+ return concat(parts);
+ case "SequenceExpression": {
+ const parent = path$$1.getParentNode(0);
+ if (
+ parent.type === "ExpressionStatement" ||
+ parent.type === "ForStatement"
+ ) {
+ // For ExpressionStatements and for-loop heads, which are among
+ // the few places a SequenceExpression appears unparenthesized, we want
+ // to indent expressions after the first.
+ const parts = [];
+ path$$1.each(p => {
+ if (p.getName() === 0) {
+ parts.push(print(p));
+ } else {
+ parts.push(",", indent(concat([line, print(p)])));
+ }
+ }, "expressions");
+ return group(concat(parts));
+ }
+ return group(
+ concat([join(concat([",", line]), path$$1.map(print, "expressions"))])
+ );
+ }
+ 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 util$1.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 util$1.printNumber(n.raw);
+ }
+ if (typeof n.value !== "string") {
+ return "" + n.value;
+ }
+ // TypeScript workaround for eslint/typescript-eslint-parser#267
+ // See corresponding workaround in needs-parens.js
+ const grandParent = path$$1.getParentNode(1);
+ const isTypeScriptDirective =
+ options.parser === "typescript" &&
+ typeof n.value === "string" &&
+ grandParent &&
+ (grandParent.type === "Program" ||
+ grandParent.type === "BlockStatement");
+
+ return nodeStr(n, options, isTypeScriptDirective);
+ }
+ case "Directive":
+ return path$$1.call(print, "value"); // Babel 6
+ case "DirectiveLiteral":
+ return nodeStr(n, options);
+ case "UnaryExpression":
+ parts.push(n.operator);
+
+ if (/[a-z]$/.test(n.operator)) {
+ parts.push(" ");
+ }
+
+ parts.push(path$$1.call(print, "argument"));
+
+ return concat(parts);
+ case "UpdateExpression":
+ parts.push(path$$1.call(print, "argument"), n.operator);
+
+ if (n.prefix) {
+ parts.reverse();
+ }
+
+ return concat(parts);
+ case "ConditionalExpression":
+ return formatTernaryOperator(path$$1, options, print, {
+ beforeParts: () => [path$$1.call(print, "test")],
+ afterParts: breakClosingParen => [breakClosingParen ? softline : ""]
+ });
+ case "VariableDeclaration": {
+ const printed = path$$1.map(childPath => {
+ return print(childPath);
+ }, "declarations");
+
+ // We generally want to terminate all variable declarations with a
+ // semicolon, except when they in the () part of for loops.
+ const parentNode = path$$1.getParentNode();
+
+ const isParentForLoop =
+ parentNode.type === "ForStatement" ||
+ parentNode.type === "ForInStatement" ||
+ parentNode.type === "ForOfStatement" ||
+ parentNode.type === "ForAwaitStatement";
+
+ const hasValue = n.declarations.some(decl => decl.init);
+
+ let firstVariable;
+ if (printed.length === 1) {
+ firstVariable = printed[0];
+ } else if (printed.length > 1) {
+ // Indent first var to comply with eslint one-var rule
+ firstVariable = indent(printed[0]);
+ }
+
+ parts = [
+ isNodeStartingWithDeclare(n, options) ? "declare " : "",
+ n.kind,
+ firstVariable ? concat([" ", firstVariable]) : "",
+ indent(
+ concat(
+ printed
+ .slice(1)
+ .map(p =>
+ concat([",", hasValue && !isParentForLoop ? hardline : line, p])
+ )
+ )
+ )
+ ];
+
+ if (!(isParentForLoop && parentNode.body !== n)) {
+ parts.push(semi);
+ }
+
+ return group(concat(parts));
+ }
+ case "VariableDeclarator":
+ return printAssignment(
+ n.id,
+ concat([path$$1.call(print, "id"), path$$1.call(print, "typeParameters")]),
+ " =",
+ n.init,
+ n.init && path$$1.call(print, "init"),
+ options
+ );
+ case "WithStatement":
+ return group(
+ concat([
+ "with (",
+ path$$1.call(print, "object"),
+ ")",
+ adjustClause(n.body, path$$1.call(print, "body"))
+ ])
+ );
+ case "IfStatement": {
+ const con = adjustClause(n.consequent, path$$1.call(print, "consequent"));
+ const opening = group(
+ concat([
+ "if (",
+ group(
+ concat([
+ indent(concat([softline, path$$1.call(print, "test")])),
+ softline
+ ])
+ ),
+ ")",
+ con
+ ])
+ );
+
+ parts.push(opening);
+
+ if (n.alternate) {
+ const commentOnOwnLine =
+ (hasTrailingComment(n.consequent) &&
+ n.consequent.comments.some(
+ comment =>
+ comment.trailing && !util$1.isBlockComment(comment)
+ )) ||
+ needsHardlineAfterDanglingComment(n);
+ const elseOnSameLine =
+ n.consequent.type === "BlockStatement" && !commentOnOwnLine;
+ parts.push(elseOnSameLine ? " " : hardline);
+
+ if (hasDanglingComments(n)) {
+ parts.push(
+ comments.printDanglingComments(path$$1, options, true),
+ commentOnOwnLine ? hardline : " "
+ );
+ }
+
+ parts.push(
+ "else",
+ group(
+ adjustClause(
+ n.alternate,
+ path$$1.call(print, "alternate"),
+ n.alternate.type === "IfStatement"
+ )
+ )
+ );
+ }
+
+ return concat(parts);
+ }
+ case "ForStatement": {
+ const body = adjustClause(n.body, path$$1.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.printDanglingComments(
+ path$$1,
+ options,
+ /* sameLine */ true
+ );
+ const printedComments = dangling ? concat([dangling, softline]) : "";
+
+ if (!n.init && !n.test && !n.update) {
+ return concat([printedComments, group(concat(["for (;;)", body]))]);
+ }
+
+ return concat([
+ printedComments,
+ group(
+ concat([
+ "for (",
+ group(
+ concat([
+ indent(
+ concat([
+ softline,
+ path$$1.call(print, "init"),
+ ";",
+ line,
+ path$$1.call(print, "test"),
+ ";",
+ line,
+ path$$1.call(print, "update")
+ ])
+ ),
+ softline
+ ])
+ ),
+ ")",
+ body
+ ])
+ )
+ ]);
+ }
+ case "WhileStatement":
+ return group(
+ concat([
+ "while (",
+ group(
+ concat([
+ indent(concat([softline, path$$1.call(print, "test")])),
+ softline
+ ])
+ ),
+ ")",
+ adjustClause(n.body, path$$1.call(print, "body"))
+ ])
+ );
+ case "ForInStatement":
+ // Note: esprima can't actually parse "for each (".
+ return group(
+ concat([
+ n.each ? "for each (" : "for (",
+ path$$1.call(print, "left"),
+ " in ",
+ path$$1.call(print, "right"),
+ ")",
+ adjustClause(n.body, path$$1.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(
+ concat([
+ "for",
+ isAwait ? " await" : "",
+ " (",
+ path$$1.call(print, "left"),
+ " of ",
+ path$$1.call(print, "right"),
+ ")",
+ adjustClause(n.body, path$$1.call(print, "body"))
+ ])
+ );
+ }
+
+ case "DoWhileStatement": {
+ const clause = adjustClause(n.body, path$$1.call(print, "body"));
+ const doBody = group(concat(["do", clause]));
+ parts = [doBody];
+
+ if (n.body.type === "BlockStatement") {
+ parts.push(" ");
+ } else {
+ parts.push(hardline);
+ }
+ parts.push("while (");
+
+ parts.push(
+ group(
+ concat([
+ indent(concat([softline, path$$1.call(print, "test")])),
+ softline
+ ])
+ ),
+ ")",
+ semi
+ );
+
+ return concat(parts);
+ }
+ case "DoExpression":
+ return concat(["do ", path$$1.call(print, "body")]);
+ case "BreakStatement":
+ parts.push("break");
+
+ if (n.label) {
+ parts.push(" ", path$$1.call(print, "label"));
+ }
+
+ parts.push(semi);
+
+ return concat(parts);
+ case "ContinueStatement":
+ parts.push("continue");
+
+ if (n.label) {
+ parts.push(" ", path$$1.call(print, "label"));
+ }
+
+ parts.push(semi);
+
+ return concat(parts);
+ case "LabeledStatement":
+ if (n.body.type === "EmptyStatement") {
+ return concat([path$$1.call(print, "label"), ":;"]);
+ }
+
+ return concat([
+ path$$1.call(print, "label"),
+ ": ",
+ path$$1.call(print, "body")
+ ]);
+ case "TryStatement":
+ return concat([
+ "try ",
+ path$$1.call(print, "block"),
+ n.handler ? concat([" ", path$$1.call(print, "handler")]) : "",
+ n.finalizer ? concat([" finally ", path$$1.call(print, "finalizer")]) : ""
+ ]);
+ case "CatchClause":
+ return concat([
+ "catch ",
+ n.param ? concat(["(", path$$1.call(print, "param"), ") "]) : "",
+ path$$1.call(print, "body")
+ ]);
+ case "ThrowStatement":
+ return concat(["throw ", path$$1.call(print, "argument"), semi]);
+ // Note: ignoring n.lexical because it has no printing consequences.
+ case "SwitchStatement":
+ return concat([
+ group(
+ concat([
+ "switch (",
+ indent(concat([softline, path$$1.call(print, "discriminant")])),
+ softline,
+ ")"
+ ])
+ ),
+ " {",
+ n.cases.length > 0
+ ? indent(
+ concat([
+ hardline,
+ join(
+ hardline,
+ path$$1.map(casePath => {
+ const caseNode = casePath.getValue();
+ return concat([
+ casePath.call(print),
+ n.cases.indexOf(caseNode) !== n.cases.length - 1 &&
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ caseNode,
+ options
+ )
+ ? hardline
+ : ""
+ ]);
+ }, "cases")
+ )
+ ])
+ )
+ : "",
+ hardline,
+ "}"
+ ]);
+ case "SwitchCase": {
+ if (n.test) {
+ parts.push("case ", path$$1.call(print, "test"), ":");
+ } else {
+ parts.push("default:");
+ }
+
+ const consequent = n.consequent.filter(
+ node => node.type !== "EmptyStatement"
+ );
+
+ if (consequent.length > 0) {
+ const cons = path$$1.call(consequentPath => {
+ return printStatementSequence(consequentPath, options, print);
+ }, "consequent");
+
+ parts.push(
+ consequent.length === 1 && consequent[0].type === "BlockStatement"
+ ? concat([" ", cons])
+ : indent(concat([hardline, cons]))
+ );
+ }
+
+ return concat(parts);
+ }
+ // JSX extensions below.
+ case "DebuggerStatement":
+ return concat(["debugger", semi]);
+ case "JSXAttribute":
+ parts.push(path$$1.call(print, "name"));
+
+ if (n.value) {
+ let res;
+ if (isStringLiteral(n.value)) {
+ const value = rawText(n.value);
+ res = '"' + value.slice(1, -1).replace(/"/g, """) + '"';
+ } else {
+ res = path$$1.call(print, "value");
+ }
+ parts.push("=", res);
+ }
+
+ return concat(parts);
+ case "JSXIdentifier":
+ // Can be removed when this is fixed:
+ // https://github.com/eslint/typescript-eslint-parser/issues/337
+ if (!n.name) {
+ return "this";
+ }
+ return "" + n.name;
+ case "JSXNamespacedName":
+ return join(":", [
+ path$$1.call(print, "namespace"),
+ path$$1.call(print, "name")
+ ]);
+ case "JSXMemberExpression":
+ return join(".", [
+ path$$1.call(print, "object"),
+ path$$1.call(print, "property")
+ ]);
+ case "TSQualifiedName":
+ return join(".", [path$$1.call(print, "left"), path$$1.call(print, "right")]);
+ case "JSXSpreadAttribute":
+ case "JSXSpreadChild": {
+ return concat([
+ "{",
+ path$$1.call(p => {
+ const printed = concat(["...", print(p)]);
+ const n = p.getValue();
+ if (!n.comments || !n.comments.length) {
+ return printed;
+ }
+ return concat([
+ indent(
+ concat([
+ softline,
+ comments.printComments(p, () => printed, options)
+ ])
+ ),
+ softline
+ ]);
+ }, n.type === "JSXSpreadAttribute" ? "argument" : "expression"),
+ "}"
+ ]);
+ }
+ case "JSXExpressionContainer": {
+ const parent = path$$1.getParentNode(0);
+
+ const preventInline =
+ parent.type === "JSXAttribute" &&
+ n.expression.comments &&
+ n.expression.comments.length > 0;
+
+ const shouldInline =
+ !preventInline &&
+ (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" ||
+ n.expression.type === "DoExpression" ||
+ (isJSXNode(parent) &&
+ (n.expression.type === "ConditionalExpression" ||
+ isBinaryish(n.expression))));
+
+ if (shouldInline) {
+ return group(
+ concat(["{", path$$1.call(print, "expression"), lineSuffixBoundary, "}"])
+ );
+ }
+
+ return group(
+ concat([
+ "{",
+ indent(concat([softline, path$$1.call(print, "expression")])),
+ softline,
+ lineSuffixBoundary,
+ "}"
+ ])
+ );
+ }
+ case "JSXFragment":
+ case "TSJsxFragment":
+ case "JSXElement": {
+ const elem = comments.printComments(
+ path$$1,
+ () => printJSXElement(path$$1, options, print),
+ options
+ );
+ return maybeWrapJSXElementInParens(path$$1, elem);
+ }
+ case "JSXOpeningElement": {
+ const n = path$$1.getValue();
+
+ const nameHasComments =
+ n.name && n.name.comments && n.name.comments.length > 0;
+
+ // Don't break self-closing elements with no attributes and no comments
+ if (n.selfClosing && !n.attributes.length && !nameHasComments) {
+ return concat(["<", path$$1.call(print, "name"), " />"]);
+ }
+
+ // don't break up opening elements with a single long text attribute
+ if (
+ n.attributes &&
+ n.attributes.length === 1 &&
+ n.attributes[0].value &&
+ isStringLiteral(n.attributes[0].value) &&
+ !n.attributes[0].value.value.includes("\n") &&
+ // We should break for the following cases:
+ //
+ //
+ !nameHasComments &&
+ (!n.attributes[0].comments || !n.attributes[0].comments.length)
+ ) {
+ return group(
+ concat([
+ "<",
+ path$$1.call(print, "name"),
+ " ",
+ concat(path$$1.map(print, "attributes")),
+ n.selfClosing ? " />" : ">"
+ ])
+ );
+ }
+
+ const lastAttrHasTrailingComments =
+ n.attributes.length &&
+ hasTrailingComment(util$1.getLast(n.attributes));
+
+ const bracketSameLine =
+ options.jsxBracketSameLine &&
+ // We should print the bracket in a new line for the following cases:
+ //
+ //
+ (!nameHasComments || n.attributes.length) &&
+ !lastAttrHasTrailingComments;
+
+ // We should print the opening element expanded if any prop value is a
+ // string literal with newlines
+ const shouldBreak =
+ n.attributes &&
+ n.attributes.some(
+ attr =>
+ attr.value &&
+ isStringLiteral(attr.value) &&
+ attr.value.value.includes("\n")
+ );
+
+ return group(
+ concat([
+ "<",
+ path$$1.call(print, "name"),
+ concat([
+ indent(
+ concat(
+ path$$1.map(attr => concat([line, print(attr)]), "attributes")
+ )
+ ),
+ n.selfClosing ? line : bracketSameLine ? ">" : softline
+ ]),
+ n.selfClosing ? "/>" : bracketSameLine ? "" : ">"
+ ]),
+ { shouldBreak }
+ );
+ }
+ case "JSXClosingElement":
+ return concat([""]);
+ case "JSXOpeningFragment":
+ case "JSXClosingFragment":
+ case "TSJsxOpeningFragment":
+ case "TSJsxClosingFragment": {
+ const hasComment = n.comments && n.comments.length;
+ const hasOwnLineComment =
+ hasComment && !n.comments.every(util$1.isBlockComment);
+ const isOpeningFragment =
+ n.type === "JSXOpeningFragment" || n.type === "TSJsxOpeningFragment";
+ return concat([
+ isOpeningFragment ? "<" : ""
+ ]);
+ }
+ case "JSXText":
+ /* istanbul ignore next */
+ throw new Error("JSXTest should be handled by JSXElement");
+ case "JSXEmptyExpression": {
+ const requiresHardline =
+ n.comments && !n.comments.every(util$1.isBlockComment);
+
+ return concat([
+ comments.printDanglingComments(
+ path$$1,
+ options,
+ /* sameIndent */ !requiresHardline
+ ),
+ requiresHardline ? hardline : ""
+ ]);
+ }
+ case "ClassBody":
+ if (!n.comments && n.body.length === 0) {
+ return "{}";
+ }
+
+ return concat([
+ "{",
+ n.body.length > 0
+ ? indent(
+ concat([
+ hardline,
+ path$$1.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body")
+ ])
+ )
+ : comments.printDanglingComments(path$$1, options),
+ hardline,
+ "}"
+ ]);
+ case "ClassProperty":
+ case "TSAbstractClassProperty":
+ case "ClassPrivateProperty": {
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.static) {
+ parts.push("static ");
+ }
+ if (n.type === "TSAbstractClassProperty") {
+ parts.push("abstract ");
+ }
+ if (n.readonly) {
+ parts.push("readonly ");
+ }
+ const variance = getFlowVariance(n);
+ if (variance) {
+ parts.push(variance);
+ }
+ if (n.computed) {
+ parts.push("[", path$$1.call(print, "key"), "]");
+ } else {
+ parts.push(printPropertyKey(path$$1, options, print));
+ }
+ parts.push(printTypeAnnotation(path$$1, options, print));
+ if (n.value) {
+ parts.push(
+ " =",
+ printAssignmentRight(
+ n.value,
+ path$$1.call(print, "value"),
+ false, // canBreak
+ options
+ )
+ );
+ }
+
+ parts.push(semi);
+
+ return concat(parts);
+ }
+ case "ClassDeclaration":
+ case "ClassExpression":
+ case "TSAbstractClassDeclaration":
+ if (isNodeStartingWithDeclare(n, options)) {
+ parts.push("declare ");
+ }
+ parts.push(concat(printClass(path$$1, options, print)));
+ return concat(parts);
+ case "TSInterfaceHeritage":
+ parts.push(path$$1.call(print, "id"));
+
+ if (n.typeParameters) {
+ parts.push(path$$1.call(print, "typeParameters"));
+ }
+
+ return concat(parts);
+ case "TemplateElement":
+ return join(literalline, n.value.raw.split(/\r?\n/g));
+ case "TemplateLiteral": {
+ const expressions = path$$1.map(print, "expressions");
+
+ parts.push("`");
+
+ path$$1.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 `.
+ const tabWidth = options.tabWidth;
+ const indentSize = util$1.getIndentSize(
+ childPath.getValue().value.raw,
+ tabWidth
+ );
+
+ let printed = expressions[i];
+
+ if (
+ (n.expressions[i].comments && n.expressions[i].comments.length) ||
+ n.expressions[i].type === "MemberExpression" ||
+ n.expressions[i].type === "ConditionalExpression"
+ ) {
+ printed = concat([indent(concat([softline, printed])), softline]);
+ }
+
+ const aligned = addAlignmentToDoc(printed, indentSize, tabWidth);
+
+ parts.push(group(concat(["${", aligned, lineSuffixBoundary, "}"])));
+ }
+ }, "quasis");
+
+ parts.push("`");
+
+ return concat(parts);
+ }
+ // These types are unprintable because they serve as abstract
+ // supertypes for other (printable) types.
+ case "TaggedTemplateExpression":
+ return concat([path$$1.call(print, "tag"), path$$1.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":
+ /* istanbul ignore next */
+ throw new Error("unprintable type: " + JSON.stringify(n.type));
+ // Type Annotations for Facebook Flow, typically stripped out or
+ // transformed away before printing.
+ case "TypeAnnotation":
+ case "TSTypeAnnotation":
+ if (n.typeAnnotation) {
+ return path$$1.call(print, "typeAnnotation");
+ }
+
+ /* istanbul ignore next */
+ return "";
+ case "TSTupleType":
+ case "TupleTypeAnnotation": {
+ const typesField = n.type === "TSTupleType" ? "elementTypes" : "types";
+ return group(
+ concat([
+ "[",
+ indent(
+ concat([
+ softline,
+ printArrayItems(path$$1, options, typesField, print)
+ ])
+ ),
+ // TypeScript doesn't support trailing commas in tuple types
+ n.type === "TSTupleType"
+ ? ""
+ : ifBreak(shouldPrintComma(options) ? "," : ""),
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true),
+ softline,
+ "]"
+ ])
+ );
+ }
+
+ case "ExistsTypeAnnotation":
+ return "*";
+ case "EmptyTypeAnnotation":
+ return "empty";
+ case "AnyTypeAnnotation":
+ return "any";
+ case "MixedTypeAnnotation":
+ return "mixed";
+ case "ArrayTypeAnnotation":
+ return concat([path$$1.call(print, "elementType"), "[]"]);
+ case "BooleanTypeAnnotation":
+ return "boolean";
+ case "BooleanLiteralTypeAnnotation":
+ return "" + n.value;
+ case "DeclareClass":
+ return printFlowDeclaration(path$$1, printClass(path$$1, options, print));
+ case "DeclareFunction":
+ // For TypeScript the DeclareFunction node shares the AST
+ // structure with FunctionDeclaration
+ if (n.params) {
+ return concat([
+ "declare ",
+ printFunctionDeclaration(path$$1, print, options),
+ semi
+ ]);
+ }
+ return printFlowDeclaration(path$$1, [
+ "function ",
+ path$$1.call(print, "id"),
+ n.predicate ? " " : "",
+ path$$1.call(print, "predicate"),
+ semi
+ ]);
+ case "DeclareModule":
+ return printFlowDeclaration(path$$1, [
+ "module ",
+ path$$1.call(print, "id"),
+ " ",
+ path$$1.call(print, "body")
+ ]);
+ case "DeclareModuleExports":
+ return printFlowDeclaration(path$$1, [
+ "module.exports",
+ ": ",
+ path$$1.call(print, "typeAnnotation"),
+ semi
+ ]);
+ case "DeclareVariable":
+ return printFlowDeclaration(path$$1, ["var ", path$$1.call(print, "id"), semi]);
+ case "DeclareExportAllDeclaration":
+ return concat(["declare export * from ", path$$1.call(print, "source")]);
+ case "DeclareExportDeclaration":
+ return concat(["declare ", printExportDeclaration(path$$1, options, print)]);
+ case "DeclareOpaqueType":
+ case "OpaqueType": {
+ parts.push(
+ "opaque type ",
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters")
+ );
+
+ if (n.supertype) {
+ parts.push(": ", path$$1.call(print, "supertype"));
+ }
+
+ if (n.impltype) {
+ parts.push(" = ", path$$1.call(print, "impltype"));
+ }
+
+ parts.push(semi);
+
+ if (n.type === "DeclareOpaqueType") {
+ return printFlowDeclaration(path$$1, parts);
+ }
+
+ return concat(parts);
+ }
+
+ case "FunctionTypeAnnotation":
+ case "TSFunctionType": {
+ // FunctionTypeAnnotation is ambiguous:
+ // declare function foo(a: B): void; OR
+ // var A: (a: B) => void;
+ const parent = path$$1.getParentNode(0);
+ const parentParent = path$$1.getParentNode(1);
+ const parentParentParent = path$$1.getParentNode(2);
+ let isArrowFunctionTypeAnnotation =
+ n.type === "TSFunctionType" ||
+ !(
+ (parent.type === "ObjectTypeProperty" &&
+ !getFlowVariance(parent) &&
+ !parent.optional &&
+ options.locStart(parent) === options.locStart(n)) ||
+ parent.type === "ObjectTypeCallProperty" ||
+ (parentParentParent && parentParentParent.type === "DeclareFunction")
+ );
+
+ let needsColon =
+ isArrowFunctionTypeAnnotation &&
+ (parent.type === "TypeAnnotation" ||
+ parent.type === "TSTypeAnnotation");
+
+ // 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" ||
+ parent.type === "TSTypeAnnotation") &&
+ parentParent.type === "ArrowFunctionExpression";
+
+ if (isObjectTypePropertyAFunction(parent, options)) {
+ isArrowFunctionTypeAnnotation = true;
+ needsColon = true;
+ }
+
+ if (needsParens) {
+ parts.push("(");
+ }
+
+ parts.push(
+ printFunctionParams(
+ path$$1,
+ print,
+ options,
+ /* expandArg */ false,
+ /* printTypeParams */ true
+ )
+ );
+
+ // 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$$1.call(print, "returnType"),
+ path$$1.call(print, "predicate"),
+ path$$1.call(print, "typeAnnotation")
+ );
+ }
+ if (needsParens) {
+ parts.push(")");
+ }
+
+ return group(concat(parts));
+ }
+ case "FunctionTypeParam":
+ return concat([
+ path$$1.call(print, "name"),
+ printOptionalToken(path$$1),
+ n.name ? ": " : "",
+ path$$1.call(print, "typeAnnotation")
+ ]);
+ case "GenericTypeAnnotation":
+ return concat([
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters")
+ ]);
+ case "DeclareInterface":
+ case "InterfaceDeclaration": {
+ if (
+ n.type === "DeclareInterface" ||
+ isNodeStartingWithDeclare(n, options)
+ ) {
+ parts.push("declare ");
+ }
+
+ parts.push(
+ "interface ",
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters")
+ );
+
+ if (n["extends"].length > 0) {
+ parts.push(
+ group(
+ indent(
+ concat([line, "extends ", join(", ", path$$1.map(print, "extends"))])
+ )
+ )
+ );
+ }
+
+ parts.push(" ");
+ parts.push(path$$1.call(print, "body"));
+
+ return group(concat(parts));
+ }
+ case "ClassImplements":
+ case "InterfaceExtends":
+ return concat([
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters")
+ ]);
+ case "TSIntersectionType":
+ case "IntersectionTypeAnnotation": {
+ const types = path$$1.map(print, "types");
+ const result = [];
+ let wasIndented = false;
+ for (let i = 0; i < types.length; ++i) {
+ if (i === 0) {
+ result.push(types[i]);
+ } else if (isObjectType(n.types[i - 1]) && isObjectType(n.types[i])) {
+ // If both are objects, don't indent
+ result.push(
+ concat([" & ", wasIndented ? indent(types[i]) : types[i]])
+ );
+ } else if (!isObjectType(n.types[i - 1]) && !isObjectType(n.types[i])) {
+ // If no object is involved, go to the next line if it breaks
+ result.push(indent(concat([" &", line, types[i]])));
+ } else {
+ // If you go from object to non-object or vis-versa, then inline it
+ if (i > 1) {
+ wasIndented = true;
+ }
+ result.push(" & ", i > 1 ? indent(types[i]) : types[i]);
+ }
+ }
+ return group(concat(result));
+ }
+ case "TSUnionType":
+ case "UnionTypeAnnotation": {
+ // single-line variation
+ // A | B | C
+
+ // multi-line variation
+ // | A
+ // | B
+ // | C
+
+ const parent = path$$1.getParentNode();
+
+ // If there's a leading comment, the parent is doing the indentation
+ const shouldIndent =
+ parent.type !== "TypeParameterInstantiation" &&
+ parent.type !== "TSTypeParameterInstantiation" &&
+ parent.type !== "GenericTypeAnnotation" &&
+ parent.type !== "TSTypeReference" &&
+ !(parent.type === "FunctionTypeParam" && !parent.name) &&
+ !(
+ (parent.type === "TypeAlias" ||
+ parent.type === "VariableDeclarator") &&
+ hasLeadingOwnLineComment(options.originalText, n, options)
+ );
+
+ // {
+ // 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$$1.map(typePath => {
+ let printedType = typePath.call(print);
+ if (!shouldHug) {
+ printedType = align(2, printedType);
+ }
+ return comments.printComments(typePath, () => printedType, options);
+ }, "types");
+
+ if (shouldHug) {
+ return join(" | ", printed);
+ }
+
+ const code = concat([
+ ifBreak(concat([shouldIndent ? line : "", "| "])),
+ join(concat([line, "| "]), printed)
+ ]);
+
+ let hasParens;
+
+ if (n.type === "TSUnionType") {
+ const greatGrandParent = path$$1.getParentNode(2);
+ const greatGreatGrandParent = path$$1.getParentNode(3);
+
+ hasParens =
+ greatGrandParent &&
+ greatGrandParent.type === "TSParenthesizedType" &&
+ greatGreatGrandParent &&
+ (greatGreatGrandParent.type === "TSUnionType" ||
+ greatGreatGrandParent.type === "TSIntersectionType");
+ } else {
+ hasParens = needsParens_1(path$$1, options);
+ }
+
+ if (hasParens) {
+ return group(concat([indent(code), softline]));
+ }
+
+ return group(shouldIndent ? indent(code) : code);
+ }
+ case "NullableTypeAnnotation":
+ return concat(["?", path$$1.call(print, "typeAnnotation")]);
+ case "TSNullKeyword":
+ case "NullLiteralTypeAnnotation":
+ return "null";
+ case "ThisTypeAnnotation":
+ return "this";
+ case "NumberTypeAnnotation":
+ return "number";
+ case "ObjectTypeCallProperty":
+ if (n.static) {
+ parts.push("static ");
+ }
+
+ parts.push(path$$1.call(print, "value"));
+
+ return concat(parts);
+ case "ObjectTypeIndexer": {
+ const variance = getFlowVariance(n);
+ return concat([
+ variance || "",
+ "[",
+ path$$1.call(print, "id"),
+ n.id ? ": " : "",
+ path$$1.call(print, "key"),
+ "]: ",
+ path$$1.call(print, "value")
+ ]);
+ }
+ case "ObjectTypeProperty": {
+ const variance = getFlowVariance(n);
+
+ return concat([
+ n.static ? "static " : "",
+ isGetterOrSetter(n) ? n.kind + " " : "",
+ variance || "",
+ printPropertyKey(path$$1, options, print),
+ printOptionalToken(path$$1),
+ isFunctionNotation(n, options) ? "" : ": ",
+ path$$1.call(print, "value")
+ ]);
+ }
+ case "QualifiedTypeIdentifier":
+ return concat([
+ path$$1.call(print, "qualification"),
+ ".",
+ path$$1.call(print, "id")
+ ]);
+ case "StringLiteralTypeAnnotation":
+ return nodeStr(n, options);
+ case "NumberLiteralTypeAnnotation":
+ assert.strictEqual(typeof n.value, "number");
+
+ if (n.extra != null) {
+ return util$1.printNumber(n.extra.raw);
+ }
+ return util$1.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$$1.call(print, "right"),
+ canBreak,
+ options
+ );
+
+ parts.push(
+ "type ",
+ path$$1.call(print, "id"),
+ path$$1.call(print, "typeParameters"),
+ " =",
+ printed,
+ semi
+ );
+
+ return group(concat(parts));
+ }
+ case "TypeCastExpression":
+ return concat([
+ "(",
+ path$$1.call(print, "expression"),
+ ": ",
+ path$$1.call(print, "typeAnnotation"),
+ ")"
+ ]);
+ case "TypeParameterDeclaration":
+ case "TypeParameterInstantiation":
+ case "TSTypeParameterDeclaration":
+ case "TSTypeParameterInstantiation":
+ return printTypeParameters(path$$1, options, print, "params");
+
+ case "TSTypeParameter":
+ case "TypeParameter": {
+ const parent = path$$1.getParentNode();
+ if (parent.type === "TSMappedType") {
+ parts.push(path$$1.call(print, "name"));
+ if (n.constraint) {
+ parts.push(" in ", path$$1.call(print, "constraint"));
+ }
+ return concat(parts);
+ }
+
+ const variance = getFlowVariance(n);
+
+ if (variance) {
+ parts.push(variance);
+ }
+
+ parts.push(path$$1.call(print, "name"));
+
+ if (n.bound) {
+ parts.push(": ");
+ parts.push(path$$1.call(print, "bound"));
+ }
+
+ if (n.constraint) {
+ parts.push(" extends ", path$$1.call(print, "constraint"));
+ }
+
+ if (n["default"]) {
+ parts.push(" = ", path$$1.call(print, "default"));
+ }
+
+ return concat(parts);
+ }
+ case "TypeofTypeAnnotation":
+ return concat(["typeof ", path$$1.call(print, "argument")]);
+ case "VoidTypeAnnotation":
+ return "void";
+ 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(["%checks(", path$$1.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([
+ path$$1.call(print, "expression"),
+ " as ",
+ path$$1.call(print, "typeAnnotation")
+ ]);
+ case "TSArrayType":
+ return concat([path$$1.call(print, "elementType"), "[]"]);
+ case "TSPropertySignature": {
+ if (n.export) {
+ parts.push("export ");
+ }
+ if (n.accessibility) {
+ parts.push(n.accessibility + " ");
+ }
+ if (n.static) {
+ parts.push("static ");
+ }
+ if (n.readonly) {
+ parts.push("readonly ");
+ }
+ if (n.computed) {
+ parts.push("[");
+ }
+
+ parts.push(printPropertyKey(path$$1, options, print));
+
+ if (n.computed) {
+ parts.push("]");
+ }
+
+ parts.push(printOptionalToken(path$$1));
+
+ if (n.typeAnnotation) {
+ parts.push(": ");
+ parts.push(path$$1.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$$1.call(print, "initializer"));
+ }
+
+ return concat(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$$1.call(print, "parameter"));
+
+ return concat(parts);
+ case "TSTypeReference":
+ return concat([
+ path$$1.call(print, "typeName"),
+ printTypeParameters(path$$1, options, print, "typeParameters")
+ ]);
+ case "TSTypeQuery":
+ return concat(["typeof ", path$$1.call(print, "exprName")]);
+ case "TSParenthesizedType": {
+ return path$$1.call(print, "typeAnnotation");
+ }
+ case "TSIndexSignature": {
+ const parent = path$$1.getParentNode();
+
+ return concat([
+ n.export ? "export " : "",
+ n.accessibility ? concat([n.accessibility, " "]) : "",
+ n.static ? "static " : "",
+ n.readonly ? "readonly " : "",
+ "[",
+ path$$1.call(print, "index"),
+ "]: ",
+ path$$1.call(print, "typeAnnotation"),
+ parent.type === "ClassBody" ? semi : ""
+ ]);
+ }
+ case "TSTypePredicate":
+ return concat([
+ path$$1.call(print, "parameterName"),
+ " is ",
+ path$$1.call(print, "typeAnnotation")
+ ]);
+ case "TSNonNullExpression":
+ return concat([path$$1.call(print, "expression"), "!"]);
+ case "TSThisType":
+ return "this";
+ case "TSLastTypeNode":
+ return path$$1.call(print, "literal");
+ case "TSIndexedAccessType":
+ return concat([
+ path$$1.call(print, "objectType"),
+ "[",
+ path$$1.call(print, "indexType"),
+ "]"
+ ]);
+ case "TSConstructSignature":
+ case "TSConstructorType":
+ case "TSCallSignature": {
+ if (n.type !== "TSCallSignature") {
+ parts.push("new ");
+ }
+
+ parts.push(
+ group(
+ printFunctionParams(
+ path$$1,
+ print,
+ options,
+ /* expandArg */ false,
+ /* printTypeParams */ true
+ )
+ )
+ );
+
+ if (n.typeAnnotation) {
+ const isType = n.type === "TSConstructorType";
+ parts.push(isType ? " => " : ": ", path$$1.call(print, "typeAnnotation"));
+ }
+ return concat(parts);
+ }
+ case "TSTypeOperator":
+ return concat([n.operator, " ", path$$1.call(print, "typeAnnotation")]);
+ case "TSMappedType":
+ return group(
+ concat([
+ "{",
+ indent(
+ concat([
+ options.bracketSpacing ? line : softline,
+ n.readonlyToken
+ ? concat([
+ getTypeScriptMappedTypeModifier(
+ n.readonlyToken,
+ "readonly"
+ ),
+ " "
+ ])
+ : "",
+ printTypeScriptModifiers(path$$1, options, print),
+ "[",
+ path$$1.call(print, "typeParameter"),
+ "]",
+ n.questionToken
+ ? getTypeScriptMappedTypeModifier(n.questionToken, "?")
+ : "",
+ ": ",
+ path$$1.call(print, "typeAnnotation")
+ ])
+ ),
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true),
+ options.bracketSpacing ? line : softline,
+ "}"
+ ])
+ );
+ case "TSMethodSignature":
+ parts.push(
+ n.accessibility ? concat([n.accessibility, " "]) : "",
+ n.export ? "export " : "",
+ n.static ? "static " : "",
+ n.readonly ? "readonly " : "",
+ n.computed ? "[" : "",
+ path$$1.call(print, "key"),
+ n.computed ? "]" : "",
+ printOptionalToken(path$$1),
+ printFunctionParams(
+ path$$1,
+ print,
+ options,
+ /* expandArg */ false,
+ /* printTypeParams */ true
+ )
+ );
+
+ if (n.typeAnnotation) {
+ parts.push(": ", path$$1.call(print, "typeAnnotation"));
+ }
+ return group(concat(parts));
+ case "TSNamespaceExportDeclaration":
+ parts.push("export as namespace ", path$$1.call(print, "name"));
+
+ if (options.semi) {
+ parts.push(";");
+ }
+
+ return group(concat(parts));
+ case "TSEnumDeclaration":
+ if (isNodeStartingWithDeclare(n, options)) {
+ parts.push("declare ");
+ }
+
+ if (n.modifiers) {
+ parts.push(printTypeScriptModifiers(path$$1, options, print));
+ }
+ if (n.const) {
+ parts.push("const ");
+ }
+
+ parts.push("enum ", path$$1.call(print, "id"), " ");
+
+ if (n.members.length === 0) {
+ parts.push(
+ group(
+ concat([
+ "{",
+ comments.printDanglingComments(path$$1, options),
+ softline,
+ "}"
+ ])
+ )
+ );
+ } else {
+ parts.push(
+ group(
+ concat([
+ "{",
+ indent(
+ concat([
+ hardline,
+ printArrayItems(path$$1, options, "members", print),
+ shouldPrintComma(options, "es5") ? "," : ""
+ ])
+ ),
+ comments.printDanglingComments(
+ path$$1,
+ options,
+ /* sameIndent */ true
+ ),
+ hardline,
+ "}"
+ ])
+ )
+ );
+ }
+
+ return concat(parts);
+ case "TSEnumMember":
+ parts.push(path$$1.call(print, "id"));
+ if (n.initializer) {
+ parts.push(" = ", path$$1.call(print, "initializer"));
+ }
+ return concat(parts);
+ case "TSImportEqualsDeclaration":
+ parts.push(
+ printTypeScriptModifiers(path$$1, options, print),
+ "import ",
+ path$$1.call(print, "name"),
+ " = ",
+ path$$1.call(print, "moduleReference")
+ );
+
+ if (options.semi) {
+ parts.push(";");
+ }
+
+ return group(concat(parts));
+ case "TSExternalModuleReference":
+ return concat(["require(", path$$1.call(print, "expression"), ")"]);
+ case "TSModuleDeclaration": {
+ const parent = path$$1.getParentNode();
+ const isExternalModule = isLiteral(n.id);
+ const parentIsDeclaration = parent.type === "TSModuleDeclaration";
+ const bodyIsDeclaration = n.body && n.body.type === "TSModuleDeclaration";
+
+ if (parentIsDeclaration) {
+ parts.push(".");
+ } else {
+ if (n.declare === true) {
+ parts.push("declare ");
+ }
+ parts.push(printTypeScriptModifiers(path$$1, options, print));
+
+ // Global declaration looks like this:
+ // (declare)? global { ... }
+ const isGlobalDeclaration =
+ n.id.type === "Identifier" &&
+ n.id.name === "global" &&
+ !/namespace|module/.test(
+ options.originalText.slice(
+ options.locStart(n),
+ options.locStart(n.id)
+ )
+ );
+
+ if (!isGlobalDeclaration) {
+ parts.push(isExternalModule ? "module " : "namespace ");
+ }
+ }
+
+ parts.push(path$$1.call(print, "id"));
+
+ if (bodyIsDeclaration) {
+ parts.push(path$$1.call(print, "body"));
+ } else if (n.body) {
+ parts.push(
+ " {",
+ indent(
+ concat([
+ line,
+ path$$1.call(
+ bodyPath =>
+ comments.printDanglingComments(bodyPath, options, true),
+ "body"
+ ),
+ group(path$$1.call(print, "body"))
+ ])
+ ),
+ line,
+ "}"
+ );
+ } else {
+ parts.push(semi);
+ }
+
+ return concat(parts);
+ }
+ case "TSModuleBlock":
+ return path$$1.call(bodyPath => {
+ return printStatementSequence(bodyPath, options, print);
+ }, "body");
+
+ case "PrivateName":
+ return concat(["#", path$$1.call(print, "id")]);
+
+ case "TSConditionalType":
+ return formatTernaryOperator(path$$1, options, print, {
+ beforeParts: () => [
+ path$$1.call(print, "checkType"),
+ " ",
+ "extends",
+ " ",
+ path$$1.call(print, "extendsType")
+ ],
+ shouldCheckJsx: false,
+ operatorName: "TSConditionalType",
+ consequentNode: "trueType",
+ alternateNode: "falseType",
+ testNode: "checkType",
+ breakNested: false
+ });
+
+ case "TSInferType":
+ return concat(["infer", " ", path$$1.call(print, "typeParameter")]);
+
+ default:
+ /* istanbul ignore next */
+ throw new Error("unknown type: " + JSON.stringify(n.type));
+ }
+}
+
+function printStatementSequence(path$$1, options, print) {
+ const printed = [];
+
+ const bodyNode = path$$1.getNode();
+ const isClass = bodyNode.type === "ClassBody";
+
+ path$$1.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.
+ /* istanbul ignore if */
+ 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
+ // don't prepend the only JSX element in a program with semicolon
+ if (
+ !options.semi &&
+ !isClass &&
+ !isTheOnlyJSXElementInMarkdown(options, stmtPath) &&
+ stmtNeedsASIProtection(stmtPath, options)
+ ) {
+ if (stmt.comments && stmt.comments.some(comment => comment.leading)) {
+ 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 (
+ utilShared.isNextLineEmpty(text, stmt, options) &&
+ !isLastStatement(stmtPath)
+ ) {
+ parts.push(hardline);
+ }
+
+ printed.push(concat(parts));
+ });
+
+ return join(hardline, printed);
+}
+
+function printPropertyKey(path$$1, options, print) {
+ const node = path$$1.getNode();
+ const key = node.key;
+
+ if (
+ isStringLiteral(key) &&
+ isIdentifierName(key.value) &&
+ !node.computed &&
+ options.parser !== "json"
+ ) {
+ // 'a' -> a
+ return path$$1.call(
+ keyPath => comments.printComments(keyPath, () => key.value, options),
+ "key"
+ );
+ }
+ return path$$1.call(print, "key");
+}
+
+function printMethod(path$$1, options, print) {
+ const node = path$$1.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.ok(kind === "get" || kind === "set");
+
+ parts.push(kind, " ");
+ }
+
+ let key = printPropertyKey(path$$1, options, print);
+
+ if (node.computed) {
+ key = concat(["[", key, "]"]);
+ }
+
+ parts.push(
+ key,
+ concat(
+ path$$1.call(
+ valuePath => [
+ printFunctionTypeParameters(valuePath, options, print),
+ group(
+ concat([
+ printFunctionParams(valuePath, print, options),
+ printReturnType(valuePath, print, options)
+ ])
+ )
+ ],
+ "value"
+ )
+ )
+ );
+
+ if (!node.value.body || node.value.body.length === 0) {
+ parts.push(semi);
+ } else {
+ parts.push(" ", path$$1.call(print, "value", "body"));
+ }
+
+ return concat(parts);
+}
+
+function couldGroupArg(arg) {
+ return (
+ (arg.type === "ObjectExpression" &&
+ (arg.properties.length > 0 || arg.comments)) ||
+ (arg.type === "ArrayExpression" &&
+ (arg.elements.length > 0 || arg.comments)) ||
+ arg.type === "TSTypeAssertionExpression" ||
+ arg.type === "TSAsExpression" ||
+ 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" ||
+ isJSXNode(arg.body)))
+ );
+}
+
+function shouldGroupLastArg(args) {
+ const lastArg = util$1.getLast(args);
+ const penultimateArg = util$1.getPenultimate(args);
+ return (
+ !hasLeadingComment(lastArg) &&
+ !hasTrailingComment(lastArg) &&
+ 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$$1, options, print) {
+ const args = path$$1.getValue().arguments;
+
+ if (args.length === 0) {
+ return concat([
+ "(",
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true),
+ ")"
+ ]);
+ }
+
+ let anyArgEmptyLine = false;
+ let hasEmptyLineFollowingFirstArg = false;
+ const lastArgIndex = args.length - 1;
+ const printedArguments = path$$1.map((argPath, index) => {
+ const arg = argPath.getNode();
+ const parts = [print(argPath)];
+
+ if (index === lastArgIndex) {
+ // do nothing
+ } else if (utilShared.isNextLineEmpty(options.originalText, arg, options)) {
+ if (index === 0) {
+ hasEmptyLineFollowingFirstArg = true;
+ }
+
+ anyArgEmptyLine = true;
+ parts.push(",", hardline, hardline);
+ } else {
+ parts.push(",", line);
+ }
+
+ return concat(parts);
+ }, "arguments");
+
+ const shouldGroupFirst = shouldGroupFirstArg(args);
+ const shouldGroupLast = shouldGroupLastArg(args);
+ if (shouldGroupFirst || shouldGroupLast) {
+ const shouldBreak =
+ (shouldGroupFirst
+ ? printedArguments.slice(1).some(willBreak$1)
+ : printedArguments.slice(0, -1).some(willBreak$1)) || anyArgEmptyLine;
+
+ // We want to print the last argument with a special flag
+ let printedExpanded;
+ let i = 0;
+ path$$1.each(argPath => {
+ if (shouldGroupFirst && i === 0) {
+ printedExpanded = [
+ concat([
+ argPath.call(p => print(p, { expandFirstArg: true })),
+ printedArguments.length > 1 ? "," : "",
+ hasEmptyLineFollowingFirstArg ? hardline : line,
+ hasEmptyLineFollowingFirstArg ? hardline : ""
+ ])
+ ].concat(printedArguments.slice(1));
+ }
+ if (shouldGroupLast && i === args.length - 1) {
+ printedExpanded = printedArguments
+ .slice(0, -1)
+ .concat(argPath.call(p => print(p, { expandLastArg: true })));
+ }
+ i++;
+ }, "arguments");
+
+ const somePrintedArgumentsWillBreak = printedArguments.some(willBreak$1);
+
+ const maybeTrailingComma = shouldPrintComma(options, "all") ? "," : "";
+
+ return concat([
+ somePrintedArgumentsWillBreak ? breakParent : "",
+ conditionalGroup(
+ [
+ concat([
+ ifBreak(
+ indent(concat(["(", softline, concat(printedExpanded)])),
+ concat(["(", concat(printedExpanded)])
+ ),
+ somePrintedArgumentsWillBreak
+ ? concat([ifBreak(maybeTrailingComma), softline])
+ : "",
+ ")"
+ ]),
+ shouldGroupFirst
+ ? concat([
+ "(",
+ group(printedExpanded[0], { shouldBreak: true }),
+ concat(printedExpanded.slice(1)),
+ ")"
+ ])
+ : concat([
+ "(",
+ concat(printedArguments.slice(0, -1)),
+ group(util$1.getLast(printedExpanded), {
+ shouldBreak: true
+ }),
+ ")"
+ ]),
+ group(
+ concat([
+ "(",
+ indent(concat([line, concat(printedArguments)])),
+ maybeTrailingComma,
+ line,
+ ")"
+ ]),
+ { shouldBreak: true }
+ )
+ ],
+ { shouldBreak }
+ )
+ ]);
+ }
+
+ return group(
+ concat([
+ "(",
+ indent(concat([softline, concat(printedArguments)])),
+ ifBreak(shouldPrintComma(options, "all") ? "," : ""),
+ softline,
+ ")"
+ ]),
+ { shouldBreak: printedArguments.some(willBreak$1) || anyArgEmptyLine }
+ );
+}
+
+function printTypeAnnotation(path$$1, options, print) {
+ const node = path$$1.getValue();
+ if (!node.typeAnnotation) {
+ return "";
+ }
+
+ const parentNode = path$$1.getParentNode();
+ const isDefinite =
+ node.definite ||
+ (parentNode &&
+ parentNode.type === "VariableDeclarator" &&
+ parentNode.definite);
+
+ const isFunctionDeclarationIdentifier =
+ parentNode.type === "DeclareFunction" && parentNode.id === node;
+
+ if (
+ isFlowAnnotationComment(options.originalText, node.typeAnnotation, options)
+ ) {
+ return concat([" /*: ", path$$1.call(print, "typeAnnotation"), " */"]);
+ }
+
+ return concat([
+ isFunctionDeclarationIdentifier ? "" : isDefinite ? "!: " : ": ",
+ path$$1.call(print, "typeAnnotation")
+ ]);
+}
+
+function printFunctionTypeParameters(path$$1, options, print) {
+ const fun = path$$1.getValue();
+ if (fun.typeParameters) {
+ return path$$1.call(print, "typeParameters");
+ }
+ return "";
+}
+
+function printFunctionParams(path$$1, print, options, expandArg, printTypeParams) {
+ const fun = path$$1.getValue();
+ const paramsField = fun.parameters ? "parameters" : "params";
+
+ const typeParams = printTypeParams
+ ? printFunctionTypeParameters(path$$1, options, print)
+ : "";
+
+ let printed = [];
+ if (fun[paramsField]) {
+ printed = path$$1.map(print, paramsField);
+ }
+
+ if (fun.rest) {
+ printed.push(concat(["...", path$$1.call(print, "rest")]));
+ }
+
+ if (printed.length === 0) {
+ return concat([
+ typeParams,
+ "(",
+ comments.printDanglingComments(
+ path$$1,
+ options,
+ /* sameIndent */ true,
+ comment =>
+ util$1.getNextNonSpaceNonCommentCharacter(
+ options.originalText,
+ comment,
+ options.locEnd
+ ) === ")"
+ ),
+ ")"
+ ]);
+ }
+
+ const lastParam = util$1.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 &&
+ !(fun[paramsField] && fun[paramsField].some(n => n.comments))
+ ) {
+ return group(
+ concat([
+ docUtils$3.removeLines(typeParams),
+ "(",
+ join(", ", printed.map(docUtils$3.removeLines)),
+ ")"
+ ])
+ );
+ }
+
+ // Single object destructuring should hug
+ //
+ // function({
+ // a,
+ // b,
+ // c
+ // }) {}
+ if (shouldHugArguments(fun)) {
+ return concat([typeParams, "(", join(", ", printed), ")"]);
+ }
+
+ const parent = path$$1.getParentNode();
+
+ // don't break in specs, eg; `it("should maintain parens around done even when long", (done) => {})`
+ if (parent.type === "CallExpression" && isTestCall(parent)) {
+ return concat([typeParams, "(", join(", ", printed), ")"]);
+ }
+
+ const flowTypeAnnotations = [
+ "AnyTypeAnnotation",
+ "NullLiteralTypeAnnotation",
+ "GenericTypeAnnotation",
+ "ThisTypeAnnotation",
+ "NumberTypeAnnotation",
+ "VoidTypeAnnotation",
+ "EmptyTypeAnnotation",
+ "MixedTypeAnnotation",
+ "BooleanTypeAnnotation",
+ "BooleanLiteralTypeAnnotation",
+ "StringTypeAnnotation"
+ ];
+
+ const isFlowShorthandWithOneArg =
+ (isObjectTypePropertyAFunction(parent, options) ||
+ isTypeAnnotationAFunction(parent, options) ||
+ 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 &&
+ fun.typeParameters === null &&
+ flowTypeAnnotations.indexOf(fun[paramsField][0].typeAnnotation.type) !==
+ -1 &&
+ !(
+ fun[paramsField][0].typeAnnotation.type === "GenericTypeAnnotation" &&
+ fun[paramsField][0].typeAnnotation.typeParameters
+ ) &&
+ !fun.rest;
+
+ if (isFlowShorthandWithOneArg) {
+ if (options.arrowParens === "always") {
+ return concat(["(", concat(printed), ")"]);
+ }
+ return concat(printed);
+ }
+
+ const canHaveTrailingComma =
+ !(lastParam && lastParam.type === "RestElement") && !fun.rest;
+
+ return concat([
+ typeParams,
+ "(",
+ indent(concat([softline, join(concat([",", line]), printed)])),
+ ifBreak(
+ canHaveTrailingComma && shouldPrintComma(options, "all") ? "," : ""
+ ),
+ softline,
+ ")"
+ ]);
+}
+
+function shouldPrintParamsWithoutParens(path$$1, options) {
+ if (options.arrowParens === "always") {
+ return false;
+ }
+
+ if (options.arrowParens === "avoid") {
+ const node = path$$1.getValue();
+ return canPrintParamsWithoutParens(node);
+ }
+
+ // Fallback default; should be unreachable
+ return false;
+}
+
+function canPrintParamsWithoutParens(node) {
+ return (
+ node.params.length === 1 &&
+ !node.rest &&
+ !node.typeParameters &&
+ !hasDanglingComments(node) &&
+ node.params[0].type === "Identifier" &&
+ !node.params[0].typeAnnotation &&
+ !node.params[0].comments &&
+ !node.params[0].optional &&
+ !node.predicate &&
+ !node.returnType
+ );
+}
+
+function printFunctionDeclaration(path$$1, print, options) {
+ const n = path$$1.getValue();
+ const parts = [];
+
+ if (n.async) {
+ parts.push("async ");
+ }
+
+ parts.push("function");
+
+ if (n.generator) {
+ parts.push("*");
+ }
+ if (n.id) {
+ parts.push(" ", path$$1.call(print, "id"));
+ }
+
+ parts.push(
+ printFunctionTypeParameters(path$$1, options, print),
+ group(
+ concat([
+ printFunctionParams(path$$1, print, options),
+ printReturnType(path$$1, print, options)
+ ])
+ ),
+ n.body ? " " : "",
+ path$$1.call(print, "body")
+ );
+
+ return concat(parts);
+}
+
+function printObjectMethod(path$$1, options, print) {
+ const objMethod = path$$1.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$$1, options, print);
+ }
+
+ const key = printPropertyKey(path$$1, options, print);
+
+ if (objMethod.computed) {
+ parts.push("[", key, "]");
+ } else {
+ parts.push(key);
+ }
+
+ parts.push(
+ printFunctionTypeParameters(path$$1, options, print),
+ group(
+ concat([
+ printFunctionParams(path$$1, print, options),
+ printReturnType(path$$1, print, options)
+ ])
+ ),
+ " ",
+ path$$1.call(print, "body")
+ );
+
+ return concat(parts);
+}
+
+function printReturnType(path$$1, print, options) {
+ const n = path$$1.getValue();
+ const returnType = path$$1.call(print, "returnType");
+
+ if (
+ n.returnType &&
+ isFlowAnnotationComment(options.originalText, n.returnType, options)
+ ) {
+ return concat([" /*: ", returnType, " */"]);
+ }
+
+ const parts = [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$$1.call(print, "predicate"));
+ }
+
+ return concat(parts);
+}
+
+function printExportDeclaration(path$$1, options, print) {
+ const decl = path$$1.getValue();
+ const semi = options.semi ? ";" : "";
+ const parts = ["export "];
+
+ const isDefault = decl["default"] || decl.type === "ExportDefaultDeclaration";
+
+ if (isDefault) {
+ parts.push("default ");
+ }
+
+ parts.push(
+ comments.printDanglingComments(path$$1, options, /* sameIndent */ true)
+ );
+
+ if (needsHardlineAfterDanglingComment(decl)) {
+ parts.push(hardline);
+ }
+
+ if (decl.declaration) {
+ parts.push(path$$1.call(print, "declaration"));
+
+ if (
+ isDefault &&
+ (decl.declaration.type !== "ClassDeclaration" &&
+ decl.declaration.type !== "FunctionDeclaration" &&
+ decl.declaration.type !== "TSAbstractClassDeclaration" &&
+ decl.declaration.type !== "TSInterfaceDeclaration" &&
+ decl.declaration.type !== "DeclareClass" &&
+ decl.declaration.type !== "DeclareFunction")
+ ) {
+ parts.push(semi);
+ }
+ } else {
+ if (decl.specifiers && decl.specifiers.length > 0) {
+ const specifiers = [];
+ const defaultSpecifiers = [];
+ const namespaceSpecifiers = [];
+ path$$1.each(specifierPath => {
+ const specifierType = path$$1.getValue().type;
+ if (specifierType === "ExportSpecifier") {
+ specifiers.push(print(specifierPath));
+ } else if (specifierType === "ExportDefaultSpecifier") {
+ defaultSpecifiers.push(print(specifierPath));
+ } else if (specifierType === "ExportNamespaceSpecifier") {
+ namespaceSpecifiers.push(concat(["* as ", print(specifierPath)]));
+ }
+ }, "specifiers");
+
+ const isNamespaceFollowed =
+ namespaceSpecifiers.length !== 0 && specifiers.length !== 0;
+
+ const isDefaultFollowed =
+ defaultSpecifiers.length !== 0 &&
+ (namespaceSpecifiers.length !== 0 || specifiers.length !== 0);
+
+ parts.push(
+ decl.exportKind === "type" ? "type " : "",
+ concat(defaultSpecifiers),
+ concat([isDefaultFollowed ? ", " : ""]),
+ concat(namespaceSpecifiers),
+ concat([isNamespaceFollowed ? ", " : ""]),
+ specifiers.length !== 0
+ ? group(
+ concat([
+ "{",
+ indent(
+ concat([
+ options.bracketSpacing ? line : softline,
+ join(concat([",", line]), specifiers)
+ ])
+ ),
+ ifBreak(shouldPrintComma(options) ? "," : ""),
+ options.bracketSpacing ? line : softline,
+ "}"
+ ])
+ )
+ : ""
+ );
+ } else {
+ parts.push("{}");
+ }
+
+ if (decl.source) {
+ parts.push(" from ", path$$1.call(print, "source"));
+ }
+
+ parts.push(semi);
+ }
+
+ return concat(parts);
+}
+
+function printFlowDeclaration(path$$1, parts) {
+ const parentExportDecl = util$1.getParentExportDeclaration(path$$1);
+
+ if (parentExportDecl) {
+ assert.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(parts);
+}
+
+function getFlowVariance(path$$1) {
+ if (!path$$1.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$$1.variance.kind || path$$1.variance;
+
+ switch (variance) {
+ case "plus":
+ return "+";
+ case "minus":
+ return "-";
+ default:
+ /* istanbul ignore next */
+ return variance;
+ }
+}
+
+function printTypeScriptModifiers(path$$1, options, print) {
+ const n = path$$1.getValue();
+ if (!n.modifiers || !n.modifiers.length) {
+ return "";
+ }
+ return concat([join(" ", path$$1.map(print, "modifiers")), " "]);
+}
+
+function printTypeParameters(path$$1, options, print, paramsKey) {
+ const n = path$$1.getValue();
+
+ if (!n[paramsKey]) {
+ return "";
+ }
+
+ // for TypeParameterDeclaration typeParameters is a single node
+ if (!Array.isArray(n[paramsKey])) {
+ return path$$1.call(print, paramsKey);
+ }
+
+ const grandparent = path$$1.getNode(2);
+
+ const isParameterInTestCall =
+ grandparent != null &&
+ grandparent.type === "CallExpression" &&
+ isTestCall(grandparent);
+
+ const shouldInline =
+ isParameterInTestCall ||
+ n[paramsKey].length === 0 ||
+ (n[paramsKey].length === 1 &&
+ (shouldHugType(n[paramsKey][0]) ||
+ (n[paramsKey][0].type === "GenericTypeAnnotation" &&
+ shouldHugType(n[paramsKey][0].id)) ||
+ (n[paramsKey][0].type === "TSTypeReference" &&
+ shouldHugType(n[paramsKey][0].typeName)) ||
+ n[paramsKey][0].type === "NullableTypeAnnotation"));
+
+ if (shouldInline) {
+ return concat(["<", join(", ", path$$1.map(print, paramsKey)), ">"]);
+ }
+
+ return group(
+ concat([
+ "<",
+ indent(
+ concat([
+ softline,
+ join(concat([",", line]), path$$1.map(print, paramsKey))
+ ])
+ ),
+ ifBreak(
+ options.parser !== "typescript" && shouldPrintComma(options, "all")
+ ? ","
+ : ""
+ ),
+ softline,
+ ">"
+ ])
+ );
+}
+
+function printClass(path$$1, options, print) {
+ const n = path$$1.getValue();
+ const parts = [];
+
+ if (n.type === "TSAbstractClassDeclaration") {
+ parts.push("abstract ");
+ }
+
+ parts.push("class");
+
+ if (n.id) {
+ parts.push(" ", path$$1.call(print, "id"));
+ }
+
+ parts.push(path$$1.call(print, "typeParameters"));
+
+ const partsGroup = [];
+ if (n.superClass) {
+ const printed = concat([
+ "extends ",
+ path$$1.call(print, "superClass"),
+ path$$1.call(print, "superTypeParameters")
+ ]);
+ // Keep old behaviour of extends in same line
+ // If there is only on extends and there are not comments
+ if (
+ (!n.implements || n.implements.length === 0) &&
+ (!n.superClass.comments || n.superClass.comments.length === 0)
+ ) {
+ parts.push(
+ concat([
+ " ",
+ path$$1.call(
+ superClass =>
+ comments.printComments(superClass, () => printed, options),
+ "superClass"
+ )
+ ])
+ );
+ } else {
+ partsGroup.push(
+ group(
+ concat([
+ line,
+ path$$1.call(
+ superClass =>
+ comments.printComments(superClass, () => printed, options),
+ "superClass"
+ )
+ ])
+ )
+ );
+ }
+ } else if (n.extends && n.extends.length > 0) {
+ parts.push(" extends ", join(", ", path$$1.map(print, "extends")));
+ }
+
+ if (n["implements"] && n["implements"].length > 0) {
+ partsGroup.push(
+ line,
+ "implements",
+ group(
+ indent(
+ concat([
+ line,
+ join(concat([",", line]), path$$1.map(print, "implements"))
+ ])
+ )
+ )
+ );
+ }
+
+ if (n["mixins"] && n["mixins"].length > 0) {
+ partsGroup.push(
+ line,
+ "mixins ",
+ group(indent(join(concat([",", line]), path$$1.map(print, "mixins"))))
+ );
+ }
+
+ if (partsGroup.length > 0) {
+ parts.push(group(indent(concat(partsGroup))));
+ }
+
+ if (
+ n.body &&
+ n.body.comments &&
+ hasLeadingOwnLineComment(options.originalText, n.body, options)
+ ) {
+ parts.push(hardline);
+ } else {
+ parts.push(" ");
+ }
+ parts.push(path$$1.call(print, "body"));
+
+ return parts;
+}
+
+function printOptionalToken(path$$1) {
+ const node = path$$1.getValue();
+ if (!node.optional) {
+ return "";
+ }
+ if (
+ node.type === "CallExpression" ||
+ (node.type === "MemberExpression" && node.computed)
+ ) {
+ return "?.";
+ }
+ return "?";
+}
+
+function printMemberLookup(path$$1, options, print) {
+ const property = path$$1.call(print, "property");
+ const n = path$$1.getValue();
+ const optional = printOptionalToken(path$$1);
+
+ if (!n.computed) {
+ return concat([optional, ".", property]);
+ }
+
+ if (!n.property || isNumericLiteral(n.property)) {
+ return concat([optional, "[", property, "]"]);
+ }
+
+ return group(
+ concat([optional, "[", indent(concat([softline, property])), softline, "]"])
+ );
+}
+
+function printBindExpressionCallee(path$$1, options, print) {
+ return concat(["::", path$$1.call(print, "callee")]);
+}
+
+// We detect calls on member expressions specially to format a
+// common 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$$1, 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 = [];
+
+ // Here we try to retain one typed empty line after each call expression or
+ // the first group whether it is in parentheses or not
+ function shouldInsertEmptyLineAfter(node) {
+ const originalText = options.originalText;
+ const nextCharIndex = utilShared.getNextNonSpaceNonCommentCharacterIndex(
+ originalText,
+ node,
+ options
+ );
+ const nextChar = originalText.charAt(nextCharIndex);
+
+ // if it is cut off by a parenthesis, we only account for one typed empty
+ // line after that parenthesis
+ if (nextChar == ")") {
+ return utilShared.isNextLineEmptyAfterIndex(
+ originalText,
+ nextCharIndex + 1,
+ options
+ );
+ }
+
+ return utilShared.isNextLineEmpty(originalText, node, options);
+ }
+
+ function rec(path$$1) {
+ const node = path$$1.getValue();
+ if (
+ node.type === "CallExpression" &&
+ (isMemberish(node.callee) || node.callee.type === "CallExpression")
+ ) {
+ printedNodes.unshift({
+ node: node,
+ printed: concat([
+ comments.printComments(
+ path$$1,
+ () =>
+ concat([
+ printOptionalToken(path$$1),
+ printFunctionTypeParameters(path$$1, options, print),
+ printArgumentsList(path$$1, options, print)
+ ]),
+ options
+ ),
+ shouldInsertEmptyLineAfter(node) ? hardline : ""
+ ])
+ });
+ path$$1.call(callee => rec(callee), "callee");
+ } else if (isMemberish(node)) {
+ printedNodes.unshift({
+ node: node,
+ printed: comments.printComments(
+ path$$1,
+ () =>
+ node.type === "MemberExpression"
+ ? printMemberLookup(path$$1, options, print)
+ : printBindExpressionCallee(path$$1, options, print),
+ options
+ )
+ });
+ path$$1.call(object => rec(object), "object");
+ } else if (node.type === "TSNonNullExpression") {
+ printedNodes.unshift({
+ node: node,
+ printed: comments.printComments(path$$1, () => "!", options)
+ });
+ path$$1.call(expression => rec(expression), "expression");
+ } else {
+ printedNodes.unshift({
+ node: node,
+ printed: path$$1.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.
+ const node = path$$1.getValue();
+ printedNodes.unshift({
+ node,
+ printed: concat([
+ printOptionalToken(path$$1),
+ printFunctionTypeParameters(path$$1, options, print),
+ printArgumentsList(path$$1, options, print)
+ ])
+ });
+ path$$1.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()
+ // - as many array acessors as possible
+ // < fn()[0][1][2] >.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 === "TSNonNullExpression" ||
+ printedNodes[i].node.type === "CallExpression" ||
+ (printedNodes[i].node.type === "MemberExpression" &&
+ printedNodes[i].node.computed &&
+ isNumericLiteral(printedNodes[i].node.property))
+ ) {
+ currentGroup.push(printedNodes[i]);
+ } else {
+ break;
+ }
+ }
+ if (printedNodes[0].node.type !== "CallExpression") {
+ for (; i + 1 < printedNodes.length; ++i) {
+ if (
+ isMemberish(printedNodes[i].node) &&
+ isMemberish(printedNodes[i + 1].node)
+ ) {
+ 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 && isMemberish(printedNodes[i].node)) {
+ // [0] should be appended at the end of the group instead of the
+ // beginning of the next one
+ if (
+ printedNodes[i].node.computed &&
+ isNumericLiteral(printedNodes[i].node.property)
+ ) {
+ 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.
+ function isFactory(name) {
+ return name.match(/(^[A-Z])|^[_$]+$/);
+ }
+ 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" &&
+ (isFactory(groups[0][0].node.name) ||
+ (groups[1].length && groups[1][0].node.computed))))) ||
+ (groups[0].length > 1 &&
+ groups[0][groups[0].length - 1].node.type === "MemberExpression" &&
+ groups[0][groups[0].length - 1].node.property.type === "Identifier" &&
+ (isFactory(groups[0][groups[0].length - 1].node.property.name) ||
+ (groups[1].length && groups[1][0].node.computed))));
+
+ function printGroup(printedGroup) {
+ return concat(printedGroup.map(tuple => tuple.printed));
+ }
+
+ function printIndentedGroup(groups) {
+ if (groups.length === 0) {
+ return "";
+ }
+ return indent(
+ group(concat([hardline, join(hardline, groups.map(printGroup))]))
+ );
+ }
+
+ const printedGroups = groups.map(printGroup);
+ const oneLine = concat(printedGroups);
+
+ const cutoff = shouldMerge ? 3 : 2;
+ const flatGroups = groups
+ .slice(0, cutoff)
+ .reduce((res, group) => res.concat(group), []);
+
+ const hasComment =
+ flatGroups.slice(1, -1).some(node => hasLeadingComment(node.node)) ||
+ flatGroups.slice(0, -1).some(node => hasTrailingComment(node.node)) ||
+ (groups[cutoff] && hasLeadingComment(groups[cutoff][0].node));
+
+ // If we only have a single `.`, we shouldn't do anything fancy and just
+ // render everything concatenated together.
+ if (groups.length <= cutoff && !hasComment) {
+ return group(oneLine);
+ }
+
+ // Find out the last node in the first group and check if it has an
+ // empty line after
+ const lastNodeBeforeIndent = util$1.getLast(
+ shouldMerge ? groups.slice(1, 2)[0] : groups[0]
+ ).node;
+ const shouldHaveEmptyLineBeforeIndent =
+ lastNodeBeforeIndent.type !== "CallExpression" &&
+ shouldInsertEmptyLineAfter(lastNodeBeforeIndent);
+
+ const expanded = concat([
+ printGroup(groups[0]),
+ shouldMerge ? concat(groups.slice(1, 2).map(printGroup)) : "",
+ shouldHaveEmptyLineBeforeIndent ? hardline : "",
+ printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))
+ ]);
+
+ const callExpressionCount = printedNodes.filter(
+ tuple => tuple.node.type === "CallExpression"
+ ).length;
+
+ // We don't want to print in one line if there's:
+ // * A comment.
+ // * 3 or more chained calls.
+ // * Any group but the last one has a hard line.
+ // If the last group is a function it's okay to inline if it fits.
+ if (
+ hasComment ||
+ callExpressionCount >= 3 ||
+ printedGroups.slice(0, -1).some(willBreak$1)
+ ) {
+ return group(expanded);
+ }
+
+ return concat([
+ // We only need to check `oneLine` because if `expanded` is chosen
+ // that means that the parent group has already been broken
+ // naturally
+ willBreak$1(oneLine) || shouldHaveEmptyLineBeforeIndent ? breakParent : "",
+ conditionalGroup([oneLine, expanded])
+ ]);
+}
+
+function isJSXNode(node) {
+ return (
+ node.type === "JSXElement" ||
+ node.type === "JSXFragment" ||
+ node.type === "TSJsxFragment"
+ );
+}
+
+function isEmptyJSXElement(node) {
+ if (node.children.length === 0) {
+ return true;
+ }
+ if (node.children.length > 1) {
+ return false;
+ }
+
+ // if there is one text child and does not contain any meaningful text
+ // we can treat the element as empty.
+ const child = node.children[0];
+ return isLiteral(child) && !isMeaningfulJSXText(child);
+}
+
+// Only space, newline, carriage return, and tab are treated as whitespace
+// inside JSX.
+const jsxWhitespaceChars = " \n\r\t";
+const containsNonJsxWhitespaceRegex = new RegExp(
+ "[^" + jsxWhitespaceChars + "]"
+);
+const matchJsxWhitespaceRegex = new RegExp("([" + jsxWhitespaceChars + "]+)");
+
+// Meaningful if it contains non-whitespace characters,
+// or it contains whitespace without a new line.
+function isMeaningfulJSXText(node) {
+ return (
+ isLiteral(node) &&
+ (containsNonJsxWhitespaceRegex.test(rawText(node)) ||
+ !/\n/.test(rawText(node)))
+ );
+}
+
+function conditionalExpressionChainContainsJSX(node) {
+ return Boolean(getConditionalChainContents(node).find(isJSXNode));
+}
+
+// If we have nested conditional expressions, we want to print them in JSX mode
+// if there's at least one JSXElement somewhere in the tree.
+//
+// A conditional expression chain like this should be printed in normal mode,
+// because there aren't JSXElements anywhere in it:
+//
+// isA ? "A" : isB ? "B" : isC ? "C" : "Unknown";
+//
+// But a conditional expression chain like this should be printed in JSX mode,
+// because there is a JSXElement in the last ConditionalExpression:
+//
+// isA ? "A" : isB ? "B" : isC ? "C" :
Unknown;
+//
+// This type of ConditionalExpression chain is structured like this in the AST:
+//
+// ConditionalExpression {
+// test: ...,
+// consequent: ...,
+// alternate: ConditionalExpression {
+// test: ...,
+// consequent: ...,
+// alternate: ConditionalExpression {
+// test: ...,
+// consequent: ...,
+// alternate: ...,
+// }
+// }
+// }
+//
+// We want to traverse over that shape and convert it into a flat structure so
+// that we can find if there's a JSXElement somewhere inside.
+function getConditionalChainContents(node) {
+ // Given this code:
+ //
+ // // Using a ConditionalExpression as the consequent is uncommon, but should
+ // // be handled.
+ // A ? B : C ? D : E ? F ? G : H : I
+ //
+ // which has this AST:
+ //
+ // ConditionalExpression {
+ // test: Identifier(A),
+ // consequent: Identifier(B),
+ // alternate: ConditionalExpression {
+ // test: Identifier(C),
+ // consequent: Identifier(D),
+ // alternate: ConditionalExpression {
+ // test: Identifier(E),
+ // consequent: ConditionalExpression {
+ // test: Identifier(F),
+ // consequent: Identifier(G),
+ // alternate: Identifier(H),
+ // },
+ // alternate: Identifier(I),
+ // }
+ // }
+ // }
+ //
+ // we should return this Array:
+ //
+ // [
+ // Identifier(A),
+ // Identifier(B),
+ // Identifier(C),
+ // Identifier(D),
+ // Identifier(E),
+ // Identifier(F),
+ // Identifier(G),
+ // Identifier(H),
+ // Identifier(I)
+ // ];
+ //
+ // This loses the information about whether each node was the test,
+ // consequent, or alternate, but we don't care about that here- we are only
+ // flattening this structure to find if there's any JSXElements inside.
+ const nonConditionalExpressions = [];
+
+ function recurse(node) {
+ if (node.type === "ConditionalExpression") {
+ recurse(node.test);
+ recurse(node.consequent);
+ recurse(node.alternate);
+ } else {
+ nonConditionalExpressions.push(node);
+ }
+ }
+ recurse(node);
+
+ return nonConditionalExpressions;
+}
+
+// Detect an expression node representing `{" "}`
+function isJSXWhitespaceExpression(node) {
+ return (
+ node.type === "JSXExpressionContainer" &&
+ isLiteral(node.expression) &&
+ node.expression.value === " " &&
+ !node.expression.comments
+ );
+}
+
+// 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.
+//
+// Leading, trailing, and lone whitespace all need to
+// turn themselves into the rather ugly `{' '}` when breaking.
+//
+// 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$$1, options, print, jsxWhitespace) {
+ const n = path$$1.getValue();
+ const children = [];
+
+ // using `map` instead of `each` because it provides `i`
+ path$$1.map((childPath, i) => {
+ const child = childPath.getValue();
+ if (isLiteral(child)) {
+ const text = rawText(child);
+
+ // Contains a non-whitespace character
+ if (isMeaningfulJSXText(child)) {
+ const words = text.split(matchJsxWhitespaceRegex);
+
+ // Starts with whitespace
+ if (words[0] === "") {
+ children.push("");
+ words.shift();
+ if (/\n/.test(words[0])) {
+ children.push(hardline);
+ } else {
+ children.push(jsxWhitespace);
+ }
+ words.shift();
+ }
+
+ let endWhitespace;
+ // Ends with whitespace
+ if (util$1.getLast(words) === "") {
+ words.pop();
+ endWhitespace = words.pop();
+ }
+
+ // This was whitespace only without a new line.
+ if (words.length === 0) {
+ return;
+ }
+
+ words.forEach((word, i) => {
+ if (i % 2 === 1) {
+ children.push(line);
+ } else {
+ children.push(word);
+ }
+ });
+
+ if (endWhitespace !== undefined) {
+ if (/\n/.test(endWhitespace)) {
+ children.push(hardline);
+ } else {
+ children.push(jsxWhitespace);
+ }
+ } else {
+ // Ideally this would be a `hardline` 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(text)) {
+ // Keep (up to one) blank line between tags/expressions/text.
+ // Note: We don't keep blank lines between text elements.
+ if (text.match(/\n/g).length > 1) {
+ children.push("");
+ children.push(hardline);
+ }
+ } else {
+ children.push("");
+ children.push(jsxWhitespace);
+ }
+ } else {
+ const printedChild = print(childPath);
+ children.push(printedChild);
+
+ const next = n.children[i + 1];
+ const directlyFollowedByMeaningfulText =
+ next && isMeaningfulJSXText(next) && !/^[ \n\r\t]/.test(rawText(next));
+ if (directlyFollowedByMeaningfulText) {
+ // Potentially this could be a hardline as well.
+ // See the comment above about the Facebook translation pipeline as
+ // to why this is an empty string.
+ children.push("");
+ } else {
+ children.push(hardline);
+ }
+ }
+ }, "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$$1, options, print) {
+ const n = path$$1.getValue();
+
+ // Turn
into
+ if (n.type === "JSXElement" && isEmptyJSXElement(n)) {
+ n.openingElement.selfClosing = true;
+ return path$$1.call(print, "openingElement");
+ }
+
+ const openingLines =
+ n.type === "JSXElement"
+ ? path$$1.call(print, "openingElement")
+ : path$$1.call(print, "openingFragment");
+ const closingLines =
+ n.type === "JSXElement"
+ ? path$$1.call(print, "closingElement")
+ : path$$1.call(print, "closingFragment");
+
+ if (
+ n.children.length === 1 &&
+ n.children[0].type === "JSXExpressionContainer" &&
+ (n.children[0].expression.type === "TemplateLiteral" ||
+ n.children[0].expression.type === "TaggedTemplateExpression")
+ ) {
+ return concat([
+ openingLines,
+ concat(path$$1.map(print, "children")),
+ closingLines
+ ]);
+ }
+
+ // Convert `{" "}` to text nodes containing a space.
+ // This makes it easy to turn them into `jsxWhitespace` which
+ // can then print as either a space or `{" "}` when breaking.
+ n.children = n.children.map(child => {
+ if (isJSXWhitespaceExpression(child)) {
+ return {
+ type: "JSXText",
+ value: " ",
+ raw: " "
+ };
+ }
+ return child;
+ });
+
+ const containsTag = n.children.filter(isJSXNode).length > 0;
+ const containsMultipleExpressions =
+ n.children.filter(child => child.type === "JSXExpressionContainer").length >
+ 1;
+ const containsMultipleAttributes =
+ n.type === "JSXElement" && n.openingElement.attributes.length > 1;
+
+ // Record any breaks. Should never go from true to false, only false to true.
+ let forcedBreak =
+ willBreak$1(openingLines) ||
+ containsTag ||
+ containsMultipleAttributes ||
+ containsMultipleExpressions;
+
+ const rawJsxWhitespace = options.singleQuote ? "{' '}" : '{" "}';
+ const jsxWhitespace = ifBreak(concat([rawJsxWhitespace, softline]), " ");
+
+ const children = printJSXChildren(path$$1, options, print, jsxWhitespace);
+
+ const containsText =
+ n.children.filter(child => isMeaningfulJSXText(child)).length > 0;
+
+ // We can end up we multiple whitespace elements with empty string
+ // content between them.
+ // We need to remove empty whitespace and softlines before JSX whitespace
+ // to get the correct output.
+ for (let i = children.length - 2; i >= 0; i--) {
+ const isPairOfEmptyStrings = children[i] === "" && children[i + 1] === "";
+ const isPairOfHardlines =
+ children[i] === hardline &&
+ children[i + 1] === "" &&
+ children[i + 2] === hardline;
+ const isLineFollowedByJSXWhitespace =
+ (children[i] === softline || children[i] === hardline) &&
+ children[i + 1] === "" &&
+ children[i + 2] === jsxWhitespace;
+ const isJSXWhitespaceFollowedByLine =
+ children[i] === jsxWhitespace &&
+ children[i + 1] === "" &&
+ (children[i + 2] === softline || children[i + 2] === hardline);
+ const isDoubleJSXWhitespace =
+ children[i] === jsxWhitespace &&
+ children[i + 1] === "" &&
+ children[i + 2] === jsxWhitespace;
+
+ if (
+ (isPairOfHardlines && containsText) ||
+ isPairOfEmptyStrings ||
+ isLineFollowedByJSXWhitespace ||
+ isDoubleJSXWhitespace
+ ) {
+ children.splice(i, 2);
+ } else if (isJSXWhitespaceFollowedByLine) {
+ children.splice(i + 1, 2);
+ }
+ }
+
+ // Trim trailing lines (or empty strings)
+ while (
+ children.length &&
+ (isLineNext$1(util$1.getLast(children)) ||
+ isEmpty$1(util$1.getLast(children)))
+ ) {
+ children.pop();
+ }
+
+ // Trim leading lines (or empty strings)
+ while (
+ children.length &&
+ (isLineNext$1(children[0]) || isEmpty$1(children[0])) &&
+ (isLineNext$1(children[1]) || isEmpty$1(children[1]))
+ ) {
+ children.shift();
+ children.shift();
+ }
+
+ // 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) => {
+ // There are a number of situations where we need to ensure we display
+ // whitespace as `{" "}` when outputting this element over multiple lines.
+ if (child === jsxWhitespace) {
+ if (i === 1 && children[i - 1] === "") {
+ if (children.length === 2) {
+ // Solitary whitespace
+ multilineChildren.push(rawJsxWhitespace);
+ return;
+ }
+ // Leading whitespace
+ multilineChildren.push(concat([rawJsxWhitespace, hardline]));
+ return;
+ } else if (i === children.length - 1) {
+ // Trailing whitespace
+ multilineChildren.push(rawJsxWhitespace);
+ return;
+ } else if (children[i - 1] === "" && children[i - 2] === hardline) {
+ // Whitespace after line break
+ multilineChildren.push(rawJsxWhitespace);
+ return;
+ }
+ }
+
+ multilineChildren.push(child);
+
+ if (willBreak$1(child)) {
+ forcedBreak = true;
+ }
+ });
+
+ // If there is text we use `fill` to fit as much onto each line as possible.
+ // When there is no text (just tags and expressions) we use `group`
+ // to output each on a separate line.
+ const content = containsText
+ ? fill(multilineChildren)
+ : group(concat(multilineChildren), { shouldBreak: true });
+
+ const multiLineElem = group(
+ concat([
+ openingLines,
+ indent(concat([hardline, content])),
+ hardline,
+ closingLines
+ ])
+ );
+
+ if (forcedBreak) {
+ return multiLineElem;
+ }
+
+ return conditionalGroup([
+ group(concat([openingLines, concat(children), closingLines])),
+ multiLineElem
+ ]);
+}
+
+function maybeWrapJSXElementInParens(path$$1, elem) {
+ const parent = path$$1.getParentNode();
+ if (!parent) {
+ return elem;
+ }
+
+ const NO_WRAP_PARENTS = {
+ ArrayExpression: true,
+ JSXAttribute: true,
+ JSXElement: true,
+ JSXExpressionContainer: true,
+ JSXFragment: true,
+ TSJsxFragment: true,
+ ExpressionStatement: true,
+ CallExpression: true,
+ ConditionalExpression: true
+ };
+ if (NO_WRAP_PARENTS[parent.type]) {
+ return elem;
+ }
+
+ return group(
+ concat([
+ ifBreak("("),
+ indent(concat([softline, elem])),
+ softline,
+ ifBreak(")")
+ ])
+ );
+}
+
+function isBinaryish(node) {
+ return node.type === "BinaryExpression" || node.type === "LogicalExpression";
+}
+
+function isMemberish(node) {
+ return (
+ node.type === "MemberExpression" ||
+ (node.type === "BindExpression" && node.object)
+ );
+}
+
+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;
+ }
+
+ if (isJSXNode(node.right)) {
+ 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$$1,
+ print,
+ options,
+ isNested,
+ isInsideParenthesis
+) {
+ let parts = [];
+ const node = path$$1.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$1.shouldFlatten(node.operator, node.left.operator)) {
+ // Flatten them out by recursively calling this function.
+ parts = parts.concat(
+ path$$1.call(
+ left =>
+ printBinaryishExpressions(
+ left,
+ print,
+ options,
+ /* isNested */ true,
+ isInsideParenthesis
+ ),
+ "left"
+ )
+ );
+ } else {
+ parts.push(path$$1.call(print, "left"));
+ }
+
+ const shouldInline = shouldInlineLogicalExpression(node);
+ const lineBeforeOperator = node.operator === "|>";
+
+ const right = shouldInline
+ ? concat([node.operator, " ", path$$1.call(print, "right")])
+ : concat([
+ lineBeforeOperator ? softline : "",
+ node.operator,
+ lineBeforeOperator ? " " : line,
+ path$$1.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$$1.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(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.printComments(path$$1, () => concat(parts), options);
+ }
+ } else {
+ // Our stopping case. Simply print the node normally.
+ parts.push(path$$1.call(print));
+ }
+
+ return parts;
+}
+
+function printAssignmentRight(rightNode, printedRight, canBreak, options) {
+ if (hasLeadingOwnLineComment(options.originalText, rightNode, options)) {
+ return indent(concat([hardline, printedRight]));
+ }
+
+ if (canBreak) {
+ return indent(concat([line, printedRight]));
+ }
+
+ return concat([" ", printedRight]);
+}
+
+function printAssignment(
+ leftNode,
+ printedLeft,
+ operator,
+ rightNode,
+ printedRight,
+ options
+) {
+ if (!rightNode) {
+ return printedLeft;
+ }
+
+ const canBreak =
+ (isBinaryish(rightNode) && !shouldInlineLogicalExpression(rightNode)) ||
+ (rightNode.type === "ConditionalExpression" &&
+ isBinaryish(rightNode.test) &&
+ !shouldInlineLogicalExpression(rightNode.test)) ||
+ ((leftNode.type === "Identifier" ||
+ isStringLiteral(leftNode) ||
+ leftNode.type === "MemberExpression") &&
+ (isStringLiteral(rightNode) || isMemberExpressionChain(rightNode)));
+
+ const printed = printAssignmentRight(
+ rightNode,
+ printedRight,
+ canBreak,
+ options
+ );
+
+ return group(concat([printedLeft, operator, printed]));
+}
+
+function adjustClause(node, clause, forceSpace) {
+ if (node.type === "EmptyStatement") {
+ return ";";
+ }
+
+ if (node.type === "BlockStatement" || forceSpace) {
+ return concat([" ", clause]);
+ }
+
+ return indent(concat([line, clause]));
+}
+
+function nodeStr(node, options, isFlowOrTypeScriptDirectiveLiteral) {
+ const raw = rawText(node);
+ const isDirectiveLiteral =
+ isFlowOrTypeScriptDirectiveLiteral || node.type === "DirectiveLiteral";
+ return util$1.printString(raw, options, isDirectiveLiteral);
+}
+
+function printRegex(node) {
+ const flags = node.flags
+ .split("")
+ .sort()
+ .join("");
+ return `/${node.pattern}/${flags}`;
+}
+
+function isLastStatement(path$$1) {
+ const parent = path$$1.getParentNode();
+ if (!parent) {
+ return true;
+ }
+ const node = path$$1.getValue();
+ const body = (parent.body || parent.consequent).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, options) {
+ if (isJSXNode(node)) {
+ return util$1.hasNodeIgnoreComment(node);
+ }
+
+ const res =
+ node.comments &&
+ node.comments.some(
+ comment =>
+ comment.leading && util$1.hasNewline(text, options.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 === "BindExpression" && !node.object) ||
+ (node.type === "UpdateExpression" && !node.prefix)
+ );
+}
+
+function isFlowAnnotationComment(text, typeAnnotation, options) {
+ const start = options.locStart(typeAnnotation);
+ const end = util$1.skipWhitespace(text, options.locEnd(typeAnnotation));
+ return text.substr(start, 2) === "/*" && text.substr(end, 2) === "*/";
+}
+
+function getLeftSide(node) {
+ if (node.expressions) {
+ return node.expressions[0];
+ }
+ return (
+ node.left ||
+ node.test ||
+ node.callee ||
+ node.object ||
+ node.tag ||
+ node.argument ||
+ node.expression
+ );
+}
+
+function getLeftSidePathName(path$$1, node) {
+ if (node.expressions) {
+ return ["expressions", 0];
+ }
+ if (node.left) {
+ return ["left"];
+ }
+ if (node.test) {
+ return ["test"];
+ }
+ if (node.callee) {
+ return ["callee"];
+ }
+ if (node.object) {
+ return ["object"];
+ }
+ if (node.tag) {
+ return ["tag"];
+ }
+ if (node.argument) {
+ return ["argument"];
+ }
+ if (node.expression) {
+ return ["expression"];
+ }
+ throw new Error("Unexpected node has no left side", node);
+}
+
+function exprNeedsASIProtection(path$$1, options) {
+ const node = path$$1.getValue();
+
+ const maybeASIProblem =
+ needsParens_1(path$$1, options) ||
+ node.type === "ParenthesizedExpression" ||
+ node.type === "TypeCastExpression" ||
+ (node.type === "ArrowFunctionExpression" &&
+ !shouldPrintParamsWithoutParens(path$$1, options)) ||
+ node.type === "ArrayExpression" ||
+ node.type === "ArrayPattern" ||
+ (node.type === "UnaryExpression" &&
+ node.prefix &&
+ (node.operator === "+" || node.operator === "-")) ||
+ node.type === "TemplateLiteral" ||
+ node.type === "TemplateElement" ||
+ isJSXNode(node) ||
+ 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 path$$1.call.apply(
+ path$$1,
+ [childPath => exprNeedsASIProtection(childPath, options)].concat(
+ getLeftSidePathName(path$$1, node)
+ )
+ );
+}
+
+function stmtNeedsASIProtection(path$$1, options) {
+ const node = path$$1.getNode();
+
+ if (node.type !== "ExpressionStatement") {
+ return false;
+ }
+
+ return path$$1.call(
+ childPath => exprNeedsASIProtection(childPath, options),
+ "expression"
+ );
+}
+
+function classPropMayCauseASIProblems(path$$1) {
+ const node = path$$1.getNode();
+
+ if (node.type !== "ClassProperty") {
+ return false;
+ }
+
+ const name = node.key && node.key.name;
+
+ // this isn't actually possible yet with most parsers available today
+ // so isn't properly tested yet.
+ if (
+ (name === "static" || name === "get" || name === "set") &&
+ !node.value &&
+ !node.typeAnnotation
+ ) {
+ return true;
+ }
+}
+
+function classChildNeedsASIProtection(node) {
+ if (!node) {
+ return;
+ }
+
+ if (!node.computed) {
+ const name = node.key && node.key.name;
+ if (name === "in" || name === "instanceof") {
+ return true;
+ }
+ }
+ 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:
+ /* istanbul ignore next */
+ 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, options)) {
+ return true;
+ }
+
+ if (hasNakedLeftSide(argument)) {
+ let leftMost = argument;
+ let newLeftMost;
+ while ((newLeftMost = getLeftSide(leftMost))) {
+ leftMost = newLeftMost;
+
+ if (hasLeadingOwnLineComment(options.originalText, leftMost, options)) {
+ 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, options) {
+ return (
+ node.type === "ObjectTypeProperty" &&
+ node.value.type === "FunctionTypeAnnotation" &&
+ !node.static &&
+ !isFunctionNotation(node, options)
+ );
+}
+
+// TODO: This is a bad hack and we need a better way to distinguish between
+// arrow functions and otherwise
+function isFunctionNotation(node, options) {
+ return isGetterOrSetter(node) || sameLocStart(node, node.value, options);
+}
+
+function isGetterOrSetter(node) {
+ return node.kind === "get" || node.kind === "set";
+}
+
+function sameLocStart(nodeA, nodeB, options) {
+ return options.locStart(nodeA) === options.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, options) {
+ return (
+ (node.type === "TypeAnnotation" || node.type === "TSTypeAnnotation") &&
+ node.typeAnnotation.type === "FunctionTypeAnnotation" &&
+ !node.static &&
+ !sameLocStart(node, node.typeAnnotation, options)
+ );
+}
+
+function isNodeStartingWithDeclare(node, options) {
+ if (!(options.parser === "flow" || options.parser === "typescript")) {
+ return false;
+ }
+ return (
+ options.originalText
+ .slice(0, options.locStart(node))
+ .match(/declare[ \t]*$/) ||
+ options.originalText
+ .slice(node.range[0], node.range[1])
+ .startsWith("declare ")
+ );
+}
+
+function shouldHugType(node) {
+ if (isObjectType(node)) {
+ return true;
+ }
+
+ if (node.type === "UnionTypeAnnotation" || node.type === "TSUnionType") {
+ const voidCount = node.types.filter(
+ n =>
+ n.type === "VoidTypeAnnotation" ||
+ n.type === "TSVoidKeyword" ||
+ n.type === "NullLiteralTypeAnnotation" ||
+ n.type === "TSNullKeyword"
+ ).length;
+
+ const objectCount = node.types.filter(
+ n =>
+ n.type === "ObjectTypeAnnotation" ||
+ n.type === "TSTypeLiteral" ||
+ // This is a bit aggressive but captures Array<{x}>
+ n.type === "GenericTypeAnnotation" ||
+ n.type === "TSTypeReference"
+ ).length;
+
+ if (node.types.length - 1 === voidCount && objectCount > 0) {
+ 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 === "ArrayPattern" ||
+ (fun.params[0].type === "Identifier" &&
+ fun.params[0].typeAnnotation &&
+ (fun.params[0].typeAnnotation.type === "TypeAnnotation" ||
+ fun.params[0].typeAnnotation.type === "TSTypeAnnotation") &&
+ isObjectType(fun.params[0].typeAnnotation.typeAnnotation)) ||
+ (fun.params[0].type === "FunctionTypeParam" &&
+ isObjectType(fun.params[0].typeAnnotation)) ||
+ (fun.params[0].type === "AssignmentPattern" &&
+ (fun.params[0].left.type === "ObjectPattern" ||
+ fun.params[0].left.type === "ArrayPattern") &&
+ (fun.params[0].right.type === "Identifier" ||
+ (fun.params[0].right.type === "ObjectExpression" &&
+ fun.params[0].right.properties.length === 0) ||
+ (fun.params[0].right.type === "ArrayExpression" &&
+ fun.params[0].right.elements.length === 0)))) &&
+ !fun.rest
+ );
+}
+
+function templateLiteralHasNewLines(template) {
+ return template.quasis.some(quasi => quasi.value.raw.includes("\n"));
+}
+
+function isTemplateOnItsOwnLine(n, text, options) {
+ return (
+ ((n.type === "TemplateLiteral" && templateLiteralHasNewLines(n)) ||
+ (n.type === "TaggedTemplateExpression" &&
+ templateLiteralHasNewLines(n.quasi))) &&
+ !util$1.hasNewline(text, options.locStart(n), { backwards: true })
+ );
+}
+
+function printArrayItems(path$$1, options, printPath, print) {
+ const printedElements = [];
+ let separatorParts = [];
+
+ path$$1.each(childPath => {
+ printedElements.push(concat(separatorParts));
+ printedElements.push(group(print(childPath)));
+
+ separatorParts = [",", line];
+ if (
+ childPath.getValue() &&
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ childPath.getValue(),
+ options
+ )
+ ) {
+ separatorParts.push(softline);
+ }
+ }, printPath);
+
+ return concat(printedElements);
+}
+
+function hasDanglingComments(node) {
+ return (
+ node.comments &&
+ node.comments.some(comment => !comment.leading && !comment.trailing)
+ );
+}
+
+function needsHardlineAfterDanglingComment(node) {
+ if (!node.comments) {
+ return false;
+ }
+ const lastDanglingComment = util$1.getLast(
+ node.comments.filter(comment => !comment.leading && !comment.trailing)
+ );
+ return (
+ lastDanglingComment && !util$1.isBlockComment(lastDanglingComment)
+ );
+}
+
+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 isNumericLiteral(node) {
+ return (
+ node.type === "NumericLiteral" ||
+ (node.type === "Literal" && typeof node.value === "number")
+ );
+}
+
+function isStringLiteral(node) {
+ return (
+ node.type === "StringLiteral" ||
+ (node.type === "Literal" && typeof node.value === "string")
+ );
+}
+
+function isObjectType(n) {
+ return n.type === "ObjectTypeAnnotation" || n.type === "TSTypeLiteral";
+}
+
+// eg; `describe("some string", (done) => {})`
+function isTestCall(n, parent) {
+ const unitTestRe = /^(skip|(f|x)?(it|describe|test))$/;
+
+ if (n.arguments.length === 1) {
+ if (
+ n.callee.type === "Identifier" &&
+ n.callee.name === "async" &&
+ parent &&
+ parent.type === "CallExpression" &&
+ isTestCall(parent)
+ ) {
+ return isFunctionOrArrowExpression(n.arguments[0].type);
+ }
+
+ if (isUnitTestSetUp(n)) {
+ return (
+ isFunctionOrArrowExpression(n.arguments[0].type) ||
+ isIdentiferAsync(n.arguments[0])
+ );
+ }
+ } else if (n.arguments.length === 2) {
+ if (
+ ((n.callee.type === "Identifier" && unitTestRe.test(n.callee.name)) ||
+ isSkipOrOnlyBlock(n)) &&
+ (isTemplateLiteral(n.arguments[0]) || isStringLiteral(n.arguments[0]))
+ ) {
+ return (
+ (isFunctionOrArrowExpression(n.arguments[1].type) &&
+ n.arguments[1].params.length <= 1) ||
+ isIdentiferAsync(n.arguments[1])
+ );
+ }
+ }
+ return false;
+}
+
+function isSkipOrOnlyBlock(node) {
+ const unitTestRe = /^(skip|(f|x)?(it|describe|test))$/;
+ return (
+ node.callee.type === "MemberExpression" &&
+ node.callee.object.type === "Identifier" &&
+ node.callee.property.type === "Identifier" &&
+ unitTestRe.test(node.callee.object.name) &&
+ (node.callee.property.name === "only" ||
+ node.callee.property.name === "skip")
+ );
+}
+
+function isTemplateLiteral(node) {
+ return node.type === "TemplateLiteral";
+}
+
+function isIdentiferAsync(node) {
+ return (
+ node.type === "CallExpression" &&
+ node.callee.type === "Identifier" &&
+ node.callee.name === "async"
+ );
+}
+
+function isFunctionOrArrowExpression(type) {
+ return type === "FunctionExpression" || type === "ArrowFunctionExpression";
+}
+
+function isUnitTestSetUp(n) {
+ const unitTestSetUpRe = /^(before|after)(Each|All)$/;
+ return (
+ n.callee.type === "Identifier" &&
+ unitTestSetUpRe.test(n.callee.name) &&
+ n.arguments.length === 1
+ );
+}
+
+function isTheOnlyJSXElementInMarkdown(options, path$$1) {
+ if (options.parentParser !== "markdown") {
+ return false;
+ }
+
+ const node = path$$1.getNode();
+
+ if (!node.expression || !isJSXNode(node.expression)) {
+ return false;
+ }
+
+ const parent = path$$1.getParentNode();
+
+ return parent.type === "Program" && parent.body.length == 1;
+}
+
+function willPrintOwnComments(path$$1) {
+ const node = path$$1.getValue();
+ const parent = path$$1.getParentNode();
+
+ return (
+ ((node && isJSXNode(node)) ||
+ (parent &&
+ (parent.type === "JSXSpreadAttribute" ||
+ parent.type === "JSXSpreadChild" ||
+ parent.type === "UnionTypeAnnotation" ||
+ parent.type === "TSUnionType" ||
+ ((parent.type === "ClassDeclaration" ||
+ parent.type === "ClassExpression") &&
+ parent.superClass === node)))) &&
+ !util$1.hasIgnoreComment(path$$1)
+ );
+}
+
+function canAttachComment(node) {
+ return (
+ node.type &&
+ node.type !== "CommentBlock" &&
+ node.type !== "CommentLine" &&
+ node.type !== "Line" &&
+ node.type !== "Block" &&
+ node.type !== "EmptyStatement" &&
+ node.type !== "TemplateElement" &&
+ node.type !== "Import" &&
+ !(node.callee && node.callee.type === "Import")
+ );
+}
+
+function printComment(commentPath, options) {
+ const comment = commentPath.getValue();
+
+ switch (comment.type) {
+ case "CommentBlock":
+ case "Block": {
+ if (isJsDocComment(comment)) {
+ return printJsDocComment(comment);
+ }
+
+ const isInsideFlowComment =
+ options.originalText.substr(options.locEnd(comment) - 3, 3) === "*-/";
+
+ return "/*" + comment.value + (isInsideFlowComment ? "*-/" : "*/");
+ }
+ case "CommentLine":
+ case "Line":
+ // Print shebangs with the proper comment characters
+ if (
+ options.originalText.slice(options.locStart(comment)).startsWith("#!")
+ ) {
+ return "#!" + comment.value.trimRight();
+ }
+ return "//" + comment.value.trimRight();
+ default:
+ throw new Error("Not a comment: " + JSON.stringify(comment));
+ }
+}
+
+function isJsDocComment(comment) {
+ const lines = comment.value.split("\n");
+ return (
+ lines.length > 1 &&
+ lines.slice(0, lines.length - 1).every(line => line.trim()[0] === "*")
+ );
+}
+
+function printJsDocComment(comment) {
+ const lines = comment.value.split("\n");
+
+ return concat([
+ "/*",
+ join(
+ hardline,
+ lines.map(
+ (line, index) =>
+ (index > 0 ? " " : "") +
+ (index < lines.length - 1 ? line.trim() : line.trimLeft())
+ )
+ ),
+ "*/"
+ ]);
+}
+
+function rawText(node) {
+ return node.extra ? node.extra.raw : node.raw;
+}
+
+var printerEstree = {
+ print: genericPrint,
+ embed: embed_1,
+ insertPragma,
+ massageAstNode: clean_1,
+ hasPrettierIgnore,
+ willPrintOwnComments,
+ canAttachComment,
+ printComment,
+ handleComments: {
+ ownLine: comments$2.handleOwnLineComment,
+ endOfLine: comments$2.handleEndOfLineComment,
+ remaining: comments$2.handleRemainingComment
+ }
+};
+
+const CATEGORY_JAVASCRIPT = "JavaScript";
+
+// format based on https://github.com/prettier/prettier/blob/master/src/common/support.js
+var options = {
+ arrowParens: {
+ since: "1.9.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "choice",
+ default: "avoid",
+ description: "Include parentheses around a sole arrow function parameter.",
+ choices: [
+ {
+ value: "avoid",
+ description: "Omit parens when possible. Example: `x => x`"
+ },
+ {
+ value: "always",
+ description: "Always include parens. Example: `(x) => x`"
+ }
+ ]
+ },
+ bracketSpacing: {
+ since: "0.0.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "boolean",
+ default: true,
+ description: "Print spaces between brackets.",
+ oppositeDescription: "Do not print spaces between brackets."
+ },
+ jsxBracketSameLine: {
+ since: "0.17.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "boolean",
+ default: false,
+ description: "Put > on the last line instead of at a new line."
+ },
+ semi: {
+ since: "1.0.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "boolean",
+ default: true,
+ description: "Print semicolons.",
+ oppositeDescription:
+ "Do not print semicolons, except at the beginning of lines which may need them."
+ },
+ singleQuote: {
+ since: "0.0.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "boolean",
+ default: false,
+ description: "Use single quotes instead of double quotes."
+ },
+ trailingComma: {
+ since: "0.0.0",
+ category: CATEGORY_JAVASCRIPT,
+ type: "choice",
+ default: [
+ { since: "0.0.0", value: false },
+ { since: "0.19.0", value: "none" }
+ ],
+ description: "Print trailing commas wherever possible when multi-line.",
+ choices: [
+ { value: "none", description: "No trailing commas." },
+ {
+ value: "es5",
+ description:
+ "Trailing commas where valid in ES5 (objects, arrays, etc.)"
+ },
+ {
+ value: "all",
+ description:
+ "Trailing commas wherever possible (including function arguments)."
+ },
+ { value: true, deprecated: "0.19.0", redirect: "es5" },
+ { value: false, deprecated: "0.19.0", redirect: "none" }
+ ]
+ }
+};
+
+const hasPragma = pragma.hasPragma;
+
+
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const locStart = function(node) {
+ // Handle nodes with decorators. They should start at the first decorator
+ if (
+ node.declaration &&
+ node.declaration.decorators &&
+ node.declaration.decorators.length > 0
+ ) {
+ return locStart(node.declaration.decorators[0]);
+ }
+ if (node.decorators && node.decorators.length > 0) {
+ return locStart(node.decorators[0]);
+ }
+
+ if (node.__location) {
+ return node.__location.startOffset;
+ }
+ if (node.range) {
+ return node.range[0];
+ }
+ if (typeof node.start === "number") {
+ return node.start;
+ }
+ if (node.loc) {
+ return node.loc.start;
+ }
+ return null;
+};
+
+const locEnd = function(node) {
+ const endNode = node.nodes && util$1.getLast(node.nodes);
+ if (endNode && node.source && !node.source.end) {
+ node = endNode;
+ }
+
+ let loc;
+ if (node.range) {
+ loc = node.range[1];
+ } else if (typeof node.end === "number") {
+ loc = node.end;
+ }
+
+ if (node.__location) {
+ return node.__location.endOffset;
+ }
+ if (node.typeAnnotation) {
+ return Math.max(loc, locEnd(node.typeAnnotation));
+ }
+
+ if (node.loc && !loc) {
+ return node.loc.end;
+ }
+
+ return loc;
+};
+
+const languages = [
+ {
+ name: "JavaScript",
+ since: "0.0.0",
+ parsers: ["babylon", "flow"],
+ group: "JavaScript",
+ tmScope: "source.js",
+ aceMode: "javascript",
+ codemirrorMode: "javascript",
+ codemirrorMimeType: "text/javascript",
+ aliases: ["js", "node"],
+ extensions: [
+ ".js",
+ "._js",
+ ".bones",
+ ".es",
+ ".es6",
+ ".frag",
+ ".gs",
+ ".jake",
+ ".jsb",
+ ".jscad",
+ ".jsfl",
+ ".jsm",
+ ".jss",
+ ".mjs",
+ ".njs",
+ ".pac",
+ ".sjs",
+ ".ssjs",
+ ".xsjs",
+ ".xsjslib"
+ ],
+ filenames: ["Jakefile"],
+ linguistLanguageId: 183,
+ vscodeLanguageIds: ["javascript"]
+ },
+ {
+ name: "JSX",
+ since: "0.0.0",
+ parsers: ["babylon", "flow"],
+ group: "JavaScript",
+ extensions: [".jsx"],
+ tmScope: "source.js.jsx",
+ aceMode: "javascript",
+ codemirrorMode: "jsx",
+ codemirrorMimeType: "text/jsx",
+ liguistLanguageId: 178,
+ vscodeLanguageIds: ["javascriptreact"]
+ },
+ {
+ name: "TypeScript",
+ since: "1.4.0",
+ parsers: ["typescript-eslint"],
+ group: "JavaScript",
+ aliases: ["ts"],
+ extensions: [".ts", ".tsx"],
+ tmScope: "source.ts",
+ aceMode: "typescript",
+ codemirrorMode: "javascript",
+ codemirrorMimeType: "application/typescript",
+ liguistLanguageId: 378,
+ vscodeLanguageIds: ["typescript", "typescriptreact"]
+ },
+ {
+ name: "JSON",
+ since: "1.5.0",
+ parsers: ["json"],
+ group: "JavaScript",
+ tmScope: "source.json",
+ aceMode: "json",
+ codemirrorMode: "javascript",
+ codemirrorMimeType: "application/json",
+ extensions: [
+ ".json",
+ ".json5",
+ ".geojson",
+ ".JSON-tmLanguage",
+ ".topojson"
+ ],
+ filenames: [
+ ".arcconfig",
+ ".jshintrc",
+ ".babelrc",
+ ".eslintrc",
+ ".prettierrc",
+ "composer.lock",
+ "mcmod.info"
+ ],
+ linguistLanguageId: 174,
+ vscodeLanguageIds: ["json", "jsonc"]
+ }
+];
+
+const typescript = {
+ get parse() {
+ return require("./parser-typescript");
+ },
+ astFormat: "estree",
+ hasPragma,
+ locStart,
+ locEnd
+};
+
+const babylon = {
+ get parse() {
+ return require("./parser-babylon");
+ },
+ astFormat: "estree",
+ hasPragma,
+ locStart,
+ locEnd
+};
+
+const parsers = {
+ babylon,
+ json: Object.assign({}, babylon, {
+ hasPragma() {
+ return false;
+ }
+ }),
+ flow: {
+ get parse() {
+ return require("./parser-flow");
+ },
+ astFormat: "estree",
+ hasPragma,
+ locStart,
+ locEnd
+ },
+ "typescript-eslint": typescript,
+ // TODO: Delete this in 2.0
+ typescript
+};
+
+const printers = {
+ estree: printerEstree
+};
+
+var languageJs = {
+ languages,
+ options,
+ parsers,
+ printers,
+ locStart,
+ locEnd
+};
+
+var index$1 = [
+ "a",
+ "abbr",
+ "acronym",
+ "address",
+ "applet",
+ "area",
+ "article",
+ "aside",
+ "audio",
+ "b",
+ "base",
+ "basefont",
+ "bdi",
+ "bdo",
+ "bgsound",
+ "big",
+ "blink",
+ "blockquote",
+ "body",
+ "br",
+ "button",
+ "canvas",
+ "caption",
+ "center",
+ "cite",
+ "code",
+ "col",
+ "colgroup",
+ "command",
+ "content",
+ "data",
+ "datalist",
+ "dd",
+ "del",
+ "details",
+ "dfn",
+ "dialog",
+ "dir",
+ "div",
+ "dl",
+ "dt",
+ "element",
+ "em",
+ "embed",
+ "fieldset",
+ "figcaption",
+ "figure",
+ "font",
+ "footer",
+ "form",
+ "frame",
+ "frameset",
+ "h1",
+ "h2",
+ "h3",
+ "h4",
+ "h5",
+ "h6",
+ "head",
+ "header",
+ "hgroup",
+ "hr",
+ "html",
+ "i",
+ "iframe",
+ "image",
+ "img",
+ "input",
+ "ins",
+ "isindex",
+ "kbd",
+ "keygen",
+ "label",
+ "legend",
+ "li",
+ "link",
+ "listing",
+ "main",
+ "map",
+ "mark",
+ "marquee",
+ "math",
+ "menu",
+ "menuitem",
+ "meta",
+ "meter",
+ "multicol",
+ "nav",
+ "nextid",
+ "nobr",
+ "noembed",
+ "noframes",
+ "noscript",
+ "object",
+ "ol",
+ "optgroup",
+ "option",
+ "output",
+ "p",
+ "param",
+ "picture",
+ "plaintext",
+ "pre",
+ "progress",
+ "q",
+ "rb",
+ "rbc",
+ "rp",
+ "rt",
+ "rtc",
+ "ruby",
+ "s",
+ "samp",
+ "script",
+ "section",
+ "select",
+ "shadow",
+ "slot",
+ "small",
+ "source",
+ "spacer",
+ "span",
+ "strike",
+ "strong",
+ "style",
+ "sub",
+ "summary",
+ "sup",
+ "svg",
+ "table",
+ "tbody",
+ "td",
+ "template",
+ "textarea",
+ "tfoot",
+ "th",
+ "thead",
+ "time",
+ "title",
+ "tr",
+ "track",
+ "tt",
+ "u",
+ "ul",
+ "var",
+ "video",
+ "wbr",
+ "xmp"
+]
+;
+
+var htmlTagNames = Object.freeze({
+ default: index$1
+});
+
+var htmlTagNames$1 = ( htmlTagNames && index$1 ) || htmlTagNames;
+
+function clean$2(ast, newObj) {
+ if (
+ ast.type === "media-query" ||
+ ast.type === "media-query-list" ||
+ ast.type === "media-feature-expression"
+ ) {
+ delete newObj.value;
+ }
+
+ if (ast.type === "css-rule") {
+ delete newObj.params;
+ }
+
+ if (ast.type === "selector-combinator") {
+ newObj.value = newObj.value.replace(/\s+/g, " ");
+ }
+
+ if (ast.type === "media-feature") {
+ newObj.value = newObj.value.replace(/ /g, "");
+ }
+
+ if (
+ (ast.type === "value-word" &&
+ ((ast.isColor && ast.isHex) ||
+ ["initial", "inherit", "unset", "revert"].indexOf(
+ newObj.value.replace().toLowerCase()
+ ) !== -1)) ||
+ ast.type === "media-feature" ||
+ ast.type === "selector-root-invalid" ||
+ ast.type === "selector-pseudo"
+ ) {
+ newObj.value = newObj.value.toLowerCase();
+ }
+ if (ast.type === "css-decl") {
+ newObj.prop = newObj.prop.toLowerCase();
+ }
+ if (ast.type === "css-atrule" || ast.type === "css-import") {
+ newObj.name = newObj.name.toLowerCase();
+ }
+ if (ast.type === "value-number") {
+ newObj.unit = newObj.unit.toLowerCase();
+ }
+
+ if (
+ (ast.type === "media-feature" ||
+ ast.type === "media-keyword" ||
+ ast.type === "media-type" ||
+ ast.type === "media-unknown" ||
+ ast.type === "media-url" ||
+ ast.type === "media-value" ||
+ ast.type === "selector-root-invalid" ||
+ ast.type === "selector-attribute" ||
+ ast.type === "selector-string" ||
+ ast.type === "selector-class" ||
+ ast.type === "selector-combinator" ||
+ ast.type === "value-string") &&
+ newObj.value
+ ) {
+ newObj.value = cleanCSSStrings(newObj.value);
+ }
+
+ if (ast.type === "css-import" && newObj.importPath) {
+ newObj.importPath = cleanCSSStrings(newObj.importPath);
+ }
+
+ if (ast.type === "selector-attribute") {
+ newObj.attribute = newObj.attribute.trim();
+
+ if (newObj.namespace) {
+ if (typeof newObj.namespace === "string") {
+ newObj.namespace = newObj.namespace.trim();
+
+ if (newObj.namespace.length === 0) {
+ newObj.namespace = true;
+ }
+ }
+ }
+
+ if (newObj.value) {
+ newObj.value = newObj.value.trim().replace(/^['"]|['"]$/g, "");
+ delete newObj.quoted;
+ }
+ }
+
+ if (
+ (ast.type === "media-value" ||
+ ast.type === "media-type" ||
+ ast.type === "value-number" ||
+ ast.type === "selector-root-invalid" ||
+ ast.type === "selector-class" ||
+ ast.type === "selector-combinator" ||
+ ast.type === "selector-tag") &&
+ newObj.value
+ ) {
+ newObj.value = newObj.value.replace(
+ /([\d.eE+-]+)([a-zA-Z]*)/g,
+ (match, numStr, unit) => {
+ const num = Number(numStr);
+ return isNaN(num) ? match : num + unit.toLowerCase();
+ }
+ );
+ }
+
+ if (ast.type === "media-url") {
+ newObj.value = newObj.value
+ .replace(/^url\(\s+/gi, "url(")
+ .replace(/\s+\)$/gi, ")");
+ }
+
+ if (ast.type === "selector-tag") {
+ const lowercasedValue = ast.value.toLowerCase();
+
+ if (htmlTagNames$1.indexOf(lowercasedValue) !== -1) {
+ newObj.value = lowercasedValue;
+ }
+
+ if (["from", "to"].indexOf(lowercasedValue) !== -1) {
+ newObj.value = lowercasedValue;
+ }
+ }
+}
+
+function cleanCSSStrings(value) {
+ return value.replace(/'/g, '"').replace(/\\([^a-fA-F\d])/g, "$1");
+}
+
+var clean_1$2 = clean$2;
+
+const docBuilders$6 = doc.builders;
+const concat$5 = docBuilders$6.concat;
+const join$4 = docBuilders$6.join;
+const line$2 = docBuilders$6.line;
+const hardline$4 = docBuilders$6.hardline;
+const softline$3 = docBuilders$6.softline;
+const group$2 = docBuilders$6.group;
+const fill$3 = docBuilders$6.fill;
+const indent$4 = docBuilders$6.indent;
+
+const removeLines$1 = doc.utils.removeLines;
+
+function genericPrint$1(path$$1, options, print) {
+ const node = path$$1.getValue();
+
+ /* istanbul ignore if */
+ if (!node) {
+ return "";
+ }
+
+ if (typeof node === "string") {
+ return node;
+ }
+
+ switch (node.type) {
+ case "css-comment-yaml":
+ return node.value;
+ case "css-root": {
+ const nodes = printNodeSequence(path$$1, options, print);
+
+ if (nodes.parts.length) {
+ return concat$5([nodes, hardline$4]);
+ }
+
+ return nodes;
+ }
+ case "css-comment": {
+ if (node.raws.content) {
+ return node.raws.content;
+ }
+ const text = options.originalText.slice(
+ options.locStart(node),
+ options.locEnd(node)
+ );
+ const rawText = node.raws.text || node.text;
+ // Workaround a bug where the location is off.
+ // https://github.com/postcss/postcss-scss/issues/63
+ if (text.indexOf(rawText) === -1) {
+ if (node.raws.inline) {
+ return concat$5(["// ", rawText]);
+ }
+ return concat$5(["/* ", rawText, " */"]);
+ }
+ return text;
+ }
+ case "css-rule": {
+ return concat$5([
+ path$$1.call(print, "selector"),
+ node.important ? " !important" : "",
+ node.nodes
+ ? concat$5([
+ " {",
+ node.nodes.length > 0
+ ? indent$4(
+ concat$5([hardline$4, printNodeSequence(path$$1, options, print)])
+ )
+ : "",
+ hardline$4,
+ "}",
+ isDetachedRulesetDeclaration(node) ? ";" : ""
+ ])
+ : ";"
+ ]);
+ }
+ case "css-decl": {
+ // When the following less construct &:extend(.foo); is parsed with scss,
+ // it will put a space after `:` and break it. Ideally we should parse
+ // less files with less, but we can hardcode this to work with scss as
+ // well.
+ const isValueExtend =
+ node.value.type === "value-root" &&
+ node.value.group.type === "value-value" &&
+ node.value.group.group.type === "value-func" &&
+ node.value.group.group.value === "extend";
+ const isComposed =
+ node.value.type === "value-root" &&
+ node.value.group.type === "value-value" &&
+ node.prop === "composes";
+ const ruleAncestorNode = getAncestorNode(path$$1, "css-rule");
+ const isiCSS =
+ ruleAncestorNode &&
+ ruleAncestorNode.raws.selector &&
+ (ruleAncestorNode.raws.selector.startsWith(":import") ||
+ ruleAncestorNode.raws.selector.startsWith(":export"));
+
+ return concat$5([
+ node.raws.before.replace(/[\s;]/g, ""),
+ isiCSS ? node.prop : maybeToLowerCase(node.prop),
+ node.raws.between.trim() === ":" ? ":" : node.raws.between.trim(),
+ isValueExtend ? "" : " ",
+ isComposed
+ ? removeLines$1(path$$1.call(print, "value"))
+ : path$$1.call(print, "value"),
+ node.raws.important
+ ? node.raws.important.replace(/\s*!\s*important/i, " !important")
+ : node.important
+ ? " !important"
+ : "",
+ node.raws.scssDefault
+ ? node.raws.scssDefault.replace(/\s*!default/i, " !default")
+ : node.scssDefault
+ ? " !default"
+ : "",
+ node.raws.scssGlobal
+ ? node.raws.scssGlobal.replace(/\s*!global/i, " !global")
+ : node.scssGlobal
+ ? " !global"
+ : "",
+ node.nodes
+ ? concat$5([
+ " {",
+ indent$4(
+ concat$5([softline$3, printNodeSequence(path$$1, options, print)])
+ ),
+ softline$3,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ case "css-atrule": {
+ const hasParams =
+ node.params &&
+ !(node.params.type === "media-query-list" && node.params.value === "");
+ const isDetachedRulesetCall = hasParams && /^\(\s*\)$/.test(node.params);
+ const hasParensAround =
+ node.value &&
+ node.value.group.group.type === "value-paren_group" &&
+ node.value.group.group.open !== null &&
+ node.value.group.group.close !== null;
+
+ return concat$5([
+ "@",
+ // If a Less file ends up being parsed with the SCSS parser, Less
+ // variable declarations will be parsed as atrules with names ending
+ // with a colon, so keep the original case then.
+ isDetachedRulesetCall || node.name.endsWith(":")
+ ? node.name
+ : maybeToLowerCase(node.name),
+ hasParams
+ ? concat$5([
+ isDetachedRulesetCall ? "" : " ",
+ path$$1.call(print, "params")
+ ])
+ : "",
+ node.selector
+ ? indent$4(concat$5([" ", path$$1.call(print, "selector")]))
+ : "",
+ node.value
+ ? group$2(
+ concat$5([
+ " ",
+ path$$1.call(print, "value"),
+ isControlDirectiveNode(node)
+ ? hasParensAround
+ ? " "
+ : line$2
+ : ""
+ ])
+ )
+ : node.name === "else"
+ ? " "
+ : "",
+ node.nodes
+ ? concat$5([
+ isControlDirectiveNode(node) ? "" : " ",
+ "{",
+ indent$4(
+ concat$5([
+ node.nodes.length > 0 ? softline$3 : "",
+ printNodeSequence(path$$1, options, print)
+ ])
+ ),
+ softline$3,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ case "css-import": {
+ return concat$5([
+ "@",
+ maybeToLowerCase(node.name),
+ " ",
+ node.directives ? concat$5([node.directives, " "]) : "",
+ adjustStrings(node.importPath, options),
+ node.nodes.length > 0
+ ? concat$5([
+ " {",
+ indent$4(
+ concat$5([softline$3, printNodeSequence(path$$1, options, print)])
+ ),
+ softline$3,
+ "}"
+ ])
+ : ";"
+ ]);
+ }
+ // postcss-media-query-parser
+ case "media-query-list": {
+ const parts = [];
+ path$$1.each(childPath => {
+ const node = childPath.getValue();
+ if (node.type === "media-query" && node.value === "") {
+ return;
+ }
+ parts.push(childPath.call(print));
+ }, "nodes");
+
+ return group$2(indent$4(join$4(line$2, parts)));
+ }
+ case "media-query": {
+ return concat$5([
+ join$4(" ", path$$1.map(print, "nodes")),
+ isLastNode(path$$1, node) ? "" : ","
+ ]);
+ }
+ case "media-type": {
+ const atRuleAncestorNode = getAncestorNode(path$$1, "css-atrule");
+ if (
+ atRuleAncestorNode &&
+ atRuleAncestorNode.name.toLowerCase() === "charset"
+ ) {
+ return node.value;
+ }
+ return adjustNumbers(adjustStrings(node.value, options));
+ }
+ case "media-feature-expression": {
+ if (!node.nodes) {
+ return node.value;
+ }
+ return concat$5(["(", concat$5(path$$1.map(print, "nodes")), ")"]);
+ }
+ case "media-feature": {
+ return maybeToLowerCase(
+ adjustStrings(node.value.replace(/ +/g, " "), options)
+ );
+ }
+ case "media-colon": {
+ return concat$5([node.value, " "]);
+ }
+ case "media-value": {
+ return adjustNumbers(adjustStrings(node.value, options));
+ }
+ case "media-keyword": {
+ return adjustStrings(node.value, options);
+ }
+ case "media-url": {
+ return adjustStrings(
+ node.value.replace(/^url\(\s+/gi, "url(").replace(/\s+\)$/gi, ")"),
+ options
+ );
+ }
+ case "media-unknown": {
+ return adjustStrings(node.value, options);
+ }
+ // postcss-selector-parser
+ case "selector-root-invalid": {
+ // This is likely a SCSS nested property: `background: { color: red; }`.
+ return adjustNumbers(
+ adjustStrings(maybeToLowerCase(node.value), options)
+ );
+ }
+ case "selector-root": {
+ const atRuleAncestorNode = getAncestorNode(path$$1, "css-atrule");
+ const insideAtRuleNode =
+ atRuleAncestorNode &&
+ ["extend", "custom-selector", "nest"].indexOf(
+ atRuleAncestorNode.name
+ ) !== -1;
+
+ return group$2(
+ concat$5([
+ atRuleAncestorNode && atRuleAncestorNode.name === "custom-selector"
+ ? concat$5([atRuleAncestorNode.customSelector, line$2])
+ : "",
+ join$4(
+ concat$5([",", insideAtRuleNode ? line$2 : hardline$4]),
+ path$$1.map(print, "nodes")
+ )
+ ])
+ );
+ }
+ case "selector-comment": {
+ return node.value;
+ }
+ case "selector-string": {
+ return adjustStrings(node.value, options);
+ }
+ case "selector-tag": {
+ const parentNode = path$$1.getParentNode();
+ const index = parentNode && parentNode.nodes.indexOf(node);
+ const prevNode = index && parentNode.nodes[index - 1];
+
+ return concat$5([
+ node.namespace
+ ? concat$5([node.namespace === true ? "" : node.namespace.trim(), "|"])
+ : "",
+ prevNode.type === "selector-nesting"
+ ? node.value
+ : adjustNumbers(
+ isHTMLTag(node.value) ||
+ isKeyframeAtRuleKeywords(path$$1, node.value)
+ ? node.value.toLowerCase()
+ : node.value
+ )
+ ]);
+ }
+ case "selector-id": {
+ return concat$5(["#", node.value]);
+ }
+ case "selector-class": {
+ return concat$5([".", adjustNumbers(adjustStrings(node.value, options))]);
+ }
+ case "selector-attribute": {
+ return concat$5([
+ "[",
+ node.namespace
+ ? concat$5([node.namespace === true ? "" : node.namespace.trim(), "|"])
+ : "",
+ node.attribute.trim(),
+ node.operator ? node.operator : "",
+ node.value
+ ? quoteAttributeValue(
+ adjustStrings(node.value.trim(), options),
+ options
+ )
+ : "",
+ node.insensitive ? " i" : "",
+ "]"
+ ]);
+ }
+ case "selector-combinator": {
+ if (
+ node.value === "+" ||
+ node.value === ">" ||
+ node.value === "~" ||
+ node.value === ">>>"
+ ) {
+ const parentNode = path$$1.getParentNode();
+ const leading =
+ parentNode.type === "selector-selector" &&
+ parentNode.nodes[0] === node
+ ? ""
+ : line$2;
+ return concat$5([leading, node.value, isLastNode(path$$1, node) ? "" : " "]);
+ }
+ const leading = node.value.trim().startsWith("(") ? line$2 : "";
+ const value =
+ adjustNumbers(adjustStrings(node.value.trim(), options)) || line$2;
+ return concat$5([leading, value]);
+ }
+ case "selector-universal": {
+ return concat$5([
+ node.namespace
+ ? concat$5([node.namespace === true ? "" : node.namespace.trim(), "|"])
+ : "",
+ adjustNumbers(node.value)
+ ]);
+ }
+ case "selector-selector": {
+ return group$2(indent$4(concat$5(path$$1.map(print, "nodes"))));
+ }
+ case "selector-pseudo": {
+ return concat$5([
+ maybeToLowerCase(node.value),
+ node.nodes && node.nodes.length > 0
+ ? concat$5(["(", join$4(", ", path$$1.map(print, "nodes")), ")"])
+ : ""
+ ]);
+ }
+ case "selector-nesting": {
+ return node.value;
+ }
+ // postcss-values-parser
+ case "value-root": {
+ return path$$1.call(print, "group");
+ }
+ case "value-comment": {
+ return concat$5([
+ node.inline ? "//" : "/*",
+ node.value,
+ node.inline ? "" : "*/"
+ ]);
+ }
+ case "value-comma_group": {
+ const parentNode = path$$1.getParentNode();
+ const declAncestorNode = getAncestorNode(path$$1, "css-decl");
+ const declAncestorProp =
+ declAncestorNode &&
+ declAncestorNode.prop &&
+ declAncestorNode.prop.toLowerCase();
+ const isGridValue =
+ declAncestorProp &&
+ parentNode.type === "value-value" &&
+ (declAncestorProp === "grid" ||
+ declAncestorProp.startsWith("grid-template"));
+ const atRuleAncestorNode = getAncestorNode(path$$1, "css-atrule");
+ const isControlDirective =
+ atRuleAncestorNode && isControlDirectiveNode(atRuleAncestorNode);
+
+ const printed = path$$1.map(print, "groups");
+ const parts = [];
+ const functionAncestorNode = getAncestorNode(path$$1, "value-func");
+ const insideInFunction =
+ functionAncestorNode && functionAncestorNode.value;
+ const insideURLFunction =
+ insideInFunction && functionAncestorNode.value.toLowerCase() === "url";
+
+ let didBreak = false;
+ for (let i = 0; i < node.groups.length; ++i) {
+ parts.push(printed[i]);
+
+ // Ignore value inside `url()`
+ if (insideURLFunction) {
+ continue;
+ }
+
+ const iPrevNode = node.groups[i - 1];
+ const iNode = node.groups[i];
+ const iNextNode = node.groups[i + 1];
+ const iNextNextNode = node.groups[i + 2];
+
+ // Ignore after latest node (i.e. before semicolon)
+ if (!iNextNode) {
+ continue;
+ }
+
+ // Ignore colon
+ if (iNode.value === ":") {
+ continue;
+ }
+
+ // Ignore `@` in Less (i.e. `@@var;`)
+ if (iNode.type === "value-atword" && iNode.value === "") {
+ continue;
+ }
+
+ // Ignore `~` in Less (i.e. `content: ~"^//* some horrible but needed css hack";`)
+ if (iNode.value === "~") {
+ continue;
+ }
+
+ if (
+ (iPrevNode &&
+ iPrevNode.type === "value-comment" &&
+ iPrevNode.inline) ||
+ (iNextNode.type === "value-comment" && iNextNode.inline)
+ ) {
+ continue;
+ }
+
+ const isHash = iNode.type === "value-word" && iNode.value === "#";
+ const isLeftCurlyBrace =
+ iNode.type === "value-word" && iNode.value === "{";
+ const isNextLeftCurlyBrace =
+ iNextNode.type === "value-word" && iNextNode.value === "{";
+ const isRightCurlyBrace =
+ iNode.type === "value-word" && iNode.value === "}";
+ const isNextRightCurlyBrace =
+ iNextNode.type === "value-word" && iNextNode.value === "}";
+
+ // Ignore interpolation in SCSS (i.e. ``#{variable}``)
+ if (
+ isHash ||
+ isLeftCurlyBrace ||
+ isNextRightCurlyBrace ||
+ (isNextLeftCurlyBrace &&
+ iNextNode.raws &&
+ iNextNode.raws.before === "") ||
+ (isRightCurlyBrace && iNextNode.raws && iNextNode.raws.before === "")
+ ) {
+ continue;
+ }
+
+ const isNextHash =
+ iNextNode.type === "value-word" && iNextNode.value === "#";
+
+ const isMathOperator = isMathOperatorNode(iNode);
+ const isNextMathOperator = isMathOperatorNode(iNextNode);
+
+ const isMultiplication =
+ !isNextHash && isMathOperator && iNode.value === "*";
+ const isNextMultiplication =
+ !isRightCurlyBrace && isNextMathOperator && iNextNode.value === "*";
+
+ const isDivision = !isNextHash && isMathOperator && iNode.value === "/";
+ const isNextDivision =
+ !isRightCurlyBrace && isNextMathOperator && iNextNode.value === "/";
+
+ const isAddition = !isNextHash && isMathOperator && iNode.value === "+";
+ const isNextAddition =
+ !isRightCurlyBrace && isNextMathOperator && iNextNode.value === "+";
+
+ const isPrevFunction = iPrevNode && iPrevNode.type === "value-func";
+ const isFunction = iNode.type === "value-func";
+ const isNextFunction = iNextNode.type === "value-func";
+ const isNextNextFunction =
+ iNextNextNode && iNextNextNode.type === "value-func";
+
+ const isPrevWord =
+ iPrevNode &&
+ ["value-word", "value-atword"].indexOf(iPrevNode.type) !== -1;
+ const isWord =
+ ["value-word", "value-atword"].indexOf(iNode.type) !== -1;
+ const isNextWord =
+ ["value-word", "value-atword"].indexOf(iNextNode.type) !== -1;
+ const isNextNextWord =
+ iNextNextNode &&
+ ["value-word", "value-atword"].indexOf(iNextNextNode.type) !== -1;
+
+ // Math operators
+ const insideCalcFunction =
+ insideInFunction &&
+ functionAncestorNode.value.toLowerCase() === "calc";
+
+ const hasSpaceBeforeOperator =
+ isNextNextFunction || isNextNextWord || isFunction || isWord;
+
+ const hasSpaceAfterOperator =
+ isNextFunction || isNextWord || isPrevFunction || isPrevWord;
+
+ if (
+ (isMathOperator || isNextMathOperator) &&
+ // Multiplication
+ !isMultiplication &&
+ !isNextMultiplication &&
+ // Division
+ !(isNextDivision && (hasSpaceBeforeOperator || insideCalcFunction)) &&
+ !(isDivision && (hasSpaceAfterOperator || insideCalcFunction)) &&
+ // Addition
+ !(isNextAddition && hasSpaceBeforeOperator) &&
+ !(isAddition && hasSpaceAfterOperator)
+ ) {
+ const isNextParenGroup = isParenGroupNode(iNextNode);
+ const isNextValueNumber = iNextNode.type === "value-number";
+
+ if (
+ (iNextNode.raws && iNextNode.raws.before === "") ||
+ (isMathOperator &&
+ (isNextParenGroup ||
+ isNextWord ||
+ isNextValueNumber ||
+ isMathOperatorNode(iNextNode)) &&
+ (!iPrevNode || (iPrevNode && isMathOperatorNode(iPrevNode))))
+ ) {
+ continue;
+ }
+ }
+
+ const isEqualityOperator =
+ isControlDirective && isEqualityOperatorNode(iNode);
+ const isRelationalOperator =
+ isControlDirective && isRelationalOperatorNode(iNode);
+ const isNextEqualityOperator =
+ isControlDirective && isEqualityOperatorNode(iNextNode);
+ const isNextRelationalOperator =
+ isControlDirective && isRelationalOperatorNode(iNextNode);
+ const isNextIfElseKeyword =
+ isControlDirective && isIfElseKeywordNode(iNextNode);
+ const isEachKeyword = isControlDirective && isEachKeywordNode(iNode);
+ const isNextEachKeyword =
+ isControlDirective && isEachKeywordNode(iNextNode);
+ const isForKeyword =
+ atRuleAncestorNode &&
+ atRuleAncestorNode.name === "for" &&
+ isForKeywordNode(iNode);
+ const isNextForKeyword =
+ isControlDirective && isForKeywordNode(iNextNode);
+ const IsNextColon = iNextNode.value === ":";
+
+ if (isGridValue) {
+ if (iNode.source.start.line !== iNextNode.source.start.line) {
+ parts.push(hardline$4);
+ didBreak = true;
+ } else {
+ parts.push(" ");
+ }
+ } else if (iNode.type === "value-comment" && iNode.inline) {
+ parts.push(hardline$4);
+ } else if (
+ isNextMathOperator ||
+ isNextEqualityOperator ||
+ isNextRelationalOperator ||
+ isNextIfElseKeyword ||
+ isForKeyword ||
+ isEachKeyword
+ ) {
+ parts.push(" ");
+ } else if (
+ !IsNextColon ||
+ isEqualityOperator ||
+ isRelationalOperator ||
+ isNextForKeyword ||
+ isNextEachKeyword
+ ) {
+ parts.push(line$2);
+ }
+ }
+
+ if (didBreak) {
+ parts.unshift(hardline$4);
+ }
+
+ if (isControlDirective) {
+ return group$2(indent$4(concat$5(parts)));
+ }
+
+ return group$2(indent$4(fill$3(parts)));
+ }
+ case "value-paren_group": {
+ const parentNode = path$$1.getParentNode();
+ const isURLCall =
+ parentNode &&
+ parentNode.type === "value-func" &&
+ parentNode.value === "url";
+
+ if (
+ isURLCall &&
+ (node.groups.length === 1 ||
+ (node.groups.length > 0 &&
+ node.groups[0].type === "value-comma_group" &&
+ node.groups[0].groups.length > 0 &&
+ node.groups[0].groups[0].type === "value-word" &&
+ node.groups[0].groups[0].value.startsWith("data:")))
+ ) {
+ return concat$5([
+ node.open ? path$$1.call(print, "open") : "",
+ join$4(",", path$$1.map(print, "groups")),
+ node.close ? path$$1.call(print, "close") : ""
+ ]);
+ }
+
+ if (!node.open) {
+ const printed = path$$1.map(print, "groups");
+ const res = [];
+
+ for (let i = 0; i < printed.length; i++) {
+ if (i !== 0) {
+ res.push(concat$5([",", line$2]));
+ }
+ res.push(printed[i]);
+ }
+ return group$2(indent$4(fill$3(res)));
+ }
+
+ const declNode = path$$1.getParentNode(2);
+ const isMap =
+ declNode &&
+ declNode.type === "css-decl" &&
+ declNode.prop.startsWith("$");
+
+ return group$2(
+ concat$5([
+ node.open ? path$$1.call(print, "open") : "",
+ indent$4(
+ concat$5([
+ softline$3,
+ join$4(
+ concat$5([",", isMap ? hardline$4 : line$2]),
+ path$$1.map(print, "groups")
+ )
+ ])
+ ),
+ softline$3,
+ node.close ? path$$1.call(print, "close") : ""
+ ])
+ );
+ }
+ case "value-value": {
+ return path$$1.call(print, "group");
+ }
+ case "value-func": {
+ return concat$5([node.value, path$$1.call(print, "group")]);
+ }
+ case "value-paren": {
+ return node.value;
+ }
+ case "value-number": {
+ return concat$5([printNumber$1(node.value), maybeToLowerCase(node.unit)]);
+ }
+ case "value-operator": {
+ return node.value;
+ }
+ case "value-word": {
+ if ((node.isColor && node.isHex) || isWideKeywords(node.value)) {
+ return node.value.toLowerCase();
+ }
+ return node.value;
+ }
+ case "value-colon": {
+ return concat$5([node.value, insideURLFunctionNode(path$$1) ? "" : line$2]);
+ }
+ case "value-comma": {
+ return concat$5([node.value, " "]);
+ }
+ case "value-string": {
+ return util$1.printString(
+ node.raws.quote + node.value + node.raws.quote,
+ options
+ );
+ }
+ case "value-atword": {
+ return concat$5(["@", node.value]);
+ }
+ case "value-unicode-range": {
+ return node.value;
+ }
+ default:
+ /* istanbul ignore next */
+ throw new Error(`Unknown postcss type ${JSON.stringify(node.type)}`);
+ }
+}
+
+function isLastNode(path$$1, node) {
+ const parentNode = path$$1.getParentNode();
+ if (!parentNode) {
+ return false;
+ }
+ const nodes = parentNode.nodes;
+ return nodes && nodes.indexOf(node) === nodes.length - 1;
+}
+
+function isDetachedRulesetDeclaration(node) {
+ // If a Less file ends up being parsed with the SCSS parser, Less
+ // variable declarations will be parsed as atrules with names ending
+ // with a colon, so keep the original case then.
+ return (
+ node.selector &&
+ node.selector.type !== "selector-root-invalid" &&
+ ((typeof node.selector === "string" && /^@.+:.*$/.test(node.selector)) ||
+ (node.selector.value && /^@.+:.*$/.test(node.selector.value)))
+ );
+}
+
+function isKeyframeAtRuleKeywords(path$$1, value) {
+ const atRuleAncestorNode = getAncestorNode(path$$1, "css-atrule");
+ return (
+ atRuleAncestorNode &&
+ atRuleAncestorNode.name &&
+ atRuleAncestorNode.name.toLowerCase().endsWith("keyframes") &&
+ ["from", "to"].indexOf(value.toLowerCase()) !== -1
+ );
+}
+
+function isHTMLTag(value) {
+ return htmlTagNames$1.indexOf(value.toLowerCase()) !== -1;
+}
+
+function insideURLFunctionNode(path$$1) {
+ const funcAncestorNode = getAncestorNode(path$$1, "value-func");
+ return (
+ funcAncestorNode &&
+ funcAncestorNode.value &&
+ funcAncestorNode.value === "url"
+ );
+}
+
+function isParenGroupNode(node) {
+ return node.type && node.type === "value-paren_group";
+}
+
+function isForKeywordNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["from", "through", "end"].indexOf(node.value) !== -1
+ );
+}
+
+function isIfElseKeywordNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["and", "or", "not"].indexOf(node.value) !== -1
+ );
+}
+
+function isEachKeywordNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["in"].indexOf(node.value) !== -1
+ );
+}
+
+function isMathOperatorNode(node) {
+ return (
+ node.type &&
+ node.type === "value-operator" &&
+ node.value &&
+ ["+", "-", "/", "*", "%"].indexOf(node.value) !== -1
+ );
+}
+
+function isEqualityOperatorNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["==", "!="].indexOf(node.value) !== -1
+ );
+}
+
+function isRelationalOperatorNode(node) {
+ return (
+ node.type &&
+ node.type === "value-word" &&
+ node.value &&
+ ["<", ">", "<=", ">="].indexOf(node.value) !== -1
+ );
+}
+
+function isControlDirectiveNode(node) {
+ return (
+ node.type &&
+ node.type === "css-atrule" &&
+ node.name &&
+ (node.name === "if" ||
+ node.name === "else" ||
+ node.name === "for" ||
+ node.name === "each" ||
+ node.name === "while")
+ );
+}
+
+function getAncestorCounter(path$$1, typeOrTypes) {
+ const types = [].concat(typeOrTypes);
+
+ let counter = -1;
+ let ancestorNode;
+
+ while ((ancestorNode = path$$1.getParentNode(++counter))) {
+ if (types.indexOf(ancestorNode.type) !== -1) {
+ return counter;
+ }
+ }
+
+ return -1;
+}
+
+function getAncestorNode(path$$1, typeOrTypes) {
+ const counter = getAncestorCounter(path$$1, typeOrTypes);
+ return counter === -1 ? null : path$$1.getParentNode(counter);
+}
+
+function printNodeSequence(path$$1, options, print) {
+ const node = path$$1.getValue();
+ const parts = [];
+ let i = 0;
+ path$$1.map(pathChild => {
+ const prevNode = node.nodes[i - 1];
+ if (
+ prevNode &&
+ prevNode.type === "css-comment" &&
+ prevNode.text.trim() === "prettier-ignore"
+ ) {
+ const childNode = pathChild.getValue();
+ parts.push(
+ options.originalText.slice(
+ options.locStart(childNode),
+ options.locEnd(childNode)
+ )
+ );
+ } else {
+ parts.push(pathChild.call(print));
+ }
+
+ if (i !== node.nodes.length - 1) {
+ if (
+ (node.nodes[i + 1].type === "css-comment" &&
+ !util$1.hasNewline(
+ options.originalText,
+ options.locStart(node.nodes[i + 1]),
+ { backwards: true }
+ )) ||
+ (node.nodes[i + 1].type === "css-atrule" &&
+ node.nodes[i + 1].name === "else" &&
+ node.nodes[i].type !== "css-comment")
+ ) {
+ parts.push(" ");
+ } else {
+ parts.push(hardline$4);
+ if (
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ pathChild.getValue(),
+ options
+ )
+ ) {
+ parts.push(hardline$4);
+ }
+ }
+ }
+ i++;
+ }, "nodes");
+
+ return concat$5(parts);
+}
+
+const STRING_REGEX = /(['"])(?:(?!\1)[^\\]|\\[\s\S])*\1/g;
+const NUMBER_REGEX = /(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g;
+const STANDARD_UNIT_REGEX = /[a-zA-Z]+/g;
+const WORD_PART_REGEX = /[$@]?[a-zA-Z_\u0080-\uFFFF][\w\-\u0080-\uFFFF]*/g;
+const ADJUST_NUMBERS_REGEX = RegExp(
+ STRING_REGEX.source +
+ `|` +
+ `(${WORD_PART_REGEX.source})?` +
+ `(${NUMBER_REGEX.source})` +
+ `(${STANDARD_UNIT_REGEX.source})?`,
+ "g"
+);
+
+function adjustStrings(value, options) {
+ return value.replace(STRING_REGEX, match =>
+ util$1.printString(match, options)
+ );
+}
+
+function quoteAttributeValue(value, options) {
+ const quote = options.singleQuote ? "'" : '"';
+ return value.includes('"') || value.includes("'")
+ ? value
+ : quote + value + quote;
+}
+
+function adjustNumbers(value) {
+ return value.replace(
+ ADJUST_NUMBERS_REGEX,
+ (match, quote, wordPart, number, unit) =>
+ !wordPart && number
+ ? (wordPart || "") + printNumber$1(number) + maybeToLowerCase(unit || "")
+ : match
+ );
+}
+
+function printNumber$1(rawNumber) {
+ return (
+ util$1
+ .printNumber(rawNumber)
+ // Remove trailing `.0`.
+ .replace(/\.0(?=$|e)/, "")
+ );
+}
+
+function maybeToLowerCase(value) {
+ return value.includes("$") ||
+ value.includes("@") ||
+ value.includes("#") ||
+ value.startsWith("%") ||
+ value.startsWith("--") ||
+ value.startsWith(":--") ||
+ (value.includes("(") && value.includes(")"))
+ ? value
+ : value.toLowerCase();
+}
+
+function isWideKeywords(value) {
+ return (
+ ["initial", "inherit", "unset", "revert"].indexOf(
+ value.replace().toLowerCase()
+ ) !== -1
+ );
+}
+
+var printerPostcss = {
+ print: genericPrint$1,
+ hasPrettierIgnore: util$1.hasIgnoreComment,
+ massageAstNode: clean_1$2
+};
+
+// format based on https://github.com/prettier/prettier/blob/master/src/common/support.js
+var options$2 = {
+ singleQuote: options.singleQuote
+};
+
+const lineColumnToIndex$1 = util$1.lineColumnToIndex;
+const getLast$1 = util$1.getLast;
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$1 = [
+ {
+ name: "CSS",
+ since: "1.4.0",
+ parsers: ["css"],
+ group: "CSS",
+ tmScope: "source.css",
+ aceMode: "css",
+ codemirrorMode: "css",
+ codemirrorMimeType: "text/css",
+ extensions: [".css", ".pcss", ".postcss"],
+ liguistLanguageId: 50,
+ vscodeLanguageIds: ["css", "postcss"]
+ },
+ {
+ name: "Less",
+ since: "1.4.0",
+ parsers: ["less"],
+ group: "CSS",
+ extensions: [".less"],
+ tmScope: "source.css.less",
+ aceMode: "less",
+ codemirrorMode: "css",
+ codemirrorMimeType: "text/css",
+ liguistLanguageId: 198,
+ vscodeLanguageIds: ["less"]
+ },
+ {
+ name: "SCSS",
+ since: "1.4.0",
+ parsers: ["scss"],
+ group: "CSS",
+ tmScope: "source.scss",
+ aceMode: "scss",
+ codemirrorMode: "css",
+ codemirrorMimeType: "text/x-scss",
+ extensions: [".scss"],
+ liguistLanguageId: 329,
+ vscodeLanguageIds: ["scss"]
+ }
+];
+
+const postcss = {
+ get parse() {
+ return require("./parser-postcss");
+ },
+ astFormat: "postcss",
+ locEnd: function(node) {
+ const endNode = node.nodes && getLast$1(node.nodes);
+ if (endNode && node.source && !node.source.end) {
+ node = endNode;
+ }
+ if (node.source) {
+ return lineColumnToIndex$1(node.source.end, node.source.input.css);
+ }
+ return null;
+ },
+ locStart: function(node) {
+ if (node.source) {
+ return lineColumnToIndex$1(node.source.start, node.source.input.css) - 1;
+ }
+ return null;
+ }
+};
+
+// TODO: switch these to just `postcss` and use `language` instead.
+const parsers$1 = {
+ css: postcss,
+ less: postcss,
+ scss: postcss
+};
+
+const printers$1 = {
+ postcss: printerPostcss
+};
+
+var languageCss = {
+ languages: languages$1,
+ options: options$2,
+ parsers: parsers$1,
+ printers: printers$1
+};
+
+const concat$6 = docBuilders$2.concat;
+const join$5 = docBuilders$2.join;
+const softline$4 = docBuilders$2.softline;
+const hardline$5 = docBuilders$2.hardline;
+const line$3 = docBuilders$2.line;
+const group$3 = docBuilders$2.group;
+const indent$5 = docBuilders$2.indent;
+const ifBreak$2 = docBuilders$2.ifBreak;
+
+// http://w3c.github.io/html/single-page.html#void-elements
+const voidTags = [
+ "area",
+ "base",
+ "br",
+ "col",
+ "embed",
+ "hr",
+ "img",
+ "input",
+ "link",
+ "meta",
+ "param",
+ "source",
+ "track",
+ "wbr"
+];
+
+// Formatter based on @glimmerjs/syntax's built-in test formatter:
+// https://github.com/glimmerjs/glimmer-vm/blob/master/packages/%40glimmer/syntax/lib/generation/print.ts
+
+function print(path$$1, options, print) {
+ const n = path$$1.getValue();
+
+ /* istanbul ignore if*/
+ if (!n) {
+ return "";
+ }
+
+ switch (n.type) {
+ case "Program": {
+ return group$3(
+ join$5(softline$4, path$$1.map(print, "body").filter(text => text !== ""))
+ );
+ }
+ case "ElementNode": {
+ const isVoid = voidTags.indexOf(n.tag) !== -1;
+ const closeTag = isVoid ? concat$6([" />", softline$4]) : ">";
+ const hasChildren = n.children.length > 0;
+ const getParams = (path$$1, print) =>
+ indent$5(
+ concat$6([
+ n.attributes.length ? line$3 : "",
+ join$5(line$3, path$$1.map(print, "attributes")),
+
+ n.modifiers.length ? line$3 : "",
+ join$5(line$3, path$$1.map(print, "modifiers")),
+
+ n.comments.length ? line$3 : "",
+ join$5(line$3, path$$1.map(print, "comments"))
+ ])
+ );
+
+ // The problem here is that I want to not break at all if the children
+ // would not break but I need to force an indent, so I use a hardline.
+ /**
+ * What happens now:
+ *
+ * Hello
+ *
+ * ==>
+ *
Hello
+ * This is due to me using hasChildren to decide to put the hardline in.
+ * I would rather use a {DOES THE WHOLE THING NEED TO BREAK}
+ */
+ return concat$6([
+ group$3(
+ concat$6([
+ "<",
+ n.tag,
+ getParams(path$$1, print),
+ ifBreak$2(softline$4, ""),
+ closeTag
+ ])
+ ),
+ group$3(
+ concat$6([
+ indent$5(join$5(softline$4, [""].concat(path$$1.map(print, "children")))),
+ ifBreak$2(hasChildren ? hardline$5 : "", ""),
+ !isVoid ? concat$6([""]) : ""
+ ])
+ )
+ ]);
+ }
+ case "BlockStatement": {
+ const pp = path$$1.getParentNode(1);
+ const isElseIf =
+ pp &&
+ pp.inverse &&
+ pp.inverse.body[0] === n &&
+ pp.inverse.body[0].path.parts[0] === "if";
+ const hasElseIf =
+ n.inverse &&
+ n.inverse.body[0] &&
+ n.inverse.body[0].type === "BlockStatement" &&
+ n.inverse.body[0].path.parts[0] === "if";
+ const indentElse = hasElseIf ? a => a : indent$5;
+ if (n.inverse) {
+ return concat$6([
+ isElseIf
+ ? concat$6(["{{else ", printPathParams(path$$1, print), "}}"])
+ : printOpenBlock(path$$1, print),
+ indent$5(concat$6([hardline$5, path$$1.call(print, "program")])),
+ n.inverse && !hasElseIf ? concat$6([hardline$5, "{{else}}"]) : "",
+ n.inverse
+ ? indentElse(concat$6([hardline$5, path$$1.call(print, "inverse")]))
+ : "",
+ isElseIf ? "" : concat$6([hardline$5, printCloseBlock(path$$1, print)])
+ ]);
+ } else if (isElseIf) {
+ return concat$6([
+ concat$6(["{{else ", printPathParams(path$$1, print), "}}"]),
+ indent$5(concat$6([hardline$5, path$$1.call(print, "program")]))
+ ]);
+ }
+ /**
+ * I want this boolean to be: if params are going to cause a break,
+ * not that it has params.
+ */
+ const hasParams = n.params.length > 0 || n.hash.pairs.length > 0;
+ const hasChildren = n.program.body.length > 0;
+ return concat$6([
+ printOpenBlock(path$$1, print),
+ group$3(
+ concat$6([
+ indent$5(concat$6([softline$4, path$$1.call(print, "program")])),
+ hasParams && hasChildren ? hardline$5 : "",
+ printCloseBlock(path$$1, print)
+ ])
+ )
+ ]);
+ }
+ case "ElementModifierStatement":
+ case "MustacheStatement": {
+ const pp = path$$1.getParentNode(1);
+ const isConcat = pp && pp.type === "ConcatStatement";
+ return group$3(
+ concat$6([
+ /*n.escaped ? "{{{" : */ "{{",
+ printPathParams(path$$1, print),
+ isConcat ? "" : softline$4,
+ /*.escaped ? "}}}" :*/ "}}"
+ ])
+ );
+ }
+ case "SubExpression": {
+ return group$3(
+ concat$6([
+ "(",
+ printPath(path$$1, print),
+ indent$5(concat$6([line$3, group$3(join$5(line$3, getParams(path$$1, print)))])),
+ softline$4,
+ ")"
+ ])
+ );
+ }
+ case "AttrNode": {
+ const quote = n.value.type === "TextNode" ? '"' : "";
+ return concat$6([n.name, "=", quote, path$$1.call(print, "value"), quote]);
+ }
+ case "ConcatStatement": {
+ return concat$6([
+ '"',
+ group$3(
+ indent$5(
+ join$5(
+ softline$4,
+ path$$1
+ .map(partPath => print(partPath), "parts")
+ .filter(a => a !== "")
+ )
+ )
+ ),
+ '"'
+ ]);
+ }
+ case "Hash": {
+ return concat$6([join$5(line$3, path$$1.map(print, "pairs"))]);
+ }
+ case "HashPair": {
+ return concat$6([n.key, "=", path$$1.call(print, "value")]);
+ }
+ case "TextNode": {
+ return n.chars.replace(/^\s+/, "").replace(/\s+$/, "");
+ }
+ case "MustacheCommentStatement": {
+ const dashes = n.value.indexOf("}}") > -1 ? "--" : "";
+ return concat$6(["{{!", dashes, n.value, dashes, "}}"]);
+ }
+ case "PathExpression": {
+ return n.original;
+ }
+ case "BooleanLiteral": {
+ return String(n.value);
+ }
+ case "CommentStatement": {
+ return concat$6([""]);
+ }
+ case "StringLiteral": {
+ return `"${n.value}"`;
+ }
+ case "NumberLiteral": {
+ return String(n.value);
+ }
+ case "UndefinedLiteral": {
+ return "undefined";
+ }
+ case "NullLiteral": {
+ return "null";
+ }
+
+ /* istanbul ignore next */
+ default:
+ throw new Error("unknown glimmer type: " + JSON.stringify(n.type));
+ }
+}
+
+function printPath(path$$1, print) {
+ return path$$1.call(print, "path");
+}
+
+function getParams(path$$1, print) {
+ const node = path$$1.getValue();
+ let parts = [];
+
+ if (node.params.length > 0) {
+ parts = parts.concat(path$$1.map(print, "params"));
+ }
+
+ if (node.hash && node.hash.pairs.length > 0) {
+ parts.push(path$$1.call(print, "hash"));
+ }
+ return parts;
+}
+
+function printPathParams(path$$1, print) {
+ let parts = [];
+
+ parts.push(printPath(path$$1, print));
+ parts = parts.concat(getParams(path$$1, print));
+
+ return indent$5(group$3(join$5(line$3, parts)));
+}
+
+function printBlockParams(path$$1) {
+ const block = path$$1.getValue();
+ if (!block.program || !block.program.blockParams.length) {
+ return "";
+ }
+ return concat$6([" as |", block.program.blockParams.join(" "), "|"]);
+}
+
+function printOpenBlock(path$$1, print) {
+ return group$3(
+ concat$6([
+ "{{#",
+ printPathParams(path$$1, print),
+ printBlockParams(path$$1, print),
+ softline$4,
+ "}}"
+ ])
+ );
+}
+
+function printCloseBlock(path$$1, print) {
+ return concat$6(["{{/", path$$1.call(print, "path"), "}}"]);
+}
+
+function clean$4(ast, newObj) {
+ // (Glimmer/HTML) ignore TextNode whitespace
+ if (ast.type === "TextNode") {
+ if (ast.chars.replace(/\s+/, "") === "") {
+ return null;
+ }
+ newObj.chars = ast.chars.replace(/^\s+/, "").replace(/\s+$/, "");
+ }
+}
+
+var printerGlimmer = {
+ print,
+ massageAstNode: clean$4
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$2 = [
+ {
+ type: "markup",
+ group: "HTML",
+ aliases: ["hbs", "htmlbars"],
+ extensions: [".handlebars", ".hbs"],
+ tm_scope: "text.html.handlebars",
+ ace_mode: "handlebars",
+ language_id: 155,
+ since: null // unreleased
+ }
+];
+
+const parsers$2 = {
+ glimmer: {
+ get parse() {
+ return require("./parser-glimmer");
+ },
+ astFormat: "glimmer",
+ locEnd: function(node) {
+ return node.loc && node.loc.end;
+ },
+ locStart: function(node) {
+ return node.loc && node.loc.start;
+ }
+ }
+};
+
+const printers$2 = {
+ glimmer: printerGlimmer
+};
+
+var languageHandlebars = {
+ languages: languages$2,
+ parsers: parsers$2,
+ printers: printers$2
+};
+
+const docBuilders$7 = doc.builders;
+const concat$7 = docBuilders$7.concat;
+const join$6 = docBuilders$7.join;
+const hardline$6 = docBuilders$7.hardline;
+const line$4 = docBuilders$7.line;
+const softline$5 = docBuilders$7.softline;
+const group$4 = docBuilders$7.group;
+const indent$6 = docBuilders$7.indent;
+const ifBreak$3 = docBuilders$7.ifBreak;
+
+
+
+function genericPrint$2(path$$1, options, print) {
+ const n = path$$1.getValue();
+ if (!n) {
+ return "";
+ }
+
+ if (typeof n === "string") {
+ return n;
+ }
+
+ switch (n.kind) {
+ case "Document": {
+ return concat$7([
+ join$6(concat$7([hardline$6, hardline$6]), path$$1.map(print, "definitions")),
+ hardline$6
+ ]);
+ }
+ case "OperationDefinition": {
+ const hasOperation = options.originalText[options.locStart(n)] !== "{";
+ const hasName = !!n.name;
+ return concat$7([
+ hasOperation ? n.operation : "",
+ hasOperation && hasName ? concat$7([" ", path$$1.call(print, "name")]) : "",
+ n.variableDefinitions && n.variableDefinitions.length
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.map(print, "variableDefinitions")
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : "",
+ printDirectives(path$$1, print, n),
+ n.selectionSet ? (!hasOperation && !hasName ? "" : " ") : "",
+ path$$1.call(print, "selectionSet")
+ ]);
+ }
+ case "FragmentDefinition": {
+ return concat$7([
+ "fragment ",
+ path$$1.call(print, "name"),
+ " on ",
+ path$$1.call(print, "typeCondition"),
+ printDirectives(path$$1, print, n),
+ " ",
+ path$$1.call(print, "selectionSet")
+ ]);
+ }
+ case "SelectionSet": {
+ return concat$7([
+ "{",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ selectionsPath => printSequence(selectionsPath, options, print),
+ "selections"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ]);
+ }
+ case "Field": {
+ return group$4(
+ concat$7([
+ n.alias ? concat$7([path$$1.call(print, "alias"), ": "]) : "",
+ path$$1.call(print, "name"),
+ n.arguments.length > 0
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.call(
+ argsPath => printSequence(argsPath, options, print),
+ "arguments"
+ )
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : "",
+ printDirectives(path$$1, print, n),
+ n.selectionSet ? " " : "",
+ path$$1.call(print, "selectionSet")
+ ])
+ );
+ }
+ case "Name": {
+ return n.value;
+ }
+ case "StringValue": {
+ if (n.block) {
+ return concat$7([
+ '"""',
+ hardline$6,
+ join$6(hardline$6, n.value.replace(/"""/g, "\\$&").split("\n")),
+ hardline$6,
+ '"""'
+ ]);
+ }
+ return concat$7(['"', n.value.replace(/["\\]/g, "\\$&"), '"']);
+ }
+ case "IntValue":
+ case "FloatValue":
+ case "EnumValue": {
+ return n.value;
+ }
+ case "BooleanValue": {
+ return n.value ? "true" : "false";
+ }
+ case "NullValue": {
+ return "null";
+ }
+ case "Variable": {
+ return concat$7(["$", path$$1.call(print, "name")]);
+ }
+ case "ListValue": {
+ return group$4(
+ concat$7([
+ "[",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.map(print, "values")
+ )
+ ])
+ ),
+ softline$5,
+ "]"
+ ])
+ );
+ }
+ case "ObjectValue": {
+ return group$4(
+ concat$7([
+ "{",
+ options.bracketSpacing && n.fields.length > 0 ? " " : "",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.map(print, "fields")
+ )
+ ])
+ ),
+ softline$5,
+ ifBreak$3("", options.bracketSpacing && n.fields.length > 0 ? " " : ""),
+ "}"
+ ])
+ );
+ }
+ case "ObjectField":
+ case "Argument": {
+ return concat$7([
+ path$$1.call(print, "name"),
+ ": ",
+ path$$1.call(print, "value")
+ ]);
+ }
+
+ case "Directive": {
+ return concat$7([
+ "@",
+ path$$1.call(print, "name"),
+ n.arguments.length > 0
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.call(
+ argsPath => printSequence(argsPath, options, print),
+ "arguments"
+ )
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : ""
+ ]);
+ }
+
+ case "NamedType": {
+ return path$$1.call(print, "name");
+ }
+
+ case "VariableDefinition": {
+ return concat$7([
+ path$$1.call(print, "variable"),
+ ": ",
+ path$$1.call(print, "type"),
+ n.defaultValue ? concat$7([" = ", path$$1.call(print, "defaultValue")]) : ""
+ ]);
+ }
+
+ case "TypeExtensionDefinition": {
+ return concat$7(["extend ", path$$1.call(print, "definition")]);
+ }
+
+ case "ObjectTypeExtension":
+ case "ObjectTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "ObjectTypeExtension" ? "extend " : "",
+ "type ",
+ path$$1.call(print, "name"),
+ n.interfaces.length > 0
+ ? concat$7([
+ " implements ",
+ join$6(
+ determineInterfaceSeparator(
+ options.originalText.substr(
+ options.locStart(n),
+ options.locEnd(n)
+ )
+ ),
+ path$$1.map(print, "interfaces")
+ )
+ ])
+ : "",
+ printDirectives(path$$1, print, n),
+ n.fields.length > 0
+ ? concat$7([
+ " {",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ fieldsPath => printSequence(fieldsPath, options, print),
+ "fields"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ])
+ : ""
+ ]);
+ }
+
+ case "FieldDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ path$$1.call(print, "name"),
+ n.arguments.length > 0
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.call(
+ argsPath => printSequence(argsPath, options, print),
+ "arguments"
+ )
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : "",
+ ": ",
+ path$$1.call(print, "type"),
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "DirectiveDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ "directive ",
+ "@",
+ path$$1.call(print, "name"),
+ n.arguments.length > 0
+ ? group$4(
+ concat$7([
+ "(",
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", ", "), softline$5]),
+ path$$1.call(
+ argsPath => printSequence(argsPath, options, print),
+ "arguments"
+ )
+ )
+ ])
+ ),
+ softline$5,
+ ")"
+ ])
+ )
+ : "",
+ concat$7([" on ", join$6(" | ", path$$1.map(print, "locations"))])
+ ]);
+ }
+
+ case "EnumTypeExtension":
+ case "EnumTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "EnumTypeExtension" ? "extend " : "",
+ "enum ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n),
+
+ n.values.length > 0
+ ? concat$7([
+ " {",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ valuesPath => printSequence(valuesPath, options, print),
+ "values"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ])
+ : ""
+ ]);
+ }
+
+ case "EnumValueDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "InputValueDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? (n.description.block ? hardline$6 : line$4) : "",
+ path$$1.call(print, "name"),
+ ": ",
+ path$$1.call(print, "type"),
+ n.defaultValue ? concat$7([" = ", path$$1.call(print, "defaultValue")]) : "",
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "InputObjectTypeExtension":
+ case "InputObjectTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "InputObjectTypeExtension" ? "extend " : "",
+ "input ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n),
+ n.fields.length > 0
+ ? concat$7([
+ " {",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ fieldsPath => printSequence(fieldsPath, options, print),
+ "fields"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ])
+ : ""
+ ]);
+ }
+
+ case "SchemaDefinition": {
+ return concat$7([
+ "schema",
+ printDirectives(path$$1, print, n),
+ " {",
+ n.operationTypes.length > 0
+ ? indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ opsPath => printSequence(opsPath, options, print),
+ "operationTypes"
+ )
+ )
+ ])
+ )
+ : "",
+ hardline$6,
+ "}"
+ ]);
+ }
+
+ case "OperationTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "operation"),
+ ": ",
+ path$$1.call(print, "type")
+ ]);
+ }
+
+ case "InterfaceTypeExtension":
+ case "InterfaceTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "InterfaceTypeExtension" ? "extend " : "",
+ "interface ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n),
+
+ n.fields.length > 0
+ ? concat$7([
+ " {",
+ indent$6(
+ concat$7([
+ hardline$6,
+ join$6(
+ hardline$6,
+ path$$1.call(
+ fieldsPath => printSequence(fieldsPath, options, print),
+ "fields"
+ )
+ )
+ ])
+ ),
+ hardline$6,
+ "}"
+ ])
+ : ""
+ ]);
+ }
+
+ case "FragmentSpread": {
+ return concat$7([
+ "...",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "InlineFragment": {
+ return concat$7([
+ "...",
+ n.typeCondition
+ ? concat$7([" on ", path$$1.call(print, "typeCondition")])
+ : "",
+ printDirectives(path$$1, print, n),
+ " ",
+ path$$1.call(print, "selectionSet")
+ ]);
+ }
+
+ case "UnionTypeExtension":
+ case "UnionTypeDefinition": {
+ return group$4(
+ concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ group$4(
+ concat$7([
+ n.kind === "UnionTypeExtension" ? "extend " : "",
+ "union ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n),
+ n.types.length > 0
+ ? concat$7([
+ " =",
+ ifBreak$3("", " "),
+ indent$6(
+ concat$7([
+ ifBreak$3(concat$7([line$4, " "])),
+ join$6(concat$7([line$4, "| "]), path$$1.map(print, "types"))
+ ])
+ )
+ ])
+ : ""
+ ])
+ )
+ ])
+ );
+ }
+
+ case "ScalarTypeExtension":
+ case "ScalarTypeDefinition": {
+ return concat$7([
+ path$$1.call(print, "description"),
+ n.description ? hardline$6 : "",
+ n.kind === "ScalarTypeExtension" ? "extend " : "",
+ "scalar ",
+ path$$1.call(print, "name"),
+ printDirectives(path$$1, print, n)
+ ]);
+ }
+
+ case "NonNullType": {
+ return concat$7([path$$1.call(print, "type"), "!"]);
+ }
+
+ case "ListType": {
+ return concat$7(["[", path$$1.call(print, "type"), "]"]);
+ }
+
+ default:
+ /* istanbul ignore next */
+ throw new Error("unknown graphql type: " + JSON.stringify(n.kind));
+ }
+}
+
+function printDirectives(path$$1, print, n) {
+ if (n.directives.length === 0) {
+ return "";
+ }
+
+ return concat$7([
+ " ",
+ group$4(
+ indent$6(
+ concat$7([
+ softline$5,
+ join$6(
+ concat$7([ifBreak$3("", " "), softline$5]),
+ path$$1.map(print, "directives")
+ )
+ ])
+ )
+ )
+ ]);
+}
+
+function printSequence(sequencePath, options, print) {
+ const count = sequencePath.getValue().length;
+
+ return sequencePath.map((path$$1, i) => {
+ const printed = print(path$$1);
+
+ if (
+ utilShared.isNextLineEmpty(
+ options.originalText,
+ path$$1.getValue(),
+ options
+ ) &&
+ i < count - 1
+ ) {
+ return concat$7([printed, hardline$6]);
+ }
+
+ return printed;
+ });
+}
+
+function canAttachComment$1(node) {
+ return node.kind && node.kind !== "Comment";
+}
+
+function printComment$2(commentPath) {
+ const comment = commentPath.getValue();
+
+ switch (comment.kind) {
+ case "Comment":
+ return "#" + comment.value.trimRight();
+ default:
+ throw new Error("Not a comment: " + JSON.stringify(comment));
+ }
+}
+
+function determineInterfaceSeparator(originalSource) {
+ const start = originalSource.indexOf("implements");
+ if (start === -1) {
+ throw new Error("Must implement interfaces: " + originalSource);
+ }
+ let end = originalSource.indexOf("{");
+ if (end === -1) {
+ end = originalSource.length;
+ }
+ return originalSource.substr(start, end).includes("&") ? " & " : ", ";
+}
+
+var printerGraphql = {
+ print: genericPrint$2,
+ hasPrettierIgnore: util$1.hasIgnoreComment,
+ printComment: printComment$2,
+ canAttachComment: canAttachComment$1
+};
+
+// format based on https://github.com/prettier/prettier/blob/master/src/common/support.js
+var options$5 = {
+ bracketSpacing: options.bracketSpacing
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$3 = [
+ {
+ name: "GraphQL",
+ since: "1.5.0",
+ parsers: ["graphql"],
+ extensions: [".graphql", ".gql"],
+ tmScope: "source.graphql",
+ aceMode: "text",
+ liguistLanguageId: 139,
+ vscodeLanguageIds: ["graphql"]
+ }
+];
+
+const parsers$3 = {
+ graphql: {
+ get parse() {
+ return require("./parser-graphql");
+ },
+ astFormat: "graphql",
+ locStart: function(node) {
+ if (typeof node.start === "number") {
+ return node.start;
+ }
+ return node.loc && node.loc.start;
+ },
+ locEnd: function(node) {
+ if (typeof node.end === "number") {
+ return node.end;
+ }
+ return node.loc && node.loc.end;
+ }
+ }
+};
+
+const printers$3 = {
+ graphql: printerGraphql
+};
+
+var languageGraphql = {
+ languages: languages$3,
+ options: options$5,
+ parsers: parsers$3,
+ printers: printers$3
+};
+
+const docBuilders$9 = doc.builders;
+const hardline$8 = docBuilders$9.hardline;
+const literalline$3 = docBuilders$9.literalline;
+const concat$9 = docBuilders$9.concat;
+const markAsRoot$1 = docBuilders$9.markAsRoot;
+
+function embed$2(path$$1, print, textToDoc, options) {
+ const node = path$$1.getValue();
+
+ if (node.type === "code" && node.lang !== null) {
+ // only look for the first string so as to support [markdown-preview-enhanced](https://shd101wyy.github.io/markdown-preview-enhanced/#/code-chunk)
+ const lang = node.lang.split(/\s/, 1)[0];
+ const parser = getParserName(lang);
+ if (parser) {
+ const styleUnit = options.__inJsTemplate ? "~" : "`";
+ const style = styleUnit.repeat(
+ Math.max(3, util$1.getMaxContinuousCount(node.value, styleUnit) + 1)
+ );
+ const doc$$2 = textToDoc(node.value, { parser });
+ return markAsRoot$1(
+ concat$9([
+ style,
+ node.lang,
+ hardline$8,
+ replaceNewlinesWithLiterallines(doc$$2),
+ style
+ ])
+ );
+ }
+ }
+
+ return null;
+
+ function getParserName(lang) {
+ const supportInfo = support.getSupportInfo(null, {
+ plugins: options.plugins,
+ pluginsLoaded: true
+ });
+ const language = supportInfo.languages.find(
+ language =>
+ language.name.toLowerCase() === lang ||
+ (language.extensions &&
+ language.extensions.find(ext => ext.substring(1) === lang))
+ );
+ if (language) {
+ return language.parsers[0];
+ }
+
+ return null;
+ }
+
+ function replaceNewlinesWithLiterallines(doc$$2) {
+ return docUtils.mapDoc(
+ doc$$2,
+ currentDoc =>
+ typeof currentDoc === "string" && currentDoc.includes("\n")
+ ? concat$9(
+ currentDoc
+ .split(/(\n)/g)
+ .map((v, i) => (i % 2 === 0 ? v : literalline$3))
+ )
+ : currentDoc
+ );
+ }
+}
+
+var embed_1$2 = embed$2;
+
+var pragma$2 = createCommonjsModule(function (module) {
+"use strict";
+
+const pragmas = ["format", "prettier"];
+
+function startWithPragma(text) {
+ const pragma = `@(${pragmas.join("|")})`;
+ const regex = new RegExp(
+ [
+ ``,
+ ``
+ ].join("|"),
+ "m"
+ );
+ const matched = text.match(regex);
+ return matched && matched.index === 0;
+}
+
+function extract(text) {
+ // yaml (---) and toml (+++)
+ const matched = text.match(
+ /^((---|\+\+\+)(?:\n[\s\S]*?\n|\n)\2(?:\n|$))?([\s\S]*)/
+ );
+ const frontMatter = matched[1];
+ const mainContent = matched[3];
+ return { frontMatter, mainContent };
+}
+
+module.exports = {
+ startWithPragma,
+ hasPragma: text => startWithPragma(extract(text).mainContent.trimLeft()),
+ insertPragma: text => {
+ const extracted = extract(text);
+ const pragma = ``;
+ return extracted.frontMatter
+ ? `${extracted.frontMatter}\n\n${pragma}\n\n${extracted.mainContent}`
+ : `${pragma}\n\n${extracted.mainContent}`;
+ }
+};
+});
+
+const docBuilders$8 = doc.builders;
+const concat$8 = docBuilders$8.concat;
+const join$7 = docBuilders$8.join;
+const line$5 = docBuilders$8.line;
+const hardline$7 = docBuilders$8.hardline;
+const softline$6 = docBuilders$8.softline;
+const fill$4 = docBuilders$8.fill;
+const align$2 = docBuilders$8.align;
+const group$5 = docBuilders$8.group;
+const printDocToString$2 = doc.printer.printDocToString;
+
+const SINGLE_LINE_NODE_TYPES = ["heading", "tableCell", "link"];
+
+const SIBLING_NODE_TYPES = ["listItem", "definition", "footnoteDefinition"];
+
+const INLINE_NODE_TYPES = [
+ "inlineCode",
+ "emphasis",
+ "strong",
+ "delete",
+ "link",
+ "linkReference",
+ "image",
+ "imageReference",
+ "footnote",
+ "footnoteReference",
+ "sentence",
+ "whitespace",
+ "word",
+ "break"
+];
+
+const INLINE_NODE_WRAPPER_TYPES = INLINE_NODE_TYPES.concat([
+ "tableCell",
+ "paragraph",
+ "heading"
+]);
+
+function genericPrint$3(path$$1, options, print) {
+ const node = path$$1.getValue();
+
+ if (shouldRemainTheSameContent(path$$1)) {
+ return concat$8(
+ util$1
+ .splitText(
+ options.originalText.slice(
+ node.position.start.offset,
+ node.position.end.offset
+ )
+ )
+ .map(
+ node =>
+ node.type === "word"
+ ? node.value
+ : node.value === ""
+ ? ""
+ : printLine(path$$1, node.value, options)
+ )
+ );
+ }
+
+ switch (node.type) {
+ case "root":
+ return concat$8([normalizeDoc(printRoot(path$$1, options, print)), hardline$7]);
+ case "paragraph":
+ return printChildren(path$$1, options, print, {
+ postprocessor: fill$4
+ });
+ case "sentence":
+ return printChildren(path$$1, options, print);
+ case "word":
+ return node.value
+ .replace(/[*]/g, "\\*") // escape all `*`
+ .replace(
+ new RegExp(
+ [
+ `(^|[${util$1.punctuationCharRange}])(_+)`,
+ `(_+)([${util$1.punctuationCharRange}]|$)`
+ ].join("|"),
+ "g"
+ ),
+ (_, text1, underscore1, underscore2, text2) =>
+ (underscore1
+ ? `${text1}${underscore1}`
+ : `${underscore2}${text2}`
+ ).replace(/_/g, "\\_")
+ ); // escape all `_` except concating with non-punctuation, e.g. `1_2_3` is not considered emphasis
+ case "whitespace": {
+ const parentNode = path$$1.getParentNode();
+ const index = parentNode.children.indexOf(node);
+ const nextNode = parentNode.children[index + 1];
+
+ const proseWrap =
+ // leading char that may cause different syntax
+ nextNode && /^>|^([-+*]|#{1,6}|[0-9]+[.)])$/.test(nextNode.value)
+ ? "never"
+ : options.proseWrap;
+
+ return printLine(path$$1, node.value, { proseWrap });
+ }
+ case "emphasis": {
+ const parentNode = path$$1.getParentNode();
+ const index = parentNode.children.indexOf(node);
+ const prevNode = parentNode.children[index - 1];
+ const nextNode = parentNode.children[index + 1];
+ const hasPrevOrNextWord = // `1*2*3` is considered emphais but `1_2_3` is not
+ (prevNode &&
+ prevNode.type === "sentence" &&
+ prevNode.children.length > 0 &&
+ util$1.getLast(prevNode.children).type === "word" &&
+ !util$1.getLast(prevNode.children).hasTrailingPunctuation) ||
+ (nextNode &&
+ nextNode.type === "sentence" &&
+ nextNode.children.length > 0 &&
+ nextNode.children[0].type === "word" &&
+ !nextNode.children[0].hasLeadingPunctuation);
+ const style =
+ hasPrevOrNextWord || getAncestorNode$1(path$$1, "emphasis") ? "*" : "_";
+ return concat$8([style, printChildren(path$$1, options, print), style]);
+ }
+ case "strong":
+ return concat$8(["**", printChildren(path$$1, options, print), "**"]);
+ case "delete":
+ return concat$8(["~~", printChildren(path$$1, options, print), "~~"]);
+ case "inlineCode": {
+ const backtickCount = util$1.getMaxContinuousCount(node.value, "`");
+ const style = backtickCount === 1 ? "``" : "`";
+ const gap = backtickCount ? " " : "";
+ return concat$8([style, gap, node.value, gap, style]);
+ }
+ case "link":
+ switch (options.originalText[node.position.start.offset]) {
+ case "<":
+ return concat$8(["<", node.url, ">"]);
+ case "[":
+ return concat$8([
+ "[",
+ printChildren(path$$1, options, print),
+ "](",
+ printUrl(node.url, ")"),
+ printTitle(node.title, options),
+ ")"
+ ]);
+ default:
+ return options.originalText.slice(
+ node.position.start.offset,
+ node.position.end.offset
+ );
+ }
+ case "image":
+ return concat$8([
+ "![",
+ node.alt || "",
+ "](",
+ printUrl(node.url, ")"),
+ printTitle(node.title, options),
+ ")"
+ ]);
+ case "blockquote":
+ return concat$8(["> ", align$2("> ", printChildren(path$$1, options, print))]);
+ case "heading":
+ return concat$8([
+ "#".repeat(node.depth) + " ",
+ printChildren(path$$1, options, print)
+ ]);
+ case "code": {
+ if (
+ // the first char may point to `\n`, e.g. `\n\t\tbar`, just ignore it
+ /^\n?( {4,}|\t)/.test(
+ options.originalText.slice(
+ node.position.start.offset,
+ node.position.end.offset
+ )
+ )
+ ) {
+ // indented code block
+ const alignment = " ".repeat(4);
+ return align$2(
+ alignment,
+ concat$8([alignment, join$7(hardline$7, node.value.split("\n"))])
+ );
+ }
+
+ // fenced code block
+ const styleUnit = options.__inJsTemplate ? "~" : "`";
+ const style = styleUnit.repeat(
+ Math.max(
+ 3,
+ util$1.getMaxContinuousCount(node.value, styleUnit) + 1
+ )
+ );
+ return concat$8([
+ style,
+ node.lang || "",
+ hardline$7,
+ join$7(hardline$7, node.value.split("\n")),
+ hardline$7,
+ style
+ ]);
+ }
+ case "yaml":
+ case "toml": {
+ const style = node.type === "yaml" ? "---" : "+++";
+ return node.value
+ ? concat$8([style, hardline$7, node.value, hardline$7, style])
+ : concat$8([style, hardline$7, style]);
+ }
+ case "html": {
+ const parentNode = path$$1.getParentNode();
+ return replaceNewlinesWithHardlines(
+ parentNode.type === "root" &&
+ util$1.getLast(parentNode.children) === node
+ ? node.value.trimRight()
+ : node.value
+ );
+ }
+ case "list": {
+ const nthSiblingIndex = getNthListSiblingIndex(
+ node,
+ path$$1.getParentNode()
+ );
+
+ const isGitDiffFriendlyOrderedList =
+ node.ordered &&
+ node.children.length > 1 &&
+ /^\s*1(\.|\))/.test(
+ options.originalText.slice(
+ node.children[1].position.start.offset,
+ node.children[1].position.end.offset
+ )
+ );
+
+ return printChildren(path$$1, options, print, {
+ processor: (childPath, index) => {
+ const prefix = getPrefix();
+ return concat$8([
+ prefix,
+ align$2(
+ " ".repeat(prefix.length),
+ printListItem(childPath, options, print, prefix)
+ )
+ ]);
+
+ function getPrefix() {
+ const rawPrefix = node.ordered
+ ? (index === 0
+ ? node.start
+ : isGitDiffFriendlyOrderedList
+ ? 1
+ : node.start + index) +
+ (nthSiblingIndex % 2 === 0 ? ". " : ") ")
+ : nthSiblingIndex % 2 === 0
+ ? "* "
+ : "- ";
+
+ // do not print trailing spaces for empty list item since it might be treated as `break` node
+ // by [doc-printer](https://github.com/prettier/prettier/blob/1.10.2/src/doc/doc-printer.js#L395-L405),
+ // we don't want to preserve unnecessary trailing spaces.
+ const listItem = childPath.getValue();
+ return listItem.children.length
+ ? alignListPrefix(rawPrefix, options)
+ : rawPrefix;
+ }
+ }
+ });
+ }
+ case "thematicBreak": {
+ const counter = getAncestorCounter$1(path$$1, "list");
+ if (counter === -1) {
+ return "---";
+ }
+ const nthSiblingIndex = getNthListSiblingIndex(
+ path$$1.getParentNode(counter),
+ path$$1.getParentNode(counter + 1)
+ );
+ return nthSiblingIndex % 2 === 0 ? "---" : "***";
+ }
+ case "linkReference":
+ return concat$8([
+ "[",
+ printChildren(path$$1, options, print),
+ "]",
+ node.referenceType === "full"
+ ? concat$8(["[", node.identifier, "]"])
+ : node.referenceType === "collapsed"
+ ? "[]"
+ : ""
+ ]);
+ case "imageReference":
+ switch (node.referenceType) {
+ case "full":
+ return concat$8(["![", node.alt || "", "][", node.identifier, "]"]);
+ default:
+ return concat$8([
+ "![",
+ node.alt,
+ "]",
+ node.referenceType === "collapsed" ? "[]" : ""
+ ]);
+ }
+ case "definition":
+ return concat$8([
+ "[",
+ node.identifier,
+ "]: ",
+ printUrl(node.url),
+ printTitle(node.title, options)
+ ]);
+ case "footnote":
+ return concat$8(["[^", printChildren(path$$1, options, print), "]"]);
+ case "footnoteReference":
+ return concat$8(["[^", node.identifier, "]"]);
+ case "footnoteDefinition": {
+ const nextNode = path$$1.getParentNode().children[path$$1.getName() + 1];
+ return concat$8([
+ "[^",
+ node.identifier,
+ "]: ",
+ group$5(
+ concat$8([
+ align$2(
+ " ".repeat(options.tabWidth),
+ printChildren(path$$1, options, print, {
+ processor: (childPath, index) =>
+ index === 0
+ ? group$5(concat$8([softline$6, softline$6, childPath.call(print)]))
+ : childPath.call(print)
+ })
+ ),
+ nextNode && nextNode.type === "footnoteDefinition" ? softline$6 : ""
+ ])
+ )
+ ]);
+ }
+ case "table":
+ return printTable(path$$1, options, print);
+ case "tableCell":
+ return printChildren(path$$1, options, print);
+ case "break":
+ return concat$8([
+ /\s/.test(options.originalText[node.position.start.offset])
+ ? " "
+ : "\\",
+ hardline$7
+ ]);
+ case "tableRow": // handled in "table"
+ case "listItem": // handled in "list"
+ default:
+ throw new Error(`Unknown markdown type ${JSON.stringify(node.type)}`);
+ }
+}
+
+function printListItem(path$$1, options, print, listPrefix) {
+ const node = path$$1.getValue();
+ const prefix = node.checked === null ? "" : node.checked ? "[x] " : "[ ] ";
+ return concat$8([
+ prefix,
+ printChildren(path$$1, options, print, {
+ processor: (childPath, index) => {
+ if (index === 0 && childPath.getValue().type !== "list") {
+ return align$2(" ".repeat(prefix.length), childPath.call(print));
+ }
+
+ const alignment = " ".repeat(
+ clamp(options.tabWidth - listPrefix.length, 0, 3) // 4+ will cause indented code block
+ );
+ return concat$8([alignment, align$2(alignment, childPath.call(print))]);
+ }
+ })
+ ]);
+}
+
+function alignListPrefix(prefix, options) {
+ const additionalSpaces = getAdditionalSpaces();
+ return (
+ prefix +
+ " ".repeat(
+ additionalSpaces >= 4 ? 0 : additionalSpaces // 4+ will cause indented code block
+ )
+ );
+
+ function getAdditionalSpaces() {
+ const restSpaces = prefix.length % options.tabWidth;
+ return restSpaces === 0 ? 0 : options.tabWidth - restSpaces;
+ }
+}
+
+function getNthListSiblingIndex(node, parentNode) {
+ return getNthSiblingIndex(
+ node,
+ parentNode,
+ siblingNode => siblingNode.ordered === node.ordered
+ );
+}
+
+function replaceNewlinesWithHardlines(str) {
+ return join$7(hardline$7, str.split("\n"));
+}
+
+function getNthSiblingIndex(node, parentNode, condition) {
+ condition = condition || (() => true);
+
+ let index = -1;
+
+ for (const childNode of parentNode.children) {
+ if (childNode.type === node.type && condition(childNode)) {
+ index++;
+ } else {
+ index = -1;
+ }
+
+ if (childNode === node) {
+ return index;
+ }
+ }
+}
+
+function getAncestorCounter$1(path$$1, typeOrTypes) {
+ const types = [].concat(typeOrTypes);
+
+ let counter = -1;
+ let ancestorNode;
+
+ while ((ancestorNode = path$$1.getParentNode(++counter))) {
+ if (types.indexOf(ancestorNode.type) !== -1) {
+ return counter;
+ }
+ }
+
+ return -1;
+}
+
+function getAncestorNode$1(path$$1, typeOrTypes) {
+ const counter = getAncestorCounter$1(path$$1, typeOrTypes);
+ return counter === -1 ? null : path$$1.getParentNode(counter);
+}
+
+function printLine(path$$1, value, options) {
+ if (options.proseWrap === "preserve" && value === "\n") {
+ return hardline$7;
+ }
+
+ const isBreakable =
+ options.proseWrap === "always" &&
+ !getAncestorNode$1(path$$1, SINGLE_LINE_NODE_TYPES);
+ return value !== ""
+ ? isBreakable
+ ? line$5
+ : " "
+ : isBreakable
+ ? softline$6
+ : "";
+}
+
+function printTable(path$$1, options, print) {
+ const node = path$$1.getValue();
+ const contents = []; // { [rowIndex: number]: { [columnIndex: number]: string } }
+
+ path$$1.map(rowPath => {
+ const rowContents = [];
+
+ rowPath.map(cellPath => {
+ rowContents.push(
+ printDocToString$2(cellPath.call(print), options).formatted
+ );
+ }, "children");
+
+ contents.push(rowContents);
+ }, "children");
+
+ const columnMaxWidths = contents.reduce(
+ (currentWidths, rowContents) =>
+ currentWidths.map((width, columnIndex) =>
+ Math.max(width, util$1.getStringWidth(rowContents[columnIndex]))
+ ),
+ contents[0].map(() => 3) // minimum width = 3 (---, :--, :-:, --:)
+ );
+
+ return join$7(hardline$7, [
+ printRow(contents[0]),
+ printSeparator(),
+ join$7(hardline$7, contents.slice(1).map(printRow))
+ ]);
+
+ function printSeparator() {
+ return concat$8([
+ "| ",
+ join$7(
+ " | ",
+ columnMaxWidths.map((width, index) => {
+ switch (node.align[index]) {
+ case "left":
+ return ":" + "-".repeat(width - 1);
+ case "right":
+ return "-".repeat(width - 1) + ":";
+ case "center":
+ return ":" + "-".repeat(width - 2) + ":";
+ default:
+ return "-".repeat(width);
+ }
+ })
+ ),
+ " |"
+ ]);
+ }
+
+ function printRow(rowContents) {
+ return concat$8([
+ "| ",
+ join$7(
+ " | ",
+ rowContents.map((rowContent, columnIndex) => {
+ switch (node.align[columnIndex]) {
+ case "right":
+ return alignRight(rowContent, columnMaxWidths[columnIndex]);
+ case "center":
+ return alignCenter(rowContent, columnMaxWidths[columnIndex]);
+ default:
+ return alignLeft(rowContent, columnMaxWidths[columnIndex]);
+ }
+ })
+ ),
+ " |"
+ ]);
+ }
+
+ function alignLeft(text, width) {
+ return concat$8([text, " ".repeat(width - util$1.getStringWidth(text))]);
+ }
+
+ function alignRight(text, width) {
+ return concat$8([" ".repeat(width - util$1.getStringWidth(text)), text]);
+ }
+
+ function alignCenter(text, width) {
+ const spaces = width - util$1.getStringWidth(text);
+ const left = Math.floor(spaces / 2);
+ const right = spaces - left;
+ return concat$8([" ".repeat(left), text, " ".repeat(right)]);
+ }
+}
+
+function printRoot(path$$1, options, print) {
+ /** @typedef {{ index: number, offset: number }} IgnorePosition */
+ /** @type {Array<{start: IgnorePosition, end: IgnorePosition}>} */
+ const ignoreRanges = [];
+
+ /** @type {IgnorePosition | null} */
+ let ignoreStart = null;
+
+ const children = path$$1.getValue().children;
+ children.forEach((childNode, index) => {
+ switch (isPrettierIgnore(childNode)) {
+ case "start":
+ if (ignoreStart === null) {
+ ignoreStart = { index, offset: childNode.position.end.offset };
+ }
+ break;
+ case "end":
+ if (ignoreStart !== null) {
+ ignoreRanges.push({
+ start: ignoreStart,
+ end: { index, offset: childNode.position.start.offset }
+ });
+ ignoreStart = null;
+ }
+ break;
+ default:
+ // do nothing
+ break;
+ }
+ });
+
+ return printChildren(path$$1, options, print, {
+ processor: (childPath, index) => {
+ if (ignoreRanges.length !== 0) {
+ const ignoreRange = ignoreRanges[0];
+
+ if (index === ignoreRange.start.index) {
+ return concat$8([
+ children[ignoreRange.start.index].value,
+ options.originalText.slice(
+ ignoreRange.start.offset,
+ ignoreRange.end.offset
+ ),
+ children[ignoreRange.end.index].value
+ ]);
+ }
+
+ if (ignoreRange.start.index < index && index < ignoreRange.end.index) {
+ return false;
+ }
+
+ if (index === ignoreRange.end.index) {
+ ignoreRanges.shift();
+ return false;
+ }
+ }
+
+ return childPath.call(print);
+ }
+ });
+}
+
+function printChildren(path$$1, options, print, events) {
+ events = events || {};
+
+ const postprocessor = events.postprocessor || concat$8;
+ const processor = events.processor || (childPath => childPath.call(print));
+
+ const node = path$$1.getValue();
+ const parts = [];
+
+ let lastChildNode;
+
+ path$$1.map((childPath, index) => {
+ const childNode = childPath.getValue();
+
+ const result = processor(childPath, index);
+ if (result !== false) {
+ const data = {
+ parts,
+ prevNode: lastChildNode,
+ parentNode: node,
+ options
+ };
+
+ if (!shouldNotPrePrintHardline(childNode, data)) {
+ parts.push(hardline$7);
+
+ if (
+ shouldPrePrintDoubleHardline(childNode, data) ||
+ shouldPrePrintTripleHardline(childNode, data)
+ ) {
+ parts.push(hardline$7);
+ }
+
+ if (shouldPrePrintTripleHardline(childNode, data)) {
+ parts.push(hardline$7);
+ }
+ }
+
+ parts.push(result);
+
+ lastChildNode = childNode;
+ }
+ }, "children");
+
+ return postprocessor(parts);
+}
+
+/** @return {false | 'next' | 'start' | 'end'} */
+function isPrettierIgnore(node) {
+ if (node.type !== "html") {
+ return false;
+ }
+ const match = node.value.match(
+ /^$/
+ );
+ return match === null ? false : match[1] ? match[1] : "next";
+}
+
+function shouldNotPrePrintHardline(node, data) {
+ const isFirstNode = data.parts.length === 0;
+ const isInlineNode = INLINE_NODE_TYPES.indexOf(node.type) !== -1;
+
+ const isInlineHTML =
+ node.type === "html" &&
+ INLINE_NODE_WRAPPER_TYPES.indexOf(data.parentNode.type) !== -1;
+
+ return isFirstNode || isInlineNode || isInlineHTML;
+}
+
+function shouldPrePrintDoubleHardline(node, data) {
+ const isSequence = (data.prevNode && data.prevNode.type) === node.type;
+ const isSiblingNode =
+ isSequence && SIBLING_NODE_TYPES.indexOf(node.type) !== -1;
+
+ const isInTightListItem =
+ data.parentNode.type === "listItem" && !data.parentNode.loose;
+
+ const isPrevNodeLooseListItem =
+ data.prevNode && data.prevNode.type === "listItem" && data.prevNode.loose;
+
+ const isPrevNodePrettierIgnore = isPrettierIgnore(data.prevNode) === "next";
+
+ return (
+ isPrevNodeLooseListItem ||
+ !(isSiblingNode || isInTightListItem || isPrevNodePrettierIgnore)
+ );
+}
+
+function shouldPrePrintTripleHardline(node, data) {
+ const isPrevNodeList = data.prevNode && data.prevNode.type === "list";
+ const isIndentedCode =
+ node.type === "code" &&
+ /\s/.test(data.options.originalText[node.position.start.offset]);
+
+ return isPrevNodeList && isIndentedCode;
+}
+
+function shouldRemainTheSameContent(path$$1) {
+ const ancestorNode = getAncestorNode$1(path$$1, [
+ "linkReference",
+ "imageReference"
+ ]);
+
+ return (
+ ancestorNode &&
+ (ancestorNode.type !== "linkReference" ||
+ ancestorNode.referenceType !== "full")
+ );
+}
+
+function normalizeDoc(doc$$2) {
+ return docUtils.mapDoc(doc$$2, currentDoc => {
+ if (!currentDoc.parts) {
+ return currentDoc;
+ }
+
+ if (currentDoc.type === "concat" && currentDoc.parts.length === 1) {
+ return currentDoc.parts[0];
+ }
+
+ const parts = [];
+
+ currentDoc.parts.forEach(part => {
+ if (part.type === "concat") {
+ parts.push.apply(parts, part.parts);
+ } else if (part !== "") {
+ parts.push(part);
+ }
+ });
+
+ return Object.assign({}, currentDoc, {
+ parts: normalizeParts(parts)
+ });
+ });
+}
+
+function printUrl(url$$1, dangerousCharOrChars) {
+ const dangerousChars = [" "].concat(dangerousCharOrChars || []);
+ return new RegExp(dangerousChars.map(x => `\\${x}`).join("|")).test(url$$1)
+ ? `<${url$$1}>`
+ : url$$1;
+}
+
+function printTitle(title, options) {
+ if (!title) {
+ return "";
+ }
+ if (title.includes('"') && title.includes("'") && !title.includes(")")) {
+ return ` (${title})`; // avoid escaped quotes
+ }
+ // faster than using RegExps: https://jsperf.com/performance-of-match-vs-split
+ const singleCount = title.split("'").length - 1;
+ const doubleCount = title.split('"').length - 1;
+ const quote =
+ singleCount > doubleCount
+ ? '"'
+ : doubleCount > singleCount
+ ? "'"
+ : options.singleQuote
+ ? "'"
+ : '"';
+ title = title.replace(new RegExp(`(${quote})`, "g"), "\\$1");
+ return ` ${quote}${title}${quote}`;
+}
+
+function normalizeParts(parts) {
+ return parts.reduce((current, part) => {
+ const lastPart = util$1.getLast(current);
+
+ if (typeof lastPart === "string" && typeof part === "string") {
+ current.splice(-1, 1, lastPart + part);
+ } else {
+ current.push(part);
+ }
+
+ return current;
+ }, []);
+}
+
+function clamp(value, min, max) {
+ return value < min ? min : value > max ? max : value;
+}
+
+function clean$5(ast, newObj, parent) {
+ // for codeblock
+ if (ast.type === "code") {
+ delete newObj.value;
+ }
+ // for whitespace: "\n" and " " are considered the same
+ if (ast.type === "whitespace" && ast.value === "\n") {
+ newObj.value = " ";
+ }
+ // for insert pragma
+ if (
+ parent &&
+ parent.type === "root" &&
+ (parent.children[0] === ast ||
+ ((parent.children[0].type === "yaml" ||
+ parent.children[0].type === "toml") &&
+ parent.children[1] === ast)) &&
+ ast.type === "html" &&
+ pragma$2.startWithPragma(ast.value)
+ ) {
+ return null;
+ }
+}
+
+function hasPrettierIgnore$1(path$$1) {
+ const index = +path$$1.getName();
+
+ if (index === 0) {
+ return false;
+ }
+
+ const prevNode = path$$1.getParentNode().children[index - 1];
+ return isPrettierIgnore(prevNode) === "next";
+}
+
+var printerMarkdown = {
+ print: genericPrint$3,
+ embed: embed_1$2,
+ massageAstNode: clean$5,
+ hasPrettierIgnore: hasPrettierIgnore$1,
+ insertPragma: pragma$2.insertPragma
+};
+
+const CATEGORY_MARKDOWN = "Markdown";
+
+// format based on https://github.com/prettier/prettier/blob/master/src/common/support.js
+var options$8 = {
+ proseWrap: {
+ since: "1.8.2",
+ category: CATEGORY_MARKDOWN,
+ type: "choice",
+ default: [
+ { since: "1.8.2", value: true },
+ { since: "1.9.0", value: "preserve" }
+ ],
+ description: "How to wrap prose. (markdown)",
+ choices: [
+ {
+ since: "1.9.0",
+ value: "always",
+ description: "Wrap prose if it exceeds the print width."
+ },
+ {
+ since: "1.9.0",
+ value: "never",
+ description: "Do not wrap prose."
+ },
+ {
+ since: "1.9.0",
+ value: "preserve",
+ description: "Wrap prose as-is."
+ },
+ { value: false, deprecated: "1.9.0", redirect: "never" },
+ { value: true, deprecated: "1.9.0", redirect: "always" }
+ ]
+ },
+ singleQuote: options.singleQuote
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$4 = [
+ {
+ name: "Markdown",
+ since: "1.8.0",
+ parsers: ["remark"],
+ aliases: ["pandoc"],
+ aceMode: "markdown",
+ codemirrorMode: "gfm",
+ codemirrorMimeType: "text/x-gfm",
+ wrap: true,
+ extensions: [
+ ".md",
+ ".markdown",
+ ".mdown",
+ ".mdwn",
+ ".mkd",
+ ".mkdn",
+ ".mkdown",
+ ".ron",
+ ".workbook"
+ ],
+ filenames: ["README"],
+ tmScope: "source.gfm",
+ linguistLanguageId: 222,
+ vscodeLanguageIds: ["markdown"]
+ }
+];
+
+const remark = {
+ get parse() {
+ return require("./parser-markdown");
+ },
+ astFormat: "mdast",
+ hasPragma: pragma$2.hasPragma,
+ locStart: node => node.position.start.offset,
+ locEnd: node => node.position.end.offset
+};
+
+const parsers$4 = {
+ remark,
+ // TODO: Delete this in 2.0
+ markdown: remark
+};
+
+const printers$4 = {
+ mdast: printerMarkdown
+};
+
+var languageMarkdown = {
+ languages: languages$4,
+ options: options$8,
+ parsers: parsers$4,
+ printers: printers$4
+};
+
+const docUtils$5 = doc.utils;
+const docBuilders$11 = doc.builders;
+const hardline$10 = docBuilders$11.hardline;
+const concat$11 = docBuilders$11.concat;
+
+function embed$4(path$$1, print, textToDoc, options) {
+ const node = path$$1.getValue();
+
+ switch (node.type) {
+ case "text": {
+ const parent = path$$1.getParentNode();
+ // Inline JavaScript
+ if (
+ parent.type === "script" &&
+ ((!parent.attribs.lang && !parent.attribs.lang) ||
+ parent.attribs.type === "text/javascript" ||
+ parent.attribs.type === "application/javascript")
+ ) {
+ const parser = options.parser === "flow" ? "flow" : "babylon";
+ const doc$$2 = textToDoc(getText(options, node), { parser });
+ return concat$11([hardline$10, doc$$2]);
+ }
+
+ // Inline TypeScript
+ if (
+ parent.type === "script" &&
+ (parent.attribs.type === "application/x-typescript" ||
+ parent.attribs.lang === "ts")
+ ) {
+ const doc$$2 = textToDoc(
+ getText(options, node),
+ { parser: "typescript" },
+ options
+ );
+ return concat$11([hardline$10, doc$$2]);
+ }
+
+ // Inline Styles
+ if (parent.type === "style") {
+ const doc$$2 = textToDoc(getText(options, node), { parser: "css" });
+ return concat$11([hardline$10, docUtils$5.stripTrailingHardline(doc$$2)]);
+ }
+
+ break;
+ }
+
+ case "attribute": {
+ /*
+ * Vue binding sytax: JS expressions
+ * :class="{ 'some-key': value }"
+ * v-bind:id="'list-' + id"
+ * v-if="foo && !bar"
+ * @click="someFunction()"
+ */
+ if (/(^@)|(^v-)|:/.test(node.key) && !/^\w+$/.test(node.value)) {
+ const doc$$2 = textToDoc(node.value, {
+ parser: parseJavaScriptExpression,
+ // Use singleQuote since HTML attributes use double-quotes.
+ // TODO(azz): We still need to do an entity escape on the attribute.
+ singleQuote: true
+ });
+ return concat$11([
+ node.key,
+ '="',
+ util$1.hasNewlineInRange(node.value, 0, node.value.length)
+ ? doc$$2
+ : docUtils$5.removeLines(doc$$2),
+ '"'
+ ]);
+ }
+ }
+ }
+}
+
+function parseJavaScriptExpression(text, parsers) {
+ // Force parsing as an expression
+ const ast = parsers.babylon(`(${text})`);
+ // Extract expression from the declaration
+ return {
+ type: "File",
+ program: ast.program.body[0].expression
+ };
+}
+
+function getText(options, node) {
+ return options.originalText.slice(
+ options.locStart(node),
+ options.locEnd(node)
+ );
+}
+
+var embed_1$4 = embed$4;
+
+const docBuilders$10 = doc.builders;
+const concat$10 = docBuilders$10.concat;
+const join$8 = docBuilders$10.join;
+const hardline$9 = docBuilders$10.hardline;
+const line$6 = docBuilders$10.line;
+const softline$7 = docBuilders$10.softline;
+const group$6 = docBuilders$10.group;
+const indent$7 = docBuilders$10.indent;
+
+// http://w3c.github.io/html/single-page.html#void-elements
+const voidTags$1 = {
+ area: true,
+ base: true,
+ br: true,
+ col: true,
+ embed: true,
+ hr: true,
+ img: true,
+ input: true,
+ link: true,
+ meta: true,
+ param: true,
+ source: true,
+ track: true,
+ wbr: true
+};
+
+function genericPrint$4(path$$1, options, print) {
+ const n = path$$1.getValue();
+ if (!n) {
+ return "";
+ }
+
+ if (typeof n === "string") {
+ return n;
+ }
+
+ switch (n.type) {
+ case "root": {
+ return printChildren$1(path$$1, print);
+ }
+ case "directive": {
+ return concat$10(["<", n.data, ">", hardline$9]);
+ }
+ case "text": {
+ return n.data.replace(/\s+/g, " ").trim();
+ }
+ case "script":
+ case "style":
+ case "tag": {
+ const selfClose = voidTags$1[n.name] ? ">" : " />";
+ const children = printChildren$1(path$$1, print);
+
+ const hasNewline = util$1.hasNewlineInRange(
+ options.originalText,
+ options.locStart(n),
+ options.locEnd(n)
+ );
+
+ return group$6(
+ concat$10([
+ hasNewline ? hardline$9 : "",
+ "<",
+ n.name,
+ printAttributes(path$$1, print),
+
+ n.children.length ? ">" : selfClose,
+
+ n.name.toLowerCase() === "html"
+ ? concat$10([hardline$9, children])
+ : indent$7(children),
+ n.children.length ? concat$10([softline$7, ""]) : hardline$9
+ ])
+ );
+ }
+ case "comment": {
+ return concat$10([""]);
+ }
+ case "attribute": {
+ if (!n.value) {
+ return n.key;
+ }
+ return concat$10([n.key, '="', n.value, '"']);
+ }
+
+ default:
+ /* istanbul ignore next */
+ throw new Error("unknown htmlparser2 type: " + n.type);
+ }
+}
+
+function printAttributes(path$$1, print) {
+ const node = path$$1.getValue();
+
+ return concat$10([
+ node.attributes.length ? " " : "",
+ indent$7(join$8(line$6, path$$1.map(print, "attributes")))
+ ]);
+}
+
+function printChildren$1(path$$1, print) {
+ const children = [];
+ path$$1.each(childPath => {
+ const child = childPath.getValue();
+ if (child.type !== "text") {
+ children.push(hardline$9);
+ }
+ children.push(childPath.call(print));
+ }, "children");
+ return concat$10(children);
+}
+
+var printerHtmlparser2 = {
+ print: genericPrint$4,
+ embed: embed_1$4,
+ hasPrettierIgnore: util$1.hasIgnoreComment
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$5 = [
+ {
+ name: "HTML",
+ since: null, // unreleased
+ parsers: ["parse5"],
+ group: "HTML",
+ tmScope: "text.html.basic",
+ aceMode: "html",
+ codemirrorMode: "htmlmixed",
+ codemirrorMimeType: "text/html",
+ aliases: ["xhtml"],
+ extensions: [".html", ".htm", ".html.hl", ".inc", ".st", ".xht", ".xhtml"],
+ linguistLanguageId: 146,
+ vscodeLanguageIds: ["html"]
+ }
+];
+
+const parsers$5 = {
+ parse5: {
+ get parse() {
+ return require("./parser-parse5");
+ },
+ astFormat: "htmlparser2",
+ locEnd: function(node) {
+ return node.__location && node.__location.endOffset;
+ },
+ locStart: function(node) {
+ return node.__location && node.__location.startOffset;
+ }
+ }
+};
+
+const printers$5 = {
+ htmlparser2: printerHtmlparser2
+};
+
+var languageHtml = {
+ languages: languages$5,
+ parsers: parsers$5,
+ printers: printers$5
+};
+
+const docBuilders$13 = doc.builders;
+const concat$13 = docBuilders$13.concat;
+const hardline$12 = docBuilders$13.hardline;
+
+function embed$6(path$$1, print, textToDoc, options) {
+ const node = path$$1.getValue();
+ const parent = path$$1.getParentNode();
+ if (!parent || parent.tag !== "root" || node.unary) {
+ return null;
+ }
+
+ let parser;
+
+ if (node.tag === "style") {
+ const langAttr = node.attrs.find(attr => attr.name === "lang");
+ if (!langAttr || langAttr.value === "postcss") {
+ parser = "css";
+ } else if (langAttr.value === "scss") {
+ parser = "scss";
+ } else if (langAttr.value === "less") {
+ parser = "less";
+ }
+ }
+
+ if (node.tag === "script") {
+ const langAttr = node.attrs.find(attr => attr.name === "lang");
+ if (!langAttr) {
+ parser = "babylon";
+ } else if (langAttr.value === "ts" || langAttr.value === "tsx") {
+ parser = "typescript";
+ }
+ }
+
+ if (!parser) {
+ return null;
+ }
+
+ return concat$13([
+ options.originalText.slice(node.start, node.contentStart),
+ hardline$12,
+ textToDoc(options.originalText.slice(node.contentStart, node.contentEnd), {
+ parser
+ }),
+ options.originalText.slice(node.contentEnd, node.end)
+ ]);
+}
+
+var embed_1$6 = embed$6;
+
+const docBuilders$12 = doc.builders;
+const concat$12 = docBuilders$12.concat;
+const hardline$11 = docBuilders$12.hardline;
+
+function genericPrint$5(path$$1, options, print) {
+ const n = path$$1.getValue();
+ const res = [];
+ let index = n.start;
+
+ path$$1.each(childPath => {
+ const child = childPath.getValue();
+ res.push(options.originalText.slice(index, child.start));
+ res.push(childPath.call(print));
+ index = child.end;
+ }, "children");
+
+ // If there are no children, we just print the node from start to end.
+ // Otherwise, index should point to the end of the last child, and we
+ // need to print the closing tag.
+ res.push(options.originalText.slice(index, n.end));
+
+ // Only force a trailing newline if there were any contents.
+ if (n.tag === "root" && n.children.length) {
+ res.push(hardline$11);
+ }
+
+ return concat$12(res);
+}
+
+const clean$6 = (ast, newObj) => {
+ delete newObj.contentStart;
+ delete newObj.contentEnd;
+};
+
+var printerVue = {
+ print: genericPrint$5,
+ embed: embed_1$6,
+ massageAstNode: clean$6
+};
+
+// Based on:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+
+const languages$6 = [
+ {
+ name: "Vue",
+ since: "1.10.0",
+ parsers: ["vue"],
+ group: "HTML",
+ tmScope: "text.html.vue",
+ aceMode: "html",
+ codemirrorMode: "htmlmixed",
+ codemirrorMimeType: "text/html",
+ extensions: [".vue"],
+ linguistLanguageId: 146,
+ vscodeLanguageIds: ["vue"]
+ }
+];
+
+const parsers$6 = {
+ vue: {
+ get parse() {
+ return require("./parser-vue");
+ },
+ astFormat: "vue"
+ }
+};
+
+const printers$6 = {
+ vue: printerVue
+};
+
+var languageVue = {
+ languages: languages$6,
+ parsers: parsers$6,
+ printers: printers$6
+};
+
+function loadPlugins(plugins) {
+ plugins = plugins || [];
+
+ const internalPlugins = [
+ languageJs,
+ languageCss,
+ languageHandlebars,
+ languageGraphql,
+ languageMarkdown,
+ languageHtml,
+ languageVue
+ ];
+
+ const externalPlugins = plugins
+ .concat(
+ getPluginsFromPackage(
+ readPkgUp.sync({
+ normalize: false
+ }).pkg
+ )
+ )
+ .map(plugin => {
+ if (typeof plugin !== "string") {
+ return plugin;
+ }
+
+ const pluginPath = resolve.sync(plugin, { basedir: process.cwd() });
+ return Object.assign({ name: plugin }, require(pluginPath));
+ });
+
+ return deduplicate(internalPlugins.concat(externalPlugins));
+}
+
+function getPluginsFromPackage(pkg) {
+ if (!pkg) {
+ return [];
+ }
+ const deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
+ return Object.keys(deps).filter(
+ dep =>
+ dep.startsWith("prettier-plugin-") || dep.startsWith("@prettier/plugin-")
+ );
+}
+
+function deduplicate(items) {
+ const uniqItems = [];
+ for (const item of items) {
+ if (uniqItems.indexOf(item) < 0) {
+ uniqItems.push(item);
+ }
+ }
+ return uniqItems;
+}
+
+var loadPlugins_1 = loadPlugins;
+
+const CATEGORY_CONFIG = "Config";
+const CATEGORY_EDITOR = "Editor";
+const CATEGORY_FORMAT = "Format";
+const CATEGORY_OTHER = "Other";
+const CATEGORY_OUTPUT = "Output";
+
+const categoryOrder = [
+ CATEGORY_OUTPUT,
+ CATEGORY_FORMAT,
+ CATEGORY_CONFIG,
+ CATEGORY_EDITOR,
+ CATEGORY_OTHER
+];
+
+/**
+ * {
+ * [optionName]: {
+ * // The type of the option. For 'choice', see also `choices` below.
+ * // When passing a type other than the ones listed below, the option is
+ * // treated as taking any string as argument, and `--option <${type}>` will
+ * // be displayed in --help.
+ * type: "boolean" | "choice" | "int" | string;
+ *
+ * // Default value to be passed to the minimist option `default`.
+ * default?: any;
+ *
+ * // Alias name to be passed to the minimist option `alias`.
+ * alias?: string;
+ *
+ * // For grouping options by category in --help.
+ * category?: string;
+ *
+ * // Description to be displayed in --help. If omitted, the option won't be
+ * // shown at all in --help (but see also `oppositeDescription` below).
+ * description?: string;
+ *
+ * // Description for `--no-${name}` to be displayed in --help. If omitted,
+ * // `--no-${name}` won't be shown.
+ * oppositeDescription?: string;
+ *
+ * // Indicate if this option is simply passed to the API.
+ * // true: use camelified name as the API option name.
+ * // string: use this value as the API option name.
+ * forwardToApi?: boolean | string;
+ *
+ * // Indicate that a CLI flag should be an array when forwarded to the API.
+ * array?: boolean;
+ *
+ * // Specify available choices for validation. They will also be displayed
+ * // in --help as
.
+ * // Use an object instead of a string if a choice is deprecated and should
+ * // be treated as `redirect` instead, or if you'd like to add description for
+ * // the choice.
+ * choices?: Array<
+ * | string
+ * | { value: string, description?: string, deprecated?: boolean, redirect?: string }
+ * >;
+ *
+ * // If the option has a value that is an exception to the regular value
+ * // constraints, indicate that value here (or use a function for more
+ * // flexibility).
+ * exception?: ((value: any) => boolean);
+ *
+ * // Indicate that the option is deprecated. Use a string to add an extra
+ * // message to --help for the option, for example to suggest a replacement
+ * // option.
+ * deprecated?: true | string;
+ * }
+ * }
+ *
+ * Note: The options below are sorted alphabetically.
+ */
+const options$11 = {
+ color: {
+ // The supports-color package (a sub sub dependency) looks directly at
+ // `process.argv` for `--no-color` and such-like options. The reason it is
+ // listed here is to avoid "Ignored unknown option: --no-color" warnings.
+ // See https://github.com/chalk/supports-color/#info for more information.
+ type: "boolean",
+ default: true,
+ description: "Colorize error messages.",
+ oppositeDescription: "Do not colorize error messages."
+ },
+ config: {
+ type: "path",
+ category: CATEGORY_CONFIG,
+ description:
+ "Path to a Prettier configuration file (.prettierrc, package.json, prettier.config.js).",
+ oppositeDescription: "Do not look for a configuration file."
+ },
+ "config-precedence": {
+ type: "choice",
+ category: CATEGORY_CONFIG,
+ default: "cli-override",
+ choices: [
+ {
+ value: "cli-override",
+ description: "CLI options take precedence over config file"
+ },
+ {
+ value: "file-override",
+ description: "Config file take precedence over CLI options"
+ },
+ {
+ value: "prefer-file",
+ description: dedent_1`
+ If a config file is found will evaluate it and ignore other CLI options.
+ If no config file is found CLI options will evaluate as normal.
+ `
+ }
+ ],
+ description:
+ "Define in which order config files and CLI options should be evaluated."
+ },
+ "debug-check": {
+ type: "boolean"
+ },
+ "debug-print-doc": {
+ type: "boolean"
+ },
+ editorconfig: {
+ type: "boolean",
+ category: CATEGORY_CONFIG,
+ description: "Take .editorconfig into account when parsing configuration.",
+ oppositeDescription:
+ "Don't take .editorconfig into account when parsing configuration.",
+ default: true
+ },
+ "find-config-path": {
+ type: "path",
+ category: CATEGORY_CONFIG,
+ description:
+ "Find and print the path to a configuration file for the given input file."
+ },
+ help: {
+ type: "flag",
+ alias: "h",
+ description: dedent_1`
+ Show CLI usage, or details about the given flag.
+ Example: --help write
+ `
+ },
+ "ignore-path": {
+ type: "path",
+ category: CATEGORY_CONFIG,
+ default: ".prettierignore",
+ description: "Path to a file with patterns describing files to ignore."
+ },
+ "list-different": {
+ type: "boolean",
+ category: CATEGORY_OUTPUT,
+ alias: "l",
+ description:
+ "Print the names of files that are different from Prettier's formatting."
+ },
+ loglevel: {
+ type: "choice",
+ description: "What level of logs to report.",
+ default: "log",
+ choices: ["silent", "error", "warn", "log", "debug"]
+ },
+ stdin: {
+ type: "boolean",
+ description: "Force reading input from stdin."
+ },
+ "support-info": {
+ type: "boolean",
+ description: "Print support information as JSON."
+ },
+ version: {
+ type: "boolean",
+ alias: "v",
+ description: "Print Prettier version."
+ },
+ "with-node-modules": {
+ type: "boolean",
+ category: CATEGORY_CONFIG,
+ description: "Process files inside 'node_modules' directory."
+ },
+ write: {
+ type: "boolean",
+ category: CATEGORY_OUTPUT,
+ description: "Edit files in-place. (Beware!)"
+ }
+};
+
+const usageSummary = dedent_1`
+ Usage: prettier [options] [file/glob ...]
+
+ By default, output is written to stdout.
+ Stdin is read if it is piped to Prettier and no files are given.
+`;
+
+var constant = {
+ CATEGORY_CONFIG,
+ CATEGORY_EDITOR,
+ CATEGORY_FORMAT,
+ CATEGORY_OTHER,
+ CATEGORY_OUTPUT,
+ categoryOrder,
+ options: options$11,
+ usageSummary
+};
+
+var require$$0$11 = ( _package$1 && _package ) || _package$1;
+
+const currentVersion = require$$0$11.version;
+
+
+
+const CATEGORY_GLOBAL = "Global";
+const CATEGORY_SPECIAL = "Special";
+
+/**
+ * @typedef {Object} OptionInfo
+ * @property {string} since - available since version
+ * @property {string} category
+ * @property {'int' | 'boolean' | 'choice' | 'path'} type
+ * @property {boolean} array - indicate it's an array of the specified type
+ * @property {boolean?} deprecated - deprecated since version
+ * @property {OptionRedirectInfo?} redirect - redirect deprecated option
+ * @property {string} description
+ * @property {string?} oppositeDescription - for `false` option
+ * @property {OptionValueInfo} default
+ * @property {OptionRangeInfo?} range - for type int
+ * @property {OptionChoiceInfo?} choices - for type choice
+ * @property {(value: any) => boolean} exception
+ *
+ * @typedef {number | boolean | string} OptionValue
+ * @typedef {OptionValue | [{ value: OptionValue[] }] | Array<{ since: string, value: OptionValue}>} OptionValueInfo
+ *
+ * @typedef {Object} OptionRedirectInfo
+ * @property {string} option
+ * @property {OptionValue} value
+ *
+ * @typedef {Object} OptionRangeInfo
+ * @property {number} start - recommended range start
+ * @property {number} end - recommended range end
+ * @property {number} step - recommended range step
+ *
+ * @typedef {Object} OptionChoiceInfo
+ * @property {boolean | string} value - boolean for the option that is originally boolean type
+ * @property {string?} description - undefined if redirect
+ * @property {string?} since - undefined if available since the first version of the option
+ * @property {string?} deprecated - deprecated since version
+ * @property {OptionValueInfo?} redirect - redirect deprecated value
+ *
+ * @property {string?} cliName
+ * @property {string?} cliCategory
+ * @property {string?} cliDescription
+ */
+/** @type {{ [name: string]: OptionInfo } */
+const supportOptions = {
+ cursorOffset: {
+ since: "1.4.0",
+ category: CATEGORY_SPECIAL,
+ type: "int",
+ default: -1,
+ range: { start: -1, end: Infinity, step: 1 },
+ description: dedent_1`
+ Print (to stderr) where a cursor at the given position would move to after formatting.
+ This option cannot be used with --range-start and --range-end.
+ `,
+ cliCategory: constant.CATEGORY_EDITOR
+ },
+ filepath: {
+ since: "1.4.0",
+ category: CATEGORY_SPECIAL,
+ type: "path",
+ default: undefined,
+ description:
+ "Specify the input filepath. This will be used to do parser inference.",
+ cliName: "stdin-filepath",
+ cliCategory: constant.CATEGORY_OTHER,
+ cliDescription: "Path to the file to pretend that stdin comes from."
+ },
+ insertPragma: {
+ since: "1.8.0",
+ category: CATEGORY_SPECIAL,
+ type: "boolean",
+ default: false,
+ description: "Insert @format pragma into file's first docblock comment.",
+ cliCategory: constant.CATEGORY_OTHER
+ },
+ parser: {
+ since: "0.0.10",
+ category: CATEGORY_GLOBAL,
+ type: "choice",
+ default: "babylon",
+ description: "Which parser to use.",
+ exception: value =>
+ typeof value === "string" || typeof value === "function",
+ choices: [
+ { value: "flow", description: "Flow" },
+ { value: "babylon", description: "JavaScript" },
+ { value: "typescript", since: "1.4.0", description: "TypeScript" },
+ { value: "css", since: "1.7.1", description: "CSS" },
+ {
+ value: "postcss",
+ since: "1.4.0",
+ description: "CSS/Less/SCSS",
+ deprecated: "1.7.1",
+ redirect: "css"
+ },
+ { value: "less", since: "1.7.1", description: "Less" },
+ { value: "scss", since: "1.7.1", description: "SCSS" },
+ { value: "json", since: "1.5.0", description: "JSON" },
+ { value: "graphql", since: "1.5.0", description: "GraphQL" },
+ { value: "markdown", since: "1.8.0", description: "Markdown" },
+ { value: "vue", since: "1.10.0", description: "Vue" }
+ ]
+ },
+ plugins: {
+ since: "1.10.0",
+ type: "path",
+ array: true,
+ default: [{ value: [] }],
+ category: CATEGORY_GLOBAL,
+ description:
+ "Add a plugin. Multiple plugins can be passed as separate `--plugin`s.",
+ exception: value => typeof value === "string" || typeof value === "object",
+ cliName: "plugin",
+ cliCategory: constant.CATEGORY_CONFIG
+ },
+ printWidth: {
+ since: "0.0.0",
+ category: CATEGORY_GLOBAL,
+ type: "int",
+ default: 80,
+ description: "The line length where Prettier will try wrap.",
+ range: { start: 0, end: Infinity, step: 1 }
+ },
+ rangeEnd: {
+ since: "1.4.0",
+ category: CATEGORY_SPECIAL,
+ type: "int",
+ default: Infinity,
+ range: { start: 0, end: Infinity, step: 1 },
+ description: dedent_1`
+ Format code ending at a given character offset (exclusive).
+ The range will extend forwards to the end of the selected statement.
+ This option cannot be used with --cursor-offset.
+ `,
+ cliCategory: constant.CATEGORY_EDITOR
+ },
+ rangeStart: {
+ since: "1.4.0",
+ category: CATEGORY_SPECIAL,
+ type: "int",
+ default: 0,
+ range: { start: 0, end: Infinity, step: 1 },
+ description: dedent_1`
+ Format code starting at a given character offset.
+ The range will extend backwards to the start of the first line containing the selected statement.
+ This option cannot be used with --cursor-offset.
+ `,
+ cliCategory: constant.CATEGORY_EDITOR
+ },
+ requirePragma: {
+ since: "1.7.0",
+ category: CATEGORY_SPECIAL,
+ type: "boolean",
+ default: false,
+ description: dedent_1`
+ Require either '@prettier' or '@format' to be present in the file's first docblock comment
+ in order for it to be formatted.
+ `,
+ cliCategory: constant.CATEGORY_OTHER
+ },
+ tabWidth: {
+ type: "int",
+ category: CATEGORY_GLOBAL,
+ default: 2,
+ description: "Number of spaces per indentation level.",
+ range: { start: 0, end: Infinity, step: 1 }
+ },
+ useFlowParser: {
+ since: "0.0.0",
+ category: CATEGORY_GLOBAL,
+ type: "boolean",
+ default: false,
+ deprecated: "0.0.10",
+ description: "Use flow parser.",
+ redirect: { option: "parser", value: "flow" },
+ cliName: "flow-parser"
+ },
+ useTabs: {
+ since: "1.0.0",
+ category: CATEGORY_GLOBAL,
+ type: "boolean",
+ default: false,
+ description: "Indent with tabs instead of spaces."
+ }
+};
+
+function getSupportInfo$1(version, opts) {
+ opts = Object.assign(
+ {
+ plugins: [],
+ pluginsLoaded: false,
+ showUnreleased: false,
+ showDeprecated: false,
+ showInternal: false
+ },
+ opts
+ );
+
+ if (!version) {
+ version = currentVersion;
+ }
+
+ const plugins = opts.pluginsLoaded ? opts.plugins : loadPlugins_1(opts.plugins);
+
+ const options = util$1
+ .arrayify(
+ Object.assign(
+ plugins.reduce(
+ (currentOptions, plugin) =>
+ Object.assign(currentOptions, plugin.options),
+ {}
+ ),
+ supportOptions
+ ),
+ "name"
+ )
+ .sort((a, b) => (a.name === b.name ? 0 : a.name < b.name ? -1 : 1))
+ .filter(filterSince)
+ .filter(filterDeprecated)
+ .map(mapDeprecated)
+ .map(mapInternal)
+ .map(option => {
+ const newOption = Object.assign({}, option);
+
+ if (Array.isArray(newOption.default)) {
+ newOption.default =
+ newOption.default.length === 1
+ ? newOption.default[0].value
+ : newOption.default
+ .filter(filterSince)
+ .sort((info1, info2) =>
+ semver.compare(info2.since, info1.since)
+ )[0].value;
+ }
+
+ if (Array.isArray(newOption.choices)) {
+ newOption.choices = newOption.choices
+ .filter(filterSince)
+ .filter(filterDeprecated)
+ .map(mapDeprecated);
+ }
+
+ return newOption;
+ })
+ .map(option => {
+ const filteredPlugins = plugins.filter(
+ plugin => plugin.defaultOptions && plugin.defaultOptions[option.name]
+ );
+ const pluginDefaults = filteredPlugins.reduce((reduced, plugin) => {
+ reduced[plugin.name] = plugin.defaultOptions[option.name];
+ return reduced;
+ }, {});
+ return Object.assign(option, { pluginDefaults });
+ });
+
+ const usePostCssParser = semver.lt(version, "1.7.1");
+
+ const languages = plugins
+ .reduce((all, plugin) => all.concat(plugin.languages), [])
+ .filter(
+ language =>
+ language.since
+ ? semver.gte(version, language.since)
+ : language.since !== null
+ )
+ .map(language => {
+ // Prevent breaking changes
+ if (language.name === "Markdown") {
+ return Object.assign({}, language, {
+ parsers: ["markdown"]
+ });
+ }
+ if (language.name === "TypeScript") {
+ return Object.assign({}, language, {
+ parsers: ["typescript"]
+ });
+ }
+
+ if (usePostCssParser && language.group === "CSS") {
+ return Object.assign({}, language, {
+ parsers: ["postcss"]
+ });
+ }
+ return language;
+ });
+
+ return { languages, options };
+
+ function filterSince(object) {
+ return (
+ opts.showUnreleased ||
+ !("since" in object) ||
+ (object.since && semver.gte(version, object.since))
+ );
+ }
+ function filterDeprecated(object) {
+ return (
+ opts.showDeprecated ||
+ !("deprecated" in object) ||
+ (object.deprecated && semver.lt(version, object.deprecated))
+ );
+ }
+ function mapDeprecated(object) {
+ if (!object.deprecated || opts.showDeprecated) {
+ return object;
+ }
+ const newObject = Object.assign({}, object);
+ delete newObject.deprecated;
+ delete newObject.redirect;
+ return newObject;
+ }
+ function mapInternal(object) {
+ if (opts.showInternal) {
+ return object;
+ }
+ const newObject = Object.assign({}, object);
+ delete newObject.cliName;
+ delete newObject.cliCategory;
+ delete newObject.cliDescription;
+ return newObject;
+ }
+}
+
+var support = {
+ getSupportInfo: getSupportInfo$1
+};
+
+function FastPath(value) {
+ assert.ok(this instanceof FastPath);
+ this.stack = [value];
+}
+
+// The name of the current property is always the penultimate element of
+// this.stack, and always a String.
+FastPath.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.
+ /* istanbul ignore next */
+ return null;
+};
+
+// The value of the current property is always the final element of
+// this.stack.
+FastPath.prototype.getValue = function getValue() {
+ const s = this.stack;
+ return s[s.length - 1];
+};
+
+function getNodeHelper(path$$1, count) {
+ const s = path$$1.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.prototype.getNode = function getNode(count) {
+ return getNodeHelper(this, ~~count);
+};
+
+FastPath.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.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.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.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;
+};
+
+var fastPath = FastPath;
+
+/* eslint-disable no-nested-ternary */
+var arr = [];
+var charCodeCache = [];
+
+var leven = 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;
+};
+
+function apiDescriptor(name, value) {
+ return arguments.length === 1
+ ? JSON.stringify(name)
+ : `\`{ ${apiDescriptor(name)}: ${JSON.stringify(value)} }\``;
+}
+
+function cliDescriptor(name, value) {
+ return value === false
+ ? `\`--no-${name}\``
+ : value === true || arguments.length === 1
+ ? `\`--${name}\``
+ : value === ""
+ ? `\`--${name}\` without an argument`
+ : `\`--${name}=${value}\``;
+}
+
+var optionsDescriptor = {
+ apiDescriptor,
+ cliDescriptor
+};
+
+function validateOption(value, optionInfo, opts) {
+ opts = opts || {};
+ const descriptor = opts.descriptor || optionsDescriptor.apiDescriptor;
+
+ if (
+ typeof optionInfo.exception === "function" &&
+ optionInfo.exception(value)
+ ) {
+ return;
+ }
+
+ try {
+ validateOptionType(value, optionInfo);
+ } catch (error) {
+ throw new Error(
+ `Invalid \`${descriptor(optionInfo.name)}\` value. ${
+ error.message
+ }, but received \`${JSON.stringify(value)}\`.`
+ );
+ }
+}
+
+function validateOptionType(value, optionInfo) {
+ if (optionInfo.array) {
+ if (!Array.isArray(value)) {
+ throw new Error(`Expected an array`);
+ }
+ value.forEach(v =>
+ validateOptionType(v, Object.assign({}, optionInfo, { array: false }))
+ );
+ } else {
+ switch (optionInfo.type) {
+ case "int":
+ validateIntOption(value);
+ break;
+ case "boolean":
+ validateBooleanOption(value);
+ break;
+ case "choice":
+ validateChoiceOption(value, optionInfo.choices);
+ break;
+ }
+ }
+}
+
+function validateBooleanOption(value) {
+ if (typeof value !== "boolean") {
+ throw new Error(`Expected a boolean`);
+ }
+}
+
+function validateIntOption(value) {
+ if (
+ !(
+ typeof value === "number" &&
+ Math.floor(value) === value &&
+ value >= 0 &&
+ value !== Infinity
+ )
+ ) {
+ throw new Error(`Expected an integer`);
+ }
+}
+
+function validateChoiceOption(value, choiceInfos) {
+ if (!choiceInfos.some(choiceInfo => choiceInfo.value === value)) {
+ const choices = choiceInfos
+ .filter(choiceInfo => !choiceInfo.deprecated)
+ .map(choiceInfo => JSON.stringify(choiceInfo.value))
+ .sort();
+ const head = choices.slice(0, -2);
+ const tail = choices.slice(-2);
+ throw new Error(`Expected ${head.concat(tail.join(" or ")).join(", ")}`);
+ }
+}
+
+var optionsValidator = { validateOption };
+
+function normalizeOptions$1(options, optionInfos, opts) {
+ opts = opts || {};
+ const logger =
+ opts.logger === false
+ ? { warn() {} }
+ : opts.logger !== undefined
+ ? opts.logger
+ : console;
+ const descriptor = opts.descriptor || optionsDescriptor.apiDescriptor;
+ const passThrough = opts.passThrough || [];
+
+ const optionInfoMap = optionInfos.reduce(
+ (reduced, optionInfo) =>
+ Object.assign(reduced, { [optionInfo.name]: optionInfo }),
+ {}
+ );
+ const normalizedOptions = Object.keys(options).reduce((newOptions, key) => {
+ const optionInfo = optionInfoMap[key];
+
+ let optionName = key;
+ let optionValue = options[key];
+
+ if (!optionInfo) {
+ if (passThrough === true || passThrough.indexOf(optionName) !== -1) {
+ newOptions[optionName] = optionValue;
+ } else {
+ logger.warn(
+ createUnknownOptionMessage(
+ optionName,
+ optionValue,
+ optionInfos,
+ descriptor
+ )
+ );
+ }
+ return newOptions;
+ }
+
+ if (!optionInfo.deprecated) {
+ optionValue = normalizeOption(optionValue, optionInfo);
+ } else if (typeof optionInfo.redirect === "string") {
+ logger.warn(createRedirectOptionMessage(optionInfo, descriptor));
+ optionName = optionInfo.redirect;
+ } else if (optionValue) {
+ logger.warn(createRedirectOptionMessage(optionInfo, descriptor));
+ optionValue = optionInfo.redirect.value;
+ optionName = optionInfo.redirect.option;
+ }
+
+ if (optionInfo.choices) {
+ const choiceInfo = optionInfo.choices.find(
+ choice => choice.value === optionValue
+ );
+ if (choiceInfo && choiceInfo.deprecated) {
+ logger.warn(
+ createRedirectChoiceMessage(optionInfo, choiceInfo, descriptor)
+ );
+ optionValue = choiceInfo.redirect;
+ }
+ }
+
+ if (optionInfo.array && !Array.isArray(optionValue)) {
+ optionValue = [optionValue];
+ }
+
+ if (optionValue !== optionInfo.default) {
+ optionsValidator.validateOption(optionValue, optionInfoMap[optionName], {
+ descriptor
+ });
+ }
+
+ newOptions[optionName] = optionValue;
+ return newOptions;
+ }, {});
+
+ return normalizedOptions;
+}
+
+function normalizeOption(option, optionInfo) {
+ return optionInfo.type === "int" ? Number(option) : option;
+}
+
+function createUnknownOptionMessage(key, value, optionInfos, descriptor) {
+ const messages = [`Ignored unknown option ${descriptor(key, value)}.`];
+
+ const suggestedOptionInfo = optionInfos.find(
+ optionInfo => leven(optionInfo.name, key) < 3
+ );
+ if (suggestedOptionInfo) {
+ messages.push(`Did you mean ${JSON.stringify(suggestedOptionInfo.name)}?`);
+ }
+
+ return messages.join(" ");
+}
+
+function createRedirectOptionMessage(optionInfo, descriptor) {
+ return `${descriptor(
+ optionInfo.name
+ )} is deprecated. Prettier now treats it as ${
+ typeof optionInfo.redirect === "string"
+ ? descriptor(optionInfo.redirect)
+ : descriptor(optionInfo.redirect.option, optionInfo.redirect.value)
+ }.`;
+}
+
+function createRedirectChoiceMessage(optionInfo, choiceInfo, descriptor) {
+ return `${descriptor(
+ optionInfo.name,
+ choiceInfo.value
+ )} is deprecated. Prettier now treats it as ${descriptor(
+ optionInfo.name,
+ choiceInfo.redirect
+ )}.`;
+}
+
+function normalizeApiOptions(options, optionInfos, opts) {
+ return normalizeOptions$1(
+ options,
+ optionInfos,
+ Object.assign({ descriptor: optionsDescriptor.apiDescriptor }, opts)
+ );
+}
+
+function normalizeCliOptions(options, optionInfos, opts) {
+ const args = options["_"] || [];
+
+ const newOptions = normalizeOptions$1(
+ Object.keys(options).reduce(
+ (reduced, key) =>
+ Object.assign(
+ reduced,
+ key.length === 1 // omit alias
+ ? null
+ : { [key]: options[key] }
+ ),
+ {}
+ ),
+ optionInfos,
+ Object.assign({ descriptor: optionsDescriptor.cliDescriptor }, opts)
+ );
+ newOptions["_"] = args;
+
+ return newOptions;
+}
+
+var optionsNormalizer = {
+ normalizeApiOptions,
+ normalizeCliOptions
+};
+
+class ConfigError$1 extends Error {}
+class DebugError extends Error {}
+
+var errors = {
+ ConfigError: ConfigError$1,
+ DebugError
+};
+
+var jsTokens = 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
+};
+});
+
+unwrapExports(jsTokens);
+
+var colorName = {
+ "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 = createCommonjsModule(function (module) {
+/* MIT license */
+
+
+// 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 colorName) {
+ if (colorName.hasOwnProperty(key)) {
+ reverseKeywords[colorName[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 colorName) {
+ if (colorName.hasOwnProperty(keyword)) {
+ var value = colorName[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 colorName[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];
+};
+});
+
+/*
+ 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);
+
+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[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$$1 = [graph[toModel].parent, toModel];
+ var fn = conversions[graph[toModel].parent][toModel];
+
+ var cur = graph[toModel].parent;
+ while (graph[cur].parent) {
+ path$$1.unshift(graph[cur].parent);
+ fn = link(conversions[graph[cur].parent][cur], fn);
+ cur = graph[cur].parent;
+ }
+
+ fn.conversion = path$$1;
+ return fn;
+}
+
+var route = 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 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 colorConvert = convert;
+
+var ansiStyles = createCommonjsModule(function (module) {
+'use strict';
+
+
+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],
+
+ // Bright color
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 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],
+
+ // Bright color
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 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] = {
+ open: `\u001B[${style[0]}m`,
+ close: `\u001B[${style[1]}m`
+ };
+
+ group[styleName] = styles[styleName];
+ });
+
+ 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
+});
+});
+
+var hasFlag = function (flag, argv) {
+ argv = argv || process.argv;
+
+ var terminatorPos = argv.indexOf('--');
+ var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+ var pos = argv.indexOf(prefix + flag);
+
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};
+
+var supportsColor = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+const env = process.env;
+
+const support = level => {
+ if (level === 0) {
+ return false;
+ }
+
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+};
+
+let supportLevel = (() => {
+ if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ return 0;
+ }
+
+ if (hasFlag('color=16m') ||
+ hasFlag('color=full') ||
+ hasFlag('color=truecolor')) {
+ return 3;
+ }
+
+ if (hasFlag('color=256')) {
+ return 2;
+ }
+
+ if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ return 1;
+ }
+
+ if (process.stdout && !process.stdout.isTTY) {
+ return 0;
+ }
+
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+ // release that supports 256 colors.
+ const osRelease = os.release().split('.');
+ if (
+ Number(process.version.split('.')[0]) >= 8 &&
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return 2;
+ }
+
+ return 1;
+ }
+
+ if ('CI' in env) {
+ if ('TRAVIS' in env || env.CI === 'Travis' || 'CIRCLECI' in env) {
+ return 1;
+ }
+
+ return 0;
+ }
+
+ if ('TEAMCITY_VERSION' in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
+
+ if ('TERM_PROGRAM' in env) {
+ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Hyper':
+ return 3;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
+
+ if (/^(screen|xterm)-256(?:color)?/.test(env.TERM)) {
+ return 2;
+ }
+
+ if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
+
+ if ('COLORTERM' in env) {
+ return 1;
+ }
+
+ if (env.TERM === 'dumb') {
+ return 0;
+ }
+
+ return 0;
+})();
+
+if ('FORCE_COLOR' in env) {
+ supportLevel = parseInt(env.FORCE_COLOR, 10) === 0 ? 0 : (supportLevel || 1);
+}
+
+module.exports = process && support(supportLevel);
+});
+
+var templates = createCommonjsModule(function (module) {
+'use strict';
+const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
+
+const ESCAPES = new Map([
+ ['n', '\n'],
+ ['r', '\r'],
+ ['t', '\t'],
+ ['b', '\b'],
+ ['f', '\f'],
+ ['v', '\v'],
+ ['0', '\0'],
+ ['\\', '\\'],
+ ['e', '\u001B'],
+ ['a', '\u0007']
+]);
+
+function unescape(c) {
+ if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
+ }
+
+ return ESCAPES.get(c) || c;
+}
+
+function parseArguments(name, args) {
+ const results = [];
+ const chunks = args.trim().split(/\s*,\s*/g);
+ let matches;
+
+ for (const chunk of chunks) {
+ if (!isNaN(chunk)) {
+ results.push(Number(chunk));
+ } else if ((matches = chunk.match(STRING_REGEX))) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
+
+ return results;
+}
+
+function parseStyle(style) {
+ STYLE_REGEX.lastIndex = 0;
+
+ const results = [];
+ let matches;
+
+ while ((matches = STYLE_REGEX.exec(style)) !== null) {
+ const name = matches[1];
+
+ if (matches[2]) {
+ const args = parseArguments(name, matches[2]);
+ results.push([name].concat(args));
+ } else {
+ results.push([name]);
+ }
+ }
+
+ return results;
+}
+
+function buildStyle(chalk, styles) {
+ const enabled = {};
+
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
+
+ let current = chalk;
+ for (const styleName of Object.keys(enabled)) {
+ if (Array.isArray(enabled[styleName])) {
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
+
+ if (enabled[styleName].length > 0) {
+ current = current[styleName].apply(current, enabled[styleName]);
+ } else {
+ current = current[styleName];
+ }
+ }
+ }
+
+ return current;
+}
+
+module.exports = (chalk, tmp) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
+
+ // eslint-disable-next-line max-params
+ tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+ if (escapeChar) {
+ chunk.push(unescape(escapeChar));
+ } else if (style) {
+ const str = chunk.join('');
+ chunk = [];
+ chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+ styles.push({inverse, styles: parseStyle(style)});
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error('Found extraneous } in Chalk template literal');
+ }
+
+ chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(chr);
+ }
+ });
+
+ chunks.push(chunk.join(''));
+
+ if (styles.length > 0) {
+ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+ throw new Error(errMsg);
+ }
+
+ return chunks.join('');
+};
+});
+
+var chalk = createCommonjsModule(function (module) {
+'use strict';
+
+
+
+
+
+
+const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+
+// `color-convert` models to exclude from the Chalk API due to conflicts and such
+const skipModels = new Set(['gray']);
+
+const styles = Object.create(null);
+
+function applyOptions(obj, options) {
+ options = options || {};
+
+ // Detect level if not set manually
+ const scLevel = supportsColor ? supportsColor.level : 0;
+ obj.level = options.level === undefined ? scLevel : options.level;
+ obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
+}
+
+function Chalk(options) {
+ // We check for this.template here since calling `chalk.constructor()`
+ // by itself will have a `this` of a previously constructed chalk object
+ if (!this || !(this instanceof Chalk) || this.template) {
+ const chalk = {};
+ applyOptions(chalk, options);
+
+ chalk.template = function () {
+ const args = [].slice.call(arguments);
+ return chalkTag.apply(null, [chalk.template].concat(args));
+ };
+
+ Object.setPrototypeOf(chalk, Chalk.prototype);
+ Object.setPrototypeOf(chalk.template, chalk);
+
+ chalk.template.constructor = Chalk;
+
+ return chalk.template;
+ }
+
+ applyOptions(this, options);
+}
+
+// Use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+ ansiStyles.blue.open = '\u001B[94m';
+}
+
+for (const key of Object.keys(ansiStyles)) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+
+ styles[key] = {
+ get() {
+ const codes = ansiStyles[key];
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+ }
+ };
+}
+
+styles.visible = {
+ get() {
+ return build.call(this, this._styles || [], true, 'visible');
+ }
+};
+
+ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
+for (const model of Object.keys(ansiStyles.color.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
+
+ styles[model] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.color.close,
+ closeRe: ansiStyles.color.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+}
+
+ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
+
+ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.bgColor.close,
+ closeRe: ansiStyles.bgColor.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+}
+
+const proto = Object.defineProperties(() => {}, styles);
+
+function build(_styles, _empty, key) {
+ const builder = function () {
+ return applyStyle.apply(builder, arguments);
+ };
+
+ builder._styles = _styles;
+ builder._empty = _empty;
+
+ const self = this;
+
+ Object.defineProperty(builder, 'level', {
+ enumerable: true,
+ get() {
+ return self.level;
+ },
+ set(level) {
+ self.level = level;
+ }
+ });
+
+ Object.defineProperty(builder, 'enabled', {
+ enumerable: true,
+ get() {
+ return self.enabled;
+ },
+ set(enabled) {
+ self.enabled = enabled;
+ }
+ });
+
+ // See below for fix regarding invisible grey/dim combination on Windows
+ builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+
+ // `__proto__` is used because we must return a function, but there is
+ // no way to create a function with a different prototype
+ builder.__proto__ = proto; // eslint-disable-line no-proto
+
+ return builder;
+}
+
+function applyStyle() {
+ // Support varags, but simply cast to string in case there's only one arg
+ const args = arguments;
+ const argsLen = args.length;
+ let str = String(arguments[0]);
+
+ if (argsLen === 0) {
+ return '';
+ }
+
+ if (argsLen > 1) {
+ // Don't slice `arguments`, it prevents V8 optimizations
+ for (let a = 1; a < argsLen; a++) {
+ str += ' ' + args[a];
+ }
+ }
+
+ if (!this.enabled || this.level <= 0 || !str) {
+ return this._empty ? '' : str;
+ }
+
+ // 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.
+ const originalDim = ansiStyles.dim.open;
+ if (isSimpleWindowsTerm && this.hasGrey) {
+ ansiStyles.dim.open = '';
+ }
+
+ for (const code of this._styles.slice().reverse()) {
+ // 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;
+
+ // Close the styling before a linebreak and reopen
+ // after next line to fix a bleed issue on macOS
+ // https://github.com/chalk/chalk/pull/92
+ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+ }
+
+ // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
+ ansiStyles.dim.open = originalDim;
+
+ return str;
+}
+
+function chalkTag(chalk, strings) {
+ if (!Array.isArray(strings)) {
+ // If chalk() was called by itself or with a string,
+ // return the string itself as a string.
+ return [].slice.call(arguments, 1).join(' ');
+ }
+
+ const args = [].slice.call(arguments, 2);
+ const parts = [strings.raw[0]];
+
+ for (let i = 1; i < strings.length; i++) {
+ parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+ parts.push(String(strings.raw[i]));
+ }
+
+ return templates(chalk, parts.join(''));
+}
+
+Object.defineProperties(Chalk.prototype, styles);
+
+module.exports = Chalk(); // eslint-disable-line new-cap
+module.exports.supportsColor = supportsColor;
+module.exports.default = module.exports; // For TypeScript
+});
+
+var lib$5 = createCommonjsModule(function (module, exports) {
+"use strict";
+
+exports.__esModule = true;
+exports.shouldHighlight = shouldHighlight;
+exports.getChalk = getChalk;
+exports.default = highlight;
+
+var _jsTokens = _interopRequireWildcard(jsTokens);
+
+var _esutils = _interopRequireDefault(utils$2);
+
+var _chalk = _interopRequireDefault(chalk);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function getDefs(chalk$$1) {
+ return {
+ keyword: chalk$$1.cyan,
+ capitalized: chalk$$1.yellow,
+ jsx_tag: chalk$$1.yellow,
+ punctuator: chalk$$1.yellow,
+ number: chalk$$1.magenta,
+ string: chalk$$1.green,
+ regex: chalk$$1.magenta,
+ comment: chalk$$1.grey,
+ invalid: chalk$$1.white.bgRed.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 (_esutils.default.keyword.isReservedWordES6(token.value)) {
+ return "keyword";
+ }
+
+ if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == ""), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
+ } else {
+ return " " + maybeHighlight(defs.gutter, gutter) + line;
+ }
+ }).join("\n");
+
+ if (opts.message && !hasColumns) {
+ frame = "" + " ".repeat(numberMaxWidth + 1) + opts.message + "\n" + frame;
+ }
+
+ if (highlighted) {
+ return chalk.reset(frame);
+ } else {
+ return frame;
+ }
+}
+
+function _default(rawLines, lineNumber, colNumber, opts) {
+ if (opts === void 0) {
+ opts = {};
+ }
+
+ if (!deprecationWarningShown) {
+ deprecationWarningShown = true;
+ var deprecationError = new Error("Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.");
+ deprecationError.name = "DeprecationWarning";
+
+ if (process.emitWarning) {
+ process.emitWarning(deprecationError);
+ } else {
+ console.warn(deprecationError);
+ }
+ }
+
+ colNumber = Math.max(colNumber, 0);
+ var location = {
+ start: {
+ column: colNumber,
+ line: lineNumber
+ }
+ };
+ return codeFrameColumns(rawLines, location, opts);
+}
+});
+
+unwrapExports(lib$4);
+
+const ConfigError = errors.ConfigError;
+
+
+const locStart$1 = languageJs.locStart;
+const locEnd$1 = languageJs.locEnd;
+
+function getParsers(options) {
+ return options.plugins.reduce(
+ (parsers, plugin) => Object.assign({}, parsers, plugin.parsers),
+ {}
+ );
+}
+
+function resolveParser$1(opts, parsers) {
+ parsers = parsers || getParsers(opts);
+
+ if (typeof opts.parser === "function") {
+ // Custom parser API always works with JavaScript.
+ return {
+ parse: opts.parser,
+ astFormat: "estree",
+ locStart: locStart$1,
+ locEnd: locEnd$1
+ };
+ }
+
+ if (typeof opts.parser === "string") {
+ if (parsers.hasOwnProperty(opts.parser)) {
+ return parsers[opts.parser];
+ }
+ try {
+ return {
+ parse: require(path.resolve(process.cwd(), opts.parser)),
+ astFormat: "estree",
+ locStart: locStart$1,
+ locEnd: locEnd$1
+ };
+ } catch (err) {
+ /* istanbul ignore next */
+ throw new ConfigError(`Couldn't resolve parser "${opts.parser}"`);
+ }
+ }
+ /* istanbul ignore next */
+ return parsers.babylon;
+}
+
+function parse$3(text, opts) {
+ const parsers = getParsers(opts);
+
+ // Copy the "parse" function from parser to a new object whose values are
+ // functions. Use defineProperty()/getOwnPropertyDescriptor() such that we
+ // don't invoke the parser.parse getters.
+ const parsersForCustomParserApi = Object.keys(parsers).reduce(
+ (object, parserName) =>
+ Object.defineProperty(
+ object,
+ parserName,
+ Object.getOwnPropertyDescriptor(parsers[parserName], "parse")
+ ),
+ {}
+ );
+
+ const parser = resolveParser$1(opts, parsers);
+
+ try {
+ if (parser.preprocess) {
+ text = parser.preprocess(text, opts);
+ }
+
+ return {
+ text,
+ ast: parser.parse(text, parsersForCustomParserApi, opts)
+ };
+ } catch (error) {
+ const loc = error.loc;
+
+ if (loc) {
+ const codeFrame = lib$4;
+ error.codeFrame = codeFrame.codeFrameColumns(text, loc, {
+ highlightCode: true
+ });
+ error.message += "\n" + error.codeFrame;
+ throw error;
+ }
+
+ /* istanbul ignore next */
+ throw error.stack;
+ }
+}
+
+var parser$3 = { parse: parse$3, resolveParser: resolveParser$1 };
+
+function getPlugin(options) {
+ const astFormat = options.astFormat;
+
+ if (!astFormat) {
+ throw new Error("getPlugin() requires astFormat to be set");
+ }
+ const printerPlugin = options.plugins.find(
+ plugin => plugin.printers[astFormat]
+ );
+ if (!printerPlugin) {
+ throw new Error(`Couldn't find plugin for AST format "${astFormat}"`);
+ }
+
+ return printerPlugin;
+}
+
+var getPlugin_1 = getPlugin;
+
+const getSupportInfo$2 = support.getSupportInfo;
+
+
+const resolveParser = parser$3.resolveParser;
+
+
+const hiddenDefaults = {
+ astFormat: "estree",
+ printer: {},
+ locStart: null,
+ locEnd: null
+};
+
+// Copy options and fill in default values.
+function normalize$2(options, opts) {
+ opts = opts || {};
+
+ const rawOptions = Object.assign({}, options);
+
+ const plugins = loadPlugins_1(rawOptions.plugins);
+ rawOptions.plugins = plugins;
+
+ const supportOptions = getSupportInfo$2(null, {
+ plugins,
+ pluginsLoaded: true,
+ showUnreleased: true,
+ showDeprecated: true
+ }).options;
+ const defaults = supportOptions.reduce(
+ (reduced, optionInfo) =>
+ Object.assign(reduced, { [optionInfo.name]: optionInfo.default }),
+ Object.assign({}, hiddenDefaults)
+ );
+
+ if (opts.inferParser !== false) {
+ if (
+ rawOptions.filepath &&
+ (!rawOptions.parser || rawOptions.parser === defaults.parser)
+ ) {
+ const inferredParser = inferParser(
+ rawOptions.filepath,
+ rawOptions.plugins
+ );
+ if (inferredParser) {
+ rawOptions.parser = inferredParser;
+ }
+ }
+ }
+
+ const parser = resolveParser(
+ !rawOptions.parser
+ ? rawOptions
+ : // handle deprecated parsers
+ optionsNormalizer.normalizeApiOptions(
+ rawOptions,
+ [supportOptions.find(x => x.name === "parser")],
+ { passThrough: true, logger: false }
+ )
+ );
+ rawOptions.astFormat = parser.astFormat;
+ rawOptions.locEnd = parser.locEnd;
+ rawOptions.locStart = parser.locStart;
+
+ const plugin = getPlugin_1(rawOptions);
+ rawOptions.printer = plugin.printers[rawOptions.astFormat];
+
+ const pluginDefaults = supportOptions
+ .filter(
+ optionInfo =>
+ optionInfo.pluginDefaults && optionInfo.pluginDefaults[plugin.name]
+ )
+ .reduce(
+ (reduced, optionInfo) =>
+ Object.assign(reduced, {
+ [optionInfo.name]: optionInfo.pluginDefaults[plugin.name]
+ }),
+ {}
+ );
+
+ const mixedDefaults = Object.assign({}, defaults, pluginDefaults);
+
+ Object.keys(mixedDefaults).forEach(k => {
+ if (rawOptions[k] == null) {
+ rawOptions[k] = mixedDefaults[k];
+ }
+ });
+
+ if (rawOptions.parser === "json") {
+ rawOptions.trailingComma = "none";
+ }
+
+ return optionsNormalizer.normalizeApiOptions(
+ rawOptions,
+ supportOptions,
+ Object.assign({ passThrough: Object.keys(hiddenDefaults) }, opts)
+ );
+}
+
+function inferParser(filepath, plugins) {
+ const extension = path.extname(filepath);
+ const filename = path.basename(filepath).toLowerCase();
+
+ const language = getSupportInfo$2(null, {
+ plugins,
+ pluginsLoaded: true
+ }).languages.find(
+ language =>
+ language.since !== null &&
+ (language.extensions.indexOf(extension) > -1 ||
+ (language.filenames &&
+ language.filenames.find(name => name.toLowerCase() === filename)))
+ );
+
+ return language && language.parsers[0];
+}
+
+var options$12 = { normalize: normalize$2, hiddenDefaults };
+
+const normalize$1 = options$12.normalize;
+
+
+function printSubtree(path$$1, print, options) {
+ if (options.printer.embed) {
+ return options.printer.embed(
+ path$$1,
+ print,
+ (text, partialNextOptions) =>
+ textToDoc(text, partialNextOptions, options),
+ options
+ );
+ }
+}
+
+function textToDoc(text, partialNextOptions, parentOptions) {
+ const nextOptions = normalize$1(
+ Object.assign({}, parentOptions, partialNextOptions, {
+ parentParser: parentOptions.parser,
+ originalText: text
+ }),
+ { passThrough: true, inferParser: false }
+ );
+
+ const result = parser$3.parse(text, nextOptions);
+ const ast = result.ast;
+ text = result.text;
+
+ const astComments = ast.comments;
+ delete ast.comments;
+ comments.attach(astComments, ast, text, nextOptions);
+ return astToDoc(ast, nextOptions);
+}
+
+var multiparser = {
+ printSubtree
+};
+
+const doc$3 = doc;
+const docBuilders$14 = doc$3.builders;
+const concat$14 = docBuilders$14.concat;
+const hardline$13 = docBuilders$14.hardline;
+const addAlignmentToDoc$2 = docBuilders$14.addAlignmentToDoc;
+const docUtils$6 = doc$3.utils;
+
+function printAstToDoc(ast, options, addAlignmentSize) {
+ addAlignmentSize = addAlignmentSize || 0;
+
+ const printer = options.printer;
+ const cache = new Map();
+
+ function printGenerically(path$$1, args) {
+ const node = path$$1.getValue();
+
+ const shouldCache = node && typeof node === "object" && args === undefined;
+ if (shouldCache && cache.has(node)) {
+ return cache.get(node);
+ }
+
+ // We let JSXElement print its comments itself because it adds () around
+ // UnionTypeAnnotation has to align the child without the comments
+ let res;
+ if (printer.willPrintOwnComments && printer.willPrintOwnComments(path$$1)) {
+ res = genericPrint$6(path$$1, options, printGenerically, args);
+ } else {
+ res = comments.printComments(
+ path$$1,
+ p => genericPrint$6(p, options, printGenerically, args),
+ options,
+ args && args.needsSemi
+ );
+ }
+
+ if (shouldCache) {
+ cache.set(node, res);
+ }
+
+ return res;
+ }
+
+ let doc$$2 = 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$$2 = addAlignmentToDoc$2(
+ docUtils$6.removeLines(concat$14([hardline$13, doc$$2])),
+ addAlignmentSize,
+ options.tabWidth
+ );
+ }
+ docUtils$6.propagateBreaks(doc$$2);
+
+ if (options.parser === "json") {
+ doc$$2 = concat$14([doc$$2, hardline$13]);
+ }
+
+ return doc$$2;
+}
+
+function genericPrint$6(path$$1, options, printPath, args) {
+ assert.ok(path$$1 instanceof fastPath);
+
+ const node = path$$1.getValue();
+ const printer = options.printer;
+
+ // Escape hatch
+ if (printer.hasPrettierIgnore && printer.hasPrettierIgnore(path$$1)) {
+ return options.originalText.slice(
+ options.locStart(node),
+ options.locEnd(node)
+ );
+ }
+
+ if (node) {
+ try {
+ // Potentially switch to a different parser
+ const sub = multiparser.printSubtree(path$$1, printPath, options);
+ if (sub) {
+ return sub;
+ }
+ } catch (error) {
+ /* istanbul ignore if */
+ if (process.env.PRETTIER_DEBUG) {
+ throw error;
+ }
+ // Continue with current parser
+ }
+ }
+
+ return printer.print(path$$1, options, printPath, args);
+}
+
+var astToDoc = printAstToDoc;
+
+var concatMap = function (xs, fn) {
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ var x = fn(xs[i], i);
+ if (isArray(x)) res.push.apply(res, x);
+ else res.push(x);
+ }
+ return res;
+};
+
+var isArray = Array.isArray || function (xs) {
+ return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+var balancedMatch = balanced;
+function balanced(a, b, str) {
+ if (a instanceof RegExp) a = maybeMatch(a, str);
+ if (b instanceof RegExp) b = maybeMatch(b, str);
+
+ var r = range(a, b, str);
+
+ return r && {
+ start: r[0],
+ end: r[1],
+ pre: str.slice(0, r[0]),
+ body: str.slice(r[0] + a.length, r[1]),
+ post: str.slice(r[1] + b.length)
+ };
+}
+
+function maybeMatch(reg, str) {
+ var m = str.match(reg);
+ return m ? m[0] : null;
+}
+
+balanced.range = range;
+function range(a, b, str) {
+ var begs, beg, left, right, result;
+ var ai = str.indexOf(a);
+ var bi = str.indexOf(b, ai + 1);
+ var i = ai;
+
+ if (ai >= 0 && bi > 0) {
+ begs = [];
+ left = str.length;
+
+ while (i >= 0 && !result) {
+ if (i == ai) {
+ begs.push(i);
+ ai = str.indexOf(a, i + 1);
+ } else if (begs.length == 1) {
+ result = [ begs.pop(), bi ];
+ } else {
+ beg = begs.pop();
+ if (beg < left) {
+ left = beg;
+ right = bi;
+ }
+
+ bi = str.indexOf(b, i + 1);
+ }
+
+ i = ai < bi && ai >= 0 ? ai : bi;
+ }
+
+ if (begs.length) {
+ result = [ left, right ];
+ }
+ }
+
+ return result;
+}
+
+var braceExpansion = expandTop;
+
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
+
+function numeric(str) {
+ return parseInt(str, 10) == str
+ ? parseInt(str, 10)
+ : str.charCodeAt(0);
+}
+
+function escapeBraces(str) {
+ return str.split('\\\\').join(escSlash)
+ .split('\\{').join(escOpen)
+ .split('\\}').join(escClose)
+ .split('\\,').join(escComma)
+ .split('\\.').join(escPeriod);
+}
+
+function unescapeBraces(str) {
+ return str.split(escSlash).join('\\')
+ .split(escOpen).join('{')
+ .split(escClose).join('}')
+ .split(escComma).join(',')
+ .split(escPeriod).join('.');
+}
+
+
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+ if (!str)
+ return [''];
+
+ var parts = [];
+ var m = balancedMatch('{', '}', str);
+
+ if (!m)
+ return str.split(',');
+
+ var pre = m.pre;
+ var body = m.body;
+ var post = m.post;
+ var p = pre.split(',');
+
+ p[p.length-1] += '{' + body + '}';
+ var postParts = parseCommaParts(post);
+ if (post.length) {
+ p[p.length-1] += postParts.shift();
+ p.push.apply(p, postParts);
+ }
+
+ parts.push.apply(parts, p);
+
+ return parts;
+}
+
+function expandTop(str) {
+ if (!str)
+ return [];
+
+ // I don't know why Bash 4.3 does this, but it does.
+ // Anything starting with {} will have the first two bytes preserved
+ // but *only* at the top level, so {},a}b will not expand to anything,
+ // but a{},b}c will be expanded to [a}c,abc].
+ // One could argue that this is a bug in Bash, but since the goal of
+ // this module is to match Bash's rules, we escape a leading {}
+ if (str.substr(0, 2) === '{}') {
+ str = '\\{\\}' + str.substr(2);
+ }
+
+ return expand(escapeBraces(str), true).map(unescapeBraces);
+}
+
+function embrace(str) {
+ return '{' + str + '}';
+}
+function isPadded(el) {
+ return /^-?0\d/.test(el);
+}
+
+function lte(i, y) {
+ return i <= y;
+}
+function gte(i, y) {
+ return i >= y;
+}
+
+function expand(str, isTop) {
+ var expansions = [];
+
+ var m = balancedMatch('{', '}', str);
+ if (!m || /\$$/.test(m.pre)) return [str];
+
+ var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+ var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+ var isSequence = isNumericSequence || isAlphaSequence;
+ var isOptions = m.body.indexOf(',') >= 0;
+ if (!isSequence && !isOptions) {
+ // {a},b}
+ if (m.post.match(/,.*\}/)) {
+ str = m.pre + '{' + m.body + escClose + m.post;
+ return expand(str);
+ }
+ return [str];
+ }
+
+ var n;
+ if (isSequence) {
+ n = m.body.split(/\.\./);
+ } else {
+ n = parseCommaParts(m.body);
+ if (n.length === 1) {
+ // x{{a,b}}y ==> x{a}y x{b}y
+ n = expand(n[0], false).map(embrace);
+ if (n.length === 1) {
+ var post = m.post.length
+ ? expand(m.post, false)
+ : [''];
+ return post.map(function(p) {
+ return m.pre + n[0] + p;
+ });
+ }
+ }
+ }
+
+ // at this point, n is the parts, and we know it's not a comma set
+ // with a single entry.
+
+ // no need to expand pre, since it is guaranteed to be free of brace-sets
+ var pre = m.pre;
+ var post = m.post.length
+ ? expand(m.post, false)
+ : [''];
+
+ var N;
+
+ if (isSequence) {
+ var x = numeric(n[0]);
+ var y = numeric(n[1]);
+ var width = Math.max(n[0].length, n[1].length);
+ var incr = n.length == 3
+ ? Math.abs(numeric(n[2]))
+ : 1;
+ var test = lte;
+ var reverse = y < x;
+ if (reverse) {
+ incr *= -1;
+ test = gte;
+ }
+ var pad = n.some(isPadded);
+
+ N = [];
+
+ for (var i = x; test(i, y); i += incr) {
+ var c;
+ if (isAlphaSequence) {
+ c = String.fromCharCode(i);
+ if (c === '\\')
+ c = '';
+ } else {
+ c = String(i);
+ if (pad) {
+ var need = width - c.length;
+ if (need > 0) {
+ var z = new Array(need + 1).join('0');
+ if (i < 0)
+ c = '-' + z + c.slice(1);
+ else
+ c = z + c;
+ }
+ }
+ }
+ N.push(c);
+ }
+ } else {
+ N = concatMap(n, function(el) { return expand(el, false) });
+ }
+
+ for (var j = 0; j < N.length; j++) {
+ for (var k = 0; k < post.length; k++) {
+ var expansion = pre + N[j] + post[k];
+ if (!isTop || isSequence || expansion)
+ expansions.push(expansion);
+ }
+ }
+
+ return expansions;
+}
+
+var minimatch_1 = minimatch;
+minimatch.Minimatch = Minimatch;
+
+var path$3 = { sep: '/' };
+try {
+ path$3 = path;
+} catch (er) {}
+
+var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
+
+
+var plTypes = {
+ '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+ '?': { open: '(?:', close: ')?' },
+ '+': { open: '(?:', close: ')+' },
+ '*': { open: '(?:', close: ')*' },
+ '@': { open: '(?:', close: ')' }
+};
+
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]';
+
+// * => any number of characters
+var star = qmark + '*?';
+
+// ** when dots are allowed. Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?';
+
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';
+
+// characters that need to be escaped in RegExp.
+var reSpecials = charSet('().*{}+?[]^$\\!');
+
+// "abc" -> { a:true, b:true, c:true }
+function charSet (s) {
+ return s.split('').reduce(function (set, c) {
+ set[c] = true;
+ return set
+ }, {})
+}
+
+// normalizes slashes.
+var slashSplit = /\/+/;
+
+minimatch.filter = filter;
+function filter (pattern, options) {
+ options = options || {};
+ return function (p, i, list) {
+ return minimatch(p, pattern, options)
+ }
+}
+
+function ext (a, b) {
+ a = a || {};
+ b = b || {};
+ var t = {};
+ Object.keys(b).forEach(function (k) {
+ t[k] = b[k];
+ });
+ Object.keys(a).forEach(function (k) {
+ t[k] = a[k];
+ });
+ return t
+}
+
+minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return minimatch
+
+ var orig = minimatch;
+
+ var m = function minimatch (p, pattern, options) {
+ return orig.minimatch(p, pattern, ext(def, options))
+ };
+
+ m.Minimatch = function Minimatch (pattern, options) {
+ return new orig.Minimatch(pattern, ext(def, options))
+ };
+
+ return m
+};
+
+Minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return Minimatch
+ return minimatch.defaults(def).Minimatch
+};
+
+function minimatch (p, pattern, options) {
+ if (typeof pattern !== 'string') {
+ throw new TypeError('glob pattern string required')
+ }
+
+ if (!options) options = {};
+
+ // shortcut: comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === '#') {
+ return false
+ }
+
+ // "" only matches ""
+ if (pattern.trim() === '') return p === ''
+
+ return new Minimatch(pattern, options).match(p)
+}
+
+function Minimatch (pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options)
+ }
+
+ if (typeof pattern !== 'string') {
+ throw new TypeError('glob pattern string required')
+ }
+
+ if (!options) options = {};
+ pattern = pattern.trim();
+
+ // windows support: need to use /, not \
+ if (path$3.sep !== '/') {
+ pattern = pattern.split(path$3.sep).join('/');
+ }
+
+ this.options = options;
+ this.set = [];
+ this.pattern = pattern;
+ this.regexp = null;
+ this.negate = false;
+ this.comment = false;
+ this.empty = false;
+
+ // make the set of regexps etc.
+ this.make();
+}
+
+Minimatch.prototype.debug = function () {};
+
+Minimatch.prototype.make = make;
+function make () {
+ // don't do it more than once.
+ if (this._made) return
+
+ var pattern = this.pattern;
+ var options = this.options;
+
+ // empty patterns and comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === '#') {
+ this.comment = true;
+ return
+ }
+ if (!pattern) {
+ this.empty = true;
+ return
+ }
+
+ // step 1: figure out negation, etc.
+ this.parseNegate();
+
+ // step 2: expand braces
+ var set = this.globSet = this.braceExpand();
+
+ if (options.debug) this.debug = console.error;
+
+ this.debug(this.pattern, set);
+
+ // step 3: now we have a set, so turn each one into a series of path-portion
+ // matching patterns.
+ // These will be regexps, except in the case of "**", which is
+ // set to the GLOBSTAR object for globstar behavior,
+ // and will not contain any / characters
+ set = this.globParts = set.map(function (s) {
+ return s.split(slashSplit)
+ });
+
+ this.debug(this.pattern, set);
+
+ // glob --> regexps
+ set = set.map(function (s, si, set) {
+ return s.map(this.parse, this)
+ }, this);
+
+ this.debug(this.pattern, set);
+
+ // filter out everything that didn't compile properly.
+ set = set.filter(function (s) {
+ return s.indexOf(false) === -1
+ });
+
+ this.debug(this.pattern, set);
+
+ this.set = set;
+}
+
+Minimatch.prototype.parseNegate = parseNegate;
+function parseNegate () {
+ var pattern = this.pattern;
+ var negate = false;
+ var options = this.options;
+ var negateOffset = 0;
+
+ if (options.nonegate) return
+
+ for (var i = 0, l = pattern.length
+ ; i < l && pattern.charAt(i) === '!'
+ ; i++) {
+ negate = !negate;
+ negateOffset++;
+ }
+
+ if (negateOffset) this.pattern = pattern.substr(negateOffset);
+ this.negate = negate;
+}
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+minimatch.braceExpand = function (pattern, options) {
+ return braceExpand(pattern, options)
+};
+
+Minimatch.prototype.braceExpand = braceExpand;
+
+function braceExpand (pattern, options) {
+ if (!options) {
+ if (this instanceof Minimatch) {
+ options = this.options;
+ } else {
+ options = {};
+ }
+ }
+
+ pattern = typeof pattern === 'undefined'
+ ? this.pattern : pattern;
+
+ if (typeof pattern === 'undefined') {
+ throw new TypeError('undefined pattern')
+ }
+
+ if (options.nobrace ||
+ !pattern.match(/\{.*\}/)) {
+ // shortcut. no need to expand.
+ return [pattern]
+ }
+
+ return braceExpansion(pattern)
+}
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion. Otherwise, any series
+// of * is equivalent to a single *. Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+Minimatch.prototype.parse = parse$4;
+var SUBPARSE = {};
+function parse$4 (pattern, isSub) {
+ if (pattern.length > 1024 * 64) {
+ throw new TypeError('pattern is too long')
+ }
+
+ var options = this.options;
+
+ // shortcuts
+ if (!options.noglobstar && pattern === '**') return GLOBSTAR
+ if (pattern === '') return ''
+
+ var re = '';
+ var hasMagic = !!options.nocase;
+ var escaping = false;
+ // ? => one single character
+ var patternListStack = [];
+ var negativeLists = [];
+ var stateChar;
+ var inClass = false;
+ var reClassStart = -1;
+ var classStart = -1;
+ // . and .. never match anything that doesn't start with .,
+ // even when options.dot is set.
+ var patternStart = pattern.charAt(0) === '.' ? '' // anything
+ // not (start or / followed by . or .. followed by / or end)
+ : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+ : '(?!\\.)';
+ var self = this;
+
+ function clearStateChar () {
+ if (stateChar) {
+ // we had some state-tracking character
+ // that wasn't consumed by this pass.
+ switch (stateChar) {
+ case '*':
+ re += star;
+ hasMagic = true;
+ break
+ case '?':
+ re += qmark;
+ hasMagic = true;
+ break
+ default:
+ re += '\\' + stateChar;
+ break
+ }
+ self.debug('clearStateChar %j %j', stateChar, re);
+ stateChar = false;
+ }
+ }
+
+ for (var i = 0, len = pattern.length, c
+ ; (i < len) && (c = pattern.charAt(i))
+ ; i++) {
+ this.debug('%s\t%s %s %j', pattern, i, re, c);
+
+ // skip over any that are escaped.
+ if (escaping && reSpecials[c]) {
+ re += '\\' + c;
+ escaping = false;
+ continue
+ }
+
+ switch (c) {
+ case '/':
+ // completely not allowed, even escaped.
+ // Should already be path-split by now.
+ return false
+
+ case '\\':
+ clearStateChar();
+ escaping = true;
+ continue
+
+ // the various stateChar values
+ // for the "extglob" stuff.
+ case '?':
+ case '*':
+ case '+':
+ case '@':
+ case '!':
+ this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);
+
+ // all of those are literals inside a class, except that
+ // the glob [!a] means [^a] in regexp
+ if (inClass) {
+ this.debug(' in class');
+ if (c === '!' && i === classStart + 1) c = '^';
+ re += c;
+ continue
+ }
+
+ // if we already have a stateChar, then it means
+ // that there was something like ** or +? in there.
+ // Handle the stateChar, then proceed with this one.
+ self.debug('call clearStateChar %j', stateChar);
+ clearStateChar();
+ stateChar = c;
+ // if extglob is disabled, then +(asdf|foo) isn't a thing.
+ // just clear the statechar *now*, rather than even diving into
+ // the patternList stuff.
+ if (options.noext) clearStateChar();
+ continue
+
+ case '(':
+ if (inClass) {
+ re += '(';
+ continue
+ }
+
+ if (!stateChar) {
+ re += '\\(';
+ continue
+ }
+
+ patternListStack.push({
+ type: stateChar,
+ start: i - 1,
+ reStart: re.length,
+ open: plTypes[stateChar].open,
+ close: plTypes[stateChar].close
+ });
+ // negation is (?:(?!js)[^/]*)
+ re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
+ this.debug('plType %j %j', stateChar, re);
+ stateChar = false;
+ continue
+
+ case ')':
+ if (inClass || !patternListStack.length) {
+ re += '\\)';
+ continue
+ }
+
+ clearStateChar();
+ hasMagic = true;
+ var pl = patternListStack.pop();
+ // negation is (?:(?!js)[^/]*)
+ // The others are (?:)
+ re += pl.close;
+ if (pl.type === '!') {
+ negativeLists.push(pl);
+ }
+ pl.reEnd = re.length;
+ continue
+
+ case '|':
+ if (inClass || !patternListStack.length || escaping) {
+ re += '\\|';
+ escaping = false;
+ continue
+ }
+
+ clearStateChar();
+ re += '|';
+ continue
+
+ // these are mostly the same in regexp and glob
+ case '[':
+ // swallow any state-tracking char before the [
+ clearStateChar();
+
+ if (inClass) {
+ re += '\\' + c;
+ continue
+ }
+
+ inClass = true;
+ classStart = i;
+ reClassStart = re.length;
+ re += c;
+ continue
+
+ case ']':
+ // a right bracket shall lose its special
+ // meaning and represent itself in
+ // a bracket expression if it occurs
+ // first in the list. -- POSIX.2 2.8.3.2
+ if (i === classStart + 1 || !inClass) {
+ re += '\\' + c;
+ escaping = false;
+ continue
+ }
+
+ // handle the case where we left a class open.
+ // "[z-a]" is valid, equivalent to "\[z-a\]"
+ if (inClass) {
+ // split where the last [ was, make sure we don't have
+ // an invalid re. if so, re-walk the contents of the
+ // would-be class to re-translate any characters that
+ // were passed through as-is
+ // TODO: It would probably be faster to determine this
+ // without a try/catch and a new RegExp, but it's tricky
+ // to do safely. For now, this is safe and works.
+ var cs = pattern.substring(classStart + 1, i);
+ try {
+ RegExp('[' + cs + ']');
+ } catch (er) {
+ // not a valid class!
+ var sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
+ hasMagic = hasMagic || sp[1];
+ inClass = false;
+ continue
+ }
+ }
+
+ // finish up the class.
+ hasMagic = true;
+ inClass = false;
+ re += c;
+ continue
+
+ default:
+ // swallow any state char that wasn't consumed
+ clearStateChar();
+
+ if (escaping) {
+ // no need
+ escaping = false;
+ } else if (reSpecials[c]
+ && !(c === '^' && inClass)) {
+ re += '\\';
+ }
+
+ re += c;
+
+ } // switch
+ } // for
+
+ // handle the case where we left a class open.
+ // "[abc" is valid, equivalent to "\[abc"
+ if (inClass) {
+ // split where the last [ was, and escape it
+ // this is a huge pita. We now have to re-walk
+ // the contents of the would-be class to re-translate
+ // any characters that were passed through as-is
+ cs = pattern.substr(classStart + 1);
+ sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + '\\[' + sp[0];
+ hasMagic = hasMagic || sp[1];
+ }
+
+ // handle the case where we had a +( thing at the *end*
+ // of the pattern.
+ // each pattern list stack adds 3 chars, and we need to go through
+ // and escape any | chars that were passed through as-is for the regexp.
+ // Go through and escape them, taking care not to double-escape any
+ // | chars that were already escaped.
+ for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+ var tail = re.slice(pl.reStart + pl.open.length);
+ this.debug('setting tail', re, pl);
+ // maybe some even number of \, then maybe 1 \, followed by a |
+ tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
+ if (!$2) {
+ // the | isn't already escaped, so escape it.
+ $2 = '\\';
+ }
+
+ // need to escape all those slashes *again*, without escaping the
+ // one that we need for escaping the | character. As it works out,
+ // escaping an even number of slashes can be done by simply repeating
+ // it exactly after itself. That's why this trick works.
+ //
+ // I am sorry that you have to see this.
+ return $1 + $1 + $2 + '|'
+ });
+
+ this.debug('tail=%j\n %s', tail, tail, pl, re);
+ var t = pl.type === '*' ? star
+ : pl.type === '?' ? qmark
+ : '\\' + pl.type;
+
+ hasMagic = true;
+ re = re.slice(0, pl.reStart) + t + '\\(' + tail;
+ }
+
+ // handle trailing things that only matter at the very end.
+ clearStateChar();
+ if (escaping) {
+ // trailing \\
+ re += '\\\\';
+ }
+
+ // only need to apply the nodot start if the re starts with
+ // something that could conceivably capture a dot
+ var addPatternStart = false;
+ switch (re.charAt(0)) {
+ case '.':
+ case '[':
+ case '(': addPatternStart = true;
+ }
+
+ // Hack to work around lack of negative lookbehind in JS
+ // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+ // like 'a.xyz.yz' doesn't match. So, the first negative
+ // lookahead, has to look ALL the way ahead, to the end of
+ // the pattern.
+ for (var n = negativeLists.length - 1; n > -1; n--) {
+ var nl = negativeLists[n];
+
+ var nlBefore = re.slice(0, nl.reStart);
+ var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+ var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+ var nlAfter = re.slice(nl.reEnd);
+
+ nlLast += nlAfter;
+
+ // Handle nested stuff like *(*.js|!(*.json)), where open parens
+ // mean that we should *not* include the ) in the bit that is considered
+ // "after" the negated section.
+ var openParensBefore = nlBefore.split('(').length - 1;
+ var cleanAfter = nlAfter;
+ for (i = 0; i < openParensBefore; i++) {
+ cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
+ }
+ nlAfter = cleanAfter;
+
+ var dollar = '';
+ if (nlAfter === '' && isSub !== SUBPARSE) {
+ dollar = '$';
+ }
+ var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+ re = newRe;
+ }
+
+ // if the re is not "" at this point, then we need to make sure
+ // it doesn't match against an empty path part.
+ // Otherwise a/* will match a/, which it should not.
+ if (re !== '' && hasMagic) {
+ re = '(?=.)' + re;
+ }
+
+ if (addPatternStart) {
+ re = patternStart + re;
+ }
+
+ // parsing just a piece of a larger pattern.
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic]
+ }
+
+ // skip the regexp for non-magical patterns
+ // unescape anything in it, though, so that it'll be
+ // an exact match against a file etc.
+ if (!hasMagic) {
+ return globUnescape(pattern)
+ }
+
+ var flags = options.nocase ? 'i' : '';
+ try {
+ var regExp = new RegExp('^' + re + '$', flags);
+ } catch (er) {
+ // If it was an invalid regular expression, then it can't match
+ // anything. This trick looks for a character after the end of
+ // the string, which is of course impossible, except in multi-line
+ // mode, but it's not a /m regex.
+ return new RegExp('$.')
+ }
+
+ regExp._glob = pattern;
+ regExp._src = re;
+
+ return regExp
+}
+
+minimatch.makeRe = function (pattern, options) {
+ return new Minimatch(pattern, options || {}).makeRe()
+};
+
+Minimatch.prototype.makeRe = makeRe;
+function makeRe () {
+ if (this.regexp || this.regexp === false) return this.regexp
+
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ var set = this.set;
+
+ if (!set.length) {
+ this.regexp = false;
+ return this.regexp
+ }
+ var options = this.options;
+
+ var twoStar = options.noglobstar ? star
+ : options.dot ? twoStarDot
+ : twoStarNoDot;
+ var flags = options.nocase ? 'i' : '';
+
+ var re = set.map(function (pattern) {
+ return pattern.map(function (p) {
+ return (p === GLOBSTAR) ? twoStar
+ : (typeof p === 'string') ? regExpEscape(p)
+ : p._src
+ }).join('\\\/')
+ }).join('|');
+
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = '^(?:' + re + ')$';
+
+ // can match anything, as long as it's not this.
+ if (this.negate) re = '^(?!' + re + ').*$';
+
+ try {
+ this.regexp = new RegExp(re, flags);
+ } catch (ex) {
+ this.regexp = false;
+ }
+ return this.regexp
+}
+
+minimatch.match = function (list, pattern, options) {
+ options = options || {};
+ var mm = new Minimatch(pattern, options);
+ list = list.filter(function (f) {
+ return mm.match(f)
+ });
+ if (mm.options.nonull && !list.length) {
+ list.push(pattern);
+ }
+ return list
+};
+
+Minimatch.prototype.match = match;
+function match (f, partial) {
+ this.debug('match', f, this.pattern);
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) return false
+ if (this.empty) return f === ''
+
+ if (f === '/' && partial) return true
+
+ var options = this.options;
+
+ // windows: need to use /, not \
+ if (path$3.sep !== '/') {
+ f = f.split(path$3.sep).join('/');
+ }
+
+ // treat the test path as a set of pathparts.
+ f = f.split(slashSplit);
+ this.debug(this.pattern, 'split', f);
+
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
+
+ var set = this.set;
+ this.debug(this.pattern, 'set', set);
+
+ // Find the basename of the path by looking for the last non-empty segment
+ var filename;
+ var i;
+ for (i = f.length - 1; i >= 0; i--) {
+ filename = f[i];
+ if (filename) break
+ }
+
+ for (i = 0; i < set.length; i++) {
+ var pattern = set[i];
+ var file = f;
+ if (options.matchBase && pattern.length === 1) {
+ file = [filename];
+ }
+ var hit = this.matchOne(file, pattern, partial);
+ if (hit) {
+ if (options.flipNegate) return true
+ return !this.negate
+ }
+ }
+
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) return false
+ return this.negate
+}
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+Minimatch.prototype.matchOne = function (file, pattern, partial) {
+ var options = this.options;
+
+ this.debug('matchOne',
+ { 'this': this, file: file, pattern: pattern });
+
+ this.debug('matchOne', file.length, pattern.length);
+
+ for (var fi = 0,
+ pi = 0,
+ fl = file.length,
+ pl = pattern.length
+ ; (fi < fl) && (pi < pl)
+ ; fi++, pi++) {
+ this.debug('matchOne loop');
+ var p = pattern[pi];
+ var f = file[fi];
+
+ this.debug(pattern, p, f);
+
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ if (p === false) return false
+
+ if (p === GLOBSTAR) {
+ this.debug('GLOBSTAR', [pattern, p, f]);
+
+ // "**"
+ // a/**/b/**/c would match the following:
+ // a/b/x/y/z/c
+ // a/x/y/z/b/c
+ // a/b/x/b/x/c
+ // a/b/c
+ // To do this, take the rest of the pattern after
+ // the **, and see if it would match the file remainder.
+ // If so, return success.
+ // If not, the ** "swallows" a segment, and try again.
+ // This is recursively awful.
+ //
+ // a/**/b/**/c matching a/b/x/y/z/c
+ // - a matches a
+ // - doublestar
+ // - matchOne(b/x/y/z/c, b/**/c)
+ // - b matches b
+ // - doublestar
+ // - matchOne(x/y/z/c, c) -> no
+ // - matchOne(y/z/c, c) -> no
+ // - matchOne(z/c, c) -> no
+ // - matchOne(c, c) yes, hit
+ var fr = fi;
+ var pr = pi + 1;
+ if (pr === pl) {
+ this.debug('** at the end');
+ // a ** at the end will just swallow the rest.
+ // We have found a match.
+ // however, it will not swallow /.x, unless
+ // options.dot is set.
+ // . and .. are *never* matched by **, for explosively
+ // exponential reasons.
+ for (; fi < fl; fi++) {
+ if (file[fi] === '.' || file[fi] === '..' ||
+ (!options.dot && file[fi].charAt(0) === '.')) return false
+ }
+ return true
+ }
+
+ // ok, let's see if we can swallow whatever we can.
+ while (fr < fl) {
+ var swallowee = file[fr];
+
+ this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
+
+ // XXX remove this slice. Just pass the start index.
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ this.debug('globstar found match!', fr, fl, swallowee);
+ // found a match.
+ return true
+ } else {
+ // can't swallow "." or ".." ever.
+ // can only swallow ".foo" when explicitly asked.
+ if (swallowee === '.' || swallowee === '..' ||
+ (!options.dot && swallowee.charAt(0) === '.')) {
+ this.debug('dot detected!', file, fr, pattern, pr);
+ break
+ }
+
+ // ** swallows a segment, and continue.
+ this.debug('globstar swallow a segment, and continue');
+ fr++;
+ }
+ }
+
+ // no match was found.
+ // However, in partial mode, we can't say this is necessarily over.
+ // If there's more *pattern* left, then
+ if (partial) {
+ // ran out of file
+ this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
+ if (fr === fl) return true
+ }
+ return false
+ }
+
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ var hit;
+ if (typeof p === 'string') {
+ if (options.nocase) {
+ hit = f.toLowerCase() === p.toLowerCase();
+ } else {
+ hit = f === p;
+ }
+ this.debug('string match', p, f, hit);
+ } else {
+ hit = f.match(p);
+ this.debug('pattern match', p, f, hit);
+ }
+
+ if (!hit) return false
+ }
+
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
+
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true
+ } else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial
+ } else if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');
+ return emptyFileEnd
+ }
+
+ // should be unreachable.
+ throw new Error('wtf?')
+};
+
+// replace stuff like \* with *
+function globUnescape (s) {
+ return s.replace(/\\(.)/g, '$1')
+}
+
+function regExpEscape (s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}
+
+var mimicFn = (to, from) => {
+ // TODO: use `Reflect.ownKeys()` when targeting Node.js 6
+ for (const prop of Object.getOwnPropertyNames(from).concat(Object.getOwnPropertySymbols(from))) {
+ Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+ }
+};
+
+var mem = createCommonjsModule(function (module) {
+'use strict';
+
+
+const cacheStore = new WeakMap();
+
+const defaultCacheKey = function (x) {
+ if (arguments.length === 1 && (x === null || x === undefined || (typeof x !== 'function' && typeof x !== 'object'))) {
+ return x;
+ }
+
+ return JSON.stringify(arguments);
+};
+
+module.exports = (fn, opts) => {
+ opts = Object.assign({
+ cacheKey: defaultCacheKey,
+ cache: new Map()
+ }, opts);
+
+ const memoized = function () {
+ const cache = cacheStore.get(memoized);
+ const key = opts.cacheKey.apply(null, arguments);
+
+ if (cache.has(key)) {
+ const c = cache.get(key);
+
+ if (typeof opts.maxAge !== 'number' || Date.now() < c.maxAge) {
+ return c.data;
+ }
+ }
+
+ const ret = fn.apply(null, arguments);
+
+ cache.set(key, {
+ data: ret,
+ maxAge: Date.now() + (opts.maxAge || 0)
+ });
+
+ return ret;
+ };
+
+ mimicFn(memoized, fn);
+
+ cacheStore.set(memoized, opts.cache);
+
+ return memoized;
+};
+
+module.exports.clear = fn => {
+ const cache = cacheStore.get(fn);
+
+ if (cache && typeof cache.clear === 'function') {
+ cache.clear();
+ }
+};
+});
+
+var semver$3 = createCommonjsModule(function (module, exports) {
+exports = module.exports = SemVer;
+
+// The debug function is excluded entirely from the minified version.
+/* nomin */ var debug;
+/* nomin */ if (typeof process === 'object' &&
+ /* nomin */ process.env &&
+ /* nomin */ process.env.NODE_DEBUG &&
+ /* nomin */ /\bsemver\b/i.test(process.env.NODE_DEBUG))
+ /* nomin */ debug = function() {
+ /* nomin */ var args = Array.prototype.slice.call(arguments, 0);
+ /* nomin */ args.unshift('SEMVER');
+ /* nomin */ console.log.apply(console, args);
+ /* nomin */ };
+/* nomin */ else
+ /* nomin */ debug = function() {};
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0';
+
+var MAX_LENGTH = 256;
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+
+// Max safe segment length for coercion.
+var MAX_SAFE_COMPONENT_LENGTH = 16;
+
+// The actual regexps go on exports.re
+var re = exports.re = [];
+var src = exports.src = [];
+var R = 0;
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+var NUMERICIDENTIFIER = R++;
+src[NUMERICIDENTIFIER] = '0|[1-9]\\d*';
+var NUMERICIDENTIFIERLOOSE = R++;
+src[NUMERICIDENTIFIERLOOSE] = '[0-9]+';
+
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+var NONNUMERICIDENTIFIER = R++;
+src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*';
+
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+var MAINVERSION = R++;
+src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')';
+
+var MAINVERSIONLOOSE = R++;
+src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')';
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+var PRERELEASEIDENTIFIER = R++;
+src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+var PRERELEASEIDENTIFIERLOOSE = R++;
+src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+var PRERELEASE = R++;
+src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))';
+
+var PRERELEASELOOSE = R++;
+src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))';
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+var BUILDIDENTIFIER = R++;
+src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+';
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+var BUILD = R++;
+src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
+ '(?:\\.' + src[BUILDIDENTIFIER] + ')*))';
+
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups. The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+var FULL = R++;
+var FULLPLAIN = 'v?' + src[MAINVERSION] +
+ src[PRERELEASE] + '?' +
+ src[BUILD] + '?';
+
+src[FULL] = '^' + FULLPLAIN + '$';
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
+ src[PRERELEASELOOSE] + '?' +
+ src[BUILD] + '?';
+
+var LOOSE = R++;
+src[LOOSE] = '^' + LOOSEPLAIN + '$';
+
+var GTLT = R++;
+src[GTLT] = '((?:<|>)?=?)';
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+var XRANGEIDENTIFIERLOOSE = R++;
+src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
+var XRANGEIDENTIFIER = R++;
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*';
+
+var XRANGEPLAIN = R++;
+src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:' + src[PRERELEASE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?';
+
+var XRANGEPLAINLOOSE = R++;
+src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:' + src[PRERELEASELOOSE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?';
+
+var XRANGE = R++;
+src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$';
+var XRANGELOOSE = R++;
+src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$';
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+var COERCE = R++;
+src[COERCE] = '(?:^|[^\\d])' +
+ '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
+ '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+ '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+ '(?:$|[^\\d])';
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+var LONETILDE = R++;
+src[LONETILDE] = '(?:~>?)';
+
+var TILDETRIM = R++;
+src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+';
+re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g');
+var tildeTrimReplace = '$1~';
+
+var TILDE = R++;
+src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$';
+var TILDELOOSE = R++;
+src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$';
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+var LONECARET = R++;
+src[LONECARET] = '(?:\\^)';
+
+var CARETTRIM = R++;
+src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+';
+re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g');
+var caretTrimReplace = '$1^';
+
+var CARET = R++;
+src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$';
+var CARETLOOSE = R++;
+src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$';
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+var COMPARATORLOOSE = R++;
+src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$';
+var COMPARATOR = R++;
+src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$';
+
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+var COMPARATORTRIM = R++;
+src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
+ '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';
+
+// this one has to use the /g flag
+re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g');
+var comparatorTrimReplace = '$1$2$3';
+
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+var HYPHENRANGE = R++;
+src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAIN] + ')' +
+ '\\s*$';
+
+var HYPHENRANGELOOSE = R++;
+src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s*$';
+
+// Star ranges basically just allow anything at all.
+var STAR = R++;
+src[STAR] = '(<|>)?=?\\s*\\*';
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+ debug(i, src[i]);
+ if (!re[i])
+ re[i] = new RegExp(src[i]);
+}
+
+exports.parse = parse;
+function parse(version, loose) {
+ if (version instanceof SemVer)
+ return version;
+
+ if (typeof version !== 'string')
+ return null;
+
+ if (version.length > MAX_LENGTH)
+ return null;
+
+ var r = loose ? re[LOOSE] : re[FULL];
+ if (!r.test(version))
+ return null;
+
+ try {
+ return new SemVer(version, loose);
+ } catch (er) {
+ return null;
+ }
+}
+
+exports.valid = valid;
+function valid(version, loose) {
+ var v = parse(version, loose);
+ return v ? v.version : null;
+}
+
+
+exports.clean = clean;
+function clean(version, loose) {
+ var s = parse(version.trim().replace(/^[=v]+/, ''), loose);
+ return s ? s.version : null;
+}
+
+exports.SemVer = SemVer;
+
+function SemVer(version, loose) {
+ if (version instanceof SemVer) {
+ if (version.loose === loose)
+ return version;
+ else
+ version = version.version;
+ } else if (typeof version !== 'string') {
+ throw new TypeError('Invalid Version: ' + version);
+ }
+
+ if (version.length > MAX_LENGTH)
+ throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
+
+ if (!(this instanceof SemVer))
+ return new SemVer(version, loose);
+
+ debug('SemVer', version, loose);
+ this.loose = loose;
+ var m = version.trim().match(loose ? re[LOOSE] : re[FULL]);
+
+ if (!m)
+ throw new TypeError('Invalid Version: ' + version);
+
+ this.raw = version;
+
+ // these are actually numbers
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
+
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0)
+ throw new TypeError('Invalid major version')
+
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0)
+ throw new TypeError('Invalid minor version')
+
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0)
+ throw new TypeError('Invalid patch version')
+
+ // numberify any prerelease numeric ids
+ if (!m[4])
+ this.prerelease = [];
+ else
+ this.prerelease = m[4].split('.').map(function(id) {
+ if (/^[0-9]+$/.test(id)) {
+ var num = +id;
+ if (num >= 0 && num < MAX_SAFE_INTEGER)
+ return num;
+ }
+ return id;
+ });
+
+ this.build = m[5] ? m[5].split('.') : [];
+ this.format();
+}
+
+SemVer.prototype.format = function() {
+ this.version = this.major + '.' + this.minor + '.' + this.patch;
+ if (this.prerelease.length)
+ this.version += '-' + this.prerelease.join('.');
+ return this.version;
+};
+
+SemVer.prototype.toString = function() {
+ return this.version;
+};
+
+SemVer.prototype.compare = function(other) {
+ debug('SemVer.compare', this.version, this.loose, other);
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ return this.compareMain(other) || this.comparePre(other);
+};
+
+SemVer.prototype.compareMain = function(other) {
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ return compareIdentifiers(this.major, other.major) ||
+ compareIdentifiers(this.minor, other.minor) ||
+ compareIdentifiers(this.patch, other.patch);
+};
+
+SemVer.prototype.comparePre = function(other) {
+ if (!(other instanceof SemVer))
+ other = new SemVer(other, this.loose);
+
+ // NOT having a prerelease is > having one
+ if (this.prerelease.length && !other.prerelease.length)
+ return -1;
+ else if (!this.prerelease.length && other.prerelease.length)
+ return 1;
+ else if (!this.prerelease.length && !other.prerelease.length)
+ return 0;
+
+ var i = 0;
+ do {
+ var a = this.prerelease[i];
+ var b = other.prerelease[i];
+ debug('prerelease compare', i, a, b);
+ if (a === undefined && b === undefined)
+ return 0;
+ else if (b === undefined)
+ return 1;
+ else if (a === undefined)
+ return -1;
+ else if (a === b)
+ continue;
+ else
+ return compareIdentifiers(a, b);
+ } while (++i);
+};
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function(release, identifier) {
+ switch (release) {
+ case 'premajor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc('pre', identifier);
+ break;
+ case 'preminor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc('pre', identifier);
+ break;
+ case 'prepatch':
+ // If this is already a prerelease, it will bump to the next version
+ // drop any prereleases that might already exist, since they are not
+ // relevant at this point.
+ this.prerelease.length = 0;
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break;
+ // If the input is a non-prerelease version, this acts the same as
+ // prepatch.
+ case 'prerelease':
+ if (this.prerelease.length === 0)
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break;
+
+ case 'major':
+ // If this is a pre-major version, bump up to the same major version.
+ // Otherwise increment major.
+ // 1.0.0-5 bumps to 1.0.0
+ // 1.1.0 bumps to 2.0.0
+ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0)
+ this.major++;
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case 'minor':
+ // If this is a pre-minor version, bump up to the same minor version.
+ // Otherwise increment minor.
+ // 1.2.0-5 bumps to 1.2.0
+ // 1.2.1 bumps to 1.3.0
+ if (this.patch !== 0 || this.prerelease.length === 0)
+ this.minor++;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case 'patch':
+ // If this is not a pre-release version, it will increment the patch.
+ // If it is a pre-release it will bump up to the same patch version.
+ // 1.2.0-5 patches to 1.2.0
+ // 1.2.0 patches to 1.2.1
+ if (this.prerelease.length === 0)
+ this.patch++;
+ this.prerelease = [];
+ break;
+ // This probably shouldn't be used publicly.
+ // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
+ case 'pre':
+ if (this.prerelease.length === 0)
+ this.prerelease = [0];
+ else {
+ var i = this.prerelease.length;
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === 'number') {
+ this.prerelease[i]++;
+ i = -2;
+ }
+ }
+ if (i === -1) // didn't increment anything
+ this.prerelease.push(0);
+ }
+ if (identifier) {
+ // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+ if (this.prerelease[0] === identifier) {
+ if (isNaN(this.prerelease[1]))
+ this.prerelease = [identifier, 0];
+ } else
+ this.prerelease = [identifier, 0];
+ }
+ break;
+
+ default:
+ throw new Error('invalid increment argument: ' + release);
+ }
+ this.format();
+ this.raw = this.version;
+ return this;
+};
+
+exports.inc = inc;
+function inc(version, release, loose, identifier) {
+ if (typeof(loose) === 'string') {
+ identifier = loose;
+ loose = undefined;
+ }
+
+ try {
+ return new SemVer(version, loose).inc(release, identifier).version;
+ } catch (er) {
+ return null;
+ }
+}
+
+exports.diff = diff;
+function diff(version1, version2) {
+ if (eq(version1, version2)) {
+ return null;
+ } else {
+ var v1 = parse(version1);
+ var v2 = parse(version2);
+ if (v1.prerelease.length || v2.prerelease.length) {
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return 'pre'+key;
+ }
+ }
+ }
+ return 'prerelease';
+ }
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return key;
+ }
+ }
+ }
+ }
+}
+
+exports.compareIdentifiers = compareIdentifiers;
+
+var numeric = /^[0-9]+$/;
+function compareIdentifiers(a, b) {
+ var anum = numeric.test(a);
+ var bnum = numeric.test(b);
+
+ if (anum && bnum) {
+ a = +a;
+ b = +b;
+ }
+
+ return (anum && !bnum) ? -1 :
+ (bnum && !anum) ? 1 :
+ a < b ? -1 :
+ a > b ? 1 :
+ 0;
+}
+
+exports.rcompareIdentifiers = rcompareIdentifiers;
+function rcompareIdentifiers(a, b) {
+ return compareIdentifiers(b, a);
+}
+
+exports.major = major;
+function major(a, loose) {
+ return new SemVer(a, loose).major;
+}
+
+exports.minor = minor;
+function minor(a, loose) {
+ return new SemVer(a, loose).minor;
+}
+
+exports.patch = patch;
+function patch(a, loose) {
+ return new SemVer(a, loose).patch;
+}
+
+exports.compare = compare;
+function compare(a, b, loose) {
+ return new SemVer(a, loose).compare(new SemVer(b, loose));
+}
+
+exports.compareLoose = compareLoose;
+function compareLoose(a, b) {
+ return compare(a, b, true);
+}
+
+exports.rcompare = rcompare;
+function rcompare(a, b, loose) {
+ return compare(b, a, loose);
+}
+
+exports.sort = sort;
+function sort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports.compare(a, b, loose);
+ });
+}
+
+exports.rsort = rsort;
+function rsort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports.rcompare(a, b, loose);
+ });
+}
+
+exports.gt = gt;
+function gt(a, b, loose) {
+ return compare(a, b, loose) > 0;
+}
+
+exports.lt = lt;
+function lt(a, b, loose) {
+ return compare(a, b, loose) < 0;
+}
+
+exports.eq = eq;
+function eq(a, b, loose) {
+ return compare(a, b, loose) === 0;
+}
+
+exports.neq = neq;
+function neq(a, b, loose) {
+ return compare(a, b, loose) !== 0;
+}
+
+exports.gte = gte;
+function gte(a, b, loose) {
+ return compare(a, b, loose) >= 0;
+}
+
+exports.lte = lte;
+function lte(a, b, loose) {
+ return compare(a, b, loose) <= 0;
+}
+
+exports.cmp = cmp;
+function cmp(a, op, b, loose) {
+ var ret;
+ switch (op) {
+ case '===':
+ if (typeof a === 'object') a = a.version;
+ if (typeof b === 'object') b = b.version;
+ ret = a === b;
+ break;
+ case '!==':
+ if (typeof a === 'object') a = a.version;
+ if (typeof b === 'object') b = b.version;
+ ret = a !== b;
+ break;
+ case '': case '=': case '==': ret = eq(a, b, loose); break;
+ case '!=': ret = neq(a, b, loose); break;
+ case '>': ret = gt(a, b, loose); break;
+ case '>=': ret = gte(a, b, loose); break;
+ case '<': ret = lt(a, b, loose); break;
+ case '<=': ret = lte(a, b, loose); break;
+ default: throw new TypeError('Invalid operator: ' + op);
+ }
+ return ret;
+}
+
+exports.Comparator = Comparator;
+function Comparator(comp, loose) {
+ if (comp instanceof Comparator) {
+ if (comp.loose === loose)
+ return comp;
+ else
+ comp = comp.value;
+ }
+
+ if (!(this instanceof Comparator))
+ return new Comparator(comp, loose);
+
+ debug('comparator', comp, loose);
+ this.loose = loose;
+ this.parse(comp);
+
+ if (this.semver === ANY)
+ this.value = '';
+ else
+ this.value = this.operator + this.semver.version;
+
+ debug('comp', this);
+}
+
+var ANY = {};
+Comparator.prototype.parse = function(comp) {
+ var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+ var m = comp.match(r);
+
+ if (!m)
+ throw new TypeError('Invalid comparator: ' + comp);
+
+ this.operator = m[1];
+ if (this.operator === '=')
+ this.operator = '';
+
+ // if it literally is just '>' or '' then allow anything.
+ if (!m[2])
+ this.semver = ANY;
+ else
+ this.semver = new SemVer(m[2], this.loose);
+};
+
+Comparator.prototype.toString = function() {
+ return this.value;
+};
+
+Comparator.prototype.test = function(version) {
+ debug('Comparator.test', version, this.loose);
+
+ if (this.semver === ANY)
+ return true;
+
+ if (typeof version === 'string')
+ version = new SemVer(version, this.loose);
+
+ return cmp(version, this.operator, this.semver, this.loose);
+};
+
+Comparator.prototype.intersects = function(comp, loose) {
+ if (!(comp instanceof Comparator)) {
+ throw new TypeError('a Comparator is required');
+ }
+
+ var rangeTmp;
+
+ if (this.operator === '') {
+ rangeTmp = new Range(comp.value, loose);
+ return satisfies(this.value, rangeTmp, loose);
+ } else if (comp.operator === '') {
+ rangeTmp = new Range(this.value, loose);
+ return satisfies(comp.semver, rangeTmp, loose);
+ }
+
+ var sameDirectionIncreasing =
+ (this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '>=' || comp.operator === '>');
+ var sameDirectionDecreasing =
+ (this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '<=' || comp.operator === '<');
+ var sameSemVer = this.semver.version === comp.semver.version;
+ var differentDirectionsInclusive =
+ (this.operator === '>=' || this.operator === '<=') &&
+ (comp.operator === '>=' || comp.operator === '<=');
+ var oppositeDirectionsLessThan =
+ cmp(this.semver, '<', comp.semver, loose) &&
+ ((this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '<=' || comp.operator === '<'));
+ var oppositeDirectionsGreaterThan =
+ cmp(this.semver, '>', comp.semver, loose) &&
+ ((this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '>=' || comp.operator === '>'));
+
+ return sameDirectionIncreasing || sameDirectionDecreasing ||
+ (sameSemVer && differentDirectionsInclusive) ||
+ oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+};
+
+
+exports.Range = Range;
+function Range(range, loose) {
+ if (range instanceof Range) {
+ if (range.loose === loose) {
+ return range;
+ } else {
+ return new Range(range.raw, loose);
+ }
+ }
+
+ if (range instanceof Comparator) {
+ return new Range(range.value, loose);
+ }
+
+ if (!(this instanceof Range))
+ return new Range(range, loose);
+
+ this.loose = loose;
+
+ // First, split based on boolean or ||
+ this.raw = range;
+ this.set = range.split(/\s*\|\|\s*/).map(function(range) {
+ return this.parseRange(range.trim());
+ }, this).filter(function(c) {
+ // throw out any that are not relevant for whatever reason
+ return c.length;
+ });
+
+ if (!this.set.length) {
+ throw new TypeError('Invalid SemVer Range: ' + range);
+ }
+
+ this.format();
+}
+
+Range.prototype.format = function() {
+ this.range = this.set.map(function(comps) {
+ return comps.join(' ').trim();
+ }).join('||').trim();
+ return this.range;
+};
+
+Range.prototype.toString = function() {
+ return this.range;
+};
+
+Range.prototype.parseRange = function(range) {
+ var loose = this.loose;
+ range = range.trim();
+ debug('range', range, loose);
+ // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+ var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace);
+ debug('hyphen replace', range);
+ // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+ range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace);
+ debug('comparator trim', range, re[COMPARATORTRIM]);
+
+ // `~ 1.2.3` => `~1.2.3`
+ range = range.replace(re[TILDETRIM], tildeTrimReplace);
+
+ // `^ 1.2.3` => `^1.2.3`
+ range = range.replace(re[CARETTRIM], caretTrimReplace);
+
+ // normalize spaces
+ range = range.split(/\s+/).join(' ');
+
+ // At this point, the range is completely trimmed and
+ // ready to be split into comparators.
+
+ var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR];
+ var set = range.split(' ').map(function(comp) {
+ return parseComparator(comp, loose);
+ }).join(' ').split(/\s+/);
+ if (this.loose) {
+ // in loose mode, throw out any that are not valid comparators
+ set = set.filter(function(comp) {
+ return !!comp.match(compRe);
+ });
+ }
+ set = set.map(function(comp) {
+ return new Comparator(comp, loose);
+ });
+
+ return set;
+};
+
+Range.prototype.intersects = function(range, loose) {
+ if (!(range instanceof Range)) {
+ throw new TypeError('a Range is required');
+ }
+
+ return this.set.some(function(thisComparators) {
+ return thisComparators.every(function(thisComparator) {
+ return range.set.some(function(rangeComparators) {
+ return rangeComparators.every(function(rangeComparator) {
+ return thisComparator.intersects(rangeComparator, loose);
+ });
+ });
+ });
+ });
+};
+
+// Mostly just for testing and legacy API reasons
+exports.toComparators = toComparators;
+function toComparators(range, loose) {
+ return new Range(range, loose).set.map(function(comp) {
+ return comp.map(function(c) {
+ return c.value;
+ }).join(' ').trim().split(' ');
+ });
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+function parseComparator(comp, loose) {
+ debug('comp', comp);
+ comp = replaceCarets(comp, loose);
+ debug('caret', comp);
+ comp = replaceTildes(comp, loose);
+ debug('tildes', comp);
+ comp = replaceXRanges(comp, loose);
+ debug('xrange', comp);
+ comp = replaceStars(comp, loose);
+ debug('stars', comp);
+ return comp;
+}
+
+function isX(id) {
+ return !id || id.toLowerCase() === 'x' || id === '*';
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes(comp, loose) {
+ return comp.trim().split(/\s+/).map(function(comp) {
+ return replaceTilde(comp, loose);
+ }).join(' ');
+}
+
+function replaceTilde(comp, loose) {
+ var r = loose ? re[TILDELOOSE] : re[TILDE];
+ return comp.replace(r, function(_, M, m, p, pr) {
+ debug('tilde', comp, _, M, m, p, pr);
+ var ret;
+
+ if (isX(M))
+ ret = '';
+ else if (isX(m))
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ else if (isX(p))
+ // ~1.2 == >=1.2.0 <1.3.0
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ else if (pr) {
+ debug('replaceTilde pr', pr);
+ if (pr.charAt(0) !== '-')
+ pr = '-' + pr;
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ // ~1.2.3 == >=1.2.3 <1.3.0
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0';
+
+ debug('tilde return', ret);
+ return ret;
+ });
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets(comp, loose) {
+ return comp.trim().split(/\s+/).map(function(comp) {
+ return replaceCaret(comp, loose);
+ }).join(' ');
+}
+
+function replaceCaret(comp, loose) {
+ debug('caret', comp, loose);
+ var r = loose ? re[CARETLOOSE] : re[CARET];
+ return comp.replace(r, function(_, M, m, p, pr) {
+ debug('caret', comp, _, M, m, p, pr);
+ var ret;
+
+ if (isX(M))
+ ret = '';
+ else if (isX(m))
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ else if (isX(p)) {
+ if (M === '0')
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ else
+ ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';
+ } else if (pr) {
+ debug('replaceCaret pr', pr);
+ if (pr.charAt(0) !== '-')
+ pr = '-' + pr;
+ if (M === '0') {
+ if (m === '0')
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + m + '.' + (+p + 1);
+ else
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ ret = '>=' + M + '.' + m + '.' + p + pr +
+ ' <' + (+M + 1) + '.0.0';
+ } else {
+ debug('no pr');
+ if (M === '0') {
+ if (m === '0')
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + m + '.' + (+p + 1);
+ else
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0';
+ } else
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + (+M + 1) + '.0.0';
+ }
+
+ debug('caret return', ret);
+ return ret;
+ });
+}
+
+function replaceXRanges(comp, loose) {
+ debug('replaceXRanges', comp, loose);
+ return comp.split(/\s+/).map(function(comp) {
+ return replaceXRange(comp, loose);
+ }).join(' ');
+}
+
+function replaceXRange(comp, loose) {
+ comp = comp.trim();
+ var r = loose ? re[XRANGELOOSE] : re[XRANGE];
+ return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
+ debug('xRange', comp, ret, gtlt, M, m, p, pr);
+ var xM = isX(M);
+ var xm = xM || isX(m);
+ var xp = xm || isX(p);
+ var anyX = xp;
+
+ if (gtlt === '=' && anyX)
+ gtlt = '';
+
+ if (xM) {
+ if (gtlt === '>' || gtlt === '<') {
+ // nothing is allowed
+ ret = '<0.0.0';
+ } else {
+ // nothing is forbidden
+ ret = '*';
+ }
+ } else if (gtlt && anyX) {
+ // replace X with 0
+ if (xm)
+ m = 0;
+ if (xp)
+ p = 0;
+
+ if (gtlt === '>') {
+ // >1 => >=2.0.0
+ // >1.2 => >=1.3.0
+ // >1.2.3 => >= 1.2.4
+ gtlt = '>=';
+ if (xm) {
+ M = +M + 1;
+ m = 0;
+ p = 0;
+ } else if (xp) {
+ m = +m + 1;
+ p = 0;
+ }
+ } else if (gtlt === '<=') {
+ // <=0.7.x is actually <0.8.0, since any 0.7.x should
+ // pass. Similarly, <=7.x is actually <8.0.0, etc.
+ gtlt = '<';
+ if (xm)
+ M = +M + 1;
+ else
+ m = +m + 1;
+ }
+
+ ret = gtlt + M + '.' + m + '.' + p;
+ } else if (xm) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+ } else if (xp) {
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+ }
+
+ debug('xRange return', ret);
+
+ return ret;
+ });
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars(comp, loose) {
+ debug('replaceStars', comp, loose);
+ // Looseness is ignored here. star is always as loose as it gets!
+ return comp.trim().replace(re[STAR], '');
+}
+
+// This function is passed to string.replace(re[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0
+function hyphenReplace($0,
+ from, fM, fm, fp, fpr, fb,
+ to, tM, tm, tp, tpr, tb) {
+
+ if (isX(fM))
+ from = '';
+ else if (isX(fm))
+ from = '>=' + fM + '.0.0';
+ else if (isX(fp))
+ from = '>=' + fM + '.' + fm + '.0';
+ else
+ from = '>=' + from;
+
+ if (isX(tM))
+ to = '';
+ else if (isX(tm))
+ to = '<' + (+tM + 1) + '.0.0';
+ else if (isX(tp))
+ to = '<' + tM + '.' + (+tm + 1) + '.0';
+ else if (tpr)
+ to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;
+ else
+ to = '<=' + to;
+
+ return (from + ' ' + to).trim();
+}
+
+
+// if ANY of the sets match ALL of its comparators, then pass
+Range.prototype.test = function(version) {
+ if (!version)
+ return false;
+
+ if (typeof version === 'string')
+ version = new SemVer(version, this.loose);
+
+ for (var i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version))
+ return true;
+ }
+ return false;
+};
+
+function testSet(set, version) {
+ for (var i = 0; i < set.length; i++) {
+ if (!set[i].test(version))
+ return false;
+ }
+
+ if (version.prerelease.length) {
+ // Find the set of versions that are allowed to have prereleases
+ // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+ // That should allow `1.2.3-pr.2` to pass.
+ // However, `1.2.4-alpha.notready` should NOT be allowed,
+ // even though it's within the range set by the comparators.
+ for (var i = 0; i < set.length; i++) {
+ debug(set[i].semver);
+ if (set[i].semver === ANY)
+ continue;
+
+ if (set[i].semver.prerelease.length > 0) {
+ var allowed = set[i].semver;
+ if (allowed.major === version.major &&
+ allowed.minor === version.minor &&
+ allowed.patch === version.patch)
+ return true;
+ }
+ }
+
+ // Version has a -pre, but it's not one of the ones we like.
+ return false;
+ }
+
+ return true;
+}
+
+exports.satisfies = satisfies;
+function satisfies(version, range, loose) {
+ try {
+ range = new Range(range, loose);
+ } catch (er) {
+ return false;
+ }
+ return range.test(version);
+}
+
+exports.maxSatisfying = maxSatisfying;
+function maxSatisfying(versions, range, loose) {
+ var max = null;
+ var maxSV = null;
+ try {
+ var rangeObj = new Range(range, loose);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) { // satisfies(v, range, loose)
+ if (!max || maxSV.compare(v) === -1) { // compare(max, v, true)
+ max = v;
+ maxSV = new SemVer(max, loose);
+ }
+ }
+ });
+ return max;
+}
+
+exports.minSatisfying = minSatisfying;
+function minSatisfying(versions, range, loose) {
+ var min = null;
+ var minSV = null;
+ try {
+ var rangeObj = new Range(range, loose);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) { // satisfies(v, range, loose)
+ if (!min || minSV.compare(v) === 1) { // compare(min, v, true)
+ min = v;
+ minSV = new SemVer(min, loose);
+ }
+ }
+ });
+ return min;
+}
+
+exports.validRange = validRange;
+function validRange(range, loose) {
+ try {
+ // Return '*' instead of '' so that truthiness works.
+ // This will throw if it's invalid anyway
+ return new Range(range, loose).range || '*';
+ } catch (er) {
+ return null;
+ }
+}
+
+// Determine if version is less than all the versions possible in the range
+exports.ltr = ltr;
+function ltr(version, range, loose) {
+ return outside(version, range, '<', loose);
+}
+
+// Determine if version is greater than all the versions possible in the range.
+exports.gtr = gtr;
+function gtr(version, range, loose) {
+ return outside(version, range, '>', loose);
+}
+
+exports.outside = outside;
+function outside(version, range, hilo, loose) {
+ version = new SemVer(version, loose);
+ range = new Range(range, loose);
+
+ var gtfn, ltefn, ltfn, comp, ecomp;
+ switch (hilo) {
+ case '>':
+ gtfn = gt;
+ ltefn = lte;
+ ltfn = lt;
+ comp = '>';
+ ecomp = '>=';
+ break;
+ case '<':
+ gtfn = lt;
+ ltefn = gte;
+ ltfn = gt;
+ comp = '<';
+ ecomp = '<=';
+ break;
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+
+ // If it satisifes the range it is not outside
+ if (satisfies(version, range, loose)) {
+ return false;
+ }
+
+ // From now on, variable terms are as if we're in "gtr" mode.
+ // but note that everything is flipped for the "ltr" function.
+
+ for (var i = 0; i < range.set.length; ++i) {
+ var comparators = range.set[i];
+
+ var high = null;
+ var low = null;
+
+ comparators.forEach(function(comparator) {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator('>=0.0.0');
+ }
+ high = high || comparator;
+ low = low || comparator;
+ if (gtfn(comparator.semver, high.semver, loose)) {
+ high = comparator;
+ } else if (ltfn(comparator.semver, low.semver, loose)) {
+ low = comparator;
+ }
+ });
+
+ // If the edge version comparator has a operator then our version
+ // isn't outside it
+ if (high.operator === comp || high.operator === ecomp) {
+ return false;
+ }
+
+ // If the lowest version comparator has an operator and our version
+ // is less than it then it isn't higher than the range
+ if ((!low.operator || low.operator === comp) &&
+ ltefn(version, low.semver)) {
+ return false;
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+exports.prerelease = prerelease;
+function prerelease(version, loose) {
+ var parsed = parse(version, loose);
+ return (parsed && parsed.prerelease.length) ? parsed.prerelease : null;
+}
+
+exports.intersects = intersects;
+function intersects(r1, r2, loose) {
+ r1 = new Range(r1, loose);
+ r2 = new Range(r2, loose);
+ return r1.intersects(r2)
+}
+
+exports.coerce = coerce;
+function coerce(version) {
+ if (version instanceof SemVer)
+ return version;
+
+ if (typeof version !== 'string')
+ return null;
+
+ var match = version.match(re[COERCE]);
+
+ if (match == null)
+ return null;
+
+ return parse((match[1] || '0') + '.' + (match[2] || '0') + '.' + (match[3] || '0'));
+}
+});
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var pseudomap = PseudoMap;
+
+function PseudoMap (set) {
+ if (!(this instanceof PseudoMap)) // whyyyyyyy
+ throw new TypeError("Constructor PseudoMap requires 'new'")
+
+ this.clear();
+
+ if (set) {
+ if ((set instanceof PseudoMap) ||
+ (typeof Map === 'function' && set instanceof Map))
+ set.forEach(function (value, key) {
+ this.set(key, value);
+ }, this);
+ else if (Array.isArray(set))
+ set.forEach(function (kv) {
+ this.set(kv[0], kv[1]);
+ }, this);
+ else
+ throw new TypeError('invalid argument')
+ }
+}
+
+PseudoMap.prototype.forEach = function (fn, thisp) {
+ thisp = thisp || this;
+ Object.keys(this._data).forEach(function (k) {
+ if (k !== 'size')
+ fn.call(thisp, this._data[k].value, this._data[k].key);
+ }, this);
+};
+
+PseudoMap.prototype.has = function (k) {
+ return !!find(this._data, k)
+};
+
+PseudoMap.prototype.get = function (k) {
+ var res = find(this._data, k);
+ return res && res.value
+};
+
+PseudoMap.prototype.set = function (k, v) {
+ set(this._data, k, v);
+};
+
+PseudoMap.prototype.delete = function (k) {
+ var res = find(this._data, k);
+ if (res) {
+ delete this._data[res._index];
+ this._data.size--;
+ }
+};
+
+PseudoMap.prototype.clear = function () {
+ var data = Object.create(null);
+ data.size = 0;
+
+ Object.defineProperty(this, '_data', {
+ value: data,
+ enumerable: false,
+ configurable: true,
+ writable: false
+ });
+};
+
+Object.defineProperty(PseudoMap.prototype, 'size', {
+ get: function () {
+ return this._data.size
+ },
+ set: function (n) {},
+ enumerable: true,
+ configurable: true
+});
+
+PseudoMap.prototype.values =
+PseudoMap.prototype.keys =
+PseudoMap.prototype.entries = function () {
+ throw new Error('iterators are not implemented in this version')
+};
+
+// Either identical, or both NaN
+function same (a, b) {
+ return a === b || a !== a && b !== b
+}
+
+function Entry$1 (k, v, i) {
+ this.key = k;
+ this.value = v;
+ this._index = i;
+}
+
+function find (data, k) {
+ for (var i = 0, s = '_' + k, key = s;
+ hasOwnProperty.call(data, key);
+ key = s + i++) {
+ if (same(data[key].key, k))
+ return data[key]
+ }
+}
+
+function set (data, k, v) {
+ for (var i = 0, s = '_' + k, key = s;
+ hasOwnProperty.call(data, key);
+ key = s + i++) {
+ if (same(data[key].key, k)) {
+ data[key].value = v;
+ return
+ }
+ }
+ data.size++;
+ data[key] = new Entry$1(k, v, key);
+}
+
+var map = createCommonjsModule(function (module) {
+if (process.env.npm_package_name === 'pseudomap' &&
+ process.env.npm_lifecycle_script === 'test')
+ process.env.TEST_PSEUDOMAP = 'true';
+
+if (typeof Map === 'function' && !process.env.TEST_PSEUDOMAP) {
+ module.exports = Map;
+} else {
+ module.exports = pseudomap;
+}
+});
+
+var yallist = Yallist;
+
+Yallist.Node = Node;
+Yallist.create = Yallist;
+
+function Yallist (list) {
+ var self = this;
+ if (!(self instanceof Yallist)) {
+ self = new Yallist();
+ }
+
+ self.tail = null;
+ self.head = null;
+ self.length = 0;
+
+ if (list && typeof list.forEach === 'function') {
+ list.forEach(function (item) {
+ self.push(item);
+ });
+ } else if (arguments.length > 0) {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ self.push(arguments[i]);
+ }
+ }
+
+ return self
+}
+
+Yallist.prototype.removeNode = function (node) {
+ if (node.list !== this) {
+ throw new Error('removing node which does not belong to this list')
+ }
+
+ var next = node.next;
+ var prev = node.prev;
+
+ if (next) {
+ next.prev = prev;
+ }
+
+ if (prev) {
+ prev.next = next;
+ }
+
+ if (node === this.head) {
+ this.head = next;
+ }
+ if (node === this.tail) {
+ this.tail = prev;
+ }
+
+ node.list.length--;
+ node.next = null;
+ node.prev = null;
+ node.list = null;
+};
+
+Yallist.prototype.unshiftNode = function (node) {
+ if (node === this.head) {
+ return
+ }
+
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+
+ var head = this.head;
+ node.list = this;
+ node.next = head;
+ if (head) {
+ head.prev = node;
+ }
+
+ this.head = node;
+ if (!this.tail) {
+ this.tail = node;
+ }
+ this.length++;
+};
+
+Yallist.prototype.pushNode = function (node) {
+ if (node === this.tail) {
+ return
+ }
+
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+
+ var tail = this.tail;
+ node.list = this;
+ node.prev = tail;
+ if (tail) {
+ tail.next = node;
+ }
+
+ this.tail = node;
+ if (!this.head) {
+ this.head = node;
+ }
+ this.length++;
+};
+
+Yallist.prototype.push = function () {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ push(this, arguments[i]);
+ }
+ return this.length
+};
+
+Yallist.prototype.unshift = function () {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ unshift(this, arguments[i]);
+ }
+ return this.length
+};
+
+Yallist.prototype.pop = function () {
+ if (!this.tail) {
+ return undefined
+ }
+
+ var res = this.tail.value;
+ this.tail = this.tail.prev;
+ if (this.tail) {
+ this.tail.next = null;
+ } else {
+ this.head = null;
+ }
+ this.length--;
+ return res
+};
+
+Yallist.prototype.shift = function () {
+ if (!this.head) {
+ return undefined
+ }
+
+ var res = this.head.value;
+ this.head = this.head.next;
+ if (this.head) {
+ this.head.prev = null;
+ } else {
+ this.tail = null;
+ }
+ this.length--;
+ return res
+};
+
+Yallist.prototype.forEach = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.head, i = 0; walker !== null; i++) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.next;
+ }
+};
+
+Yallist.prototype.forEachReverse = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.prev;
+ }
+};
+
+Yallist.prototype.get = function (n) {
+ for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+ // abort out of the list early if we hit a cycle
+ walker = walker.next;
+ }
+ if (i === n && walker !== null) {
+ return walker.value
+ }
+};
+
+Yallist.prototype.getReverse = function (n) {
+ for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+ // abort out of the list early if we hit a cycle
+ walker = walker.prev;
+ }
+ if (i === n && walker !== null) {
+ return walker.value
+ }
+};
+
+Yallist.prototype.map = function (fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.head; walker !== null;) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.next;
+ }
+ return res
+};
+
+Yallist.prototype.mapReverse = function (fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.tail; walker !== null;) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.prev;
+ }
+ return res
+};
+
+Yallist.prototype.reduce = function (fn, initial) {
+ var acc;
+ var walker = this.head;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.head) {
+ walker = this.head.next;
+ acc = this.head.value;
+ } else {
+ throw new TypeError('Reduce of empty list with no initial value')
+ }
+
+ for (var i = 0; walker !== null; i++) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.next;
+ }
+
+ return acc
+};
+
+Yallist.prototype.reduceReverse = function (fn, initial) {
+ var acc;
+ var walker = this.tail;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.tail) {
+ walker = this.tail.prev;
+ acc = this.tail.value;
+ } else {
+ throw new TypeError('Reduce of empty list with no initial value')
+ }
+
+ for (var i = this.length - 1; walker !== null; i--) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.prev;
+ }
+
+ return acc
+};
+
+Yallist.prototype.toArray = function () {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.head; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.next;
+ }
+ return arr
+};
+
+Yallist.prototype.toArrayReverse = function () {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.tail; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.prev;
+ }
+ return arr
+};
+
+Yallist.prototype.slice = function (from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+ walker = walker.next;
+ }
+ for (; walker !== null && i < to; i++, walker = walker.next) {
+ ret.push(walker.value);
+ }
+ return ret
+};
+
+Yallist.prototype.sliceReverse = function (from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+ walker = walker.prev;
+ }
+ for (; walker !== null && i > from; i--, walker = walker.prev) {
+ ret.push(walker.value);
+ }
+ return ret
+};
+
+Yallist.prototype.reverse = function () {
+ var head = this.head;
+ var tail = this.tail;
+ for (var walker = head; walker !== null; walker = walker.prev) {
+ var p = walker.prev;
+ walker.prev = walker.next;
+ walker.next = p;
+ }
+ this.head = tail;
+ this.tail = head;
+ return this
+};
+
+function push (self, item) {
+ self.tail = new Node(item, self.tail, null, self);
+ if (!self.head) {
+ self.head = self.tail;
+ }
+ self.length++;
+}
+
+function unshift (self, item) {
+ self.head = new Node(item, null, self.head, self);
+ if (!self.tail) {
+ self.tail = self.head;
+ }
+ self.length++;
+}
+
+function Node (value, prev, next, list) {
+ if (!(this instanceof Node)) {
+ return new Node(value, prev, next, list)
+ }
+
+ this.list = list;
+ this.value = value;
+
+ if (prev) {
+ prev.next = this;
+ this.prev = prev;
+ } else {
+ this.prev = null;
+ }
+
+ if (next) {
+ next.prev = this;
+ this.next = next;
+ } else {
+ this.next = null;
+ }
+}
+
+var lruCache = LRUCache;
+
+// This will be a proper iterable 'Map' in engines that support it,
+// or a fakey-fake PseudoMap in older versions.
+
+
+
+// A linked list to keep track of recently-used-ness
+
+
+// use symbols if possible, otherwise just _props
+var hasSymbol = typeof Symbol === 'function';
+var makeSymbol;
+if (hasSymbol) {
+ makeSymbol = function (key) {
+ return Symbol.for(key)
+ };
+} else {
+ makeSymbol = function (key) {
+ return '_' + key
+ };
+}
+
+var MAX = makeSymbol('max');
+var LENGTH = makeSymbol('length');
+var LENGTH_CALCULATOR = makeSymbol('lengthCalculator');
+var ALLOW_STALE = makeSymbol('allowStale');
+var MAX_AGE = makeSymbol('maxAge');
+var DISPOSE = makeSymbol('dispose');
+var NO_DISPOSE_ON_SET = makeSymbol('noDisposeOnSet');
+var LRU_LIST = makeSymbol('lruList');
+var CACHE = makeSymbol('cache');
+
+function naiveLength () { return 1 }
+
+// lruList is a yallist where the head is the youngest
+// item, and the tail is the oldest. the list contains the Hit
+// objects as the entries.
+// Each Hit object has a reference to its Yallist.Node. This
+// never changes.
+//
+// cache is a Map (or PseudoMap) that matches the keys to
+// the Yallist.Node object.
+function LRUCache (options) {
+ if (!(this instanceof LRUCache)) {
+ return new LRUCache(options)
+ }
+
+ if (typeof options === 'number') {
+ options = { max: options };
+ }
+
+ if (!options) {
+ options = {};
+ }
+
+ var max = this[MAX] = options.max;
+ // Kind of weird to have a default max of Infinity, but oh well.
+ if (!max ||
+ !(typeof max === 'number') ||
+ max <= 0) {
+ this[MAX] = Infinity;
+ }
+
+ var lc = options.length || naiveLength;
+ if (typeof lc !== 'function') {
+ lc = naiveLength;
+ }
+ this[LENGTH_CALCULATOR] = lc;
+
+ this[ALLOW_STALE] = options.stale || false;
+ this[MAX_AGE] = options.maxAge || 0;
+ this[DISPOSE] = options.dispose;
+ this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+ this.reset();
+}
+
+// resize the cache when the max changes.
+Object.defineProperty(LRUCache.prototype, 'max', {
+ set: function (mL) {
+ if (!mL || !(typeof mL === 'number') || mL <= 0) {
+ mL = Infinity;
+ }
+ this[MAX] = mL;
+ trim(this);
+ },
+ get: function () {
+ return this[MAX]
+ },
+ enumerable: true
+});
+
+Object.defineProperty(LRUCache.prototype, 'allowStale', {
+ set: function (allowStale) {
+ this[ALLOW_STALE] = !!allowStale;
+ },
+ get: function () {
+ return this[ALLOW_STALE]
+ },
+ enumerable: true
+});
+
+Object.defineProperty(LRUCache.prototype, 'maxAge', {
+ set: function (mA) {
+ if (!mA || !(typeof mA === 'number') || mA < 0) {
+ mA = 0;
+ }
+ this[MAX_AGE] = mA;
+ trim(this);
+ },
+ get: function () {
+ return this[MAX_AGE]
+ },
+ enumerable: true
+});
+
+// resize the cache when the lengthCalculator changes.
+Object.defineProperty(LRUCache.prototype, 'lengthCalculator', {
+ set: function (lC) {
+ if (typeof lC !== 'function') {
+ lC = naiveLength;
+ }
+ if (lC !== this[LENGTH_CALCULATOR]) {
+ this[LENGTH_CALCULATOR] = lC;
+ this[LENGTH] = 0;
+ this[LRU_LIST].forEach(function (hit) {
+ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
+ this[LENGTH] += hit.length;
+ }, this);
+ }
+ trim(this);
+ },
+ get: function () { return this[LENGTH_CALCULATOR] },
+ enumerable: true
+});
+
+Object.defineProperty(LRUCache.prototype, 'length', {
+ get: function () { return this[LENGTH] },
+ enumerable: true
+});
+
+Object.defineProperty(LRUCache.prototype, 'itemCount', {
+ get: function () { return this[LRU_LIST].length },
+ enumerable: true
+});
+
+LRUCache.prototype.rforEach = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this[LRU_LIST].tail; walker !== null;) {
+ var prev = walker.prev;
+ forEachStep(this, fn, walker, thisp);
+ walker = prev;
+ }
+};
+
+function forEachStep (self, fn, node, thisp) {
+ var hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE]) {
+ hit = undefined;
+ }
+ }
+ if (hit) {
+ fn.call(thisp, hit.value, hit.key, self);
+ }
+}
+
+LRUCache.prototype.forEach = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this[LRU_LIST].head; walker !== null;) {
+ var next = walker.next;
+ forEachStep(this, fn, walker, thisp);
+ walker = next;
+ }
+};
+
+LRUCache.prototype.keys = function () {
+ return this[LRU_LIST].toArray().map(function (k) {
+ return k.key
+ }, this)
+};
+
+LRUCache.prototype.values = function () {
+ return this[LRU_LIST].toArray().map(function (k) {
+ return k.value
+ }, this)
+};
+
+LRUCache.prototype.reset = function () {
+ if (this[DISPOSE] &&
+ this[LRU_LIST] &&
+ this[LRU_LIST].length) {
+ this[LRU_LIST].forEach(function (hit) {
+ this[DISPOSE](hit.key, hit.value);
+ }, this);
+ }
+
+ this[CACHE] = new map(); // hash of items by key
+ this[LRU_LIST] = new yallist(); // list of items in order of use recency
+ this[LENGTH] = 0; // length of items in the list
+};
+
+LRUCache.prototype.dump = function () {
+ return this[LRU_LIST].map(function (hit) {
+ if (!isStale(this, hit)) {
+ return {
+ k: hit.key,
+ v: hit.value,
+ e: hit.now + (hit.maxAge || 0)
+ }
+ }
+ }, this).toArray().filter(function (h) {
+ return h
+ })
+};
+
+LRUCache.prototype.dumpLru = function () {
+ return this[LRU_LIST]
+};
+
+LRUCache.prototype.inspect = function (n, opts) {
+ var str = 'LRUCache {';
+ var extras = false;
+
+ var as = this[ALLOW_STALE];
+ if (as) {
+ str += '\n allowStale: true';
+ extras = true;
+ }
+
+ var max = this[MAX];
+ if (max && max !== Infinity) {
+ if (extras) {
+ str += ',';
+ }
+ str += '\n max: ' + util.inspect(max, opts);
+ extras = true;
+ }
+
+ var maxAge = this[MAX_AGE];
+ if (maxAge) {
+ if (extras) {
+ str += ',';
+ }
+ str += '\n maxAge: ' + util.inspect(maxAge, opts);
+ extras = true;
+ }
+
+ var lc = this[LENGTH_CALCULATOR];
+ if (lc && lc !== naiveLength) {
+ if (extras) {
+ str += ',';
+ }
+ str += '\n length: ' + util.inspect(this[LENGTH], opts);
+ extras = true;
+ }
+
+ var didFirst = false;
+ this[LRU_LIST].forEach(function (item) {
+ if (didFirst) {
+ str += ',\n ';
+ } else {
+ if (extras) {
+ str += ',\n';
+ }
+ didFirst = true;
+ str += '\n ';
+ }
+ var key = util.inspect(item.key).split('\n').join('\n ');
+ var val = { value: item.value };
+ if (item.maxAge !== maxAge) {
+ val.maxAge = item.maxAge;
+ }
+ if (lc !== naiveLength) {
+ val.length = item.length;
+ }
+ if (isStale(this, item)) {
+ val.stale = true;
+ }
+
+ val = util.inspect(val, opts).split('\n').join('\n ');
+ str += key + ' => ' + val;
+ });
+
+ if (didFirst || extras) {
+ str += '\n';
+ }
+ str += '}';
+
+ return str
+};
+
+LRUCache.prototype.set = function (key, value, maxAge) {
+ maxAge = maxAge || this[MAX_AGE];
+
+ var now = maxAge ? Date.now() : 0;
+ var len = this[LENGTH_CALCULATOR](value, key);
+
+ if (this[CACHE].has(key)) {
+ if (len > this[MAX]) {
+ del(this, this[CACHE].get(key));
+ return false
+ }
+
+ var node = this[CACHE].get(key);
+ var item = node.value;
+
+ // dispose of the old one before overwriting
+ // split out into 2 ifs for better coverage tracking
+ if (this[DISPOSE]) {
+ if (!this[NO_DISPOSE_ON_SET]) {
+ this[DISPOSE](key, item.value);
+ }
+ }
+
+ item.now = now;
+ item.maxAge = maxAge;
+ item.value = value;
+ this[LENGTH] += len - item.length;
+ item.length = len;
+ this.get(key);
+ trim(this);
+ return true
+ }
+
+ var hit = new Entry(key, value, len, now, maxAge);
+
+ // oversized objects fall out of cache automatically.
+ if (hit.length > this[MAX]) {
+ if (this[DISPOSE]) {
+ this[DISPOSE](key, value);
+ }
+ return false
+ }
+
+ this[LENGTH] += hit.length;
+ this[LRU_LIST].unshift(hit);
+ this[CACHE].set(key, this[LRU_LIST].head);
+ trim(this);
+ return true
+};
+
+LRUCache.prototype.has = function (key) {
+ if (!this[CACHE].has(key)) return false
+ var hit = this[CACHE].get(key).value;
+ if (isStale(this, hit)) {
+ return false
+ }
+ return true
+};
+
+LRUCache.prototype.get = function (key) {
+ return get(this, key, true)
+};
+
+LRUCache.prototype.peek = function (key) {
+ return get(this, key, false)
+};
+
+LRUCache.prototype.pop = function () {
+ var node = this[LRU_LIST].tail;
+ if (!node) return null
+ del(this, node);
+ return node.value
+};
+
+LRUCache.prototype.del = function (key) {
+ del(this, this[CACHE].get(key));
+};
+
+LRUCache.prototype.load = function (arr) {
+ // reset the cache
+ this.reset();
+
+ var now = Date.now();
+ // A previous serialized cache has the most recent items first
+ for (var l = arr.length - 1; l >= 0; l--) {
+ var hit = arr[l];
+ var expiresAt = hit.e || 0;
+ if (expiresAt === 0) {
+ // the item was created without expiration in a non aged cache
+ this.set(hit.k, hit.v);
+ } else {
+ var maxAge = expiresAt - now;
+ // dont add already expired items
+ if (maxAge > 0) {
+ this.set(hit.k, hit.v, maxAge);
+ }
+ }
+ }
+};
+
+LRUCache.prototype.prune = function () {
+ var self = this;
+ this[CACHE].forEach(function (value, key) {
+ get(self, key, false);
+ });
+};
+
+function get (self, key, doUse) {
+ var node = self[CACHE].get(key);
+ if (node) {
+ var hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE]) hit = undefined;
+ } else {
+ if (doUse) {
+ self[LRU_LIST].unshiftNode(node);
+ }
+ }
+ if (hit) hit = hit.value;
+ }
+ return hit
+}
+
+function isStale (self, hit) {
+ if (!hit || (!hit.maxAge && !self[MAX_AGE])) {
+ return false
+ }
+ var stale = false;
+ var diff = Date.now() - hit.now;
+ if (hit.maxAge) {
+ stale = diff > hit.maxAge;
+ } else {
+ stale = self[MAX_AGE] && (diff > self[MAX_AGE]);
+ }
+ return stale
+}
+
+function trim (self) {
+ if (self[LENGTH] > self[MAX]) {
+ for (var walker = self[LRU_LIST].tail;
+ self[LENGTH] > self[MAX] && walker !== null;) {
+ // We know that we're about to delete this one, and also
+ // what the next least recently used key will be, so just
+ // go ahead and set it now.
+ var prev = walker.prev;
+ del(self, walker);
+ walker = prev;
+ }
+ }
+}
+
+function del (self, node) {
+ if (node) {
+ var hit = node.value;
+ if (self[DISPOSE]) {
+ self[DISPOSE](hit.key, hit.value);
+ }
+ self[LENGTH] -= hit.length;
+ self[CACHE].delete(hit.key);
+ self[LRU_LIST].removeNode(node);
+ }
+}
+
+// classy, since V8 prefers predictable objects.
+function Entry (key, value, length, now, maxAge) {
+ this.key = key;
+ this.value = value;
+ this.length = length;
+ this.now = now;
+ this.maxAge = maxAge || 0;
+}
+
+var sigmund_1 = sigmund;
+function sigmund (subject, maxSessions) {
+ maxSessions = maxSessions || 10;
+ var notes = [];
+ var analysis = '';
+ var RE = RegExp;
+
+ function psychoAnalyze (subject, session) {
+ if (session > maxSessions) return;
+
+ if (typeof subject === 'function' ||
+ typeof subject === 'undefined') {
+ return;
+ }
+
+ if (typeof subject !== 'object' || !subject ||
+ (subject instanceof RE)) {
+ analysis += subject;
+ return;
+ }
+
+ if (notes.indexOf(subject) !== -1 || session === maxSessions) return;
+
+ notes.push(subject);
+ analysis += '{';
+ Object.keys(subject).forEach(function (issue, _, __) {
+ // pseudo-private values. skip those.
+ if (issue.charAt(0) === '_') return;
+ var to = typeof subject[issue];
+ if (to === 'function' || to === 'undefined') return;
+ analysis += issue;
+ psychoAnalyze(subject[issue], session + 1);
+ });
+ }
+ psychoAnalyze(subject, 0);
+ return analysis;
+}
+
+// vim: set softtabstop=4 shiftwidth=4:
+
+var fnmatch = createCommonjsModule(function (module, exports) {
+// Based on minimatch.js by isaacs
+
+ var platform = typeof process === "object" ? process.platform : "win32";
+
+ if (module) module.exports = minimatch;
+ else exports.minimatch = minimatch;
+
+ minimatch.Minimatch = Minimatch;
+
+ var cache = minimatch.cache = new lruCache({max: 100})
+ , GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
+
+ var qmark = "[^/]"
+
+ // * => any number of characters
+ , star = qmark + "*?"
+
+ // ** when dots are allowed. Anything goes, except .. and .
+ // not (^ or / followed by one or two dots followed by $ or /),
+ // followed by anything, any number of times.
+ , twoStarDot = "(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?"
+
+ // not a ^ or / followed by a dot,
+ // followed by anything, any number of times.
+ , twoStarNoDot = "(?:(?!(?:\\\/|^)\\.).)*?"
+
+ // characters that need to be escaped in RegExp.
+ , reSpecials = charSet("().*{}+?[]^$\\!");
+
+// "abc" -> { a:true, b:true, c:true }
+ function charSet (s) {
+ return s.split("").reduce(function (set, c) {
+ set[c] = true;
+ return set
+ }, {})
+ }
+
+// normalizes slashes.
+ var slashSplit = /\/+/;
+
+ minimatch.monkeyPatch = monkeyPatch;
+ function monkeyPatch () {
+ var desc = Object.getOwnPropertyDescriptor(String.prototype, "match");
+ var orig = desc.value;
+ desc.value = function (p) {
+ if (p instanceof Minimatch) return p.match(this)
+ return orig.call(this, p)
+ };
+ Object.defineProperty(String.prototype, desc);
+ }
+
+ minimatch.filter = filter;
+ function filter (pattern, options) {
+ options = options || {};
+ return function (p, i, list) {
+ return minimatch(p, pattern, options)
+ }
+ }
+
+ function ext (a, b) {
+ a = a || {};
+ b = b || {};
+ var t = {};
+ Object.keys(b).forEach(function (k) {
+ t[k] = b[k];
+ });
+ Object.keys(a).forEach(function (k) {
+ t[k] = a[k];
+ });
+ return t
+ }
+
+ minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return minimatch
+
+ var orig = minimatch;
+
+ var m = function minimatch (p, pattern, options) {
+ return orig.minimatch(p, pattern, ext(def, options))
+ };
+
+ m.Minimatch = function Minimatch (pattern, options) {
+ return new orig.Minimatch(pattern, ext(def, options))
+ };
+
+ return m
+ };
+
+ Minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return Minimatch
+ return minimatch.defaults(def).Minimatch
+ };
+
+
+ function minimatch (p, pattern, options) {
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required")
+ }
+
+ if (!options) options = {};
+
+ // shortcut: comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ return false
+ }
+
+ // "" only matches ""
+ if (pattern.trim() === "") return p === ""
+
+ return new Minimatch(pattern, options).match(p)
+ }
+
+ function Minimatch (pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options, cache)
+ }
+
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required")
+ }
+
+ if (!options) options = {};
+
+ // windows: need to use /, not \
+ // On other platforms, \ is a valid (albeit bad) filename char.
+ if (platform === "win32") {
+ pattern = pattern.split("\\").join("/");
+ }
+
+ // lru storage.
+ // these things aren't particularly big, but walking down the string
+ // and turning it into a regexp can get pretty costly.
+ var cacheKey = pattern + "\n" + sigmund_1(options);
+ var cached = minimatch.cache.get(cacheKey);
+ if (cached) return cached
+ minimatch.cache.set(cacheKey, this);
+
+ this.options = options;
+ this.set = [];
+ this.pattern = pattern;
+ this.regexp = null;
+ this.negate = false;
+ this.comment = false;
+ this.empty = false;
+
+ // make the set of regexps etc.
+ this.make();
+ }
+
+ Minimatch.prototype.make = make;
+ function make () {
+ // don't do it more than once.
+ if (this._made) return
+
+ var pattern = this.pattern;
+ var options = this.options;
+
+ // empty patterns and comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ this.comment = true;
+ return
+ }
+ if (!pattern) {
+ this.empty = true;
+ return
+ }
+
+ // step 1: figure out negation, etc.
+ this.parseNegate();
+
+ // step 2: expand braces
+ var set = this.globSet = this.braceExpand();
+
+ if (options.debug) console.error(this.pattern, set);
+
+ // step 3: now we have a set, so turn each one into a series of path-portion
+ // matching patterns.
+ // These will be regexps, except in the case of "**", which is
+ // set to the GLOBSTAR object for globstar behavior,
+ // and will not contain any / characters
+ set = this.globParts = set.map(function (s) {
+ return s.split(slashSplit)
+ });
+
+ if (options.debug) console.error(this.pattern, set);
+
+ // glob --> regexps
+ set = set.map(function (s, si, set) {
+ return s.map(this.parse, this)
+ }, this);
+
+ if (options.debug) console.error(this.pattern, set);
+
+ // filter out everything that didn't compile properly.
+ set = set.filter(function (s) {
+ return -1 === s.indexOf(false)
+ });
+
+ if (options.debug) console.error(this.pattern, set);
+
+ this.set = set;
+ }
+
+ Minimatch.prototype.parseNegate = parseNegate;
+ function parseNegate () {
+ var pattern = this.pattern
+ , negate = false
+ , options = this.options
+ , negateOffset = 0;
+
+ if (options.nonegate) return
+
+ for ( var i = 0, l = pattern.length
+ ; i < l && pattern.charAt(i) === "!"
+ ; i ++) {
+ negate = !negate;
+ negateOffset ++;
+ }
+
+ if (negateOffset) this.pattern = pattern.substr(negateOffset);
+ this.negate = negate;
+ }
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+ minimatch.braceExpand = function (pattern, options) {
+ return new Minimatch(pattern, options).braceExpand()
+ };
+
+ Minimatch.prototype.braceExpand = braceExpand;
+ function braceExpand (pattern, options) {
+ options = options || this.options;
+ pattern = typeof pattern === "undefined"
+ ? this.pattern : pattern;
+
+ if (typeof pattern === "undefined") {
+ throw new Error("undefined pattern")
+ }
+
+ if (options.nobrace ||
+ !pattern.match(/\{.*\}/)) {
+ // shortcut. no need to expand.
+ return [pattern]
+ }
+
+ var escaping = false;
+
+ // examples and comments refer to this crazy pattern:
+ // a{b,c{d,e},{f,g}h}x{y,z}
+ // expected:
+ // abxy
+ // abxz
+ // acdxy
+ // acdxz
+ // acexy
+ // acexz
+ // afhxy
+ // afhxz
+ // aghxy
+ // aghxz
+
+ // everything before the first \{ is just a prefix.
+ // So, we pluck that off, and work with the rest,
+ // and then prepend it to everything we find.
+ if (pattern.charAt(0) !== "{") {
+ // console.error(pattern)
+ var prefix = null;
+ for (var i = 0, l = pattern.length; i < l; i ++) {
+ var c = pattern.charAt(i);
+ // console.error(i, c)
+ if (c === "\\") {
+ escaping = !escaping;
+ } else if (c === "{" && !escaping) {
+ prefix = pattern.substr(0, i);
+ break
+ }
+ }
+
+ // actually no sets, all { were escaped.
+ if (prefix === null) {
+ // console.error("no sets")
+ return [pattern]
+ }
+
+ var tail = braceExpand(pattern.substr(i), options);
+ return tail.map(function (t) {
+ return prefix + t
+ })
+ }
+
+ // now we have something like:
+ // {b,c{d,e},{f,g}h}x{y,z}
+ // walk through the set, expanding each part, until
+ // the set ends. then, we'll expand the suffix.
+ // If the set only has a single member, then'll put the {} back
+
+ // first, handle numeric sets, since they're easier
+ var numset = pattern.match(/^\{(-?[0-9]+)\.\.(-?[0-9]+)\}/);
+ if (numset) {
+ // console.error("numset", numset[1], numset[2])
+ var suf = braceExpand(pattern.substr(numset[0].length), options)
+ , start = +numset[1]
+ , end = +numset[2]
+ , inc = start > end ? -1 : 1
+ , set = [];
+ for (var i = start; i != (end + inc); i += inc) {
+ // append all the suffixes
+ for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
+ set.push(i + suf[ii]);
+ }
+ }
+ return set
+ }
+
+ // ok, walk through the set
+ // We hope, somewhat optimistically, that there
+ // will be a } at the end.
+ // If the closing brace isn't found, then the pattern is
+ // interpreted as braceExpand("\\" + pattern) so that
+ // the leading \{ will be interpreted literally.
+ var i = 1 // skip the \{
+ , depth = 1
+ , set = []
+ , member = ""
+ , sawEnd = false
+ , escaping = false;
+
+ function addMember () {
+ set.push(member);
+ member = "";
+ }
+
+ // console.error("Entering for")
+ FOR: for (i = 1, l = pattern.length; i < l; i ++) {
+ var c = pattern.charAt(i);
+ // console.error("", i, c)
+
+ if (escaping) {
+ escaping = false;
+ member += "\\" + c;
+ } else {
+ switch (c) {
+ case "\\":
+ escaping = true;
+ continue
+
+ case "{":
+ depth ++;
+ member += "{";
+ continue
+
+ case "}":
+ depth --;
+ // if this closes the actual set, then we're done
+ if (depth === 0) {
+ addMember();
+ // pluck off the close-brace
+ i ++;
+ break FOR
+ } else {
+ member += c;
+ continue
+ }
+
+ case ",":
+ if (depth === 1) {
+ addMember();
+ } else {
+ member += c;
+ }
+ continue
+
+ default:
+ member += c;
+ continue
+ } // switch
+ } // else
+ } // for
+
+ // now we've either finished the set, and the suffix is
+ // pattern.substr(i), or we have *not* closed the set,
+ // and need to escape the leading brace
+ if (depth !== 0) {
+ // console.error("didn't close", pattern)
+ return braceExpand("\\" + pattern, options)
+ }
+
+ // x{y,z} -> ["xy", "xz"]
+ // console.error("set", set)
+ // console.error("suffix", pattern.substr(i))
+ var suf = braceExpand(pattern.substr(i), options);
+ // ["b", "c{d,e}","{f,g}h"] ->
+ // [["b"], ["cd", "ce"], ["fh", "gh"]]
+ var addBraces = set.length === 1;
+ // console.error("set pre-expanded", set)
+ set = set.map(function (p) {
+ return braceExpand(p, options)
+ });
+ // console.error("set expanded", set)
+
+
+ // [["b"], ["cd", "ce"], ["fh", "gh"]] ->
+ // ["b", "cd", "ce", "fh", "gh"]
+ set = set.reduce(function (l, r) {
+ return l.concat(r)
+ });
+
+ if (addBraces) {
+ set = set.map(function (s) {
+ return "{" + s + "}"
+ });
+ }
+
+ // now attach the suffixes.
+ var ret = [];
+ for (var i = 0, l = set.length; i < l; i ++) {
+ for (var ii = 0, ll = suf.length; ii < ll; ii ++) {
+ ret.push(set[i] + suf[ii]);
+ }
+ }
+ return ret
+ }
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion. Otherwise, any series
+// of * is equivalent to a single *. Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+ Minimatch.prototype.parse = parse;
+ var SUBPARSE = {};
+ function parse (pattern, isSub) {
+ var options = this.options;
+
+ // shortcuts
+ if (!options.noglobstar && pattern === "**") return GLOBSTAR
+ if (pattern === "") return ""
+
+ var re = ""
+ , hasMagic = !!options.nocase
+ , escaping = false
+ // ? => one single character
+ , patternListStack = []
+ , plType
+ , stateChar
+ , inClass = false
+ , reClassStart = -1
+ , classStart = -1
+ // . and .. never match anything that doesn't start with .,
+ // even when options.dot is set.
+ , patternStart = pattern.charAt(0) === "." ? "" // anything
+ // not (start or / followed by . or .. followed by / or end)
+ : options.dot ? "(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))"
+ : "(?!\\.)";
+
+ function clearStateChar () {
+ if (stateChar) {
+ // we had some state-tracking character
+ // that wasn't consumed by this pass.
+ switch (stateChar) {
+ case "*":
+ re += star;
+ hasMagic = true;
+ break
+ case "?":
+ re += qmark;
+ hasMagic = true;
+ break
+ default:
+ re += "\\"+stateChar;
+ break
+ }
+ stateChar = false;
+ }
+ }
+
+ for ( var i = 0, len = pattern.length, c
+ ; (i < len) && (c = pattern.charAt(i))
+ ; i ++ ) {
+
+ if (options.debug) {
+ console.error("%s\t%s %s %j", pattern, i, re, c);
+ }
+
+ // skip over any that are escaped.
+ if (escaping && reSpecials[c]) {
+ re += "\\" + c;
+ escaping = false;
+ continue
+ }
+
+ SWITCH: switch (c) {
+ case "/":
+ // completely not allowed, even escaped.
+ // Should already be path-split by now.
+ return false
+
+ case "\\":
+ clearStateChar();
+ escaping = true;
+ continue
+
+ // the various stateChar values
+ // for the "extglob" stuff.
+ case "?":
+ case "*":
+ case "+":
+ case "@":
+ case "!":
+ if (options.debug) {
+ console.error("%s\t%s %s %j <-- stateChar", pattern, i, re, c);
+ }
+
+ // all of those are literals inside a class, except that
+ // the glob [!a] means [^a] in regexp
+ if (inClass) {
+ if (c === "!" && i === classStart + 1) c = "^";
+ re += c;
+ continue
+ }
+
+ // if we already have a stateChar, then it means
+ // that there was something like ** or +? in there.
+ // Handle the stateChar, then proceed with this one.
+ clearStateChar();
+ stateChar = c;
+ // if extglob is disabled, then +(asdf|foo) isn't a thing.
+ // just clear the statechar *now*, rather than even diving into
+ // the patternList stuff.
+ if (options.noext) clearStateChar();
+ continue
+
+ case "(":
+ if (inClass) {
+ re += "(";
+ continue
+ }
+
+ if (!stateChar) {
+ re += "\\(";
+ continue
+ }
+
+ plType = stateChar;
+ patternListStack.push({ type: plType
+ , start: i - 1
+ , reStart: re.length });
+ // negation is (?:(?!js)[^/]*)
+ re += stateChar === "!" ? "(?:(?!" : "(?:";
+ stateChar = false;
+ continue
+
+ case ")":
+ if (inClass || !patternListStack.length) {
+ re += "\\)";
+ continue
+ }
+
+ hasMagic = true;
+ re += ")";
+ plType = patternListStack.pop().type;
+ // negation is (?:(?!js)[^/]*)
+ // The others are (?:)
+ switch (plType) {
+ case "!":
+ re += "[^/]*?)";
+ break
+ case "?":
+ case "+":
+ case "*": re += plType;
+ case "@": break // the default anyway
+ }
+ continue
+
+ case "|":
+ if (inClass || !patternListStack.length || escaping) {
+ re += "\\|";
+ escaping = false;
+ continue
+ }
+
+ re += "|";
+ continue
+
+ // these are mostly the same in regexp and glob
+ case "[":
+ // swallow any state-tracking char before the [
+ clearStateChar();
+
+ if (inClass) {
+ re += "\\" + c;
+ continue
+ }
+
+ inClass = true;
+ classStart = i;
+ reClassStart = re.length;
+ re += c;
+ continue
+
+ case "]":
+ // a right bracket shall lose its special
+ // meaning and represent itself in
+ // a bracket expression if it occurs
+ // first in the list. -- POSIX.2 2.8.3.2
+ if (i === classStart + 1 || !inClass) {
+ re += "\\" + c;
+ escaping = false;
+ continue
+ }
+
+ // finish up the class.
+ hasMagic = true;
+ inClass = false;
+ re += c;
+ continue
+
+ default:
+ // swallow any state char that wasn't consumed
+ clearStateChar();
+
+ if (escaping) {
+ // no need
+ escaping = false;
+ } else if (reSpecials[c]
+ && !(c === "^" && inClass)) {
+ re += "\\";
+ }
+
+ re += c;
+
+ } // switch
+ } // for
+
+
+ // handle the case where we left a class open.
+ // "[abc" is valid, equivalent to "\[abc"
+ if (inClass) {
+ // split where the last [ was, and escape it
+ // this is a huge pita. We now have to re-walk
+ // the contents of the would-be class to re-translate
+ // any characters that were passed through as-is
+ var cs = pattern.substr(classStart + 1)
+ , sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0];
+ hasMagic = hasMagic || sp[1];
+ }
+
+ // handle the case where we had a +( thing at the *end*
+ // of the pattern.
+ // each pattern list stack adds 3 chars, and we need to go through
+ // and escape any | chars that were passed through as-is for the regexp.
+ // Go through and escape them, taking care not to double-escape any
+ // | chars that were already escaped.
+ var pl;
+ while (pl = patternListStack.pop()) {
+ var tail = re.slice(pl.reStart + 3);
+ // maybe some even number of \, then maybe 1 \, followed by a |
+ tail = tail.replace(/((?:\\{2})*)(\\?)\|/g, function (_, $1, $2) {
+ if (!$2) {
+ // the | isn't already escaped, so escape it.
+ $2 = "\\";
+ }
+
+ // need to escape all those slashes *again*, without escaping the
+ // one that we need for escaping the | character. As it works out,
+ // escaping an even number of slashes can be done by simply repeating
+ // it exactly after itself. That's why this trick works.
+ //
+ // I am sorry that you have to see this.
+ return $1 + $1 + $2 + "|"
+ });
+
+ // console.error("tail=%j\n %s", tail, tail)
+ var t = pl.type === "*" ? star
+ : pl.type === "?" ? qmark
+ : "\\" + pl.type;
+
+ hasMagic = true;
+ re = re.slice(0, pl.reStart)
+ + t + "\\("
+ + tail;
+ }
+
+ // handle trailing things that only matter at the very end.
+ clearStateChar();
+ if (escaping) {
+ // trailing \\
+ re += "\\\\";
+ }
+
+ // only need to apply the nodot start if the re starts with
+ // something that could conceivably capture a dot
+ var addPatternStart = false;
+ switch (re.charAt(0)) {
+ case ".":
+ case "[":
+ case "(": addPatternStart = true;
+ }
+
+ // if the re is not "" at this point, then we need to make sure
+ // it doesn't match against an empty path part.
+ // Otherwise a/* will match a/, which it should not.
+ if (re !== "" && hasMagic) re = "(?=.)" + re;
+
+ if (addPatternStart) re = patternStart + re;
+
+ // parsing just a piece of a larger pattern.
+ if (isSub === SUBPARSE) {
+ return [ re, hasMagic ]
+ }
+
+ // skip the regexp for non-magical patterns
+ // unescape anything in it, though, so that it'll be
+ // an exact match against a file etc.
+ if (!hasMagic) {
+ return globUnescape(pattern)
+ }
+
+ var flags = options.nocase ? "i" : ""
+ , regExp = new RegExp("^" + re + "$", flags);
+
+ regExp._glob = pattern;
+ regExp._src = re;
+
+ return regExp
+ }
+
+ minimatch.makeRe = function (pattern, options) {
+ return new Minimatch(pattern, options || {}).makeRe()
+ };
+
+ Minimatch.prototype.makeRe = makeRe;
+ function makeRe () {
+ if (this.regexp || this.regexp === false) return this.regexp
+
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ var set = this.set;
+
+ if (!set.length) return this.regexp = false
+ var options = this.options;
+
+ var twoStar = options.noglobstar ? star
+ : options.dot ? twoStarDot
+ : twoStarNoDot
+ , flags = options.nocase ? "i" : "";
+
+ var re = set.map(function (pattern) {
+ return pattern.map(function (p) {
+ return (p === GLOBSTAR) ? twoStar
+ : (typeof p === "string") ? regExpEscape(p)
+ : p._src
+ }).join("\\\/")
+ }).join("|");
+
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = "^(?:" + re + ")$";
+
+ // can match anything, as long as it's not this.
+ if (this.negate) re = "^(?!" + re + ").*$";
+
+ try {
+ return this.regexp = new RegExp(re, flags)
+ } catch (ex) {
+ return this.regexp = false
+ }
+ }
+
+ minimatch.match = function (list, pattern, options) {
+ var mm = new Minimatch(pattern, options);
+ list = list.filter(function (f) {
+ return mm.match(f)
+ });
+ if (options.nonull && !list.length) {
+ list.push(pattern);
+ }
+ return list
+ };
+
+ Minimatch.prototype.match = match;
+ function match (f, partial) {
+ // console.error("match", f, this.pattern)
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) return false
+ if (this.empty) return f === ""
+
+ if (f === "/" && partial) return true
+
+ var options = this.options;
+
+ // windows: need to use /, not \
+ // On other platforms, \ is a valid (albeit bad) filename char.
+ if (platform === "win32") {
+ f = f.split("\\").join("/");
+ }
+
+ // treat the test path as a set of pathparts.
+ f = f.split(slashSplit);
+ if (options.debug) {
+ console.error(this.pattern, "split", f);
+ }
+
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
+
+ var set = this.set;
+ // console.error(this.pattern, "set", set)
+
+ for (var i = 0, l = set.length; i < l; i ++) {
+ var pattern = set[i];
+ var hit = this.matchOne(f, pattern, partial);
+ if (hit) {
+ if (options.flipNegate) return true
+ return !this.negate
+ }
+ }
+
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) return false
+ return this.negate
+ }
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+ Minimatch.prototype.matchOne = function (file, pattern, partial) {
+ var options = this.options;
+
+ if (options.debug) {
+ console.error("matchOne",
+ { "this": this
+ , file: file
+ , pattern: pattern });
+ }
+
+ if (options.matchBase && pattern.length === 1) {
+ file = path.basename(file.join("/")).split("/");
+ }
+
+ if (options.debug) {
+ console.error("matchOne", file.length, pattern.length);
+ }
+
+ for ( var fi = 0
+ , pi = 0
+ , fl = file.length
+ , pl = pattern.length
+ ; (fi < fl) && (pi < pl)
+ ; fi ++, pi ++ ) {
+
+ if (options.debug) {
+ console.error("matchOne loop");
+ }
+ var p = pattern[pi]
+ , f = file[fi];
+
+ if (options.debug) {
+ console.error(pattern, p, f);
+ }
+
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ if (p === false) return false
+
+ if (p === GLOBSTAR) {
+ if (options.debug)
+ console.error('GLOBSTAR', [pattern, p, f]);
+
+ // "**"
+ // a/**/b/**/c would match the following:
+ // a/b/x/y/z/c
+ // a/x/y/z/b/c
+ // a/b/x/b/x/c
+ // a/b/c
+ // To do this, take the rest of the pattern after
+ // the **, and see if it would match the file remainder.
+ // If so, return success.
+ // If not, the ** "swallows" a segment, and try again.
+ // This is recursively awful.
+ //
+ // a/**/b/**/c matching a/b/x/y/z/c
+ // - a matches a
+ // - doublestar
+ // - matchOne(b/x/y/z/c, b/**/c)
+ // - b matches b
+ // - doublestar
+ // - matchOne(x/y/z/c, c) -> no
+ // - matchOne(y/z/c, c) -> no
+ // - matchOne(z/c, c) -> no
+ // - matchOne(c, c) yes, hit
+ var fr = fi
+ , pr = pi + 1;
+ if (pr === pl) {
+ if (options.debug)
+ console.error('** at the end');
+ // a ** at the end will just swallow the rest.
+ // We have found a match.
+ // however, it will not swallow /.x, unless
+ // options.dot is set.
+ // . and .. are *never* matched by **, for explosively
+ // exponential reasons.
+ for ( ; fi < fl; fi ++) {
+ if (file[fi] === "." || file[fi] === ".." ||
+ (!options.dot && file[fi].charAt(0) === ".")) return false
+ }
+ return true
+ }
+
+ // ok, let's see if we can swallow whatever we can.
+ WHILE: while (fr < fl) {
+ var swallowee = file[fr];
+
+ if (options.debug) {
+ console.error('\nglobstar while',
+ file, fr, pattern, pr, swallowee);
+ }
+
+ // XXX remove this slice. Just pass the start index.
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ if (options.debug)
+ console.error('globstar found match!', fr, fl, swallowee);
+ // found a match.
+ return true
+ } else {
+ // can't swallow "." or ".." ever.
+ // can only swallow ".foo" when explicitly asked.
+ if (swallowee === "." || swallowee === ".." ||
+ (!options.dot && swallowee.charAt(0) === ".")) {
+ if (options.debug)
+ console.error("dot detected!", file, fr, pattern, pr);
+ break WHILE
+ }
+
+ // ** swallows a segment, and continue.
+ if (options.debug)
+ console.error('globstar swallow a segment, and continue');
+ fr ++;
+ }
+ }
+ // no match was found.
+ // However, in partial mode, we can't say this is necessarily over.
+ // If there's more *pattern* left, then
+ if (partial) {
+ // ran out of file
+ // console.error("\n>>> no match, partial?", file, fr, pattern, pr)
+ if (fr === fl) return true
+ }
+ return false
+ }
+
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ var hit;
+ if (typeof p === "string") {
+ if (options.nocase) {
+ hit = f.toLowerCase() === p.toLowerCase();
+ } else {
+ hit = f === p;
+ }
+ if (options.debug) {
+ console.error("string match", p, f, hit);
+ }
+ } else {
+ hit = f.match(p);
+ if (options.debug) {
+ console.error("pattern match", p, f, hit);
+ }
+ }
+
+ if (!hit) return false
+ }
+
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
+
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true
+ } else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial
+ } else if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ var emptyFileEnd = (fi === fl - 1) && (file[fi] === "");
+ return emptyFileEnd
+ }
+
+ // should be unreachable.
+ throw new Error("wtf?")
+ };
+
+
+// replace stuff like \* with *
+ function globUnescape (s) {
+ return s.replace(/\\(.)/g, "$1")
+ }
+
+
+ function regExpEscape (s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")
+ }
+});
+
+var ini = createCommonjsModule(function (module, exports) {
+"use strict";
+// Based on iniparser by shockie
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+ function verb(n) { return function (v) { return step([n, v]); }; }
+ function step(op) {
+ if (f) throw new TypeError("Generator is already executing.");
+ while (_) try {
+ if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+ if (y = 0, t) op = [0, t.value];
+ switch (op[0]) {
+ case 0: case 1: t = op; break;
+ case 4: _.label++; return { value: op[1], done: false };
+ case 5: _.label++; y = op[1]; op = [0]; continue;
+ case 7: op = _.ops.pop(); _.trys.pop(); continue;
+ default:
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+ if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+ if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+ if (t[2]) _.ops.pop();
+ _.trys.pop(); continue;
+ }
+ op = body.call(thisArg, _);
+ } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+ if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+ }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+/**
+ * define the possible values:
+ * section: [section]
+ * param: key=value
+ * comment: ;this is a comment
+ */
+var regex = {
+ section: /^\s*\[(([^#;]|\\#|\\;)+)\]\s*([#;].*)?$/,
+ param: /^\s*([\w\.\-\_]+)\s*[=:]\s*(.*?)\s*([#;].*)?$/,
+ comment: /^\s*[#;].*$/,
+};
+/**
+ * Parses an .ini file
+ * @param file The location of the .ini file
+ */
+function parse(file) {
+ return __awaiter(this, void 0, void 0, function () {
+ return __generator(this, function (_a) {
+ return [2 /*return*/, new Promise(function (resolve, reject) {
+ fs.readFile(file, 'utf8', function (err, data) {
+ if (err) {
+ reject(err);
+ return;
+ }
+ resolve(parseString(data));
+ });
+ })];
+ });
+ });
+}
+exports.parse = parse;
+function parseSync(file) {
+ return parseString(fs.readFileSync(file, 'utf8'));
+}
+exports.parseSync = parseSync;
+function parseString(data) {
+ var sectionBody = {};
+ var sectionName = null;
+ var value = [[sectionName, sectionBody]];
+ var lines = data.split(/\r\n|\r|\n/);
+ lines.forEach(function (line) {
+ var match;
+ if (regex.comment.test(line)) {
+ return;
+ }
+ if (regex.param.test(line)) {
+ match = line.match(regex.param);
+ sectionBody[match[1]] =
+ match[2];
+ }
+ else if (regex.section.test(line)) {
+ match = line.match(regex.section);
+ sectionName = match[1];
+ sectionBody = {};
+ value.push([sectionName, sectionBody]);
+ }
+ });
+ return value;
+}
+exports.parseString = parseString;
+});
+
+unwrapExports(ini);
+
+var name$1 = "editorconfig";
+var version$2 = "0.15.0";
+var description$1 = "EditorConfig File Locator and Interpreter for Node.js";
+var keywords = ["editorconfig","core"];
+var main$1 = "index.js";
+var bin$1 = {"editorconfig":"bin/editorconfig"};
+var contributors = ["Hong Xu (topbug.net)","Jed Mao (https://github.com/jedmao/)","Trey Hunner (http://treyhunner.com)"];
+var directories = {"bin":"./bin","lib":"./lib"};
+var scripts$1 = {"clean":"rimraf dist","prebuild":"npm run clean","build":"tsc","pretest":"npm run lint && npm run build && npm run copy && cmake .","test":"ctest .","pretest:ci":"npm run pretest","test:ci":"ctest -VV --output-on-failure .","lint":"npm run eclint && npm run tslint","eclint":"eclint check --indent_size ignore \"src/**\"","tslint":"tslint --project tslint.json","copy":"cpy package.json .npmignore LICENSE README.md CHANGELOG.md dist && cpy src/bin/* dist/bin && cpy src/lib/fnmatch*.* dist/lib","prepub":"npm run lint && npm run build && npm run copy","pub":"npm publish ./dist"};
+var repository$1 = {"type":"git","url":"git://github.com/editorconfig/editorconfig-core-js.git"};
+var bugs$1 = "https://github.com/editorconfig/editorconfig-core-js/issues";
+var author$1 = "EditorConfig Team";
+var license$1 = "MIT";
+var dependencies$1 = {"@types/commander":"^2.11.0","@types/semver":"^5.4.0","commander":"^2.11.0","lru-cache":"^4.1.1","semver":"^5.4.1","sigmund":"^1.0.1"};
+var devDependencies$1 = {"@types/mocha":"^2.2.43","cpy-cli":"^1.0.1","eclint":"^2.4.3","mocha":"^4.0.1","rimraf":"^2.6.2","should":"^13.1.2","tslint":"^5.7.0","typescript":"^2.5.3"};
+var _package$2 = {
+ name: name$1,
+ version: version$2,
+ description: description$1,
+ keywords: keywords,
+ main: main$1,
+ bin: bin$1,
+ contributors: contributors,
+ directories: directories,
+ scripts: scripts$1,
+ repository: repository$1,
+ bugs: bugs$1,
+ author: author$1,
+ license: license$1,
+ dependencies: dependencies$1,
+ devDependencies: devDependencies$1
+};
+
+var _package$3 = Object.freeze({
+ name: name$1,
+ version: version$2,
+ description: description$1,
+ keywords: keywords,
+ main: main$1,
+ bin: bin$1,
+ contributors: contributors,
+ directories: directories,
+ scripts: scripts$1,
+ repository: repository$1,
+ bugs: bugs$1,
+ author: author$1,
+ license: license$1,
+ dependencies: dependencies$1,
+ devDependencies: devDependencies$1,
+ default: _package$2
+});
+
+var pkg = ( _package$3 && _package$2 ) || _package$3;
+
+var editorconfig = createCommonjsModule(function (module, exports) {
+"use strict";
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+ function verb(n) { return function (v) { return step([n, v]); }; }
+ function step(op) {
+ if (f) throw new TypeError("Generator is already executing.");
+ while (_) try {
+ if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+ if (y = 0, t) op = [0, t.value];
+ switch (op[0]) {
+ case 0: case 1: t = op; break;
+ case 4: _.label++; return { value: op[1], done: false };
+ case 5: _.label++; y = op[1]; op = [0]; continue;
+ case 7: op = _.ops.pop(); _.trys.pop(); continue;
+ default:
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+ if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+ if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+ if (t[2]) _.ops.pop();
+ _.trys.pop(); continue;
+ }
+ op = body.call(thisArg, _);
+ } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+ if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+ }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+
+
+
+exports.parseString = ini.parseString;
+// tslint:disable-next-line:no-var-requires
+
+var knownProps = {
+ end_of_line: true,
+ indent_style: true,
+ indent_size: true,
+ insert_final_newline: true,
+ trim_trailing_whitespace: true,
+ charset: true,
+};
+function fnmatch$$1(filepath, glob) {
+ var matchOptions = { matchBase: true, dot: true, noext: true };
+ glob = glob.replace(/\*\*/g, '{*,**/**/**}');
+ return fnmatch(filepath, glob, matchOptions);
+}
+function getConfigFileNames(filepath, options) {
+ var paths = [];
+ do {
+ filepath = path.dirname(filepath);
+ paths.push(path.join(filepath, options.config));
+ } while (filepath !== options.root);
+ return paths;
+}
+function processMatches(matches, version) {
+ // Set indent_size to 'tab' if indent_size is unspecified and
+ // indent_style is set to 'tab'.
+ if ('indent_style' in matches
+ && matches.indent_style === 'tab'
+ && !('indent_size' in matches)
+ && semver$3.gte(version, '0.10.0')) {
+ matches.indent_size = 'tab';
+ }
+ // Set tab_width to indent_size if indent_size is specified and
+ // tab_width is unspecified
+ if ('indent_size' in matches
+ && !('tab_width' in matches)
+ && matches.indent_size !== 'tab') {
+ matches.tab_width = matches.indent_size;
+ }
+ // Set indent_size to tab_width if indent_size is 'tab'
+ if ('indent_size' in matches
+ && 'tab_width' in matches
+ && matches.indent_size === 'tab') {
+ matches.indent_size = matches.tab_width;
+ }
+ return matches;
+}
+function processOptions(options, filepath) {
+ if (options === void 0) { options = {}; }
+ return {
+ config: options.config || '.editorconfig',
+ version: options.version || pkg.version,
+ root: path.resolve(options.root || path.parse(filepath).root),
+ };
+}
+function buildFullGlob(pathPrefix, glob) {
+ switch (glob.indexOf('/')) {
+ case -1:
+ glob = '**/' + glob;
+ break;
+ case 0:
+ glob = glob.substring(1);
+ break;
+ default:
+ break;
+ }
+ return path.join(pathPrefix, glob);
+}
+function extendProps(props, options) {
+ if (props === void 0) { props = {}; }
+ if (options === void 0) { options = {}; }
+ for (var key in options) {
+ if (options.hasOwnProperty(key)) {
+ var value = options[key];
+ var key2 = key.toLowerCase();
+ var value2 = value;
+ if (knownProps[key2]) {
+ value2 = value.toLowerCase();
+ }
+ try {
+ value2 = JSON.parse(value);
+ }
+ catch (e) { }
+ if (typeof value === 'undefined' || value === null) {
+ // null and undefined are values specific to JSON (no special meaning
+ // in editorconfig) & should just be returned as regular strings.
+ value2 = String(value);
+ }
+ props[key2] = value2;
+ }
+ }
+ return props;
+}
+function parseFromConfigs(configs, filepath, options) {
+ return processMatches(configs
+ .reverse()
+ .reduce(function (matches, file) {
+ var pathPrefix = path.dirname(file.name);
+ file.contents.forEach(function (section) {
+ var glob = section[0];
+ var options2 = section[1];
+ if (!glob) {
+ return;
+ }
+ var fullGlob = buildFullGlob(pathPrefix, glob);
+ if (!fnmatch$$1(filepath, fullGlob)) {
+ return;
+ }
+ matches = extendProps(matches, options2);
+ });
+ return matches;
+ }, {}), options.version);
+}
+function getConfigsForFiles(files) {
+ var configs = [];
+ for (var i in files) {
+ if (files.hasOwnProperty(i)) {
+ var file = files[i];
+ var contents = ini.parseString(file.contents);
+ configs.push({
+ name: file.name,
+ contents: contents,
+ });
+ if ((contents[0][1].root || '').toLowerCase() === 'true') {
+ break;
+ }
+ }
+ }
+ return configs;
+}
+function readConfigFiles(filepaths) {
+ return __awaiter(this, void 0, void 0, function () {
+ return __generator(this, function (_a) {
+ return [2 /*return*/, Promise.all(filepaths.map(function (name) { return new Promise(function (resolve) {
+ fs.readFile(name, 'utf8', function (err, data) {
+ resolve({
+ name: name,
+ contents: err ? '' : data,
+ });
+ });
+ }); }))];
+ });
+ });
+}
+function readConfigFilesSync(filepaths) {
+ var files = [];
+ var file;
+ filepaths.forEach(function (filepath) {
+ try {
+ file = fs.readFileSync(filepath, 'utf8');
+ }
+ catch (e) {
+ file = '';
+ }
+ files.push({
+ name: filepath,
+ contents: file,
+ });
+ });
+ return files;
+}
+function opts(filepath, options) {
+ if (options === void 0) { options = {}; }
+ var resolvedFilePath = path.resolve(filepath);
+ return [
+ resolvedFilePath,
+ processOptions(options, resolvedFilePath),
+ ];
+}
+function parseFromFiles(filepath, files, options) {
+ if (options === void 0) { options = {}; }
+ return __awaiter(this, void 0, void 0, function () {
+ var _a, resolvedFilePath, processedOptions;
+ return __generator(this, function (_b) {
+ _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1];
+ return [2 /*return*/, files.then(getConfigsForFiles)
+ .then(function (configs) { return parseFromConfigs(configs, resolvedFilePath, processedOptions); })];
+ });
+ });
+}
+exports.parseFromFiles = parseFromFiles;
+function parseFromFilesSync(filepath, files, options) {
+ if (options === void 0) { options = {}; }
+ var _a = opts(filepath, options), resolvedFilePath = _a[0], processedOptions = _a[1];
+ return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions);
+}
+exports.parseFromFilesSync = parseFromFilesSync;
+function parse(_filepath, _options) {
+ if (_options === void 0) { _options = {}; }
+ return __awaiter(this, void 0, void 0, function () {
+ var _a, resolvedFilePath, processedOptions, filepaths;
+ return __generator(this, function (_b) {
+ _a = opts(_filepath, _options), resolvedFilePath = _a[0], processedOptions = _a[1];
+ filepaths = getConfigFileNames(resolvedFilePath, processedOptions);
+ return [2 /*return*/, readConfigFiles(filepaths)
+ .then(getConfigsForFiles)
+ .then(function (configs) { return parseFromConfigs(configs, resolvedFilePath, processedOptions); })];
+ });
+ });
+}
+exports.parse = parse;
+function parseSync(_filepath, _options) {
+ if (_options === void 0) { _options = {}; }
+ var _a = opts(_filepath, _options), resolvedFilePath = _a[0], processedOptions = _a[1];
+ var filepaths = getConfigFileNames(resolvedFilePath, processedOptions);
+ var files = readConfigFilesSync(filepaths);
+ return parseFromConfigs(getConfigsForFiles(files), resolvedFilePath, processedOptions);
+}
+exports.parseSync = parseSync;
+});
+
+unwrapExports(editorconfig);
+
+var editorconfigToPrettier = editorConfigToPrettier;
+
+function editorConfigToPrettier(editorConfig) {
+ if (!editorConfig || Object.keys(editorConfig).length === 0) {
+ return null;
+ }
+
+ const result = {};
+
+ if (editorConfig.indent_style) {
+ result.useTabs = editorConfig.indent_style === "tab";
+ }
+
+ if (editorConfig.indent_size === "tab") {
+ result.useTabs = true;
+ }
+
+ if (result.useTabs && editorConfig.tab_width) {
+ result.tabWidth = editorConfig.tab_width;
+ } else if (
+ editorConfig.indent_style === "space" &&
+ editorConfig.indent_size &&
+ editorConfig.indent_size !== "tab"
+ ) {
+ result.tabWidth = editorConfig.indent_size;
+ } else if (editorConfig.tab_width !== undefined) {
+ result.tabWidth = editorConfig.tab_width;
+ }
+
+ if (editorConfig.max_line_length && editorConfig.max_line_length !== "off") {
+ result.printWidth = editorConfig.max_line_length;
+ }
+
+ if (editorConfig.quote_type === "single") {
+ result.singleQuote = true;
+ } else if (editorConfig.quote_type === "double") {
+ result.singleQuote = false;
+ }
+
+ return result;
+}
+
+function markerExists (files, markers) {
+ return markers.some(function(marker) {
+ return files.some(function(file) {
+ return file === marker;
+ });
+ });
+}
+
+function traverseFolder (directory, levels, markers) {
+ var files = fs.readdirSync(directory);
+ if (levels === 0) {
+ return null;
+ } else if (markerExists(files, markers)) {
+ return directory;
+ } else {
+ return traverseFolder(path.resolve(directory, '..'), levels - 1, markers);
+ }
+}
+
+var findProjectRoot = function findRoot(dir, opts) {
+ if (!dir) throw new Error("Directory not defined");
+ opts = opts || {};
+ var levels = opts.maxDepth || findRoot.MAX_DEPTH;
+ var markers = opts.markers || findRoot.MARKERS;
+ return traverseFolder(dir, levels, markers);
+};
+
+var MAX_DEPTH = 9;
+var MARKERS = [ '.git', '.hg' ];
+
+findProjectRoot.MAX_DEPTH = MAX_DEPTH;
+findProjectRoot.MARKERS = MARKERS;
+
+var resolveConfigEditorconfig = createCommonjsModule(function (module) {
+"use strict";
+
+
+
+
+
+
+
+
+const maybeParse = (filePath, config, parse) => {
+ const root = findProjectRoot(path.dirname(path.resolve(filePath)));
+ return filePath && parse(filePath, { root });
+};
+
+const editorconfigAsyncNoCache = (filePath, config) => {
+ return Promise.resolve(maybeParse(filePath, config, editorconfig.parse)).then(
+ editorconfigToPrettier
+ );
+};
+const editorconfigAsyncWithCache = mem(editorconfigAsyncNoCache);
+
+const editorconfigSyncNoCache = (filePath, config) => {
+ return editorconfigToPrettier(
+ maybeParse(filePath, config, editorconfig.parseSync)
+ );
+};
+const editorconfigSyncWithCache = mem(editorconfigSyncNoCache);
+
+function getLoadFunction(opts) {
+ if (!opts.editorconfig) {
+ return () => null;
+ }
+
+ if (opts.sync) {
+ return opts.cache ? editorconfigSyncWithCache : editorconfigSyncNoCache;
+ }
+
+ return opts.cache ? editorconfigAsyncWithCache : editorconfigAsyncNoCache;
+}
+
+function clearCache() {
+ mem.clear(editorconfigSyncWithCache);
+ mem.clear(editorconfigAsyncWithCache);
+}
+
+module.exports = {
+ getLoadFunction,
+ clearCache
+};
+});
+
+var thirdParty$1 = ( thirdParty && thirdParty__default ) || thirdParty;
+
+var resolveConfig_1 = createCommonjsModule(function (module) {
+"use strict";
+
+
+
+
+
+
+
+
+const getExplorerMemoized = mem(opts =>
+ thirdParty$1.cosmiconfig("prettier", {
+ sync: opts.sync,
+ cache: opts.cache,
+ rcExtensions: true,
+ transform: result => {
+ if (result && result.config) {
+ delete result.config.$schema;
+ }
+ return result;
+ }
+ })
+);
+
+/** @param {{ cache: boolean, sync: boolean }} opts */
+function getLoadFunction(opts) {
+ // Normalize opts before passing to a memoized function
+ opts = Object.assign({ sync: false, cache: false }, opts);
+ return getExplorerMemoized(opts).load;
+}
+
+function _resolveConfig(filePath, opts, sync) {
+ opts = Object.assign({ useCache: true }, opts);
+ const loadOpts = {
+ cache: !!opts.useCache,
+ sync: !!sync,
+ editorconfig: !!opts.editorconfig
+ };
+ const load = getLoadFunction(loadOpts);
+ const loadEditorConfig = resolveConfigEditorconfig.getLoadFunction(loadOpts);
+ const arr = [load, loadEditorConfig].map(l => l(filePath, opts.config));
+
+ const unwrapAndMerge = arr => {
+ const result = arr[0];
+ const editorConfigured = arr[1];
+ const merged = Object.assign(
+ {},
+ editorConfigured,
+ mergeOverrides(Object.assign({}, result), filePath)
+ );
+
+ if (!result && !editorConfigured) {
+ return null;
+ }
+
+ return merged;
+ };
+
+ if (loadOpts.sync) {
+ return unwrapAndMerge(arr);
+ }
+
+ return Promise.all(arr).then(unwrapAndMerge);
+}
+
+const resolveConfig = (filePath, opts) => _resolveConfig(filePath, opts, false);
+
+resolveConfig.sync = (filePath, opts) => _resolveConfig(filePath, opts, true);
+
+function clearCache() {
+ mem.clear(getExplorerMemoized);
+ resolveConfigEditorconfig.clearCache();
+}
+
+function resolveConfigFile(filePath) {
+ const load = getLoadFunction({ sync: false });
+ return load(filePath).then(result => {
+ return result ? result.filepath : null;
+ });
+}
+
+resolveConfigFile.sync = filePath => {
+ const load = getLoadFunction({ sync: true });
+ const result = load(filePath);
+ return result ? result.filepath : null;
+};
+
+function mergeOverrides(configResult, filePath) {
+ const options = Object.assign({}, configResult.config);
+ if (filePath && options.overrides) {
+ const relativeFilePath = path.relative(
+ path.dirname(configResult.filepath),
+ filePath
+ );
+ for (const override of options.overrides) {
+ if (
+ pathMatchesGlobs(
+ relativeFilePath,
+ override.files,
+ override.excludeFiles
+ )
+ ) {
+ Object.assign(options, override.options);
+ }
+ }
+ }
+
+ delete options.overrides;
+ return options;
+}
+
+// Based on eslint: https://github.com/eslint/eslint/blob/master/lib/config/config-ops.js
+function pathMatchesGlobs(filePath, patterns, excludedPatterns) {
+ const patternList = [].concat(patterns);
+ const excludedPatternList = [].concat(excludedPatterns || []);
+ const opts = { matchBase: true };
+
+ return (
+ patternList.some(pattern => minimatch_1(filePath, pattern, opts)) &&
+ !excludedPatternList.some(excludedPattern =>
+ minimatch_1(filePath, excludedPattern, opts)
+ )
+ );
+}
+
+module.exports = {
+ resolveConfig,
+ resolveConfigFile,
+ clearCache
+};
+});
+
+const version = require$$0$11.version;
+
+
+
+const getSupportInfo = support.getSupportInfo;
+
+
+
+const normalizeOptions = options$12.normalize;
+
+
+
+
+
+const printDocToString = doc.printer.printDocToString;
+const printDocToDebug = doc.debug.printDocToDebug;
+
+function guessLineEnding(text) {
+ const index = text.indexOf("\n");
+ if (index >= 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 formatWithCursor(text, opts, addAlignmentSize) {
+ const selectedParser = parser$3.resolveParser(opts);
+ const hasPragma = !selectedParser.hasPragma || selectedParser.hasPragma(text);
+ if (opts.requirePragma && !hasPragma) {
+ return { formatted: text };
+ }
+
+ const UTF8BOM = 0xfeff;
+ const hasUnicodeBOM = text.charCodeAt(0) === UTF8BOM;
+ if (hasUnicodeBOM) {
+ text = text.substring(1);
+ }
+
+ if (
+ opts.insertPragma &&
+ opts.printer.insertPragma &&
+ !hasPragma &&
+ opts.rangeStart === 0 &&
+ opts.rangeEnd === Infinity
+ ) {
+ text = opts.printer.insertPragma(text);
+ }
+
+ addAlignmentSize = addAlignmentSize || 0;
+
+ const result = parser$3.parse(text, opts);
+ const ast = result.ast;
+ text = result.text;
+
+ const formattedRangeOnly = formatRange(text, opts, ast);
+ if (formattedRangeOnly) {
+ return { formatted: formattedRangeOnly };
+ }
+
+ let cursorOffset;
+ if (opts.cursorOffset >= 0) {
+ const cursorNodeAndParents = findNodeAtOffset(ast, opts.cursorOffset, opts);
+ const cursorNode = cursorNodeAndParents.node;
+ if (cursorNode) {
+ cursorOffset = opts.cursorOffset - opts.locStart(cursorNode);
+ opts.cursorNode = cursorNode;
+ }
+ }
+
+ const astComments = attachComments(text, ast, opts);
+ const doc$$1 = astToDoc(ast, opts, addAlignmentSize);
+ opts.newLine = guessLineEnding(text);
+ const toStringResult = printDocToString(doc$$1, opts);
+ let str = toStringResult.formatted;
+ if (hasUnicodeBOM) {
+ str = String.fromCharCode(UTF8BOM) + str;
+ }
+ const cursorOffsetResult = toStringResult.cursor;
+ ensureAllCommentsPrinted(astComments);
+ // Remove extra leading indentation as well as the added indentation after last newline
+ if (addAlignmentSize > 0) {
+ return { formatted: str.trim() + opts.newLine };
+ }
+
+ if (cursorOffset !== undefined) {
+ return {
+ formatted: str,
+ cursorOffset: cursorOffsetResult + cursorOffset
+ };
+ }
+
+ return { formatted: str };
+}
+
+function format(text, opts, addAlignmentSize) {
+ return formatWithCursor(text, opts, addAlignmentSize).formatted;
+}
+
+function findSiblingAncestors(startNodeAndParents, endNodeAndParents, opts) {
+ let resultStartNode = startNodeAndParents.node;
+ let resultEndNode = endNodeAndParents.node;
+
+ if (resultStartNode === resultEndNode) {
+ return {
+ startNode: resultStartNode,
+ endNode: resultEndNode
+ };
+ }
+
+ for (const endParent of endNodeAndParents.parentNodes) {
+ if (
+ endParent.type !== "Program" &&
+ endParent.type !== "File" &&
+ opts.locStart(endParent) >= opts.locStart(startNodeAndParents.node)
+ ) {
+ resultEndNode = endParent;
+ } else {
+ break;
+ }
+ }
+
+ for (const startParent of startNodeAndParents.parentNodes) {
+ if (
+ startParent.type !== "Program" &&
+ startParent.type !== "File" &&
+ opts.locEnd(startParent) <= opts.locEnd(endNodeAndParents.node)
+ ) {
+ resultStartNode = startParent;
+ } else {
+ break;
+ }
+ }
+
+ return {
+ startNode: resultStartNode,
+ endNode: resultEndNode
+ };
+}
+
+function findNodeAtOffset(node, offset, options, predicate, parentNodes) {
+ predicate = predicate || (() => true);
+ parentNodes = parentNodes || [];
+ const start = options.locStart(node, options.locStart);
+ const end = options.locEnd(node, options.locEnd);
+ if (start <= offset && offset <= end) {
+ for (const childNode of comments.getSortedChildNodes(
+ node,
+ undefined /* text */,
+ options
+ )) {
+ const childResult = findNodeAtOffset(
+ childNode,
+ offset,
+ options,
+ predicate,
+ [node].concat(parentNodes)
+ );
+ if (childResult) {
+ return childResult;
+ }
+ }
+
+ if (predicate(node)) {
+ return {
+ node: node,
+ parentNodes: parentNodes
+ };
+ }
+ }
+}
+
+// See https://www.ecma-international.org/ecma-262/5.1/#sec-A.5
+function isSourceElement(opts, node) {
+ if (node == null) {
+ return false;
+ }
+ // JS and JS like to avoid repetitions
+ const jsSourceElements = [
+ "FunctionDeclaration",
+ "BlockStatement",
+ "BreakStatement",
+ "ContinueStatement",
+ "DebuggerStatement",
+ "DoWhileStatement",
+ "EmptyStatement",
+ "ExpressionStatement",
+ "ForInStatement",
+ "ForStatement",
+ "IfStatement",
+ "LabeledStatement",
+ "ReturnStatement",
+ "SwitchStatement",
+ "ThrowStatement",
+ "TryStatement",
+ "VariableDeclaration",
+ "WhileStatement",
+ "WithStatement",
+ "ClassDeclaration", // ES 2015
+ "ImportDeclaration", // Module
+ "ExportDefaultDeclaration", // Module
+ "ExportNamedDeclaration", // Module
+ "ExportAllDeclaration", // Module
+ "TypeAlias", // Flow
+ "InterfaceDeclaration", // Flow, TypeScript
+ "TypeAliasDeclaration", // TypeScript
+ "ExportAssignment", // TypeScript
+ "ExportDeclaration" // TypeScript
+ ];
+ const jsonSourceElements = [
+ "ObjectExpression",
+ "ArrayExpression",
+ "StringLiteral",
+ "NumericLiteral",
+ "BooleanLiteral",
+ "NullLiteral"
+ ];
+ const graphqlSourceElements = [
+ "OperationDefinition",
+ "FragmentDefinition",
+ "VariableDefinition",
+ "TypeExtensionDefinition",
+ "ObjectTypeDefinition",
+ "FieldDefinition",
+ "DirectiveDefinition",
+ "EnumTypeDefinition",
+ "EnumValueDefinition",
+ "InputValueDefinition",
+ "InputObjectTypeDefinition",
+ "SchemaDefinition",
+ "OperationTypeDefinition",
+ "InterfaceTypeDefinition",
+ "UnionTypeDefinition",
+ "ScalarTypeDefinition"
+ ];
+ switch (opts.parser) {
+ case "flow":
+ case "babylon":
+ case "typescript":
+ return jsSourceElements.indexOf(node.type) > -1;
+ case "json":
+ return jsonSourceElements.indexOf(node.type) > -1;
+ case "graphql":
+ return graphqlSourceElements.indexOf(node.kind) > -1;
+ }
+ 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,
+ opts,
+ node => isSourceElement(opts, node)
+ );
+ const endNodeAndParents = findNodeAtOffset(
+ ast,
+ endNonWhitespace,
+ opts,
+ node => isSourceElement(opts, node)
+ );
+
+ if (!startNodeAndParents || !endNodeAndParents) {
+ return {
+ rangeStart: 0,
+ rangeEnd: 0
+ };
+ }
+
+ const siblingAncestors = findSiblingAncestors(
+ startNodeAndParents,
+ endNodeAndParents,
+ opts
+ );
+ const startNode = siblingAncestors.startNode;
+ const endNode = siblingAncestors.endNode;
+ const rangeStart = Math.min(
+ opts.locStart(startNode, opts.locStart),
+ opts.locStart(endNode, opts.locStart)
+ );
+ const rangeEnd = Math.max(
+ opts.locEnd(startNode, opts.locEnd),
+ opts.locEnd(endNode, opts.locEnd)
+ );
+
+ return {
+ rangeStart: rangeStart,
+ rangeEnd: rangeEnd
+ };
+}
+
+function formatRange(text, opts, ast) {
+ if (opts.rangeStart <= 0 && text.length <= opts.rangeEnd) {
+ return;
+ }
+
+ 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$1.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);
+}
+
+var prettier = {
+ formatWithCursor: function(text, opts) {
+ return formatWithCursor(text, normalizeOptions(opts));
+ },
+
+ format: function(text, opts) {
+ return format(text, normalizeOptions(opts));
+ },
+
+ check: function(text, opts) {
+ try {
+ const formatted = format(text, normalizeOptions(opts));
+ return formatted === text;
+ } catch (e) {
+ return false;
+ }
+ },
+
+ doc,
+
+ resolveConfig: resolveConfig_1.resolveConfig,
+ clearConfigCache: resolveConfig_1.clearCache,
+
+ getSupportInfo,
+
+ version,
+
+ util: utilShared,
+
+ /* istanbul ignore next */
+ __debug: {
+ parse: function(text, opts) {
+ opts = normalizeOptions(opts);
+ return parser$3.parse(text, opts);
+ },
+ formatAST: function(ast, opts) {
+ opts = normalizeOptions(opts);
+ const doc$$1 = astToDoc(ast, opts);
+ const str = printDocToString(doc$$1, opts);
+ return str;
+ },
+ // Doesn't handle shebang for now
+ formatDoc: function(doc$$1, opts) {
+ opts = normalizeOptions(opts);
+ const debug = printDocToDebug(doc$$1);
+ const str = format(debug, opts);
+ return str;
+ },
+ printToDoc: function(text, opts) {
+ opts = normalizeOptions(opts);
+ const result = parser$3.parse(text, opts);
+ const ast = result.ast;
+ text = result.text;
+ attachComments(text, ast, opts);
+ const doc$$1 = astToDoc(ast, opts);
+ return doc$$1;
+ },
+ printDocToString: function(doc$$1, opts) {
+ opts = normalizeOptions(opts);
+ const str = printDocToString(doc$$1, opts);
+ return str;
+ }
+ }
+};
+
+module.exports = prettier;
diff --git a/Colorui-UniApp/node_modules/prettier/package.json b/Colorui-UniApp/node_modules/prettier/package.json
new file mode 100644
index 0000000..8dd3fb1
--- /dev/null
+++ b/Colorui-UniApp/node_modules/prettier/package.json
@@ -0,0 +1,86 @@
+{
+ "_from": "prettier@~1.12.0",
+ "_id": "prettier@1.12.1",
+ "_inBundle": false,
+ "_integrity": "sha1-wa0g6APndJ+vkFpAnSNn4Gu+cyU=",
+ "_location": "/prettier",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "prettier@~1.12.0",
+ "name": "prettier",
+ "escapedName": "prettier",
+ "rawSpec": "~1.12.0",
+ "saveSpec": null,
+ "fetchSpec": "~1.12.0"
+ },
+ "_requiredBy": [
+ "#USER",
+ "/"
+ ],
+ "_resolved": "http://registry.npm.taobao.org/prettier/download/prettier-1.12.1.tgz",
+ "_shasum": "c1ad20e803e7749faf905a409d2367e06bbe7325",
+ "_spec": "prettier@~1.12.0",
+ "_where": "E:\\weilanwlSVN\\colorui\\github\\ColorUI\\Colorui-UniApp",
+ "author": {
+ "name": "James Long"
+ },
+ "bin": {
+ "prettier": "./bin-prettier.js"
+ },
+ "bugs": {
+ "url": "https://github.com/prettier/prettier/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Prettier is an opinionated code formatter",
+ "devDependencies": {
+ "babel-cli": "6.24.1",
+ "babel-preset-es2015": "6.24.1",
+ "codecov": "2.2.0",
+ "cross-env": "5.0.5",
+ "eslint": "4.18.2",
+ "eslint-config-prettier": "2.9.0",
+ "eslint-friendly-formatter": "3.0.0",
+ "eslint-plugin-import": "2.9.0",
+ "eslint-plugin-prettier": "2.6.0",
+ "eslint-plugin-react": "7.7.0",
+ "jest": "21.1.0",
+ "mkdirp": "0.5.1",
+ "prettier": "1.12.0",
+ "prettylint": "1.0.0",
+ "rimraf": "2.6.2",
+ "rollup": "0.47.6",
+ "rollup-plugin-commonjs": "8.2.6",
+ "rollup-plugin-json": "2.1.1",
+ "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.2.1",
+ "shelljs": "0.8.1",
+ "snapshot-diff": "0.2.2",
+ "strip-ansi": "4.0.0",
+ "tempy": "0.2.1",
+ "uglify-es": "3.3.9",
+ "webpack": "2.6.1"
+ },
+ "engines": {
+ "node": ">=4"
+ },
+ "files": [
+ "*.js"
+ ],
+ "homepage": "https://prettier.io",
+ "license": "MIT",
+ "main": "./index.js",
+ "name": "prettier",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/prettier/prettier.git"
+ },
+ "scripts": {
+ "prepublishOnly": "node -e \"assert.equal(require('.').version, require('..').version)\""
+ },
+ "version": "1.12.1"
+}
diff --git a/Colorui-UniApp/node_modules/prettier/parser-babylon.js b/Colorui-UniApp/node_modules/prettier/parser-babylon.js
new file mode 100644
index 0000000..401d5a7
--- /dev/null
+++ b/Colorui-UniApp/node_modules/prettier/parser-babylon.js
@@ -0,0 +1 @@
+"use strict";function createError(t,e){const s=new SyntaxError(t+" ("+e.start.line+":"+e.start.column+")");return s.loc=e,s}var parserCreateError=createError;function unwrapExports(t){return t&&t.__esModule&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t}function createCommonjsModule(t,e){return t(e={exports:{}},e.exports),e.exports}var lib=createCommonjsModule(function(t,e){function s(t,e){t.prototype=Object.create(e.prototype),t.prototype.constructor=t,t.__proto__=e}Object.defineProperty(e,"__esModule",{value:!0});var i={sourceType:"script",sourceFilename:void 0,startLine:1,allowReturnOutsideFunction:!1,allowImportExportEverywhere:!1,allowSuperOutsideMethod:!1,plugins:[],strictMode:null,ranges:!1,tokens:!1};var r=!0,a=function(t,e){void 0===e&&(e={}),this.label=t,this.keyword=e.keyword,this.beforeExpr=!!e.beforeExpr,this.startsExpr=!!e.startsExpr,this.rightAssociative=!!e.rightAssociative,this.isLoop=!!e.isLoop,this.isAssign=!!e.isAssign,this.prefix=!!e.prefix,this.postfix=!!e.postfix,this.binop=0===e.binop?0:e.binop||null,this.updateContext=null},n=function(t){function e(e,s){return void 0===s&&(s={}),s.keyword=e,t.call(this,e,s)||this}return s(e,t),e}(a),o=function(t){function e(e,s){return t.call(this,e,{beforeExpr:r,binop:s})||this}return s(e,t),e}(a),h={num:new a("num",{startsExpr:!0}),bigint:new a("bigint",{startsExpr:!0}),regexp:new a("regexp",{startsExpr:!0}),string:new a("string",{startsExpr:!0}),name:new a("name",{startsExpr:!0}),eof:new a("eof"),bracketL:new a("[",{beforeExpr:r,startsExpr:!0}),bracketR:new a("]"),braceL:new a("{",{beforeExpr:r,startsExpr:!0}),braceBarL:new a("{|",{beforeExpr:r,startsExpr:!0}),braceR:new a("}"),braceBarR:new a("|}"),parenL:new a("(",{beforeExpr:r,startsExpr:!0}),parenR:new a(")"),comma:new a(",",{beforeExpr:r}),semi:new a(";",{beforeExpr:r}),colon:new a(":",{beforeExpr:r}),doubleColon:new a("::",{beforeExpr:r}),dot:new a("."),question:new a("?",{beforeExpr:r}),questionDot:new a("?."),arrow:new a("=>",{beforeExpr:r}),template:new a("template"),ellipsis:new a("...",{beforeExpr:r}),backQuote:new a("`",{startsExpr:!0}),dollarBraceL:new a("${",{beforeExpr:r,startsExpr:!0}),at:new a("@"),hash:new a("#"),eq:new a("=",{beforeExpr:r,isAssign:!0}),assign:new a("_=",{beforeExpr:r,isAssign:!0}),incDec:new a("++/--",{prefix:!0,postfix:!0,startsExpr:!0}),bang:new a("!",{beforeExpr:r,prefix:!0,startsExpr:!0}),tilde:new a("~",{beforeExpr:r,prefix:!0,startsExpr:!0}),pipeline:new o("|>",0),nullishCoalescing:new o("??",1),logicalOR:new o("||",1),logicalAND:new o("&&",2),bitwiseOR:new o("|",3),bitwiseXOR:new o("^",4),bitwiseAND:new o("&",5),equality:new o("==/!=",6),relational:new o("",7),bitShift:new o("<>",8),plusMin:new a("+/-",{beforeExpr:r,binop:9,prefix:!0,startsExpr:!0}),modulo:new o("%",10),star:new o("*",10),slash:new o("/",10),exponent:new a("**",{beforeExpr:r,binop:11,rightAssociative:!0})},p={break:new n("break"),case:new n("case",{beforeExpr:r}),catch:new n("catch"),continue:new n("continue"),debugger:new n("debugger"),default:new n("default",{beforeExpr:r}),do:new n("do",{isLoop:!0,beforeExpr:r}),else:new n("else",{beforeExpr:r}),finally:new n("finally"),for:new n("for",{isLoop:!0}),function:new n("function",{startsExpr:!0}),if:new n("if"),return:new n("return",{beforeExpr:r}),switch:new n("switch"),throw:new n("throw",{beforeExpr:r,prefix:!0,startsExpr:!0}),try:new n("try"),var:new n("var"),let:new n("let"),const:new n("const"),while:new n("while",{isLoop:!0}),with:new n("with"),new:new n("new",{beforeExpr:r,startsExpr:!0}),this:new n("this",{startsExpr:!0}),super:new n("super",{startsExpr:!0}),class:new n("class"),extends:new n("extends",{beforeExpr:r}),export:new n("export"),import:new n("import",{startsExpr:!0}),yield:new n("yield",{beforeExpr:r,startsExpr:!0}),null:new n("null",{startsExpr:!0}),true:new n("true",{startsExpr:!0}),false:new n("false",{startsExpr:!0}),in:new n("in",{beforeExpr:r,binop:7}),instanceof:new n("instanceof",{beforeExpr:r,binop:7}),typeof:new n("typeof",{beforeExpr:r,prefix:!0,startsExpr:!0}),void:new n("void",{beforeExpr:r,prefix:!0,startsExpr:!0}),delete:new n("delete",{beforeExpr:r,prefix:!0,startsExpr:!0})};function c(t){var e=t.split(" ");return function(t){return e.indexOf(t)>=0}}Object.keys(p).forEach(function(t){h["_"+t]=p[t]});var l={6:c("enum await"),strict:c("implements interface let package private protected public static yield"),strictBind:c("eval arguments")},u=c("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"),d="ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠ-ࢴࢶ-ࢽऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲈᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞮꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ",f="·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࣔ-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఃా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ഁ-ഃാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ංඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ູົຼ່-ໍ໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠐-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭ᳲ-᳴᳸᳹᷀-᷵᷻-᷿‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱꤀-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿",m=new RegExp("["+d+"]"),y=new RegExp("["+d+f+"]");d=f=null;var x=[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],P=[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];function v(t,e){for(var s=65536,i=0;it)return!1;if((s+=e[i+1])>=t)return!0}return!1}function g(t){return t<65?36===t:t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&m.test(String.fromCharCode(t)):v(t,x)))}function b(t){return t<48?36===t:t<58||!(t<65)&&(t<91||(t<97?95===t:t<123||(t<=65535?t>=170&&y.test(String.fromCharCode(t)):v(t,x)||v(t,P))))}var T=/\r\n?|\n|\u2028|\u2029/,w=new RegExp(T.source,"g");function A(t){return 10===t||13===t||8232===t||8233===t}var N=/[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/,C=function(t,e,s,i){this.token=t,this.isExpr=!!e,this.preserveSpace=!!s,this.override=i},E={braceStatement:new C("{",!1),braceExpression:new C("{",!0),templateQuasi:new C("${",!0),parenStatement:new C("(",!1),parenExpression:new C("(",!0),template:new C("`",!0,!0,function(t){return t.readTmplToken()}),functionExpression:new C("function",!0)};h.parenR.updateContext=h.braceR.updateContext=function(){if(1!==this.state.context.length){var t=this.state.context.pop();t===E.braceStatement&&this.curContext()===E.functionExpression?(this.state.context.pop(),this.state.exprAllowed=!1):t===E.templateQuasi?this.state.exprAllowed=!0:this.state.exprAllowed=!t.isExpr}else this.state.exprAllowed=!0},h.name.updateContext=function(t){"of"!==this.state.value||this.curContext()!==E.parenStatement?(this.state.exprAllowed=!1,t!==h._let&&t!==h._const&&t!==h._var||T.test(this.input.slice(this.state.end))&&(this.state.exprAllowed=!0)):this.state.exprAllowed=!t.beforeExpr},h.braceL.updateContext=function(t){this.state.context.push(this.braceIsBlock(t)?E.braceStatement:E.braceExpression),this.state.exprAllowed=!0},h.dollarBraceL.updateContext=function(){this.state.context.push(E.templateQuasi),this.state.exprAllowed=!0},h.parenL.updateContext=function(t){var e=t===h._if||t===h._for||t===h._with||t===h._while;this.state.context.push(e?E.parenStatement:E.parenExpression),this.state.exprAllowed=!0},h.incDec.updateContext=function(){},h._function.updateContext=function(){this.curContext()!==E.braceStatement&&this.state.context.push(E.functionExpression),this.state.exprAllowed=!1},h.backQuote.updateContext=function(){this.curContext()===E.template?this.state.context.pop():this.state.context.push(E.template),this.state.exprAllowed=!1};var k=function(t,e){this.line=t,this.column=e},S=function(t,e){this.start=t,this.end=e};function L(t){return t[t.length-1]}var I=function(t){function e(){return t.apply(this,arguments)||this}return s(e,t),e.prototype.raise=function(t,e,s){var i=function(t,e){for(var s=1,i=0;;){w.lastIndex=i;var r=w.exec(t);if(!(r&&r.index0)){var e,s,i,r,a,n=this.state.commentStack;if(this.state.trailingComments.length>0)this.state.trailingComments[0].start>=t.end?(i=this.state.trailingComments,this.state.trailingComments=[]):this.state.trailingComments.length=0;else if(n.length>0){var o=L(n);o.trailingComments&&o.trailingComments[0].start>=t.end&&(i=o.trailingComments,o.trailingComments=null)}for(n.length>0&&L(n).start>=t.start&&(e=n.pop());n.length>0&&L(n).start>=t.start;)s=n.pop();if(!s&&e&&(s=e),e&&this.state.leadingComments.length>0){var h=L(this.state.leadingComments);if("ObjectProperty"===e.type){if(h.start>=t.start&&this.state.commentPreviousNode){for(a=0;a0&&(e.trailingComments=this.state.leadingComments,this.state.leadingComments=[])}}else if("CallExpression"===t.type&&t.arguments&&t.arguments.length){var p=L(t.arguments);p&&h.start>=p.start&&h.end<=t.end&&this.state.commentPreviousNode&&this.state.leadingComments.length>0&&(p.trailingComments=this.state.leadingComments,this.state.leadingComments=[])}}if(s){if(s.leadingComments)if(s!==t&&s.leadingComments.length>0&&L(s.leadingComments).end<=t.start)t.leadingComments=s.leadingComments,s.leadingComments=null;else for(r=s.leadingComments.length-2;r>=0;--r)if(s.leadingComments[r].end<=t.start){t.leadingComments=s.leadingComments.splice(0,r+1);break}}else if(this.state.leadingComments.length>0)if(L(this.state.leadingComments).end<=t.start){if(this.state.commentPreviousNode)for(a=0;a0&&(t.leadingComments=this.state.leadingComments,this.state.leadingComments=[])}else{for(r=0;rt.start);r++);var c=this.state.leadingComments.slice(0,r);t.leadingComments=0===c.length?null:c,0===(i=this.state.leadingComments.slice(r)).length&&(i=null)}this.state.commentPreviousNode=t,i&&(i.length&&i[0].start>=t.start&&L(i).end<=t.end?t.innerComments=i:t.trailingComments=i),n.push(t)}},e}(function(){function t(){}var e=t.prototype;return e.isReservedWord=function(t){return"await"===t?this.inModule:l[6](t)},e.hasPlugin=function(t){return!!this.plugins[t]},t}())),M=function(){function t(){}var e=t.prototype;return e.init=function(t,e){this.strict=!1!==t.strictMode&&"module"===t.sourceType,this.input=e,this.potentialArrowAt=-1,this.noArrowAt=[],this.noArrowParamsConversionAt=[],this.inMethod=this.inFunction=this.inParameters=this.maybeInArrowParameters=this.inGenerator=this.inAsync=this.inPropertyName=this.inType=this.inClassProperty=this.noAnonFunctionType=!1,this.classLevel=0,this.labels=[],this.decoratorStack=[[]],this.yieldInPossibleArrowParameters=null,this.tokens=[],this.comments=[],this.trailingComments=[],this.leadingComments=[],this.commentStack=[],this.commentPreviousNode=null,this.pos=this.lineStart=0,this.curLine=t.startLine,this.type=h.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=[E.braceStatement],this.exprAllowed=!0,this.containsEsc=this.containsOctal=!1,this.octalPosition=null,this.invalidTemplateEscapePosition=null,this.exportedIdentifiers=[]},e.curPosition=function(){return new k(this.curLine,this.pos-this.lineStart)},e.clone=function(e){var s=this,i=new t;return Object.keys(this).forEach(function(t){var r=s[t];e&&"context"!==t||!Array.isArray(r)||(r=r.slice()),i[t]=r}),i},t}(),D=function(t){return t>=48&&t<=57},O={decBinOct:[46,66,69,79,95,98,101,111],hex:[46,88,95,120]},R={bin:[48,49]};R.oct=R.bin.concat([50,51,52,53,54,55]),R.dec=R.oct.concat([56,57]),R.hex=R.dec.concat([65,66,67,68,69,70,97,98,99,100,101,102]);function _(t){return t<=65535?String.fromCharCode(t):String.fromCharCode(55296+(t-65536>>10),56320+(t-65536&1023))}var j=function(t){function e(){return t.apply(this,arguments)||this}s(e,t);var i=e.prototype;return i.addExtra=function(t,e,s){t&&((t.extra=t.extra||{})[e]=s)},i.isRelational=function(t){return this.match(h.relational)&&this.state.value===t},i.expectRelational=function(t){this.isRelational(t)?this.next():this.unexpected(null,h.relational)},i.eatRelational=function(t){return!!this.isRelational(t)&&(this.next(),!0)},i.isContextual=function(t){return this.match(h.name)&&this.state.value===t},i.isLookaheadContextual=function(t){var e=this.lookahead();return e.type===h.name&&e.value===t},i.eatContextual=function(t){return this.state.value===t&&this.eat(h.name)},i.expectContextual=function(t,e){this.eatContextual(t)||this.unexpected(null,e)},i.canInsertSemicolon=function(){return this.match(h.eof)||this.match(h.braceR)||this.hasPrecedingLineBreak()},i.hasPrecedingLineBreak=function(){return T.test(this.input.slice(this.state.lastTokEnd,this.state.start))},i.isLineTerminator=function(){return this.eat(h.semi)||this.canInsertSemicolon()},i.semicolon=function(){this.isLineTerminator()||this.unexpected(null,h.semi)},i.expect=function(t,e){this.eat(t)||this.unexpected(e,t)},i.unexpected=function(t,e){throw void 0===e&&(e="Unexpected token"),"string"!=typeof e&&(e=`Unexpected token, expected "${e.label}"`),this.raise(null!=t?t:this.state.start,e)},i.expectPlugin=function(t,e){if(!this.hasPlugin(t))throw this.raise(null!=e?e:this.state.start,`This experimental syntax requires enabling the parser plugin: '${t}'`,[t]);return!0},i.expectOnePlugin=function(t,e){var s=this;if(!t.some(function(t){return s.hasPlugin(t)}))throw this.raise(null!=e?e:this.state.start,`This experimental syntax requires enabling one of the following parser plugin(s): '${t.join(", ")}'`,t)},e}(function(t){function e(e,s){var i;return(i=t.call(this)||this).state=new M,i.state.init(e,s),i.isLookahead=!1,i}s(e,t);var i=e.prototype;return i.next=function(){this.options.tokens&&!this.isLookahead&&this.state.tokens.push(new function(t){this.type=t.type,this.value=t.value,this.start=t.start,this.end=t.end,this.loc=new S(t.startLoc,t.endLoc)}(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()},i.eat=function(t){return!!this.match(t)&&(this.next(),!0)},i.match=function(t){return this.state.type===t},i.isKeyword=function(t){return u(t)},i.lookahead=function(){var t=this.state;this.state=t.clone(!0),this.isLookahead=!0,this.next(),this.isLookahead=!1;var e=this.state;return this.state=t,e},i.setStrict=function(t){if(this.state.strict=t,this.match(h.num)||this.match(h.string)){for(this.state.pos=this.state.start;this.state.pos=this.input.length?this.finishToken(h.eof):t.override?t.override(this):this.readToken(this.fullCharCodeAtPos())},i.readToken=function(t){g(t)||92===t?this.readWord():this.getTokenFromCode(t)},i.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},i.pushComment=function(t,e,s,i,r,a){var n={type:t?"CommentBlock":"CommentLine",value:e,start:s,end:i,loc:new S(r,a)};this.isLookahead||(this.options.tokens&&this.state.tokens.push(n),this.state.comments.push(n),this.addComment(n))},i.skipBlockComment=function(){var t,e=this.state.curPosition(),s=this.state.pos,i=this.input.indexOf("*/",this.state.pos+=2);for(-1===i&&this.raise(this.state.pos-2,"Unterminated comment"),this.state.pos=i+2,w.lastIndex=s;(t=w.exec(this.input))&&t.index8&&t<14||t>=5760&&N.test(String.fromCharCode(t))))break t;++this.state.pos}}},i.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)},i.readToken_dot=function(){var t=this.input.charCodeAt(this.state.pos+1);if(t>=48&&t<=57)this.readNumber(!0);else{var e=this.input.charCodeAt(this.state.pos+2);46===t&&46===e?(this.state.pos+=3,this.finishToken(h.ellipsis)):(++this.state.pos,this.finishToken(h.dot))}},i.readToken_slash=function(){if(this.state.exprAllowed)return++this.state.pos,void this.readRegexp();61===this.input.charCodeAt(this.state.pos+1)?this.finishOp(h.assign,2):this.finishOp(h.slash,1)},i.readToken_mult_modulo=function(t){var e=42===t?h.star:h.modulo,s=1,i=this.input.charCodeAt(this.state.pos+1),r=this.state.exprAllowed;42===t&&42===i&&(s++,i=this.input.charCodeAt(this.state.pos+2),e=h.exponent),61!==i||r||(s++,e=h.assign),this.finishOp(e,s)},i.readToken_pipe_amp=function(t){var e=this.input.charCodeAt(this.state.pos+1);if(e!==t){if(124===t){if(62===e)return void this.finishOp(h.pipeline,2);if(125===e&&this.hasPlugin("flow"))return void this.finishOp(h.braceBarR,2)}61!==e?this.finishOp(124===t?h.bitwiseOR:h.bitwiseAND,1):this.finishOp(h.assign,2)}else this.finishOp(124===t?h.logicalOR:h.logicalAND,2)},i.readToken_caret=function(){61===this.input.charCodeAt(this.state.pos+1)?this.finishOp(h.assign,2):this.finishOp(h.bitwiseXOR,1)},i.readToken_plus_min=function(t){var e=this.input.charCodeAt(this.state.pos+1);if(e===t)return 45===e&&!this.inModule&&62===this.input.charCodeAt(this.state.pos+2)&&T.test(this.input.slice(this.state.lastTokEnd,this.state.pos))?(this.skipLineComment(3),this.skipSpace(),void this.nextToken()):void this.finishOp(h.incDec,2);61===e?this.finishOp(h.assign,2):this.finishOp(h.plusMin,1)},i.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)?void this.finishOp(h.assign,s+1):void this.finishOp(h.bitShift,s)):33!==e||60!==t||this.inModule||45!==this.input.charCodeAt(this.state.pos+2)||45!==this.input.charCodeAt(this.state.pos+3)?(61===e&&(s=2),void this.finishOp(h.relational,s)):(this.skipLineComment(4),this.skipSpace(),void this.nextToken())},i.readToken_eq_excl=function(t){var e=this.input.charCodeAt(this.state.pos+1);if(61!==e)return 61===t&&62===e?(this.state.pos+=2,void this.finishToken(h.arrow)):void this.finishOp(61===t?h.eq:h.bang,1);this.finishOp(h.equality,61===this.input.charCodeAt(this.state.pos+2)?3:2)},i.readToken_question=function(){var t=this.input.charCodeAt(this.state.pos+1),e=this.input.charCodeAt(this.state.pos+2);63===t?this.finishOp(h.nullishCoalescing,2):46!==t||e>=48&&e<=57?(++this.state.pos,this.finishToken(h.question)):(this.state.pos+=2,this.finishToken(h.questionDot))},i.getTokenFromCode=function(t){switch(t){case 35:if((this.hasPlugin("classPrivateProperties")||this.hasPlugin("classPrivateMethods"))&&this.state.classLevel>0)return++this.state.pos,void this.finishToken(h.hash);this.raise(this.state.pos,`Unexpected character '${_(t)}'`);case 46:return void this.readToken_dot();case 40:return++this.state.pos,void this.finishToken(h.parenL);case 41:return++this.state.pos,void this.finishToken(h.parenR);case 59:return++this.state.pos,void this.finishToken(h.semi);case 44:return++this.state.pos,void this.finishToken(h.comma);case 91:return++this.state.pos,void this.finishToken(h.bracketL);case 93:return++this.state.pos,void this.finishToken(h.bracketR);case 123:return void(this.hasPlugin("flow")&&124===this.input.charCodeAt(this.state.pos+1)?this.finishOp(h.braceBarL,2):(++this.state.pos,this.finishToken(h.braceL)));case 125:return++this.state.pos,void this.finishToken(h.braceR);case 58:return void(this.hasPlugin("functionBind")&&58===this.input.charCodeAt(this.state.pos+1)?this.finishOp(h.doubleColon,2):(++this.state.pos,this.finishToken(h.colon)));case 63:return void this.readToken_question();case 64:return++this.state.pos,void this.finishToken(h.at);case 96:return++this.state.pos,void this.finishToken(h.backQuote);case 48:var e=this.input.charCodeAt(this.state.pos+1);if(120===e||88===e)return void this.readRadixNumber(16);if(111===e||79===e)return void this.readRadixNumber(8);if(98===e||66===e)return void this.readRadixNumber(2);case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:return void this.readNumber(!1);case 34:case 39:return void this.readString(t);case 47:return void this.readToken_slash();case 37:case 42:return void this.readToken_mult_modulo(t);case 124:case 38:return void this.readToken_pipe_amp(t);case 94:return void this.readToken_caret();case 43:case 45:return void this.readToken_plus_min(t);case 60:case 62:return void this.readToken_lt_gt(t);case 61:case 33:return void this.readToken_eq_excl(t);case 126:return void this.finishOp(h.tilde,1)}this.raise(this.state.pos,`Unexpected character '${_(t)}'`)},i.finishOp=function(t,e){var s=this.input.slice(this.state.pos,this.state.pos+e);this.state.pos+=e,this.finishToken(t,s)},i.readRegexp=function(){for(var t,e,s=this.state.pos;;){this.state.pos>=this.input.length&&this.raise(s,"Unterminated regular expression");var i=this.input.charAt(this.state.pos);if(T.test(i)&&this.raise(s,"Unterminated regular expression"),t)t=!1;else{if("["===i)e=!0;else if("]"===i&&e)e=!1;else if("/"===i&&!e)break;t="\\"===i}++this.state.pos}var r=this.input.slice(s,this.state.pos);++this.state.pos;var a=this.readWord1();if(a){/^[gmsiyu]*$/.test(a)||this.raise(s,"Invalid regular expression flag")}this.finishToken(h.regexp,{pattern:r,flags:a})},i.readInt=function(t,e){for(var s=this.state.pos,i=16===t?O.hex:O.decBinOct,r=16===t?R.hex:10===t?R.dec:8===t?R.oct:R.bin,a=0,n=0,o=null==e?1/0:e;n-1||i.indexOf(l)>-1||Number.isNaN(l))&&this.raise(this.state.pos,"Invalid or unexpected token"),++this.state.pos;continue}}if((p=h>=97?h-97+10:h>=65?h-65+10:D(h)?h-48:1/0)>=t)break;++this.state.pos,a=a*t+p}return this.state.pos===s||null!=e&&this.state.pos-s!==e?null:a},i.readRadixNumber=function(t){var e=this.state.pos,s=!1;this.state.pos+=2;var i=this.readInt(t);if(null==i&&this.raise(this.state.start+2,"Expected number in radix "+t),this.hasPlugin("bigInt")&&110===this.input.charCodeAt(this.state.pos)&&(++this.state.pos,s=!0),g(this.fullCharCodeAtPos())&&this.raise(this.state.pos,"Identifier directly after number"),s){var r=this.input.slice(e,this.state.pos).replace(/[_n]/g,"");this.finishToken(h.bigint,r)}else this.finishToken(h.num,i)},i.readNumber=function(t){var e=this.state.pos,s=48===this.input.charCodeAt(e),i=!1,r=!1;t||null!==this.readInt(10)||this.raise(e,"Invalid number"),s&&this.state.pos==e+1&&(s=!1);var a=this.input.charCodeAt(this.state.pos);46!==a||s||(++this.state.pos,this.readInt(10),i=!0,a=this.input.charCodeAt(this.state.pos)),69!==a&&101!==a||s||(43!==(a=this.input.charCodeAt(++this.state.pos))&&45!==a||++this.state.pos,null===this.readInt(10)&&this.raise(e,"Invalid number"),i=!0,a=this.input.charCodeAt(this.state.pos)),this.hasPlugin("bigInt")&&110===a&&((i||s)&&this.raise(e,"Invalid BigIntLiteral"),++this.state.pos,r=!0),g(this.fullCharCodeAtPos())&&this.raise(this.state.pos,"Identifier directly after number");var n,o=this.input.slice(e,this.state.pos).replace(/[_n]/g,"");r?this.finishToken(h.bigint,o):(i?n=parseFloat(o):s&&1!==o.length?this.state.strict?this.raise(e,"Invalid number"):n=/[89]/.test(o)?parseInt(o,10):parseInt(o,8):n=parseInt(o,10),this.finishToken(h.num,n))},i.readCodePoint=function(t){var e;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},i.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):(A(i)&&this.raise(this.state.start,"Unterminated string constant"),++this.state.pos)}e+=this.input.slice(s,this.state.pos++),this.finishToken(h.string,e)},i.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(h.template)?36===i?(this.state.pos+=2,void this.finishToken(h.dollarBraceL)):(++this.state.pos,void this.finishToken(h.backQuote)):(t+=this.input.slice(e,this.state.pos),void this.finishToken(h.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(A(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}},i.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:_(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)}},i.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},i.readWord1=function(){this.state.containsEsc=!1;for(var t="",e=!0,s=this.state.pos;this.state.pos=0;n--){var o=this.state.labels[n];if(o.statementStart!==t.start)break;o.statementStart=this.state.start,o.kind=a}return this.state.labels.push({name:e,kind:a,statementStart:this.state.start}),t.body=this.parseStatement(!0),("ClassDeclaration"==t.body.type||"VariableDeclaration"==t.body.type&&"var"!==t.body.kind||"FunctionDeclaration"==t.body.type&&(this.state.strict||t.body.generator||t.body.async))&&this.raise(t.body.start,"Invalid labeled declaration"),this.state.labels.pop(),t.label=s,this.finishNode(t,"LabeledStatement")},i.parseExpressionStatement=function(t,e){return t.expression=e,this.semicolon(),this.finishNode(t,"ExpressionStatement")},i.parseBlock=function(t){var e=this.startNode();return this.expect(h.braceL),this.parseBlockBody(e,t,!1,h.braceR),this.finishNode(e,"BlockStatement")},i.isValidDirective=function(t){return"ExpressionStatement"===t.type&&"StringLiteral"===t.expression.type&&!t.expression.extra.parenthesized},i.parseBlockBody=function(t,e,s,i){var r=t.body=[],a=t.directives=[];this.parseBlockOrModuleBlockBody(r,e?a:void 0,s,i)},i.parseBlockOrModuleBlockBody=function(t,e,s,i){for(var r,a,n=!1;!this.eat(i);){n||!this.state.containsOctal||a||(a=this.state.octalPosition);var o=this.parseStatement(!0,s);if(e&&!n&&this.isValidDirective(o)){var h=this.stmtToDirective(o);e.push(h),void 0===r&&"use strict"===h.value.value&&(r=this.state.strict,this.setStrict(!0),a&&this.raise(a,"Octal literal in strict mode"))}else n=!0,t.push(o)}!1===r&&this.setStrict(!1)},i.parseFor=function(t,e){return t.init=e,this.expect(h.semi),t.test=this.match(h.semi)?null:this.parseExpression(),this.expect(h.semi),t.update=this.match(h.parenR)?null:this.parseExpression(),this.expect(h.parenR),t.body=this.parseStatement(!1),this.state.labels.pop(),this.finishNode(t,"ForStatement")},i.parseForIn=function(t,e,s){var i=this.match(h._in)?"ForInStatement":"ForOfStatement";return s?this.eatContextual("of"):this.next(),"ForOfStatement"===i&&(t.await=!!s),t.left=e,t.right=this.parseExpression(),this.expect(h.parenR),t.body=this.parseStatement(!1),this.state.labels.pop(),this.finishNode(t,i)},i.parseVar=function(t,e,s){var i=t.declarations=[];for(t.kind=s.keyword;;){var r=this.startNode();if(this.parseVarHead(r),this.eat(h.eq)?r.init=this.parseMaybeAssign(e):(s!==h._const||this.match(h._in)||this.isContextual("of")?"Identifier"===r.id.type||e&&(this.match(h._in)||this.isContextual("of"))||this.raise(this.state.lastTokEnd,"Complex binding patterns require an initialization value"):this.hasPlugin("typescript")||this.unexpected(),r.init=null),i.push(this.finishNode(r,"VariableDeclarator")),!this.eat(h.comma))break}return t},i.parseVarHead=function(t){t.id=this.parseBindingAtom(),this.checkLVal(t.id,!0,void 0,"variable declaration")},i.parseFunction=function(t,e,s,i,r){var a=this.state.inFunction,n=this.state.inMethod,o=this.state.inGenerator;return this.state.inFunction=!0,this.state.inMethod=!1,this.initFunction(t,i),this.match(h.star)&&(t.async&&this.expectPlugin("asyncGenerators"),t.generator=!0,this.next()),!e||r||this.match(h.name)||this.match(h._yield)||this.unexpected(),e||(this.state.inGenerator=t.generator),(this.match(h.name)||this.match(h._yield))&&(t.id=this.parseBindingIdentifier()),e&&(this.state.inGenerator=t.generator),this.parseFunctionParams(t),this.parseFunctionBodyAndFinish(t,e?"FunctionDeclaration":"FunctionExpression",s),this.state.inFunction=a,this.state.inMethod=n,this.state.inGenerator=o,t},i.parseFunctionParams=function(t,e){var s=this.state.inParameters;this.state.inParameters=!0,this.expect(h.parenL),t.params=this.parseBindingList(h.parenR,!1,e),this.state.inParameters=s},i.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")},i.isClassProperty=function(){return this.match(h.eq)||this.match(h.semi)||this.match(h.braceR)},i.isClassMethod=function(){return this.match(h.parenL)},i.isNonstaticConstructor=function(t){return!(t.computed||t.static||"constructor"!==t.key.name&&"constructor"!==t.key.value)},i.parseClassBody=function(t){var e=this.state.strict;this.state.strict=!0,this.state.classLevel++;var s={hadConstructor:!1},i=[],r=this.startNode();for(r.body=[],this.expect(h.braceL);!this.eat(h.braceR);)if(this.eat(h.semi))i.length>0&&this.raise(this.state.lastTokEnd,"Decorators must not be followed by a semicolon");else if(this.match(h.at))i.push(this.parseDecorator());else{var a=this.startNode();i.length&&(a.decorators=i,this.resetStartLocationFromNode(a,i[0]),i=[]),this.parseClassMember(r,a,s),this.hasPlugin("decorators2")&&-1===["method","get","set"].indexOf(a.kind)&&a.decorators&&a.decorators.length>0&&this.raise(a.start,"Stage 2 decorators may only be used with a class or a class method")}i.length&&this.raise(this.state.start,"You have trailing decorators with no method"),t.body=this.finishNode(r,"ClassBody"),this.state.classLevel--,this.state.strict=e},i.parseClassMember=function(t,e,s){var i=!1;if(this.match(h.name)&&"static"===this.state.value){var r=this.parseIdentifier(!0);if(this.isClassMethod()){var a=e;return a.kind="method",a.computed=!1,a.key=r,a.static=!1,void this.pushClassMethod(t,a,!1,!1,!1)}if(this.isClassProperty()){var n=e;return n.computed=!1,n.key=r,n.static=!1,void t.body.push(this.parseClassProperty(n))}i=!0}this.parseClassMemberWithIsStatic(t,e,s,i)},i.parseClassMemberWithIsStatic=function(t,e,s,i){var r=e,a=e,n=e,o=e,p=r,c=r;if(e.static=i,this.eat(h.star))return p.kind="method",this.parseClassPropertyName(p),"PrivateName"===p.key.type?void this.pushClassPrivateMethod(t,a,!0,!1):(this.isNonstaticConstructor(r)&&this.raise(r.key.start,"Constructor can't be a generator"),void this.pushClassMethod(t,r,!0,!1,!1));var l=this.parseClassPropertyName(e),u="PrivateName"===l.type,d="Identifier"===l.type;if(this.parsePostMemberNameModifiers(c),this.isClassMethod()){if(p.kind="method",u)return void this.pushClassPrivateMethod(t,a,!1,!1);var f=this.isNonstaticConstructor(r);f&&(r.kind="constructor",r.decorators&&this.raise(r.start,"You can't attach decorators to a class constructor"),s.hadConstructor&&!this.hasPlugin("typescript")&&this.raise(l.start,"Duplicate constructor in the same class"),s.hadConstructor=!0),this.pushClassMethod(t,r,!1,!1,f)}else if(this.isClassProperty())u?this.pushClassPrivateProperty(t,o):this.pushClassProperty(t,n);else if(d&&"async"===l.name&&!this.isLineTerminator()){var m=this.match(h.star);m&&(this.expectPlugin("asyncGenerators"),this.next()),p.kind="method",this.parseClassPropertyName(p),"PrivateName"===p.key.type?this.pushClassPrivateMethod(t,a,m,!0):(this.isNonstaticConstructor(r)&&this.raise(r.key.start,"Constructor can't be an async function"),this.pushClassMethod(t,r,m,!0,!1))}else!d||"get"!==l.name&&"set"!==l.name||this.isLineTerminator()&&this.match(h.star)?this.isLineTerminator()?u?this.pushClassPrivateProperty(t,o):this.pushClassProperty(t,n):this.unexpected():(p.kind=l.name,this.parseClassPropertyName(r),"PrivateName"===p.key.type?this.pushClassPrivateMethod(t,a,!1,!1):(this.isNonstaticConstructor(r)&&this.raise(r.key.start,"Constructor can't have get/set modifier"),this.pushClassMethod(t,r,!1,!1,!1)),this.checkGetterSetterParamCount(r))},i.parseClassPropertyName=function(t){var e=this.parsePropertyName(t);return t.computed||!t.static||"prototype"!==e.name&&"prototype"!==e.value||this.raise(e.start,"Classes may not have static property named prototype"),"PrivateName"===e.type&&"constructor"===e.id.name&&this.raise(e.start,"Classes may not have a private field named '#constructor'"),e},i.pushClassProperty=function(t,e){this.isNonstaticConstructor(e)&&this.raise(e.key.start,"Classes may not have a non-static field named 'constructor'"),t.body.push(this.parseClassProperty(e))},i.pushClassPrivateProperty=function(t,e){this.expectPlugin("classPrivateProperties",e.key.start),t.body.push(this.parseClassPrivateProperty(e))},i.pushClassMethod=function(t,e,s,i,r){t.body.push(this.parseMethod(e,s,i,r,"ClassMethod"))},i.pushClassPrivateMethod=function(t,e,s,i){this.expectPlugin("classPrivateMethods",e.key.start),t.body.push(this.parseMethod(e,s,i,!1,"ClassPrivateMethod"))},i.parsePostMemberNameModifiers=function(t){},i.parseAccessModifier=function(){},i.parseClassPrivateProperty=function(t){return this.state.inClassProperty=!0,t.value=this.eat(h.eq)?this.parseMaybeAssign():null,this.semicolon(),this.state.inClassProperty=!1,this.finishNode(t,"ClassPrivateProperty")},i.parseClassProperty=function(t){return t.typeAnnotation||this.expectPlugin("classProperties"),this.state.inClassProperty=!0,this.match(h.eq)?(this.expectPlugin("classProperties"),this.next(),t.value=this.parseMaybeAssign()):t.value=null,this.semicolon(),this.state.inClassProperty=!1,this.finishNode(t,"ClassProperty")},i.parseClassId=function(t,e,s){this.match(h.name)?t.id=this.parseIdentifier():s||!e?t.id=null:this.unexpected(null,"A class name is required")},i.parseClassSuper=function(t){t.superClass=this.eat(h._extends)?this.parseExprSubscripts():null},i.parseExport=function(t){if(this.shouldParseExportStar()){if(this.parseExportStar(t),"ExportAllDeclaration"===t.type)return t}else if(this.isExportDefaultSpecifier()){this.expectPlugin("exportDefaultFrom");var e=this.startNode();e.exported=this.parseIdentifier(!0);var s=[this.finishNode(e,"ExportDefaultSpecifier")];if(t.specifiers=s,this.match(h.comma)&&this.lookahead().type===h.star){this.expect(h.comma);var i=this.startNode();this.expect(h.star),this.expectContextual("as"),i.exported=this.parseIdentifier(),s.push(this.finishNode(i,"ExportNamespaceSpecifier"))}else this.parseExportSpecifiersMaybe(t);this.parseExportFrom(t,!0)}else{if(this.eat(h._default)){var r=this.startNode(),a=!1;return this.eat(h._function)?r=this.parseFunction(r,!0,!1,!1,!0):this.isContextual("async")&&this.lookahead().type===h._function?(this.eatContextual("async"),this.eat(h._function),r=this.parseFunction(r,!0,!1,!0,!0)):this.match(h._class)?r=this.parseClass(r,!0,!0):(a=!0,r=this.parseMaybeAssign()),t.declaration=r,a&&this.semicolon(),this.checkExport(t,!0,!0),this.finishNode(t,"ExportDefaultDeclaration")}if(this.shouldParseExportDeclaration()){if(this.isContextual("async")){var n=this.lookahead();n.type!==h._function&&this.unexpected(n.start,'Unexpected token, expected "function"')}t.specifiers=[],t.source=null,t.declaration=this.parseExportDeclaration(t)}else t.declaration=null,t.specifiers=this.parseExportSpecifiers(),this.parseExportFrom(t)}return this.checkExport(t,!0),this.finishNode(t,"ExportNamedDeclaration")},i.parseExportDeclaration=function(t){return this.parseStatement(!0)},i.isExportDefaultSpecifier=function(){if(this.match(h.name))return"async"!==this.state.value;if(!this.match(h._default))return!1;var t=this.lookahead();return t.type===h.comma||t.type===h.name&&"from"===t.value},i.parseExportSpecifiersMaybe=function(t){this.eat(h.comma)&&(t.specifiers=t.specifiers.concat(this.parseExportSpecifiers()))},i.parseExportFrom=function(t,e){this.eatContextual("from")?(t.source=this.match(h.string)?this.parseExprAtom():this.unexpected(),this.checkExport(t)):e?this.unexpected():t.source=null,this.semicolon()},i.shouldParseExportStar=function(){return this.match(h.star)},i.parseExportStar=function(t){this.expect(h.star),this.isContextual("as")?this.parseExportNamespace(t):(this.parseExportFrom(t,!0),this.finishNode(t,"ExportAllDeclaration"))},i.parseExportNamespace=function(t){this.expectPlugin("exportNamespaceFrom");var e=this.startNodeAt(this.state.lastTokStart,this.state.lastTokStartLoc);this.next(),e.exported=this.parseIdentifier(!0),t.specifiers=[this.finishNode(e,"ExportNamespaceSpecifier")],this.parseExportSpecifiersMaybe(t),this.parseExportFrom(t,!0)},i.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")||this.match(h.at)&&this.expectPlugin("decorators2")},i.checkExport=function(t,e,s){if(e)if(s)this.checkDuplicateExports(t,"default");else if(t.specifiers&&t.specifiers.length)for(var i=0,r=t.specifiers;i-1&&this.raiseDuplicateExportError(t,e),this.state.exportedIdentifiers.push(e)},i.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.`)},i.parseExportSpecifiers=function(){var t,e=[],s=!0;for(this.expect(h.braceL);!this.eat(h.braceR);){if(s)s=!1;else if(this.expect(h.comma),this.eat(h.braceR))break;var i=this.match(h._default);i&&!t&&(t=!0);var r=this.startNode();r.local=this.parseIdentifier(i),r.exported=this.eatContextual("as")?this.parseIdentifier(!0):r.local.__clone(),e.push(this.finishNode(r,"ExportSpecifier"))}return t&&!this.isContextual("from")&&this.unexpected(),e},i.parseImport=function(t){return this.match(h.string)?(t.specifiers=[],t.source=this.parseExprAtom()):(t.specifiers=[],this.parseImportSpecifiers(t),this.expectContextual("from"),t.source=this.match(h.string)?this.parseExprAtom():this.unexpected()),this.semicolon(),this.finishNode(t,"ImportDeclaration")},i.shouldParseDefaultImport=function(t){return this.match(h.name)},i.parseImportSpecifierLocal=function(t,e,s,i){e.local=this.parseIdentifier(),this.checkLVal(e.local,!0,void 0,i),t.specifiers.push(this.finishNode(e,s))},i.parseImportSpecifiers=function(t){var e=!0;if(!this.shouldParseDefaultImport(t)||(this.parseImportSpecifierLocal(t,this.startNode(),"ImportDefaultSpecifier","default import specifier"),this.eat(h.comma))){if(this.match(h.star)){var s=this.startNode();return this.next(),this.expectContextual("as"),void this.parseImportSpecifierLocal(t,s,"ImportNamespaceSpecifier","import namespace specifier")}for(this.expect(h.braceL);!this.eat(h.braceR);){if(e)e=!1;else if(this.eat(h.colon)&&this.unexpected(null,"ES2015 named imports do not destructure. Use another statement for destructuring after the import."),this.expect(h.comma),this.eat(h.braceR))break;this.parseImportSpecifier(t)}}},i.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}(function(t){function e(){return t.apply(this,arguments)||this}s(e,t);var i=e.prototype;return i.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)}},i.getExpression=function(){this.nextToken();var t=this.parseExpression();return this.match(h.eof)||this.unexpected(),t.comments=this.state.comments,t},i.parseExpression=function(t,e){var s=this.state.start,i=this.state.startLoc,r=this.parseMaybeAssign(t,e);if(this.match(h.comma)){var a=this.startNodeAt(s,i);for(a.expressions=[r];this.eat(h.comma);)a.expressions.push(this.parseMaybeAssign(t,e));return this.toReferencedList(a.expressions),this.finishNode(a,"SequenceExpression")}return r},i.parseMaybeAssign=function(t,e,s,i){var r,a=this.state.start,n=this.state.startLoc;if(this.match(h._yield)&&this.state.inGenerator){var o=this.parseYield();return s&&(o=s.call(this,o,a,n)),o}e?r=!1:(e={start:0},r=!0),(this.match(h.parenL)||this.match(h.name)||this.match(h._yield))&&(this.state.potentialArrowAt=this.state.start);var p=this.parseMaybeConditional(t,e,i);if(s&&(p=s.call(this,p,a,n)),this.state.type.isAssign){var c,l=this.startNodeAt(a,n);if(l.operator=this.state.value,l.left=this.match(h.eq)?this.toAssignable(p,void 0,"assignment expression"):p,e.start=0,this.checkLVal(p,void 0,void 0,"assignment expression"),p.extra&&p.extra.parenthesized)"ObjectPattern"===p.type?c="`({a}) = 0` use `({a} = 0)`":"ArrayPattern"===p.type&&(c="`([a]) = 0` use `([a] = 0)`"),c&&this.raise(p.start,`You're trying to assign to a parenthesized expression, eg. instead of ${c}`);return this.next(),l.right=this.parseMaybeAssign(t),this.finishNode(l,"AssignmentExpression")}return r&&e.start&&this.unexpected(e.start),p},i.parseMaybeConditional=function(t,e,s){var i=this.state.start,r=this.state.startLoc,a=this.state.potentialArrowAt,n=this.parseExprOps(t,e);return"ArrowFunctionExpression"===n.type&&n.start===a?n:e&&e.start?n:this.parseConditional(n,t,i,r,s)},i.parseConditional=function(t,e,s,i,r){if(this.eat(h.question)){var a=this.startNodeAt(s,i);return a.test=t,a.consequent=this.parseMaybeAssign(),this.expect(h.colon),a.alternate=this.parseMaybeAssign(e),this.finishNode(a,"ConditionalExpression")}return t},i.parseExprOps=function(t,e){var s=this.state.start,i=this.state.startLoc,r=this.state.potentialArrowAt,a=this.parseMaybeUnary(e);return"ArrowFunctionExpression"===a.type&&a.start===r?a:e&&e.start?a:this.parseExprOp(a,s,i,-1,t)},i.parseExprOp=function(t,e,s,i,r){var a=this.state.type.binop;if(!(null==a||r&&this.match(h._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 p=this.state.start,c=this.state.startLoc;return"|>"===n.operator&&(this.expectPlugin("pipelineOperator"),this.state.potentialArrowAt=p),"??"===n.operator&&this.expectPlugin("nullishCoalescingOperator"),n.right=this.parseExprOp(this.parseMaybeUnary(),p,c,o.rightAssociative?a-1:a,r),this.finishNode(n,o===h.logicalOR||o===h.logicalAND||o===h.nullishCoalescing?"LogicalExpression":"BinaryExpression"),this.parseExprOp(n,e,s,i,r)}return t},i.parseMaybeUnary=function(t){if(this.state.type.prefix){var e=this.startNode(),s=this.match(h.incDec);e.operator=this.state.value,e.prefix=!0,"throw"===e.operator&&this.expectPlugin("throwExpressions"),this.next();var i=this.state.type;if(e.argument=this.parseMaybeUnary(),this.addExtra(e,"parenthesizedArgument",!(i!==h.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");else if(this.state.strict&&"delete"===e.operator){var r=e.argument;"Identifier"===r.type?this.raise(e.start,"Deleting local variable in strict mode"):"MemberExpression"===r.type&&"PrivateName"===r.property.type&&this.raise(e.start,"Deleting a private field is not allowed")}return this.finishNode(e,s?"UpdateExpression":"UnaryExpression")}var a=this.state.start,n=this.state.startLoc,o=this.parseExprSubscripts(t);if(t&&t.start)return o;for(;this.state.type.postfix&&!this.canInsertSemicolon();){var p=this.startNodeAt(a,n);p.operator=this.state.value,p.prefix=!1,p.argument=o,this.checkLVal(o,void 0,void 0,"postfix operation"),this.next(),o=this.finishNode(p,"UpdateExpression")}return o},i.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)},i.parseSubscripts=function(t,e,s,i){var r={stop:!1};do{t=this.parseSubscript(t,e,s,i,r)}while(!r.stop);return t},i.parseSubscript=function(t,e,s,i,r){if(!i&&this.eat(h.doubleColon)){var a=this.startNodeAt(e,s);return a.object=t,a.callee=this.parseNoCallExpr(),r.stop=!0,this.parseSubscripts(this.finishNode(a,"BindExpression"),e,s,i)}if(this.match(h.questionDot)){if(this.expectPlugin("optionalChaining"),i&&this.lookahead().type==h.parenL)return r.stop=!0,t;this.next();var n=this.startNodeAt(e,s);if(this.eat(h.bracketL))return n.object=t,n.property=this.parseExpression(),n.computed=!0,n.optional=!0,this.expect(h.bracketR),this.finishNode(n,"MemberExpression");if(this.eat(h.parenL)){var o=this.atPossibleAsync(t);return n.callee=t,n.arguments=this.parseCallExpressionArguments(h.parenR,o),n.optional=!0,this.finishNode(n,"CallExpression")}return n.object=t,n.property=this.parseIdentifier(!0),n.computed=!1,n.optional=!0,this.finishNode(n,"MemberExpression")}if(this.eat(h.dot)){var p=this.startNodeAt(e,s);return p.object=t,p.property=this.parseMaybePrivateName(),p.computed=!1,this.finishNode(p,"MemberExpression")}if(this.eat(h.bracketL)){var c=this.startNodeAt(e,s);return c.object=t,c.property=this.parseExpression(),c.computed=!0,this.expect(h.bracketR),this.finishNode(c,"MemberExpression")}if(!i&&this.match(h.parenL)){var l=this.atPossibleAsync(t);this.next();var u=this.startNodeAt(e,s);u.callee=t;var d={start:-1};return u.arguments=this.parseCallExpressionArguments(h.parenR,l,d),this.finishCallExpression(u),l&&this.shouldParseAsyncArrow()?(r.stop=!0,d.start>-1&&this.raise(d.start,"A trailing comma is not permitted after the rest element"),this.parseAsyncArrowFromCallExpression(this.startNodeAt(e,s),u)):(this.toReferencedList(u.arguments),u)}if(this.match(h.backQuote)){var f=this.startNodeAt(e,s);return f.tag=t,f.quasi=this.parseTemplate(!0),this.finishNode(f,"TaggedTemplateExpression")}return r.stop=!0,t},i.atPossibleAsync=function(t){return this.state.potentialArrowAt===t.start&&"Identifier"===t.type&&"async"===t.name&&!this.canInsertSemicolon()},i.finishCallExpression=function(t){if("Import"===t.callee.type){1!==t.arguments.length&&this.raise(t.start,"import() requires exactly one argument");var e=t.arguments[0];e&&"SpreadElement"===e.type&&this.raise(e.start,"... is not allowed in import()")}return this.finishNode(t,"CallExpression")},i.parseCallExpressionArguments=function(t,e,s){for(var i,r=[],a=!0;!this.eat(t);){if(a)a=!1;else if(this.expect(h.comma),this.eat(t))break;this.match(h.parenL)&&!i&&(i=this.state.start),r.push(this.parseExprListItem(!1,e?{start:0}:void 0,e?{start:0}:void 0,e?s:void 0))}return e&&i&&this.shouldParseAsyncArrow()&&this.unexpected(),r},i.shouldParseAsyncArrow=function(){return this.match(h.arrow)},i.parseAsyncArrowFromCallExpression=function(t,e){var s=this.state.yieldInPossibleArrowParameters;return this.state.yieldInPossibleArrowParameters=null,this.expect(h.arrow),this.parseArrowExpression(t,e.arguments,!0),this.state.yieldInPossibleArrowParameters=s,t},i.parseNoCallExpr=function(){var t=this.state.start,e=this.state.startLoc;return this.parseSubscripts(this.parseExprAtom(),t,e,!0)},i.parseExprAtom=function(t){var e,s=this.state.potentialArrowAt===this.state.start;switch(this.state.type){case h._super:return this.state.inMethod||this.state.inClassProperty||this.options.allowSuperOutsideMethod||this.raise(this.state.start,"super is only allowed in object methods and classes"),e=this.startNode(),this.next(),this.match(h.parenL)||this.match(h.bracketL)||this.match(h.dot)||this.unexpected(),this.match(h.parenL)&&"constructor"!==this.state.inMethod&&!this.options.allowSuperOutsideMethod&&this.raise(e.start,"super() is only valid inside a class constructor. Make sure the method name is spelled exactly as 'constructor'."),this.finishNode(e,"Super");case h._import:return this.lookahead().type===h.dot?this.parseImportMetaProperty():(this.expectPlugin("dynamicImport"),e=this.startNode(),this.next(),this.match(h.parenL)||this.unexpected(null,h.parenL),this.finishNode(e,"Import"));case h._this:return e=this.startNode(),this.next(),this.finishNode(e,"ThisExpression");case h._yield:this.state.inGenerator&&this.unexpected();case h.name:e=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(e)}else{if("async"===a.name&&this.match(h._function)&&!this.canInsertSemicolon())return this.next(),this.parseFunction(e,!1,!1,!0);if(s&&"async"===a.name&&this.match(h.name)){var n=this.state.yieldInPossibleArrowParameters;this.state.yieldInPossibleArrowParameters=null;var o=[this.parseIdentifier()];return this.expect(h.arrow),this.parseArrowExpression(e,o,!0),this.state.yieldInPossibleArrowParameters=n,e}}if(s&&!this.canInsertSemicolon()&&this.eat(h.arrow)){var p=this.state.yieldInPossibleArrowParameters;return this.state.yieldInPossibleArrowParameters=null,this.parseArrowExpression(e,[a]),this.state.yieldInPossibleArrowParameters=p,e}return a;case h._do:this.expectPlugin("doExpressions");var c=this.startNode();this.next();var l=this.state.inFunction,u=this.state.labels;return this.state.labels=[],this.state.inFunction=!1,c.body=this.parseBlock(!1),this.state.inFunction=l,this.state.labels=u,this.finishNode(c,"DoExpression");case h.regexp:var d=this.state.value;return(e=this.parseLiteral(d.value,"RegExpLiteral")).pattern=d.pattern,e.flags=d.flags,e;case h.num:return this.parseLiteral(this.state.value,"NumericLiteral");case h.bigint:return this.parseLiteral(this.state.value,"BigIntLiteral");case h.string:return this.parseLiteral(this.state.value,"StringLiteral");case h._null:return e=this.startNode(),this.next(),this.finishNode(e,"NullLiteral");case h._true:case h._false:return this.parseBooleanLiteral();case h.parenL:return this.parseParenAndDistinguishExpression(s);case h.bracketL:return e=this.startNode(),this.next(),e.elements=this.parseExprList(h.bracketR,!0,t),this.toReferencedList(e.elements),this.finishNode(e,"ArrayExpression");case h.braceL:return this.parseObj(!1,t);case h._function:return this.parseFunctionExpression();case h.at:this.parseDecorators();case h._class:return e=this.startNode(),this.takeDecorators(e),this.parseClass(e,!1);case h._new:return this.parseNew();case h.backQuote:return this.parseTemplate(!1);case h.doubleColon:e=this.startNode(),this.next(),e.object=null;var f=e.callee=this.parseNoCallExpr();if("MemberExpression"===f.type)return this.finishNode(e,"BindExpression");throw this.raise(f.start,"Binding should be performed on object property.");default:throw this.unexpected()}},i.parseBooleanLiteral=function(){var t=this.startNode();return t.value=this.match(h._true),this.next(),this.finishNode(t,"BooleanLiteral")},i.parseMaybePrivateName=function(){if(this.match(h.hash)){this.expectOnePlugin(["classPrivateProperties","classPrivateMethods"]);var t=this.startNode();return this.next(),t.id=this.parseIdentifier(!0),this.finishNode(t,"PrivateName")}return this.parseIdentifier(!0)},i.parseFunctionExpression=function(){var t=this.startNode(),e=this.parseIdentifier(!0);return this.state.inGenerator&&this.eat(h.dot)?this.parseMetaProperty(t,e,"sent"):this.parseFunction(t,!1)},i.parseMetaProperty=function(t,e,s){return t.meta=e,"function"===e.name&&"sent"===s&&(this.isContextual(s)?this.expectPlugin("functionSent"):this.hasPlugin("functionSent")||this.unexpected()),t.property=this.parseIdentifier(!0),t.property.name!==s&&this.raise(t.property.start,`The only valid meta property for ${e.name} is ${e.name}.${s}`),this.finishNode(t,"MetaProperty")},i.parseImportMetaProperty=function(){var t=this.startNode(),e=this.parseIdentifier(!0);return this.expect(h.dot),"import"===e.name&&(this.isContextual("meta")?this.expectPlugin("importMeta"):this.hasPlugin("importMeta")||this.raise(e.start,"Dynamic imports require a parameter: import('a.js').then")),this.inModule||this.raise(e.start,"import.meta may appear only with 'sourceType: \"module\"'"),this.parseMetaProperty(t,e,"meta")},i.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)},i.parseParenExpression=function(){this.expect(h.parenL);var t=this.parseExpression();return this.expect(h.parenR),t},i.parseParenAndDistinguishExpression=function(t){var e,s=this.state.start,i=this.state.startLoc;this.expect(h.parenL);var r=this.state.maybeInArrowParameters,a=this.state.yieldInPossibleArrowParameters;this.state.maybeInArrowParameters=!0,this.state.yieldInPossibleArrowParameters=null;for(var n,o,p=this.state.start,c=this.state.startLoc,l=[],u={start:0},d={start:0},f=!0;!this.match(h.parenR);){if(f)f=!1;else if(this.expect(h.comma,d.start||null),this.match(h.parenR)){o=this.state.start;break}if(this.match(h.ellipsis)){var m=this.state.start,y=this.state.startLoc;n=this.state.start,l.push(this.parseParenItem(this.parseRest(),m,y)),this.match(h.comma)&&this.lookahead().type===h.parenR&&this.raise(this.state.start,"A trailing comma is not permitted after the rest element");break}l.push(this.parseMaybeAssign(!1,u,this.parseParenItem,d))}var x=this.state.start,P=this.state.startLoc;this.expect(h.parenR),this.state.maybeInArrowParameters=r;var v=this.startNodeAt(s,i);if(t&&this.shouldParseArrow()&&(v=this.parseArrow(v))){for(var g=0;g1?((e=this.startNodeAt(p,c)).expressions=l,this.toReferencedList(e.expressions),this.finishNodeAt(e,"SequenceExpression",x,P)):e=l[0],this.addExtra(e,"parenthesized",!0),this.addExtra(e,"parenStart",s),e},i.shouldParseArrow=function(){return!this.canInsertSemicolon()},i.parseArrow=function(t){if(this.eat(h.arrow))return t},i.parseParenItem=function(t,e,s){return t},i.parseNew=function(){var t=this.startNode(),e=this.parseIdentifier(!0);if(this.eat(h.dot)){var s=this.parseMetaProperty(t,e,"target");if(!this.state.inFunction&&!this.state.inClassProperty){var i="new.target can only be used in functions";this.hasPlugin("classProperties")&&(i+=" or class properties"),this.raise(s.start,i)}return s}return t.callee=this.parseNoCallExpr(),this.eat(h.questionDot)&&(t.optional=!0),this.parseNewArguments(t),this.finishNode(t,"NewExpression")},i.parseNewArguments=function(t){if(this.eat(h.parenL)){var e=this.parseExprList(h.parenR);this.toReferencedList(e),t.arguments=e}else t.arguments=[]},i.parseTemplateElement=function(t){var e=this.startNode();return null===this.state.value&&(t?this.state.invalidTemplateEscapePosition=null:this.raise(this.state.invalidTemplateEscapePosition||0,"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(h.backQuote),this.finishNode(e,"TemplateElement")},i.parseTemplate=function(t){var e=this.startNode();this.next(),e.expressions=[];var s=this.parseTemplateElement(t);for(e.quasis=[s];!s.tail;)this.expect(h.dollarBraceL),e.expressions.push(this.parseExpression()),this.expect(h.braceR),e.quasis.push(s=this.parseTemplateElement(t));return this.next(),this.finishNode(e,"TemplateLiteral")},i.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(h.braceR);){if(r)r=!1;else if(this.expect(h.comma),this.eat(h.braceR))break;if(this.match(h.at))if(this.hasPlugin("decorators2"))this.raise(this.state.start,"Stage 2 decorators disallow object literal property decorators");else for(;this.match(h.at);)s.push(this.parseDecorator());var o=this.startNode(),p=!1,c=!1,l=void 0,u=void 0;if(s.length&&(o.decorators=s,s=[]),this.match(h.ellipsis)){if(this.expectPlugin("objectRestSpread"),o=this.parseSpread(t?{start:0}:void 0),t&&this.toAssignable(o,!0,"object pattern"),a.properties.push(o),!t)continue;var d=this.state.start;if(null!==n)this.unexpected(n,"Cannot have multiple rest elements when destructuring");else{if(this.eat(h.braceR))break;if(!this.match(h.comma)||this.lookahead().type!==h.braceR){n=d;continue}this.unexpected(d,"A trailing comma is not permitted after the rest element")}}if(o.method=!1,(t||e)&&(l=this.state.start,u=this.state.startLoc),t||(p=this.eat(h.star)),!t&&this.isContextual("async")){p&&this.unexpected();var f=this.parseIdentifier();this.match(h.colon)||this.match(h.parenL)||this.match(h.braceR)||this.match(h.eq)||this.match(h.comma)?(o.key=f,o.computed=!1):(c=!0,this.match(h.star)&&(this.expectPlugin("asyncGenerators"),this.next(),p=!0),this.parsePropertyName(o))}else this.parsePropertyName(o);this.parseObjPropValue(o,l,u,p,c,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")},i.isGetterOrSetterMethod=function(t,e){return!e&&!t.computed&&"Identifier"===t.key.type&&("get"===t.key.name||"set"===t.key.name)&&(this.match(h.string)||this.match(h.num)||this.match(h.bracketL)||this.match(h.name)||!!this.state.type.keyword)},i.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")}},i.parseObjectMethod=function(t,e,s,i){return s||e||this.match(h.parenL)?(i&&this.unexpected(),t.kind="method",t.method=!0,this.parseMethod(t,e,s,!1,"ObjectMethod")):this.isGetterOrSetterMethod(t,i)?((e||s)&&this.unexpected(),t.kind=t.key.name,this.parsePropertyName(t),this.parseMethod(t,!1,!1,!1,"ObjectMethod"),this.checkGetterSetterParamCount(t),t):void 0},i.parseObjectProperty=function(t,e,s,i,r){return t.shorthand=!1,this.eat(h.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(h.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"))},i.parseObjPropValue=function(t,e,s,i,r,a,n){var o=this.parseObjectMethod(t,i,r,a)||this.parseObjectProperty(t,e,s,a,n);return o||this.unexpected(),o},i.parsePropertyName=function(t){if(this.eat(h.bracketL))t.computed=!0,t.key=this.parseMaybeAssign(),this.expect(h.bracketR);else{var e=this.state.inPropertyName;this.state.inPropertyName=!0,t.key=this.match(h.num)||this.match(h.string)?this.parseExprAtom():this.parseMaybePrivateName(),"PrivateName"!==t.key.type&&(t.computed=!1),this.state.inPropertyName=e}return t.key},i.initFunction=function(t,e){t.id=null,t.generator=!1,t.async=!!e},i.parseMethod=function(t,e,s,i,r){var a=this.state.inFunction,n=this.state.inMethod,o=this.state.inGenerator;this.state.inFunction=!0,this.state.inMethod=t.kind||!0,this.state.inGenerator=e,this.initFunction(t,s),t.generator=!!e;var h=i;return this.parseFunctionParams(t,h),this.parseFunctionBodyAndFinish(t,r),this.state.inFunction=a,this.state.inMethod=n,this.state.inGenerator=o,t},i.parseArrowExpression=function(t,e,s){this.state.yieldInPossibleArrowParameters&&this.raise(this.state.yieldInPossibleArrowParameters.start,"yield is not allowed in the parameters of an arrow function inside a generator");var i=this.state.inFunction;this.state.inFunction=!0,this.initFunction(t,s),e&&this.setArrowFunctionParameters(t,e);var r=this.state.inGenerator,a=this.state.maybeInArrowParameters;return this.state.inGenerator=!1,this.state.maybeInArrowParameters=!1,this.parseFunctionBody(t,!0),this.state.inGenerator=r,this.state.inFunction=i,this.state.maybeInArrowParameters=a,this.finishNode(t,"ArrowFunctionExpression")},i.setArrowFunctionParameters=function(t,e){t.params=this.toAssignableList(e,!0,"arrow function parameters")},i.isStrictBody=function(t){if("BlockStatement"===t.body.type&&t.body.directives.length)for(var e=0,s=t.body.directives;e",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:"♦"},Q=/^[\da-fA-F]+$/,Y=/^\d+$/;function Z(t){return!!t&&("JSXOpeningFragment"===t.type||"JSXClosingFragment"===t.type)}function tt(t){if("JSXIdentifier"===t.type)return t.name;if("JSXNamespacedName"===t.type)return t.namespace.name+":"+t.name.name;if("JSXMemberExpression"===t.type)return tt(t.object)+"."+tt(t.property);throw new Error("Node had unexpected type: "+t.type)}E.j_oTag=new C("...",!0,!0),h.jsxName=new a("jsxName"),h.jsxText=new a("jsxText",{beforeExpr:!0}),h.jsxTagStart=new a("jsxTagStart",{startsExpr:!0}),h.jsxTagEnd=new a("jsxTagEnd"),h.jsxTagStart.updateContext=function(){this.state.context.push(E.j_expr),this.state.context.push(E.j_oTag),this.state.exprAllowed=!1},h.jsxTagEnd.updateContext=function(t){var e=this.state.context.pop();e===E.j_oTag&&t===h.slash||e===E.j_cTag?(this.state.context.pop(),this.state.exprAllowed=this.curContext()===E.j_expr):this.state.exprAllowed=!0};function et(t){if(null==t)throw new Error(`Unexpected ${t} value.`);return t}function st(t){if(!t)throw new Error("Assert fail")}function it(t,e){return new(t&&t.plugins?function(t){if(t.indexOf("decorators")>=0&&t.indexOf("decorators2")>=0)throw new Error("Cannot use decorators and decorators2 plugin together");var e=t.filter(function(t){return"estree"===t||"flow"===t||"jsx"===t||"typescript"===t});e.indexOf("flow")>=0&&(e=e.filter(function(t){return"flow"!==t})).push("flow");if(e.indexOf("flow")>=0&&e.indexOf("typescript")>=0)throw new Error("Cannot combine flow and typescript plugins.");e.indexOf("typescript")>=0&&(e=e.filter(function(t){return"typescript"!==t})).push("typescript");e.indexOf("estree")>=0&&(e=e.filter(function(t){return"estree"!==t})).unshift("estree");var s=e.join("/"),i=rt[s];if(!i){i=W;for(var r=0,a=e;r0)for(var e=0,s=t.body.body;e-1&&this.raise(e,`Cannot overwrite primitive type ${t}`)},i.flowParseRestrictedIdentifier=function(t){return this.checkReservedType(this.state.value,this.state.start),this.parseIdentifier(t)},i.flowParseTypeAlias=function(t){return t.id=this.flowParseRestrictedIdentifier(),this.isRelational("<")?t.typeParameters=this.flowParseTypeParameterDeclaration():t.typeParameters=null,t.right=this.flowParseTypeInitialiser(h.eq),this.semicolon(),this.finishNode(t,"TypeAlias")},i.flowParseOpaqueType=function(t,e){return this.expectContextual("type"),t.id=this.flowParseRestrictedIdentifier(!0),this.isRelational("<")?t.typeParameters=this.flowParseTypeParameterDeclaration():t.typeParameters=null,t.supertype=null,this.match(h.colon)&&(t.supertype=this.flowParseTypeInitialiser(h.colon)),t.impltype=null,e||(t.impltype=this.flowParseTypeInitialiser(h.eq)),this.semicolon(),this.finishNode(t,"OpaqueType")},i.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(h.eq)&&(this.eat(h.eq),t.default=this.flowParseType()),this.finishNode(t,"TypeParameter")},i.flowParseTypeParameterDeclaration=function(){var t=this.state.inType,e=this.startNode();e.params=[],this.state.inType=!0,this.isRelational("<")||this.match(h.jsxTagStart)?this.next():this.unexpected();do{e.params.push(this.flowParseTypeParameter()),this.isRelational(">")||this.expect(h.comma)}while(!this.isRelational(">"));return this.expectRelational(">"),this.state.inType=t,this.finishNode(e,"TypeParameterDeclaration")},i.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(h.comma);return this.expectRelational(">"),this.state.inType=e,this.finishNode(t,"TypeParameterInstantiation")},i.flowParseObjectPropertyKey=function(){return this.match(h.num)||this.match(h.string)?this.parseExprAtom():this.parseIdentifier(!0)},i.flowParseObjectTypeIndexer=function(t,e,s){return t.static=e,this.expect(h.bracketL),this.lookahead().type===h.colon?(t.id=this.flowParseObjectPropertyKey(),t.key=this.flowParseTypeInitialiser()):(t.id=null,t.key=this.flowParseType()),this.expect(h.bracketR),t.value=this.flowParseTypeInitialiser(),t.variance=s,this.finishNode(t,"ObjectTypeIndexer")},i.flowParseObjectTypeMethodish=function(t){for(t.params=[],t.rest=null,t.typeParameters=null,this.isRelational("<")&&(t.typeParameters=this.flowParseTypeParameterDeclaration()),this.expect(h.parenL);!this.match(h.parenR)&&!this.match(h.ellipsis);)t.params.push(this.flowParseFunctionTypeParam()),this.match(h.parenR)||this.expect(h.comma);return this.eat(h.ellipsis)&&(t.rest=this.flowParseFunctionTypeParam()),this.expect(h.parenR),t.returnType=this.flowParseTypeInitialiser(),this.finishNode(t,"FunctionTypeAnnotation")},i.flowParseObjectTypeCallProperty=function(t,e){var s=this.startNode();return t.static=e,t.value=this.flowParseObjectTypeMethodish(s),this.finishNode(t,"ObjectTypeCallProperty")},i.flowParseObjectType=function(t,e,s){var i=this.state.inType;this.state.inType=!0;var r,a,n=this.startNode();for(n.callProperties=[],n.properties=[],n.indexers=[],e&&this.match(h.braceBarL)?(this.expect(h.braceBarL),r=h.braceBarR,a=!0):(this.expect(h.braceL),r=h.braceR,a=!1),n.exact=a;!this.match(r);){var o=!1,p=this.startNode();t&&this.isContextual("static")&&this.lookahead().type!==h.colon&&(this.next(),o=!0);var c=this.flowParseVariance();if(this.match(h.bracketL))n.indexers.push(this.flowParseObjectTypeIndexer(p,o,c));else if(this.match(h.parenL)||this.isRelational("<"))c&&this.unexpected(c.start),n.callProperties.push(this.flowParseObjectTypeCallProperty(p,o));else{var l="init";if(this.isContextual("get")||this.isContextual("set")){var u=this.lookahead();u.type!==h.name&&u.type!==h.string&&u.type!==h.num||(l=this.state.value,this.next())}n.properties.push(this.flowParseObjectTypeProperty(p,o,c,l,s))}this.flowObjectTypeSemicolon()}this.expect(r);var d=this.finishNode(n,"ObjectTypeAnnotation");return this.state.inType=i,d},i.flowParseObjectTypeProperty=function(t,e,s,i,r){if(this.match(h.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(h.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(h.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(h.question)&&(a=!0),t.value=this.flowParseTypeInitialiser(),t.variance=s),t.optional=a,this.finishNode(t,"ObjectTypeProperty")},i.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")}},i.flowObjectTypeSemicolon=function(){this.eat(h.semi)||this.eat(h.comma)||this.match(h.braceR)||this.match(h.braceBarR)||this.unexpected()},i.flowParseQualifiedTypeIdentifier=function(t,e,s){t=t||this.state.start,e=e||this.state.startLoc;for(var i=s||this.parseIdentifier();this.eat(h.dot);){var r=this.startNodeAt(t,e);r.qualification=i,r.id=this.parseIdentifier(),i=this.finishNode(r,"QualifiedTypeIdentifier")}return i},i.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")},i.flowParseTypeofType=function(){var t=this.startNode();return this.expect(h._typeof),t.argument=this.flowParsePrimaryType(),this.finishNode(t,"TypeofTypeAnnotation")},i.flowParseTupleType=function(){var t=this.startNode();for(t.types=[],this.expect(h.bracketL);this.state.pos0){var P=c.concat();if(x.length>0){this.state=p,this.state.noArrowAt=P;for(var v=0;v1&&this.raise(p.start,"Ambiguous expression: wrap the arrow functions in parentheses to disambiguate."),f&&1===y.length){this.state=p,this.state.noArrowAt=P.concat(y[0].start);var T=this.tryParseConditionalConsequent();d=T.consequent,f=T.failed}this.getArrowLikeExpressions(d,!0)}return this.state.noArrowAt=c,this.expect(h.colon),l.test=e,l.consequent=d,l.alternate=this.forwardNoArrowParamsConversionAt(l,function(){return n.parseMaybeAssign(s,void 0,void 0,void 0)}),this.finishNode(l,"ConditionalExpression")},i.tryParseConditionalConsequent=function(){this.state.noArrowParamsConversionAt.push(this.state.start);var t=this.parseMaybeAssign(),e=!this.match(h.colon);return this.state.noArrowParamsConversionAt.pop(),{consequent:t,failed:e}},i.getArrowLikeExpressions=function(e,s){for(var i=this,r=[e],a=[];0!==r.length;){var n=r.pop();"ArrowFunctionExpression"===n.type?(n.typeParameters||!n.returnType?(this.toAssignableList(n.params,!0,"arrow function parameters"),t.prototype.checkFunctionNameAndParams.call(this,n,!0)):a.push(n),r.push(n.body)):"ConditionalExpression"===n.type&&(r.push(n.consequent),r.push(n.alternate))}if(s){for(var o=0;o=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(h.jsxTagStart)):this.getTokenFromCode(s):(t+=this.input.slice(e,this.state.pos),this.finishToken(h.jsxText,t));case 38:t+=this.input.slice(e,this.state.pos),t+=this.jsxReadEntity(),e=this.state.pos;break;default:A(s)?(t+=this.input.slice(e,this.state.pos),t+=this.jsxReadNewLine(!0),e=this.state.pos):++this.state.pos}}},i.jsxReadNewLine=function(t){var e,s=this.input.charCodeAt(this.state.pos);return++this.state.pos,13===s&&10===this.input.charCodeAt(this.state.pos)?(++this.state.pos,e=t?"\n":"\r\n"):e=String.fromCharCode(s),++this.state.curLine,this.state.lineStart=this.state.pos,e},i.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):A(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(h.string,e)},i.jsxReadEntity=function(){for(var t,e="",s=0,i=this.input[this.state.pos],r=++this.state.pos;this.state.pos"):!Z(r)&&Z(a)?this.raise(a.start,"Expected corresponding JSX closing tag for <"+tt(r.name)+">"):Z(r)||Z(a)||tt(a.name)!==tt(r.name)&&this.raise(a.start,"Expected corresponding JSX closing tag for <"+tt(r.name)+">")}return Z(r)?(s.openingFragment=r,s.closingFragment=a):(s.openingElement=r,s.closingElement=a),s.children=i,this.match(h.relational)&&"<"===this.state.value&&this.raise(this.state.start,"Adjacent JSX elements must be wrapped in an enclosing tag"),Z(r)?this.finishNode(s,"JSXFragment"):this.finishNode(s,"JSXElement")},i.jsxParseElement=function(){var t=this.state.start,e=this.state.startLoc;return this.next(),this.jsxParseElementAt(t,e)},i.parseExprAtom=function(e){return this.match(h.jsxText)?this.parseLiteral(this.state.value,"JSXText"):this.match(h.jsxTagStart)?this.jsxParseElement():t.prototype.parseExprAtom.call(this,e)},i.readToken=function(e){if(this.state.inPropertyName)return t.prototype.readToken.call(this,e);var s=this.curContext();if(s===E.j_expr)return this.jsxReadToken();if(s===E.j_oTag||s===E.j_cTag){if(g(e))return this.jsxReadWord();if(62===e)return++this.state.pos,this.finishToken(h.jsxTagEnd);if((34===e||39===e)&&s===E.j_oTag)return this.jsxReadString(e)}return 60===e&&this.state.exprAllowed?(++this.state.pos,this.finishToken(h.jsxTagStart)):t.prototype.readToken.call(this,e)},i.updateContext=function(e){if(this.match(h.braceL)){var s=this.curContext();s===E.j_oTag?this.state.context.push(E.braceExpression):s===E.j_expr?this.state.context.push(E.templateQuasi):t.prototype.updateContext.call(this,e),this.state.exprAllowed=!0}else{if(!this.match(h.slash)||e!==h.jsxTagStart)return t.prototype.updateContext.call(this,e);this.state.context.length-=2,this.state.context.push(E.j_cTag),this.state.exprAllowed=!1}},e}(t)},K.typescript=function(t){return function(t){function e(){return t.apply(this,arguments)||this}s(e,t);var i=e.prototype;return i.tsIsIdentifier=function(){return this.match(h.name)},i.tsNextTokenCanFollowModifier=function(){return this.next(),!(this.hasPrecedingLineBreak()||this.match(h.parenL)||this.match(h.colon)||this.match(h.eq)||this.match(h.question))},i.tsParseModifier=function(t){if(this.match(h.name)){var e=this.state.value;return-1!==t.indexOf(e)&&this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))?e:void 0}},i.tsIsListTerminator=function(t){switch(t){case"EnumMembers":case"TypeMembers":return this.match(h.braceR);case"HeritageClauseElement":return this.match(h.braceL);case"TupleElementTypes":return this.match(h.bracketR);case"TypeParametersOrArguments":return this.isRelational(">")}throw new Error("Unreachable")},i.tsParseList=function(t,e){for(var s=[];!this.tsIsListTerminator(t);)s.push(e());return s},i.tsParseDelimitedList=function(t,e){return et(this.tsParseDelimitedListWorker(t,e,!0))},i.tsTryParseDelimitedList=function(t,e){return this.tsParseDelimitedListWorker(t,e,!1)},i.tsParseDelimitedListWorker=function(t,e,s){for(var i=[];!this.tsIsListTerminator(t);){var r=e();if(null==r)return;if(i.push(r),!this.eat(h.comma)){if(this.tsIsListTerminator(t))break;return void(s&&this.expect(h.comma))}}return i},i.tsParseBracketedList=function(t,e,s,i){i||(s?this.expect(h.bracketL):this.expectRelational("<"));var r=this.tsParseDelimitedList(t,e);return s?this.expect(h.bracketR):this.expectRelational(">"),r},i.tsParseEntityName=function(t){for(var e=this.parseIdentifier();this.eat(h.dot);){var s=this.startNodeAtNode(e);s.left=e,s.right=this.parseIdentifier(t),e=this.finishNode(s,"TSQualifiedName")}return e},i.tsParseTypeReference=function(){var t=this.startNode();return t.typeName=this.tsParseEntityName(!1),!this.hasPrecedingLineBreak()&&this.isRelational("<")&&(t.typeParameters=this.tsParseTypeArguments()),this.finishNode(t,"TSTypeReference")},i.tsParseThisTypePredicate=function(t){this.next();var e=this.startNode();return e.parameterName=t,e.typeAnnotation=this.tsParseTypeAnnotation(!1),this.finishNode(e,"TSTypePredicate")},i.tsParseThisTypeNode=function(){var t=this.startNode();return this.next(),this.finishNode(t,"TSThisType")},i.tsParseTypeQuery=function(){var t=this.startNode();return this.expect(h._typeof),t.exprName=this.tsParseEntityName(!0),this.finishNode(t,"TSTypeQuery")},i.tsParseTypeParameter=function(){var t=this.startNode();return t.name=this.parseIdentifierName(t.start),this.eat(h._extends)&&(t.constraint=this.tsParseType()),this.eat(h.eq)&&(t.default=this.tsParseType()),this.finishNode(t,"TSTypeParameter")},i.tsTryParseTypeParameters=function(){if(this.isRelational("<"))return this.tsParseTypeParameters()},i.tsParseTypeParameters=function(){var t=this.startNode();return this.isRelational("<")||this.match(h.jsxTagStart)?this.next():this.unexpected(),t.params=this.tsParseBracketedList("TypeParametersOrArguments",this.tsParseTypeParameter.bind(this),!1,!0),this.finishNode(t,"TSTypeParameterDeclaration")},i.tsFillSignature=function(t,e){var s=t===h.arrow;e.typeParameters=this.tsTryParseTypeParameters(),this.expect(h.parenL),e.parameters=this.tsParseBindingListForSignature(),s?e.typeAnnotation=this.tsParseTypeOrTypePredicateAnnotation(t):this.match(t)&&(e.typeAnnotation=this.tsParseTypeOrTypePredicateAnnotation(t))},i.tsParseBindingListForSignature=function(){var t=this;return this.parseBindingList(h.parenR).map(function(e){if("Identifier"!==e.type&&"RestElement"!==e.type)throw t.unexpected(e.start,"Name in a signature must be an Identifier.");return e})},i.tsParseTypeMemberSemicolon=function(){this.eat(h.comma)||this.semicolon()},i.tsParseSignatureMember=function(t){var e=this.startNode();return"TSConstructSignatureDeclaration"===t&&this.expect(h._new),this.tsFillSignature(h.colon,e),this.tsParseTypeMemberSemicolon(),this.finishNode(e,t)},i.tsIsUnambiguouslyIndexSignature=function(){return this.next(),this.eat(h.name)&&this.match(h.colon)},i.tsTryParseIndexSignature=function(t){if(this.match(h.bracketL)&&this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this))){this.expect(h.bracketL);var e=this.parseIdentifier();this.expect(h.colon),e.typeAnnotation=this.tsParseTypeAnnotation(!1),this.expect(h.bracketR),t.parameters=[e];var s=this.tsTryParseTypeAnnotation();return s&&(t.typeAnnotation=s),this.tsParseTypeMemberSemicolon(),this.finishNode(t,"TSIndexSignature")}},i.tsParsePropertyOrMethodSignature=function(t,e){this.parsePropertyName(t),this.eat(h.question)&&(t.optional=!0);var s=t;if(e||!this.match(h.parenL)&&!this.isRelational("<")){var i=s;e&&(i.readonly=!0);var r=this.tsTryParseTypeAnnotation();return r&&(i.typeAnnotation=r),this.tsParseTypeMemberSemicolon(),this.finishNode(i,"TSPropertySignature")}var a=s;return this.tsFillSignature(h.colon,a),this.tsParseTypeMemberSemicolon(),this.finishNode(a,"TSMethodSignature")},i.tsParseTypeMember=function(){if(this.match(h.parenL)||this.isRelational("<"))return this.tsParseSignatureMember("TSCallSignatureDeclaration");if(this.match(h._new)&&this.tsLookAhead(this.tsIsStartOfConstructSignature.bind(this)))return this.tsParseSignatureMember("TSConstructSignatureDeclaration");var t=this.startNode(),e=!!this.tsParseModifier(["readonly"]),s=this.tsTryParseIndexSignature(t);return s?(e&&(t.readonly=!0),s):this.tsParsePropertyOrMethodSignature(t,e)},i.tsIsStartOfConstructSignature=function(){return this.next(),this.match(h.parenL)||this.isRelational("<")},i.tsParseTypeLiteral=function(){var t=this.startNode();return t.members=this.tsParseObjectTypeMembers(),this.finishNode(t,"TSTypeLiteral")},i.tsParseObjectTypeMembers=function(){this.expect(h.braceL);var t=this.tsParseList("TypeMembers",this.tsParseTypeMember.bind(this));return this.expect(h.braceR),t},i.tsIsStartOfMappedType=function(){return this.next(),this.isContextual("readonly")&&this.next(),!!this.match(h.bracketL)&&(this.next(),!!this.tsIsIdentifier()&&(this.next(),this.match(h._in)))},i.tsParseMappedTypeParameter=function(){var t=this.startNode();return t.name=this.parseIdentifierName(t.start),this.expect(h._in),t.constraint=this.tsParseType(),this.finishNode(t,"TSTypeParameter")},i.tsParseMappedType=function(){var t=this.startNode();return this.expect(h.braceL),this.eatContextual("readonly")&&(t.readonly=!0),this.expect(h.bracketL),t.typeParameter=this.tsParseMappedTypeParameter(),this.expect(h.bracketR),this.eat(h.question)&&(t.optional=!0),t.typeAnnotation=this.tsTryParseType(),this.semicolon(),this.expect(h.braceR),this.finishNode(t,"TSMappedType")},i.tsParseTupleType=function(){var t=this.startNode();return t.elementTypes=this.tsParseBracketedList("TupleElementTypes",this.tsParseType.bind(this),!0,!1),this.finishNode(t,"TSTupleType")},i.tsParseParenthesizedType=function(){var t=this.startNode();return this.expect(h.parenL),t.typeAnnotation=this.tsParseType(),this.expect(h.parenR),this.finishNode(t,"TSParenthesizedType")},i.tsParseFunctionOrConstructorType=function(t){var e=this.startNode();return"TSConstructorType"===t&&this.expect(h._new),this.tsFillSignature(h.arrow,e),this.finishNode(e,t)},i.tsParseLiteralTypeNode=function(){var t=this,e=this.startNode();return e.literal=function(){switch(t.state.type){case h.num:return t.parseLiteral(t.state.value,"NumericLiteral");case h.string:return t.parseLiteral(t.state.value,"StringLiteral");case h._true:case h._false:return t.parseBooleanLiteral();default:throw t.unexpected()}}(),this.finishNode(e,"TSLiteralType")},i.tsParseNonArrayType=function(){switch(this.state.type){case h.name:case h._void:case h._null:var t=this.match(h._void)?"TSVoidKeyword":this.match(h._null)?"TSNullKeyword":function(t){switch(t){case"any":return"TSAnyKeyword";case"boolean":return"TSBooleanKeyword";case"never":return"TSNeverKeyword";case"number":return"TSNumberKeyword";case"object":return"TSObjectKeyword";case"string":return"TSStringKeyword";case"symbol":return"TSSymbolKeyword";case"undefined":return"TSUndefinedKeyword";default:return}}(this.state.value);if(void 0!==t&&this.lookahead().type!==h.dot){var e=this.startNode();return this.next(),this.finishNode(e,t)}return this.tsParseTypeReference();case h.string:case h.num:case h._true:case h._false:return this.tsParseLiteralTypeNode();case h.plusMin:if("-"===this.state.value){var s=this.startNode();if(this.next(),!this.match(h.num))throw this.unexpected();return s.literal=this.parseLiteral(-this.state.value,"NumericLiteral",s.start,s.loc.start),this.finishNode(s,"TSLiteralType")}break;case h._this:var i=this.tsParseThisTypeNode();return this.isContextual("is")&&!this.hasPrecedingLineBreak()?this.tsParseThisTypePredicate(i):i;case h._typeof:return this.tsParseTypeQuery();case h.braceL:return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this))?this.tsParseMappedType():this.tsParseTypeLiteral();case h.bracketL:return this.tsParseTupleType();case h.parenL:return this.tsParseParenthesizedType()}throw this.unexpected()},i.tsParseArrayTypeOrHigher=function(){for(var t=this.tsParseNonArrayType();!this.hasPrecedingLineBreak()&&this.eat(h.bracketL);)if(this.match(h.bracketR)){var e=this.startNodeAtNode(t);e.elementType=t,this.expect(h.bracketR),t=this.finishNode(e,"TSArrayType")}else{var s=this.startNodeAtNode(t);s.objectType=t,s.indexType=this.tsParseType(),this.expect(h.bracketR),t=this.finishNode(s,"TSIndexedAccessType")}return t},i.tsParseTypeOperator=function(t){var e=this.startNode();return this.expectContextual(t),e.operator=t,e.typeAnnotation=this.tsParseTypeOperatorOrHigher(),this.finishNode(e,"TSTypeOperator")},i.tsParseTypeOperatorOrHigher=function(){return this.isContextual("keyof")?this.tsParseTypeOperator("keyof"):this.tsParseArrayTypeOrHigher()},i.tsParseUnionOrIntersectionType=function(t,e,s){this.eat(s);var i=e();if(this.match(s)){for(var r=[i];this.eat(s);)r.push(e());var a=this.startNodeAtNode(i);a.types=r,i=this.finishNode(a,t)}return i},i.tsParseIntersectionTypeOrHigher=function(){return this.tsParseUnionOrIntersectionType("TSIntersectionType",this.tsParseTypeOperatorOrHigher.bind(this),h.bitwiseAND)},i.tsParseUnionTypeOrHigher=function(){return this.tsParseUnionOrIntersectionType("TSUnionType",this.tsParseIntersectionTypeOrHigher.bind(this),h.bitwiseOR)},i.tsIsStartOfFunctionType=function(){return!!this.isRelational("<")||this.match(h.parenL)&&this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this))},i.tsSkipParameterStart=function(){return!(!this.match(h.name)&&!this.match(h._this)||(this.next(),0))},i.tsIsUnambiguouslyStartOfFunctionType=function(){if(this.next(),this.match(h.parenR)||this.match(h.ellipsis))return!0;if(this.tsSkipParameterStart()){if(this.match(h.colon)||this.match(h.comma)||this.match(h.question)||this.match(h.eq))return!0;if(this.match(h.parenR)&&(this.next(),this.match(h.arrow)))return!0}return!1},i.tsParseTypeOrTypePredicateAnnotation=function(t){var e=this.startNode();this.expect(t);var s=this.tsIsIdentifier()&&this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));if(!s)return this.tsParseTypeAnnotation(!1,e);var i=this.tsParseTypeAnnotation(!1),r=this.startNodeAtNode(s);return r.parameterName=s,r.typeAnnotation=i,e.typeAnnotation=this.finishNode(r,"TSTypePredicate"),this.finishNode(e,"TSTypeAnnotation")},i.tsTryParseTypeOrTypePredicateAnnotation=function(){return this.match(h.colon)?this.tsParseTypeOrTypePredicateAnnotation(h.colon):void 0},i.tsTryParseTypeAnnotation=function(){return this.match(h.colon)?this.tsParseTypeAnnotation():void 0},i.tsTryParseType=function(){return this.eat(h.colon)?this.tsParseType():void 0},i.tsParseTypePredicatePrefix=function(){var t=this.parseIdentifier();if(this.isContextual("is")&&!this.hasPrecedingLineBreak())return this.next(),t},i.tsParseTypeAnnotation=function(t,e){return void 0===t&&(t=!0),void 0===e&&(e=this.startNode()),t&&this.expect(h.colon),e.typeAnnotation=this.tsParseType(),this.finishNode(e,"TSTypeAnnotation")},i.tsParseType=function(){var t=this.state.inType;this.state.inType=!0;try{return this.tsIsStartOfFunctionType()?this.tsParseFunctionOrConstructorType("TSFunctionType"):this.match(h._new)?this.tsParseFunctionOrConstructorType("TSConstructorType"):this.tsParseUnionTypeOrHigher()}finally{this.state.inType=t}},i.tsParseTypeAssertion=function(){var t=this.startNode();return t.typeAnnotation=this.tsParseType(),this.expectRelational(">"),t.expression=this.parseMaybeUnary(),this.finishNode(t,"TSTypeAssertion")},i.tsTryParseTypeArgumentsInExpression=function(){var t=this;return this.tsTryParseAndCatch(function(){var e=t.startNode();t.expectRelational("<");var s=t.tsParseDelimitedList("TypeParametersOrArguments",t.tsParseType.bind(t));return t.expectRelational(">"),e.params=s,t.finishNode(e,"TSTypeParameterInstantiation"),t.expect(h.parenL),e})},i.tsParseHeritageClause=function(){return this.tsParseDelimitedList("HeritageClauseElement",this.tsParseExpressionWithTypeArguments.bind(this))},i.tsParseExpressionWithTypeArguments=function(){var t=this.startNode();return t.expression=this.tsParseEntityName(!1),this.isRelational("<")&&(t.typeParameters=this.tsParseTypeArguments()),this.finishNode(t,"TSExpressionWithTypeArguments")},i.tsParseInterfaceDeclaration=function(t){t.id=this.parseIdentifier(),t.typeParameters=this.tsTryParseTypeParameters(),this.eat(h._extends)&&(t.extends=this.tsParseHeritageClause());var e=this.startNode();return e.body=this.tsParseObjectTypeMembers(),t.body=this.finishNode(e,"TSInterfaceBody"),this.finishNode(t,"TSInterfaceDeclaration")},i.tsParseTypeAliasDeclaration=function(t){return t.id=this.parseIdentifier(),t.typeParameters=this.tsTryParseTypeParameters(),this.expect(h.eq),t.typeAnnotation=this.tsParseType(),this.semicolon(),this.finishNode(t,"TSTypeAliasDeclaration")},i.tsParseEnumMember=function(){var t=this.startNode();return t.id=this.match(h.string)?this.parseLiteral(this.state.value,"StringLiteral"):this.parseIdentifier(!0),this.eat(h.eq)&&(t.initializer=this.parseMaybeAssign()),this.finishNode(t,"TSEnumMember")},i.tsParseEnumDeclaration=function(t,e){return e&&(t.const=!0),t.id=this.parseIdentifier(),this.expect(h.braceL),t.members=this.tsParseDelimitedList("EnumMembers",this.tsParseEnumMember.bind(this)),this.expect(h.braceR),this.finishNode(t,"TSEnumDeclaration")},i.tsParseModuleBlock=function(){var t=this.startNode();return this.expect(h.braceL),this.parseBlockOrModuleBlockBody(t.body=[],void 0,!0,h.braceR),this.finishNode(t,"TSModuleBlock")},i.tsParseModuleOrNamespaceDeclaration=function(t){if(t.id=this.parseIdentifier(),this.eat(h.dot)){var e=this.startNode();this.tsParseModuleOrNamespaceDeclaration(e),t.body=e}else t.body=this.tsParseModuleBlock();return this.finishNode(t,"TSModuleDeclaration")},i.tsParseAmbientExternalModuleDeclaration=function(t){return this.isContextual("global")?(t.global=!0,t.id=this.parseIdentifier()):this.match(h.string)?t.id=this.parseExprAtom():this.unexpected(),this.match(h.braceL)?t.body=this.tsParseModuleBlock():this.semicolon(),this.finishNode(t,"TSModuleDeclaration")},i.tsParseImportEqualsDeclaration=function(t,e){return t.isExport=e||!1,t.id=this.parseIdentifier(),this.expect(h.eq),t.moduleReference=this.tsParseModuleReference(),this.semicolon(),this.finishNode(t,"TSImportEqualsDeclaration")},i.tsIsExternalModuleReference=function(){return this.isContextual("require")&&this.lookahead().type===h.parenL},i.tsParseModuleReference=function(){return this.tsIsExternalModuleReference()?this.tsParseExternalModuleReference():this.tsParseEntityName(!1)},i.tsParseExternalModuleReference=function(){var t=this.startNode();if(this.expectContextual("require"),this.expect(h.parenL),!this.match(h.string))throw this.unexpected();return t.expression=this.parseLiteral(this.state.value,"StringLiteral"),this.expect(h.parenR),this.finishNode(t,"TSExternalModuleReference")},i.tsLookAhead=function(t){var e=this.state.clone(),s=t();return this.state=e,s},i.tsTryParseAndCatch=function(t){var e=this.state.clone();try{return t()}catch(t){if(t instanceof SyntaxError)return void(this.state=e);throw t}},i.tsTryParse=function(t){var e=this.state.clone(),s=t();return void 0!==s&&!1!==s?s:void(this.state=e)},i.nodeWithSamePosition=function(t,e){var s=this.startNodeAtNode(t);return s.type=e,s.end=t.end,s.loc.end=t.loc.end,t.leadingComments&&(s.leadingComments=t.leadingComments),t.trailingComments&&(s.trailingComments=t.trailingComments),t.innerComments&&(s.innerComments=t.innerComments),s},i.tsTryParseDeclare=function(t){switch(this.state.type){case h._function:return this.next(),this.parseFunction(t,!0);case h._class:return this.parseClass(t,!0,!1);case h._const:if(this.match(h._const)&&this.isLookaheadContextual("enum"))return this.expect(h._const),this.expectContextual("enum"),this.tsParseEnumDeclaration(t,!0);case h._var:case h._let:return this.parseVarStatement(t,this.state.type);case h.name:var e=this.state.value;return"global"===e?this.tsParseAmbientExternalModuleDeclaration(t):this.tsParseDeclaration(t,e,!0)}},i.tsTryParseExportDeclaration=function(){return this.tsParseDeclaration(this.startNode(),this.state.value,!0)},i.tsParseExpressionStatement=function(t,e){switch(e.name){case"declare":var s=this.tsTryParseDeclare(t);if(s)return s.declare=!0,s;break;case"global":if(this.match(h.braceL)){var i=t;return i.global=!0,i.id=e,i.body=this.tsParseModuleBlock(),this.finishNode(i,"TSModuleDeclaration")}break;default:return this.tsParseDeclaration(t,e.name,!1)}},i.tsParseDeclaration=function(t,e,s){switch(e){case"abstract":if(s||this.match(h._class)){var i=t;return i.abstract=!0,s&&this.next(),this.parseClass(i,!0,!1)}break;case"enum":if(s||this.match(h.name))return s&&this.next(),this.tsParseEnumDeclaration(t,!1);break;case"interface":if(s||this.match(h.name))return s&&this.next(),this.tsParseInterfaceDeclaration(t);break;case"module":if(s&&this.next(),this.match(h.string))return this.tsParseAmbientExternalModuleDeclaration(t);if(s||this.match(h.name))return this.tsParseModuleOrNamespaceDeclaration(t);break;case"namespace":if(s||this.match(h.name))return s&&this.next(),this.tsParseModuleOrNamespaceDeclaration(t);break;case"type":if(s||this.match(h.name))return s&&this.next(),this.tsParseTypeAliasDeclaration(t)}},i.tsTryParseGenericAsyncArrowFunction=function(e,s){var i=this,r=this.tsTryParseAndCatch(function(){var r=i.startNodeAt(e,s);return r.typeParameters=i.tsParseTypeParameters(),t.prototype.parseFunctionParams.call(i,r),r.returnType=i.tsTryParseTypeOrTypePredicateAnnotation(),i.expect(h.arrow),r});if(r)return r.id=null,r.generator=!1,r.expression=!0,r.async=!0,this.parseFunctionBody(r,!0),this.finishNode(r,"ArrowFunctionExpression")},i.tsParseTypeArguments=function(){var t=this.startNode();return this.expectRelational("<"),t.params=this.tsParseDelimitedList("TypeParametersOrArguments",this.tsParseType.bind(this)),this.expectRelational(">"),this.finishNode(t,"TSTypeParameterInstantiation")},i.tsIsDeclarationStart=function(){if(this.match(h.name))switch(this.state.value){case"abstract":case"declare":case"enum":case"interface":case"module":case"namespace":case"type":return!0}return!1},i.isExportDefaultSpecifier=function(){return!this.tsIsDeclarationStart()&&t.prototype.isExportDefaultSpecifier.call(this)},i.parseAssignableListItem=function(t,e){var s,i=!1;t&&(s=this.parseAccessModifier(),i=!!this.tsParseModifier(["readonly"]));var r=this.parseMaybeDefault();this.parseAssignableListItemTypes(r);var a=this.parseMaybeDefault(r.start,r.loc.start,r);if(s||i){var n=this.startNodeAtNode(a);if(e.length&&(n.decorators=e),s&&(n.accessibility=s),i&&(n.readonly=i),"Identifier"!==a.type&&"AssignmentPattern"!==a.type)throw this.raise(n.start,"A parameter property may not be declared using a binding pattern.");return n.parameter=a,this.finishNode(n,"TSParameterProperty")}return e.length&&(r.decorators=e),a},i.parseFunctionBodyAndFinish=function(e,s,i){!i&&this.match(h.colon)&&(e.returnType=this.tsParseTypeOrTypePredicateAnnotation(h.colon));var r="FunctionDeclaration"===s?"TSDeclareFunction":"ClassMethod"===s?"TSDeclareMethod":void 0;r&&!this.match(h.braceL)&&this.isLineTerminator()?this.finishNode(e,r):t.prototype.parseFunctionBodyAndFinish.call(this,e,s,i)},i.parseSubscript=function(e,s,i,r,a){if(this.eat(h.bang)){var n=this.startNodeAt(s,i);return n.expression=e,this.finishNode(n,"TSNonNullExpression")}if(!r&&this.isRelational("<")){if(this.atPossibleAsync(e)){var o=this.tsTryParseGenericAsyncArrowFunction(s,i);if(o)return o}var p=this.startNodeAt(s,i);p.callee=e;var c=this.tsTryParseTypeArgumentsInExpression();if(c)return p.arguments=this.parseCallExpressionArguments(h.parenR,!1),p.typeParameters=c,this.finishCallExpression(p)}return t.prototype.parseSubscript.call(this,e,s,i,r,a)},i.parseNewArguments=function(e){var s=this;if(this.isRelational("<")){var i=this.tsTryParseAndCatch(function(){var t=s.tsParseTypeArguments();return s.match(h.parenL)||s.unexpected(),t});i&&(e.typeParameters=i)}t.prototype.parseNewArguments.call(this,e)},i.parseExprOp=function(e,s,i,r,a){if(et(h._in.binop)>r&&!this.hasPrecedingLineBreak()&&this.eatContextual("as")){var n=this.startNodeAt(s,i);return n.expression=e,n.typeAnnotation=this.tsParseType(),this.finishNode(n,"TSAsExpression"),this.parseExprOp(n,s,i,r,a)}return t.prototype.parseExprOp.call(this,e,s,i,r,a)},i.checkReservedWord=function(t,e,s,i){},i.checkDuplicateExports=function(){},i.parseImport=function(e){return this.match(h.name)&&this.lookahead().type===h.eq?this.tsParseImportEqualsDeclaration(e):t.prototype.parseImport.call(this,e)},i.parseExport=function(e){if(this.match(h._import))return this.expect(h._import),this.tsParseImportEqualsDeclaration(e,!0);if(this.eat(h.eq)){var s=e;return s.expression=this.parseExpression(),this.semicolon(),this.finishNode(s,"TSExportAssignment")}if(this.eatContextual("as")){var i=e;return this.expectContextual("namespace"),i.id=this.parseIdentifier(),this.semicolon(),this.finishNode(i,"TSNamespaceExportDeclaration")}return t.prototype.parseExport.call(this,e)},i.parseStatementContent=function(e,s){if(this.state.type===h._const){var i=this.lookahead();if(i.type===h.name&&"enum"===i.value){var r=this.startNode();return this.expect(h._const),this.expectContextual("enum"),this.tsParseEnumDeclaration(r,!0)}}return t.prototype.parseStatementContent.call(this,e,s)},i.parseAccessModifier=function(){return this.tsParseModifier(["public","protected","private"])},i.parseClassMember=function(e,s,i){var r=this.parseAccessModifier();r&&(s.accessibility=r),t.prototype.parseClassMember.call(this,e,s,i)},i.parseClassMemberWithIsStatic=function(e,s,i,r){var a=s,n=s,o=s,h=!1,p=!1;switch(this.tsParseModifier(["abstract","readonly"])){case"readonly":p=!0,h=!!this.tsParseModifier(["abstract"]);break;case"abstract":h=!0,p=!!this.tsParseModifier(["readonly"])}if(h&&(a.abstract=!0),p&&(o.readonly=!0),!h&&!r&&!a.accessibility){var c=this.tsTryParseIndexSignature(s);if(c)return void e.body.push(c)}if(p)return a.static=r,this.parseClassPropertyName(n),this.parsePostMemberNameModifiers(a),void this.pushClassProperty(e,n);t.prototype.parseClassMemberWithIsStatic.call(this,e,s,i,r)},i.parsePostMemberNameModifiers=function(t){this.eat(h.question)&&(t.optional=!0)},i.parseExpressionStatement=function(e,s){return("Identifier"===s.type?this.tsParseExpressionStatement(e,s):void 0)||t.prototype.parseExpressionStatement.call(this,e,s)},i.shouldParseExportDeclaration=function(){return!!this.tsIsDeclarationStart()||t.prototype.shouldParseExportDeclaration.call(this)},i.parseConditional=function(e,s,i,r,a){if(!a||!this.match(h.question))return t.prototype.parseConditional.call(this,e,s,i,r,a);var n=this.state.clone();try{return t.prototype.parseConditional.call(this,e,s,i,r)}catch(t){if(!(t instanceof SyntaxError))throw t;return this.state=n,a.start=t.pos||this.state.start,e}},i.parseParenItem=function(e,s,i){if(e=t.prototype.parseParenItem.call(this,e,s,i),this.eat(h.question)&&(e.optional=!0),this.match(h.colon)){var r=this.startNodeAt(s,i);return r.expression=e,r.typeAnnotation=this.tsParseTypeAnnotation(),this.finishNode(r,"TSTypeCastExpression")}return e},i.parseExportDeclaration=function(e){var s,i=this.eatContextual("declare");return this.match(h.name)&&(s=this.tsTryParseExportDeclaration()),s||(s=t.prototype.parseExportDeclaration.call(this,e)),s&&i&&(s.declare=!0),s},i.parseClassId=function(e,s,i){var r;if(s&&!i||!this.isContextual("implements")){(r=t.prototype.parseClassId).call.apply(r,[this].concat(Array.prototype.slice.call(arguments)));var a=this.tsTryParseTypeParameters();a&&(e.typeParameters=a)}},i.parseClassProperty=function(e){var s=this.tsTryParseTypeAnnotation();return s&&(e.typeAnnotation=s),t.prototype.parseClassProperty.call(this,e)},i.pushClassMethod=function(e,s,i,r,a){var n=this.tsTryParseTypeParameters();n&&(s.typeParameters=n),t.prototype.pushClassMethod.call(this,e,s,i,r,a)},i.pushClassPrivateMethod=function(e,s,i,r){var a=this.tsTryParseTypeParameters();a&&(s.typeParameters=a),t.prototype.pushClassPrivateMethod.call(this,e,s,i,r)},i.parseClassSuper=function(e){t.prototype.parseClassSuper.call(this,e),e.superClass&&this.isRelational("<")&&(e.superTypeParameters=this.tsParseTypeArguments()),this.eatContextual("implements")&&(e.implements=this.tsParseHeritageClause())},i.parseObjPropValue=function(e){var s;if(this.isRelational("<"))throw new Error("TODO");for(var i=arguments.length,r=new Array(i>1?i-1:0),a=1;a=r.l||2==r.t&&n>=r.c.length))r.c=4==t.t?mk(t.c,e,n):0==e&&t.c.length==n?t.c:t.c.substr(e,n),r.t=r.c.length==r.l?0:2;else if(2==r.t&&a==r.c.length)r.c+=4==t.t?mk(t.c,e,n):0==e&&t.c.length==n?t.c:t.c.substr(e,n),r.t=r.c.length==r.l?0:2;else{4!=r.t&&wk(r);var s=t.c,c=r.c;if(4==t.t)if(a<=e)for(var i=0;i=0;i--)c[a+i]=s[e+i];else{var u=Math.min(n,s.length-e);for(i=0;i>=1))return r;e+=e,9==++a&&e.slice(0,1)}}function Tk(t){2==t.t?t.c+=_k(t.l-t.c.length,"\0"):t.c=mk(t.c,0,t.c.length),t.t=0}function Sk(t){if(t.length<24){for(var e=0;euo)return!1;return!0}return!/[^\x00-\x7f]/.test(t)}function Ek(t){switch(t.t){case 9:return t.c;default:Tk(t);case 0:if(Sk(t.c))return t.t=9,t.c;t.t=8;case 8:return function(t){for(var e,r,a,n,s=Of,c=Of,i=0,u=t.length;ig?(c.substr(0,1),s+=c,c=Of,s+=t.slice(i,f)):c+=t.slice(i,f),f==u)break;i=f}n=1,++i=55295&&nau)&&(n=3))))),n<4?(i-=n,c+="�"):c+=n>$e?String.fromCharCode(55232+(n>>10),Or+(1023&n)):String.fromCharCode(n),c.length>ve&&(c.substr(0,1),s+=c,c=Of)}return s+c}(t.c)}}function xk(t,e,r){this.t=t,this.c=e,this.l=r}function Ak(t){return new xk(0,t,t.length)}function Ik(t,e){kk(t,Ak(e))}function Ck(t){Ik(dk.Invalid_argument,t)}function Nk(t,e){return e>>>0>=t.length-1&&Ck(zt),t}function Ok(t,e){var r=t[3]<<16,a=e[3]<<16;return r>a?1:re[2]?1:t[2]e[1]?1:t[1]e.c?1:0}function Pk(t,e,r){for(var n=[];;){if(!r||t!==e)if(t instanceof xk){if(!(e instanceof xk))return 1;if(t!==e&&0!=(i=Lk(t,e)))return i}else if(t instanceof Array&&t[0]===(0|t[0])){var s=t[0];if(s===a&&(s=0),s===cf){t=t[1];continue}if(!(e instanceof Array&&e[0]===(0|e[0])))return 1;var c=e[0];if(c===a&&(c=0),c===cf){e=e[1];continue}if(s!=c)return s1&&n.push(t,e,1)}}else{if(e instanceof xk||e instanceof Array&&e[0]===(0|e[0]))return-1;if("number"!=typeof t&&t&&t.compare)return t.compare(e,r);if("function"==typeof t)Ck("compare: functional value");else{if(te)return 1;if(t!=e){if(!r)return NaN;if(t==t)return 1;if(e==e)return-1}}}if(0==n.length)return 0;var u=n.pop();e=n.pop(),u+1<(t=n.pop()).length&&n.push(t,e,u+1),t=t[u],e=e[u]}}function Uk(t,e){return Pk(t,e,!0)}function Dk(t){return t<0&&Ck("String.create"),new xk(t?2:9,Of,t)}function Fk(t,e){return+(0==Pk(t,e,!1))}function Mk(t){Ik(dk.Failure,t)}function Xk(t){return 0!=(6&t.t)&&Tk(t),t.c}function jk(t){var e;if(e=+(t=Xk(t)),t.length>0&&e==e)return e;if(e=+(t=t.replace(/_/g,Of)),t.length>0&&e==e||/^[+-]?nan$/i.test(t))return e;var r=/^ *([+-]?)0x([0-9a-f]+)\.?([0-9a-f]*)p([+-]?[0-9]+)/i.exec(t);if(r){var a=r[3].replace(/0+$/,Of),n=parseInt(r[1]+r[2]+a,16),s=(0|r[4])-4*a.length;return e=n*Math.pow(2,s)}return/^\+?inf(inity)?$/i.test(t)?1/0:/^-inf(inity)?$/i.test(t)?-1/0:void Mk("float_of_string")}function Bk(t){var e=(t=Xk(t)).length;e>31&&Ck("format_int: format too long");for(var r={justify:zf,signstyle:Cu,filler:qb,alternate:!1,base:0,signedconv:!1,width:0,uppercase:!1,sign:1,prec:-1,conv:rc},a=0;a=0&&n<=9;)r.width=10*r.width+n,a++;a--;break;case".":for(r.prec=0,a++;(n=t.charCodeAt(a)-48)>=0&&n<=9;)r.prec=10*r.prec+n,a++;a--;case"d":case"i":r.signedconv=!0;case"u":r.base=10;break;case"x":r.base=16;break;case"X":r.base=16,r.uppercase=!0;break;case"o":r.base=8;break;case"e":case"f":case"g":r.signedconv=!0,r.conv=n;break;case"E":case"F":case"G":r.signedconv=!0,r.uppercase=!0,r.conv=n.toLowerCase()}}return r}function qk(t,e){t.uppercase&&(e=e.toUpperCase());var r=e.length;t.signedconv&&(t.sign<0||t.signstyle!=Cu)&&r++,t.alternate&&(8==t.base&&(r+=1),16==t.base&&(r+=2));var a=Of;if(t.justify==zf&&t.filler==qb)for(var n=r;n=1e21||e.toFixed(0).length>a){for(s=c-1;n.charAt(s)==Ci;)s--;n.charAt(s)==Qe&&s--,s=(n=n.slice(0,s+1)+n.slice(c)).length,n.charAt(s-3)==At&&(n=n.slice(0,s-1)+Ci+n.slice(s-1));break}var u=a;if(i<0)u-=i+1,n=e.toFixed(u);else for(;(n=e.toFixed(u)).length>a+1;)u--;if(u){for(s=n.length-1;n.charAt(s)==Ci;)s--;n.charAt(s)==Qe&&s--,n=n.slice(0,s+1)}}else n="inf",r.filler=qb;return qk(r,n)}function Yk(t,e){if(Xk(t)==sn)return Ak(Of+e);var r=Bk(t);e<0&&(r.signedconv?(r.sign=-1,e=-e):e>>>=0);var a=e.toString(r.base);if(r.prec>=0){r.filler=qb;var n=r.prec-a.length;n>0&&(a=_k(n,Ci)+a)}return qk(r,a)}xk.prototype.toString=function(){return Ek(this)};var Jk=0;function Hk(){return Jk++}function Wk(t,e){return+(Pk(t,e,!1)>=0)}function Vk(t){var e=9;return Sk(t)||(e=8,t=function(t){for(var e,r,a=Of,n=a,s=0,c=t.length;sg?(n.substr(0,1),a+=n,n=Of,a+=t.slice(s,i)):n+=t.slice(s,i),i==c)break;s=i}e>6),n+=String.fromCharCode(I|63&e)):e=fn?n+=String.fromCharCode(Qu|e>>12,I|e>>6&63,I|63&e):e>=56319||s+1==c||(r=t.charCodeAt(s+1))fn?n+="�":(s++,e=(e<<10)+r-56613888,n+=String.fromCharCode(pl|e>>18,I|e>>12&63,I|e>>6&63,I|63&e)),n.length>ve&&(n.substr(0,1),a+=n,n=Of)}return a+n}(t)),new xk(e,t,t.length)}function zk(t){return 0==(t[3]|t[2]|t[1])}function Kk(t){return[Ll,t&f,t>>24&f,t>>31&$e]}function Qk(t){for(var e=t.length,r=new Array(e),a=0;a>24),n=t[3]-e[3]+(a>>24);return[Ll,r&f,a&f,n&$e]}function Zk(t,e){return t[3]>e[3]?1:t[3]e[2]?1:t[2]e[1]?1:t[1]>23,t[2]=(t[2]<<1|t[1]>>23)&f,t[1]=t[1]<<1&f}function ed(t){t[1]=(t[1]>>>1|t[2]<<23)&f,t[2]=(t[2]>>>1|t[3]<<23)&f,t[3]=t[3]>>>1}function rd(t,e){for(var r=0,a=Qk(t),n=Qk(e),s=[Ll,0,0,0];Zk(a,n)>0;)r++,td(n);for(;r>=0;)r--,td(s),Zk(a,n)>=0&&(s[1]++,a=$k(a,n)),ed(n);return[0,s,a]}function ad(t){return t[1]|t[2]<<24}function nd(t){var e=-t[1],r=-t[2]+(e>>24),a=-t[3]+(r>>24);return[Ll,e&f,r&f,a&$e]}function sd(t){return t.l}function cd(t,e){switch(6&t.t){default:if(e>=t.c.length)return 0;case 0:return t.c.charCodeAt(e);case 4:return t.c[e]}}function id(t,e){var r=t[1]+e[1],a=t[2]+e[2]+(r>>24),n=t[3]+e[3]+(a>>24);return[Ll,r&f,a&f,n&$e]}var ud=Math.pow(2,-24);function fd(t,e){var r=t[1]*e[1],a=(r*ud|0)+t[2]*e[1]+t[1]*e[2],n=(a*ud|0)+t[3]*e[1]+t[2]*e[2]+t[1]*e[3];return[Ll,r&f,a&f,n&$e]}function od(t,e){return Zk(t,e)<0}function vd(t){var e=0,r=sd(t),a=10,n=r>0&&45==cd(t,0)?(e++,-1):1;if(e+1=48&&t<=57?t-48:t>=65&&t<=90?t-55:t>=97&&t<=ws?t-87:-1}function bd(t){var e=vd(t),r=e[0],a=e[1],n=e[2],s=Kk(n),c=rd([Ll,f,268435455,$e],s)[1],i=cd(t,r),u=ld(i);(u<0||u>=n)&&Mk(Yv);for(var o=Kk(u);;)if(95!=(i=cd(t,++r))){if((u=ld(i))<0||u>=n)break;od(c,o)&&Mk(Yv),u=Kk(u),od(o=id(fd(s,o),u),u)&&Mk(Yv)}return r!=sd(t)&&Mk(Yv),10==e[2]&&od([Ll,0,0,32768],o)&&Mk(Yv),a<0&&(o=nd(o)),o}function kd(t){return(t[3]<<16)*Math.pow(2,32)+t[2]*Math.pow(2,24)+t[1]}function dd(t){var e=vd(t),r=e[0],a=e[1],n=e[2],s=sd(t),c=r=n)&&Mk(Yv);var u=i;for(r++;r=n)break;(u=n*u+i)>-1>>>0&&Mk(Yv)}return r!=s&&Mk(Yv),u*=a,10==n&&(0|u)!=u&&Mk(Yv),0|u}function hd(t){return pk(t,1,t.length-1)}function pd(t){return t.toString()}function md(t){for(var e={},r=1;r>>0>=t.l&&Sd(),cd(t,e)}function xd(){}function Ad(t){this.data=t}function Id(t,e){this.content={},this.root=t,this.lookupFun=e}function Cd(t){return 4!=t.t&&wk(t),t.c}function Nd(t,e,r){if(r&=Ll,4!=t.t){if(e==t.c.length)return t.c+=String.fromCharCode(r),e+1==t.l&&(t.t=0),0;wk(t)}return t.c[e]=r,0}function Od(t,e,r){return e>>>0>=t.l&&Sd(),Nd(t,e,r)}Td.slice(-1)!==Io&&(Td+=Io),Ad.prototype=new xd,Ad.prototype.truncate=function(t){var e=this.data;this.data=Dk(0|t),yk(e,0,this.data,0,t)},Ad.prototype.length=function(){return sd(this.data)},Ad.prototype.write=function(t,e,r,a){var n=this.length();if(t+a>=n){var s=Dk(t+a),c=this.data;this.data=s,yk(c,0,this.data,0,n)}return yk(e,r,this.data,t,a),0},Ad.prototype.read=function(t,e,r,a){this.length();return yk(this.data,t,e,r,a),0},Ad.prototype.read_one=function(t){return Ed(this.data,t)},Ad.prototype.close=function(){},Ad.prototype.constructor=Ad,Id.prototype.nm=function(t){return this.root+t},Id.prototype.lookup=function(t){if(!this.content[t]&&this.lookupFun){var e=this.lookupFun(Ak(this.root),Ak(t));0!=e&&(this.content[t]=new Ad(e[1]))}},Id.prototype.exists=function(t){if(t==Of)return 1;var e=new RegExp("^"+(t+Io));for(var r in this.content)if(r.match(e))return 1;return this.lookup(t),this.content[t]?1:0},Id.prototype.readdir=function(t){var e=new RegExp("^"+(t==Of?Of:t+Io)+It),r={},a=[];for(var n in this.content){var s=n.match(e);s&&!r[s[1]]&&(r[s[1]]=!0,a.push(s[1]))}return a},Id.prototype.is_dir=function(t){var e=new RegExp("^"+(t==Of?Of:t+Io)+It);for(var r in this.content){if(r.match(e))return 1}return 0},Id.prototype.unlink=function(t){var e=!!this.content[t];return delete this.content[t],e},Id.prototype.open=function(t,e){if(e.rdonly&&e.wronly&&yd(this.nm(t)+" : flags Open_rdonly and Open_wronly are not compatible"),e.text&&e.binary&&yd(this.nm(t)+" : flags Open_text and Open_binary are not compatible"),this.lookup(t),this.content[t]){this.is_dir(t)&&yd(this.nm(t)+" : is a directory"),e.create&&e.excl&&yd(this.nm(t)+Uu);var r=this.content[t];return e.truncate&&r.truncate(),r}if(e.create)return this.content[t]=new Ad(Dk(0)),this.content[t];!function(t){yd((t=t instanceof xk?t.toString():t)+": No such file or directory")}(this.nm(t))},Id.prototype.register=function(t,e){if(this.content[t]&&yd(this.nm(t)+Uu),e instanceof xk)this.content[t]=new Ad(e);else if(e instanceof Array)this.content[t]=new Ad(function(t){return new xk(4,t,t.length)}(e));else if(e.toString){var r=Ak(e.toString());this.content[t]=new Ad(r)}},Id.prototype.constructor=Id;var Rd=r.Buffer;function Ld(t){this.fs=fs,this.fd=t}function Pd(t){this.fs=fs,this.root=t}Ld.prototype=new xd,Ld.prototype.truncate=function(t){this.fs.ftruncateSync(this.fd,0|t)},Ld.prototype.length=function(){return this.fs.fstatSync(this.fd).size},Ld.prototype.write=function(t,e,a,n){var s=Cd(e);s instanceof r.Uint8Array||(s=new r.Uint8Array(s));var c=new Rd(s);return this.fs.writeSync(this.fd,c,a,n,t),0},Ld.prototype.read=function(t,e,a,n){var s=Cd(e);s instanceof r.Uint8Array||(s=new r.Uint8Array(s));var c=new Rd(s);this.fs.readSync(this.fd,c,a,n,t);for(var i=0;idk.fd_last_idx)&&(dk.fd_last_idx=t),t}function Md(t){var e=dk.fds[t];e.flags.rdonly&&yd(X+t+" is readonly");var r={file:e.file,offset:e.offset,fd:t,opened:!0,out:!0,buffer:Of};return gd[r.fd]=r,r.fd}t.exports&&void 0!==commonjsRequire?Dd.push({path:Ud,device:new Pd(Ud)}):Dd.push({path:Ud,device:new Id(Ud)}),Dd.push({path:Ud+yb,device:new Id(Ud+yb)}),Fd(0,function(t,e){var r=gd[t],a=Ak(e),n=sd(a);return r.file.write(r.offset,a,0,n),r.offset+=n,0},new Ad(Dk(0))),Fd(1,function(t){var e=r;if(e.process&&e.process.stdout&&e.process.stdout.write)e.process.stdout.write(t);else{10==t.charCodeAt(t.length-1)&&(t=t.substr(0,t.length-1));var a=e.console;a&&a.log&&a.log(t)}},new Ad(Dk(0))),Fd(2,function(t){var e=r;if(e.process&&e.process.stdout&&e.process.stdout.write)e.process.stderr.write(t);else{10==t.charCodeAt(t.length-1)&&(t=t.substr(0,t.length-1));var a=e.console;a&&a.error&&a.error(t)}},new Ad(Dk(0))),Math.imul||(Math.imul=function(t,e){return((t>>16)*(e|=0)<<16)+(t&$e)*e|0});Math.imul;function Xd(t,e){return+(0!=Pk(t,e,!1))}function jd(t){return t instanceof Array?t[0]:t instanceof xk?Xb:1e3}function Bd(t,e,r){dk[t+1]=e,r&&(dk[r]=e)}var qd={};function Gd(t,e){return t===e?1:(6&t.t&&Tk(t),6&e.t&&Tk(e),t.c==e.c?1:0)}function Yd(t,e){return 1-Gd(t,e)}function Jd(t){var e=r,a=t.toString();if(e.process&&e.process.env&&void 0!=e.process.env[a])return Vk(e.process.env[a]);!function(t){throw t}(dk.Not_found)}function Hd(t){for(;t&&t.joo_tramp;)t=t.joo_tramp.apply(null,t.joo_args),0;return t}function Wd(t,e){return{joo_tramp:t,joo_args:e}}function Vd(t){return t}function zd(t){return qd[t]}function Kd(t){return t instanceof Array?t:r.RangeError&&t instanceof r.RangeError&&t.message&&t.message.match(/maximum call stack/i)?Vd(dk.Stack_overflow):r.InternalError&&t instanceof r.InternalError&&t.message&&t.message.match(/too much recursion/i)?Vd(dk.Stack_overflow):t instanceof r.Error&&zd(tv)?[0,zd(tv),t]:[0,dk.Failure,Vk(String(t))]}function Qd(t,e){return 1==t.length?t(e):gk(t,[e])}function $d(t,e,r){return 2==t.length?t(e,r):gk(t,[e,r])}function Zd(t,e,r,a){return 3==t.length?t(e,r,a):gk(t,[e,r,a])}function th(t,e,r,a,n){return 4==t.length?t(e,r,a,n):gk(t,[e,r,a,n])}function eh(t,e,r,a,n,s){return 5==t.length?t(e,r,a,n,s):gk(t,[e,r,a,n,s])}var rh=[Li,Ak(Bt),-1],ah=[Li,Ak(kv),-3],nh=[Li,Ak(Zc),-4],sh=[Li,Ak(Ps),-7],ch=[Li,Ak(Yf),-8],ih=[Li,Ak(Ts),-9],uh=[Li,Ak(Mr),-11],fh=[Li,Ak(Jb),-12],oh=[0,[11,Ak('File "'),[2,0,[11,Ak('", line '),[4,0,0,0,[11,Ak(", characters "),[4,0,0,0,[12,45,[4,0,0,0,[11,Ak(": "),[2,0,0]]]]]]]]]],Ak('File "%s", line %d, characters %d-%d: %s')],vh=[0,0,[0,0,0,0],[0,0,0,0]],lh=[0,0,0],bh=Ak(""),kh=Ak("\0\0\0\0\0\0\0\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=[0,0,0,0,0,0,1,0],hh=[0,0,0],ph=[0,0];Bd(11,fh,Jb),Bd(10,uh,Mr),Bd(9,[Li,Ak(Fi),-10],Fi),Bd(8,ih,Ts),Bd(7,ch,Yf),Bd(6,sh,Ps),Bd(5,[Li,Ak(Ya),-6],Ya),Bd(4,[Li,Ak(fv),-5],fv),Bd(3,nh,Zc),Bd(2,ah,kv),Bd(1,[Li,Ak(Uv),-2],Uv),Bd(0,rh,Bt);var mh=Ak("output_substring"),wh=Ak("%.12g"),yh=Ak(Qe),gh=Ak(Wc),_h=Ak(vc),Th=[0,Ak("list.ml"),227,11],Sh=Ak("tl"),Eh=Ak("hd"),xh=Ak("\\\\"),Ah=Ak("\\'"),Ih=Ak("\\b"),Ch=Ak("\\t"),Nh=Ak("\\n"),Oh=Ak("\\r"),Rh=Ak("Char.chr"),Lh=Ak("String.blit / Bytes.blit_string"),Ph=Ak("Bytes.blit"),Uh=Ak("String.sub / Bytes.sub"),Dh=(Ak(Of),Ak("Array.blit")),Fh=Ak("Array.sub"),Mh=Ak("Array.init"),Xh=Ak("Set.remove_min_elt"),jh=[0,0,0,0],Bh=[0,0,0],qh=[0,Ak("set.ml"),389,18],Gh=Ak(ck),Yh=Ak(ck),Jh=Ak(ck),Hh=Ak(ck),Wh=Ak("Buffer.add_substring/add_subbytes"),Vh=Ak("Buffer.add: cannot grow buffer"),zh=Ak("%c"),Kh=Ak("%s"),Qh=Ak("%i"),$h=Ak("%li"),Zh=Ak("%ni"),tp=Ak("%Li"),ep=Ak("%f"),rp=Ak("%B"),ap=Ak("%{"),np=Ak("%}"),sp=Ak("%("),cp=Ak("%)"),ip=Ak("%a"),up=Ak("%t"),fp=Ak("%?"),op=Ak("%r"),vp=Ak("%_r"),lp=[0,Ak(Ov),845,23],bp=[0,Ak(Ov),809,21],kp=[0,Ak(Ov),810,21],dp=[0,Ak(Ov),813,21],hp=[0,Ak(Ov),814,21],pp=[0,Ak(Ov),817,19],mp=[0,Ak(Ov),818,19],wp=[0,Ak(Ov),821,22],yp=[0,Ak(Ov),822,22],gp=[0,Ak(Ov),826,30],_p=[0,Ak(Ov),827,30],Tp=[0,Ak(Ov),831,26],Sp=[0,Ak(Ov),832,26],Ep=[0,Ak(Ov),841,28],xp=[0,Ak(Ov),842,28],Ap=[0,Ak(Ov),846,23],Ip=Ak("%u"),Cp=[0,Ak(Ov),1520,4],Np=Ak("Printf: bad conversion %["),Op=[0,Ak(Ov),1588,39],Rp=[0,Ak(Ov),1611,31],Lp=[0,Ak(Ov),1612,31],Pp=Ak("Printf: bad conversion %_"),Up=Ak("@{"),Dp=Ak("@["),Fp=Ak(mo),Mp=Ak(Qe),Xp=Ak("neg_infinity"),jp=Ak(ge),Bp=Ak("%.12g"),qp=Ak("%nd"),Gp=Ak("%+nd"),Yp=Ak("% nd"),Jp=Ak("%ni"),Hp=Ak("%+ni"),Wp=Ak("% ni"),Vp=Ak("%nx"),zp=Ak("%#nx"),Kp=Ak("%nX"),Qp=Ak("%#nX"),$p=Ak("%no"),Zp=Ak("%#no"),tm=Ak("%nu"),em=Ak("%ld"),rm=Ak("%+ld"),am=Ak("% ld"),nm=Ak("%li"),sm=Ak("%+li"),cm=Ak("% li"),im=Ak("%lx"),um=Ak("%#lx"),fm=Ak("%lX"),om=Ak("%#lX"),vm=Ak("%lo"),lm=Ak("%#lo"),bm=Ak("%lu"),km=Ak("%Ld"),dm=Ak("%+Ld"),hm=Ak("% Ld"),pm=Ak("%Li"),mm=Ak("%+Li"),wm=Ak("% Li"),ym=Ak("%Lx"),gm=Ak("%#Lx"),_m=Ak("%LX"),Tm=Ak("%#LX"),Sm=Ak("%Lo"),Em=Ak("%#Lo"),xm=Ak("%Lu"),Am=Ak(sn),Im=Ak("%+d"),Cm=Ak("% d"),Nm=Ak("%i"),Om=Ak("%+i"),Rm=Ak("% i"),Lm=Ak("%x"),Pm=Ak("%#x"),Um=Ak("%X"),Dm=Ak("%#X"),Fm=Ak("%o"),Mm=Ak("%#o"),Xm=Ak("%u"),jm=Ak("@]"),Bm=Ak("@}"),qm=Ak("@?"),Gm=Ak("@\n"),Ym=Ak("@."),Jm=Ak("@@"),Hm=Ak("@%"),Wm=Ak("@"),Vm=Ak("CamlinternalFormat.Type_mismatch"),zm=Ak(Of),Km=[0,[11,Ak(", "),[2,0,[2,0,0]]],Ak(", %s%s")],Qm=Ak("Out of memory"),$m=Ak("Stack overflow"),Zm=Ak("Pattern matching failed"),tw=Ak("Assertion failed"),ew=Ak("Undefined recursive module"),rw=[0,[12,40,[2,0,[2,0,[12,41,0]]]],Ak("(%s%s)")],aw=Ak(Of),nw=Ak(Of),sw=[0,[12,40,[2,0,[12,41,0]]],Ak("(%s)")],cw=[0,[4,0,0,0,0],Ak(sn)],iw=[0,[3,0,0],Ak("%S")],uw=Ak("_"),fw=[3,0,3],ow=Ak(Qe),vw=Ak(">"),lw=Ak(""),kw=Ak("<"),dw=Ak("\n"),hw=Ak("Format.Empty_queue"),pw=[0,Ak(Of)],mw=Ak("TMPDIR"),ww=Ak("TEMP"),yw=Ak("Cygwin"),gw=Ak(Jv),_w=Ak("Win32"),Tw=[0,Ak("filename.ml"),191,9],Sw=[0,Ak("sedlexing.ml"),51,25],Ew=Ak("Sedlexing.MalFormed"),xw=Ak("Js.Error"),Aw=Ak(tv),Iw=[0,[0]],Cw=[0,Ak(Bf),15,6],Nw=[0,[0]],Ow=[0,Ak(Bf),19,6],Rw=[0,[0,[0,[0]]]],Lw=[0,Ak(Bf),40,6],Pw=[0,[0]],Uw=[0,Ak(Bf),47,6],Dw=[0,[0]],Fw=[0,Ak(Bf),54,6],Mw=[0,[0]],Xw=[0,Ak(Bf),59,6],jw=[0,[0,[0,[0,[0,[0]],[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]]]],Bw=[0,Ak(Bf),219,6],qw=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],Gw=[0,Ak(Bf),540,6],Yw=[0,[0,[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0,[0,[0]],[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]]]],Jw=[0,Ak(Bf),815,6],Hw=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],Ww=[0,Ak(Bf),927,6],Vw=[0,[0,[0,[0,[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]]]],zw=[0,Ak(Bf),992,6],Kw=[0,[0]],Qw=[0,Ak(Bf),999,6],$w=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],Zw=[0,Ak(Bf),1063,6],ty=[0,[0,[0,[0]],[0,[0]]]],ey=[0,Ak(Bf),1093,6],ry=[0,[0]],ay=[0,[0]],ny=[0,[0,[0,[0]]]],sy=[0,[0]],cy=[0,[0]],iy=[0,[0]],uy=[0,[0,[0,[0,[0,[0]],[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]]]],fy=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],oy=[0,[0,[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0,[0,[0]],[0,[0]]]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]],[0,[0]]]],vy=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],ly=[0,[0,[0,[0,[0,[0]],[0,[0]]]],[0,[0,[0,[0]]]],[0,[0]],[0,[0]]]],by=[0,[0]],ky=[0,[0,[0,[0]],[0,[0]],[0,[0]],[0,[0]],[0,[0]]]],dy=[0,[0,[0,[0]],[0,[0]]]],hy=Ak(ka),py=Ak("Unexpected number"),my=Ak("Unexpected string"),wy=Ak("Unexpected identifier"),yy=Ak("Unexpected reserved word"),gy=Ak("Unexpected reserved type"),_y=Ak("Unexpected `super` outside of a class method"),Ty=Ak("`super()` is only valid in a class constructor"),Sy=Ak("Unexpected end of input"),Ey=Ak("Unexpected variance sigil"),xy=Ak("Unexpected static modifier"),Ay=Ak("Type aliases are not allowed in untyped mode"),Iy=Ak("Opaque type aliases are not allowed in untyped mode"),Cy=Ak("Type annotations are not allowed in untyped mode"),Ny=Ak("Type declarations are not allowed in untyped mode"),Oy=Ak("Type imports are not allowed in untyped mode"),Ry=Ak("Type exports are not allowed in untyped mode"),Ly=Ak("Interfaces are not allowed in untyped mode"),Py=Ak("Illegal newline after throw"),Uy=Ak("Invalid regular expression"),Dy=Ak("Invalid regular expression: missing /"),Fy=Ak("Invalid left-hand side in assignment"),My=Ak("Invalid left-hand side in exponentiation expression"),Xy=Ak("Invalid left-hand side in for-in"),jy=Ak("Invalid left-hand side in for-of"),By=Ak("found an expression instead"),qy=Ak("Expected an object pattern, array pattern, or an identifier but "),Gy=Ak("More than one default clause in switch statement"),Yy=Ak("Missing catch or finally after try"),Jy=Ak("Illegal continue statement"),Hy=Ak("Illegal break statement"),Wy=Ak("Illegal return statement"),Vy=Ak("Illegal Unicode escape"),zy=Ak("Strict mode code may not include a with statement"),Ky=Ak("Catch variable may not be eval or arguments in strict mode"),Qy=Ak("Variable name may not be eval or arguments in strict mode"),$y=Ak("Parameter name eval or arguments is not allowed in strict mode"),Zy=Ak("Strict mode function may not have duplicate parameter names"),tg=Ak("Function name may not be eval or arguments in strict mode"),eg=Ak("Octal literals are not allowed in strict mode."),rg=Ak("Delete of an unqualified identifier in strict mode."),ag=Ak("Duplicate data property in object literal not allowed in strict mode"),ng=Ak("Object literal may not have data and accessor property with the same name"),sg=Ak("Object literal may not have multiple get/set accessors with the same name"),cg=Ak("Assignment to eval or arguments is not allowed in strict mode"),ig=Ak("Postfix increment/decrement may not have eval or arguments operand in strict mode"),ug=Ak("Prefix increment/decrement may not have eval or arguments operand in strict mode"),fg=Ak("Use of future reserved word in strict mode"),og=Ak("JSX attributes must only be assigned a non-empty expression"),vg=Ak("JSX value should be either an expression or a quoted JSX text"),lg=Ak("Const must be initialized"),bg=Ak("Destructuring assignment must be initialized"),kg=Ak("Illegal newline before arrow"),dg=Ak(Qa),hg=Ak("Async functions can only be declared at top level or "),pg=Ak(Qa),mg=Ak("Generators can only be declared at top level or "),wg=Ak("elements must be wrapped in an enclosing parent tag"),yg=Ak("Unexpected token <. Remember, adjacent JSX "),gg=Ak("Rest parameter must be final parameter of an argument list"),_g=Ak("Rest element must be final element of an array pattern"),Tg=Ak("Rest property must be final property of an object pattern"),Sg=Ak("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."),Eg=Ak("`declare export let` is not supported. Use `declare export var` instead."),xg=Ak("`declare export const` is not supported. Use `declare export var` instead."),Ag=Ak("`declare export type` is not supported. Use `export type` instead."),Ig=Ak("`declare export interface` is not supported. Use `export interface` instead."),Cg=Ak("`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"),Ng=Ak("When exporting a class as a named export, you must specify a class name. Did you mean `export default class ...`?"),Og=Ak("When exporting a function as a named export, you must specify a function name. Did you mean `export default function ...`?"),Rg=Ak("Found a decorator in an unsupported position."),Lg=Ak("Type parameter declaration needs a default, since a preceding type parameter declaration has a default."),Pg=Ak("The Windows version of OCaml has a bug in how it parses hexadecimal numbers. It is fixed in OCaml 4.03.0. Until we can switch to 4.03.0, please avoid either hexadecimal notation or Windows."),Ug=Ak("Duplicate `declare module.exports` statement!"),Dg=Ak("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."),Fg=Ak("Getter should have zero parameters"),Mg=Ak("Setter should have exactly one parameter"),Xg=Ak("`import type` or `import typeof`!"),jg=Ak("Imports within a `declare module` body must always be "),Bg=Ak("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"),qg=Ak("Missing comma between import specifiers"),Gg=Ak("Missing comma between export specifiers"),Yg=Ak("Malformed unicode"),Jg=Ak("Classes may only have one constructor"),Hg=Ak("Classes may not have private methods."),Wg=Ak("Private fields may not be deleted."),Vg=Ak("Private fields can only be referenced from within a class."),zg=Ak("You may not access a private field through the `super` keyword."),Kg=Ak("Yield expression not allowed in formal parameter"),Qg=Ak("`await` is an invalid identifier in async functions"),$g=Ak("`yield` is an invalid identifier in generators"),Zg=Ak("either a `let` binding pattern, or a member expression."),t_=Ak("`let [` is ambiguous in this position because it is "),e_=Ak("Literals cannot be used as shorthand properties."),r_=Ak("Computed properties must have a value."),a_=Ak("Object pattern can't contain methods"),n_=Ak("A trailing comma is not permitted after the rest element"),s_=Ak("The optional chaining plugin must be enabled in order to use the optional chaining operator (`?.`). Optional chaining is an active early-stage feature proposal which may change and is not enabled by default. To enable support in the parser, use the `esproposal_optional_chaining` option."),c_=Ak("`new` may not be combined with an optional chain."),i_=Ak("Template literals may not be used in an optional chain."),u_=Ak("Unexpected parser state: "),f_=Ak("Unexpected token "),o_=[0,[11,Ak("Unexpected token `"),[2,0,[11,Ak("`. Did you mean `"),[2,0,[11,Ak("`?"),0]]]]],Ak("Unexpected token `%s`. Did you mean `%s`?")],v_=Ak("'"),l_=Ak("Invalid flags supplied to RegExp constructor '"),b_=Ak("'"),k_=Ak("Undefined label '"),d_=Ak("' has already been declared"),h_=Ak(" '"),p_=Ak("Expected corresponding JSX closing tag for "),m_=Ak(Qa),w_=Ak("In strict mode code, functions can only be declared at top level or "),y_=Ak("inside a block, or as the body of an if statement."),g_=Ak("In non-strict mode code, functions can only be declared at top level, "),__=[0,[11,Ak("Duplicate export for `"),[2,0,[12,96,0]]],Ak("Duplicate export for `%s`")],T_=Ak("` is declared more than once."),S_=Ak("Private fields may only be declared once. `#"),E_=Ak("static "),x_=Ak(Of),A_=Ak("#"),I_=Ak("`."),C_=Ak("fields named `"),N_=Ak("Classes may not have "),O_=Ak("` has not been declared."),R_=Ak("Private fields must be declared before they can be referenced. `#"),L_=Ak("Parse_error.Error"),P_=Ak("comments"),U_=Ak(Rn),D_=Ak("Program"),F_=Ak("DebuggerStatement"),M_=Ak("EmptyStatement"),X_=Ak(mi),j_=Ak("BreakStatement"),B_=Ak(mi),q_=Ak("ContinueStatement"),G_=Ak(ql),Y_=Ak("DeclareExportAllDeclaration"),J_=Ak(ql),H_=Ak(sk),W_=Ak(is),V_=Ak(Cf),z_=Ak("DeclareExportDeclaration"),K_=Ak(tr),Q_=Ak(Rn),$_=Ak(Jc),Z_=Ak("DeclareModule"),tT=Ak(tk),eT=Ak("DeclareModuleExports"),rT=Ak(dc),aT=Ak(Rn),nT=Ak("DoWhileStatement"),sT=Ak(Rf),cT=Ak(is),iT=Ak("ExportDefaultDeclaration"),uT=Ak(Rf),fT=Ak(ql),oT=Ak("ExportAllDeclaration"),vT=Ak(Rf),lT=Ak(ql),bT=Ak(sk),kT=Ak(is),dT=Ak("ExportNamedDeclaration"),hT=Ak("directive"),pT=Ak(Ar),mT=Ak("ExpressionStatement"),wT=Ak(Rn),yT=Ak("update"),gT=Ak(dc),_T=Ak(ks),TT=Ak("ForStatement"),ST=Ak("each"),ET=Ak(Rn),xT=Ak(Cn),AT=Ak(Du),IT=Ak("ForInStatement"),CT=Ak("ForAwaitStatement"),NT=Ak("ForOfStatement"),OT=Ak(Rn),RT=Ak(Cn),LT=Ak(Du),PT=Ak(Je),UT=Ak(y),DT=Ak(dc),FT=Ak("IfStatement"),MT=Ak(se),XT=Ak(Wu),jT=Ak(Cr),BT=Ak(lk),qT=Ak(ql),GT=Ak(sk),YT=Ak("ImportDeclaration"),JT=Ak(Rn),HT=Ak(mi),WT=Ak("LabeledStatement"),VT=Ak(Df),zT=Ak("ReturnStatement"),KT=Ak("cases"),QT=Ak("discriminant"),$T=Ak("SwitchStatement"),ZT=Ak(Df),tS=Ak("ThrowStatement"),eS=Ak("finalizer"),rS=Ak("handler"),aS=Ak("block"),nS=Ak("TryStatement"),sS=Ak(Rn),cS=Ak(dc),iS=Ak("WhileStatement"),uS=Ak(Rn),fS=Ak(uu),oS=Ak("WithStatement"),vS=Ak("Super"),lS=Ak("ThisExpression"),bS=Ak(Rv),kS=Ak("ArrayExpression"),dS=Ak(ic),hS=Ak(xu),pS=Ak(Ar),mS=Ak(vl),wS=Ak(Kl),yS=Ak(Ru),gS=Ak(Rn),_S=Ak(A),TS=Ak(Jc),SS=Ak("ArrowFunctionExpression"),ES=Ak("="),xS=Ak("+="),AS=Ak("-="),IS=Ak("*="),CS=Ak("**="),NS=Ak("/="),OS=Ak("%="),RS=Ak("<<="),LS=Ak(">>="),PS=Ak(">>>="),US=Ak("|="),DS=Ak("^="),FS=Ak("&="),MS=Ak(Cn),XS=Ak(Du),jS=Ak(zv),BS=Ak("AssignmentExpression"),qS=Ak("=="),GS=Ak("!="),YS=Ak("==="),JS=Ak("!=="),HS=Ak("<"),WS=Ak("<="),VS=Ak(">"),zS=Ak(">="),KS=Ak("<<"),QS=Ak(">>"),$S=Ak(">>>"),ZS=Ak(zf),tE=Ak(Cu),eE=Ak("*"),rE=Ak("**"),aE=Ak(Io),nE=Ak("%"),sE=Ak("|"),cE=Ak("^"),iE=Ak("&"),uE=Ak("in"),fE=Ak(Lf),oE=Ak(Cn),vE=Ak(Du),lE=Ak(zv),bE=Ak("BinaryExpression"),kE=Ak(Sl),dE=Ak($n),hE=Ak(rl),pE=Ak(Bs),mE=Ak("filter"),wE=Ak("blocks"),yE=Ak("ComprehensionExpression"),gE=Ak(Je),_E=Ak(y),TE=Ak(dc),SE=Ak("ConditionalExpression"),EE=Ak("filter"),xE=Ak("blocks"),AE=Ak("GeneratorExpression"),IE=Ak($n),CE=Ak("Import"),NE=Ak(rl),OE=Ak(Bs),RE=Ak("&&"),LE=Ak("||"),PE=Ak(Cn),UE=Ak(Du),DE=Ak(zv),FE=Ak("LogicalExpression"),ME=Ak(Sl),XE=Ak(Xc),jE=Ak(Lo),BE=Ak(uu),qE=Ak("MemberExpression"),GE=Ak(Lo),YE=Ak("meta"),JE=Ak("MetaProperty"),HE=Ak($n),WE=Ak(rl),VE=Ak("NewExpression"),zE=Ak(Wn),KE=Ak("ObjectExpression"),QE=Ak(Kr),$E=Ak("SequenceExpression"),ZE=Ak(tk),tx=Ak(Ar),ex=Ak("TypeCastExpression"),rx=Ak(Df),ax=Ak("AwaitExpression"),nx=Ak(Cu),sx=Ak(zf),cx=Ak("!"),ix=Ak("~"),ux=Ak(Wu),fx=Ak(lo),ox=Ak(uc),vx=Ak("matched above"),lx=Ak(Df),bx=Ak("prefix"),kx=Ak(zv),dx=Ak("UnaryExpression"),hx=Ak("--"),px=Ak("++"),mx=Ak("prefix"),wx=Ak(Df),yx=Ak(zv),gx=Ak("UpdateExpression"),_x=Ak("delegate"),Tx=Ak(Df),Sx=Ak("YieldExpression"),Ex=Ak(ic),xx=Ak(xu),Ax=Ak(Ar),Ix=Ak(vl),Cx=Ak(Kl),Nx=Ak(Ru),Ox=Ak(Rn),Rx=Ak(A),Lx=Ak(Jc),Px=Ak("FunctionDeclaration"),Ux=Ak(ic),Dx=Ak(xu),Fx=Ak(Ar),Mx=Ak(vl),Xx=Ak(Kl),jx=Ak(Ru),Bx=Ak(Rn),qx=Ak(A),Gx=Ak(Jc),Yx=Ak("FunctionExpression"),Jx=Ak(Sl),Hx=Ak(tk),Wx=Ak(Kv),Vx=Ak(u),zx=Ak(Jc),Kx=Ak("PrivateName"),Qx=Ak(Sl),$x=Ak(tk),Zx=Ak(Kv),tA=Ak(u),eA=Ak(y),rA=Ak(dc),aA=Ak("SwitchCase"),nA=Ak(Rn),sA=Ak("param"),cA=Ak("CatchClause"),iA=Ak(Rn),uA=Ak("BlockStatement"),fA=Ak(Jc),oA=Ak("DeclareVariable"),vA=Ak(vl),lA=Ak(Jc),bA=Ak("DeclareFunction"),kA=Ak(vk),dA=Ak(Rn),hA=Ak(ic),pA=Ak(Jc),mA=Ak("DeclareClass"),wA=Ak(vk),yA=Ak(Rn),gA=Ak(ic),_A=Ak(Jc),TA=Ak("DeclareInterface"),SA=Ak(Cr),EA=Ak(se),xA=Ak(ta),AA=Ak("ExportNamespaceSpecifier"),IA=Ak(Cn),CA=Ak(ic),NA=Ak(Jc),OA=Ak("DeclareTypeAlias"),RA=Ak(Cn),LA=Ak(ic),PA=Ak(Jc),UA=Ak("TypeAlias"),DA=Ak("DeclareOpaqueType"),FA=Ak("OpaqueType"),MA=Ak("supertype"),XA=Ak("impltype"),jA=Ak(ic),BA=Ak(Jc),qA=Ak(tt),GA=Ak(De),YA=Ak(Xi),JA=Ak(ic),HA=Ak(ec),WA=Ak(Rn),VA=Ak(Jc),zA=Ak("ClassDeclaration"),KA=Ak(tt),QA=Ak(De),$A=Ak(Xi),ZA=Ak(ic),tI=Ak(ec),eI=Ak(Rn),rI=Ak(Jc),aI=Ak("ClassExpression"),nI=Ak(ic),sI=Ak(Jc),cI=Ak("ClassImplements"),iI=Ak(Rn),uI=Ak("ClassBody"),fI=Ak(P),oI=Ak(lt),vI=Ak($r),lI=Ak(En),bI=Ak(tt),kI=Ak(Xc),dI=Ak(cs),hI=Ak(tr),pI=Ak(Cr),mI=Ak(Bb),wI=Ak("MethodDefinition"),yI=Ak(b),gI=Ak(cs),_I=Ak(tk),TI=Ak(Cr),SI=Ak(Bb),EI=Ak("ClassPrivateProperty"),xI=Ak("Internal Error: Private name found in class prop"),AI=Ak(b),II=Ak(cs),CI=Ak(Xc),NI=Ak(tk),OI=Ak(Cr),RI=Ak(Bb),LI=Ak("ClassProperty"),PI=Ak(vk),UI=Ak(Rn),DI=Ak(ic),FI=Ak(Jc),MI=Ak("InterfaceDeclaration"),XI=Ak(ic),jI=Ak(Jc),BI=Ak("InterfaceExtends"),qI=Ak(tk),GI=Ak(Wn),YI=Ak("ObjectPattern"),JI=Ak(tk),HI=Ak(Rv),WI=Ak("ArrayPattern"),VI=Ak(Cn),zI=Ak(Du),KI=Ak("AssignmentPattern"),QI=Ak(Df),$I=Ak(Yb),ZI=Ak(Df),tC=Ak(Yb),eC=Ak(ks),rC=Ak(ks),aC=Ak($r),nC=Ak(En),sC=Ak(ki),cC=Ak(Xc),iC=Ak(Si),uC=Ak(lt),fC=Ak(tr),oC=Ak(Cr),vC=Ak(Bb),lC=Ak(Le),bC=Ak(Df),kC=Ak("SpreadProperty"),dC=Ak(Xc),hC=Ak(Si),pC=Ak(lt),mC=Ak(tr),wC=Ak(Cr),yC=Ak(Bb),gC=Ak(Le),_C=Ak(Df),TC=Ak("RestProperty"),SC=Ak(Df),EC=Ak("SpreadElement"),xC=Ak("each"),AC=Ak(Cn),IC=Ak(Du),CC=Ak("ComprehensionBlock"),NC=Ak("flags"),OC=Ak("pattern"),RC=Ak("regex"),LC=Ak(Be),PC=Ak(Cr),UC=Ak(Be),DC=Ak(Cr),FC=Ak(Xo),MC=Ak(Be),XC=Ak(Cr),jC=Ak(Xo),BC=Ak(Kr),qC=Ak("quasis"),GC=Ak("TemplateLiteral"),YC=Ak("cooked"),JC=Ak(Be),HC=Ak("tail"),WC=Ak(Cr),VC=Ak("TemplateElement"),zC=Ak("quasi"),KC=Ak("tag"),QC=Ak("TaggedTemplateExpression"),$C=Ak(J),ZC=Ak(ko),tN=Ak(cc),eN=Ak(tr),rN=Ak("declarations"),aN=Ak("VariableDeclaration"),nN=Ak(ks),sN=Ak(Jc),cN=Ak("VariableDeclarator"),iN=Ak(tr),uN=Ak("Variance"),fN=Ak("AnyTypeAnnotation"),oN=Ak("MixedTypeAnnotation"),vN=Ak("EmptyTypeAnnotation"),lN=Ak("VoidTypeAnnotation"),bN=Ak("NullLiteralTypeAnnotation"),kN=Ak("NumberTypeAnnotation"),dN=Ak("StringTypeAnnotation"),hN=Ak("BooleanTypeAnnotation"),pN=Ak(tk),mN=Ak("NullableTypeAnnotation"),wN=Ak(ic),yN=Ak("rest"),gN=Ak(xu),_N=Ak(A),TN=Ak("FunctionTypeAnnotation"),SN=Ak(Sl),EN=Ak(tk),xN=Ak(Kv),AN=Ak("FunctionTypeParam"),IN=[0,0,0,0],CN=Ak("callProperties"),NN=Ak("indexers"),ON=Ak(Wn),RN=Ak("exact"),LN=Ak("ObjectTypeAnnotation"),PN=Ak(ki),UN=Ak("There should not be computed object type property keys"),DN=Ak(ks),FN=Ak($r),MN=Ak(En),XN=Ak(tr),jN=Ak(b),BN=Ak(cs),qN=Ak(Sl),GN=Ak(lt),YN=Ak(Cr),JN=Ak(Bb),HN=Ak("ObjectTypeProperty"),WN=Ak(Df),VN=Ak("ObjectTypeSpreadProperty"),zN=Ak(b),KN=Ak(cs),QN=Ak(Cr),$N=Ak(Bb),ZN=Ak(Jc),tO=Ak("ObjectTypeIndexer"),eO=Ak(cs),rO=Ak(Cr),aO=Ak("ObjectTypeCallProperty"),nO=Ak("elementType"),sO=Ak("ArrayTypeAnnotation"),cO=Ak(Jc),iO=Ak("qualification"),uO=Ak("QualifiedTypeIdentifier"),fO=Ak(ic),oO=Ak(Jc),vO=Ak("GenericTypeAnnotation"),lO=Ak(bl),bO=Ak("UnionTypeAnnotation"),kO=Ak(bl),dO=Ak("IntersectionTypeAnnotation"),hO=Ak(Df),pO=Ak("TypeofTypeAnnotation"),mO=Ak(bl),wO=Ak("TupleTypeAnnotation"),yO=Ak(Be),gO=Ak(Cr),_O=Ak("StringLiteralTypeAnnotation"),TO=Ak(Be),SO=Ak(Cr),EO=Ak("NumberLiteralTypeAnnotation"),xO=Ak(Wc),AO=Ak(vc),IO=Ak(Be),CO=Ak(Cr),NO=Ak("BooleanLiteralTypeAnnotation"),OO=Ak("ExistsTypeAnnotation"),RO=Ak(tk),LO=Ak("TypeAnnotation"),PO=Ak(A),UO=Ak("TypeParameterDeclaration"),DO=Ak(Cf),FO=Ak(b),MO=Ak("bound"),XO=Ak(Kv),jO=Ak("TypeParameter"),BO=Ak(A),qO=Ak("TypeParameterInstantiation"),GO=Ak(i),YO=Ak("closingElement"),JO=Ak("openingElement"),HO=Ak("JSXElement"),WO=Ak("closingFragment"),VO=Ak(i),zO=Ak("openingFragment"),KO=Ak("JSXFragment"),QO=Ak("selfClosing"),$O=Ak("attributes"),ZO=Ak(Kv),tR=Ak("JSXOpeningElement"),eR=Ak("JSXOpeningFragment"),rR=Ak(Kv),aR=Ak("JSXClosingElement"),nR=Ak("JSXClosingFragment"),sR=Ak(Ar),cR=Ak("JSXSpreadChild"),iR=Ak(Cr),uR=Ak(Kv),fR=Ak("JSXAttribute"),oR=Ak(Df),vR=Ak("JSXSpreadAttribute"),lR=Ak("JSXEmptyExpression"),bR=Ak(Ar),kR=Ak("JSXExpressionContainer"),dR=Ak(Be),hR=Ak(Cr),pR=Ak("JSXText"),mR=Ak(Lo),wR=Ak(uu),yR=Ak("JSXMemberExpression"),gR=Ak(Kv),_R=Ak("namespace"),TR=Ak("JSXNamespacedName"),SR=Ak(Kv),ER=Ak("JSXIdentifier"),xR=Ak(ta),AR=Ak(hv),IR=Ak("ExportSpecifier"),CR=Ak(hv),NR=Ak("ImportDefaultSpecifier"),OR=Ak(hv),RR=Ak("ImportNamespaceSpecifier"),LR=Ak(lk),PR=Ak(hv),UR=Ak("imported"),DR=Ak("ImportSpecifier"),FR=Ak("Block"),MR=Ak("Line"),XR=Ak(Cr),jR=Ak(Cr),BR=Ak("DeclaredPredicate"),qR=Ak("InferredPredicate"),GR=Ak("message"),YR=Ak("loc"),JR=Ak(se),HR=Ak("loc"),WR=Ak("range"),VR=Ak("end"),zR=Ak("start"),KR=Ak(ql),QR=Ak("column"),$R=Ak("line"),ZR=[0,1,0],tL=Ak("{"),eL=Ak("}"),rL=Ak("{|"),aL=Ak("|}"),nL=Ak("("),sL=Ak(")"),cL=Ak("["),iL=Ak("]"),uL=Ak(";"),fL=Ak(","),oL=Ak(Qe),vL=Ak("=>"),lL=Ak("..."),bL=Ak("@"),kL=Ak("#"),dL=Ak(Ko),hL=Ak("if"),pL=Ak("in"),mL=Ak(Lf),wL=Ak(ca),yL=Ak(Te),gL=Ak(te),_L=Ak(kt),TL=Ak("try"),SL=Ak(J),EL=Ak(Nv),xL=Ak(pv),AL=Ak(cc),IL=Ak(ko),CL=Ak(Hr),NL=Ak(vc),OL=Ak(Wc),RL=Ak(fu),LL=Ak(Bu),PL=Ak(Wi),UL=Ak(Fb),DL=Ak(Cf),FL=Ak("do"),ML=Ak(Nl),XL=Ak("for"),jL=Ak(Ub),BL=Ak(vk),qL=Ak(cs),GL=Ak(Jn),YL=Ak(bv),JL=Ak(uc),HL=Ak(Wu),WL=Ak(lo),VL=Ak(ef),zL=Ak(Ke),KL=Ak(fi),QL=Ak(ff),$L=Ak(De),ZL=Ak(df),tP=Ak(Kt),eP=Ak(Se),rP=Ak(eu),aP=Ak($u),nP=Ak(D),sP=Ak(bi),cP=Ak(ur),iP=Ak(se),uP=Ak("opaque"),fP=Ak("of"),oP=Ak(Ru),vP=Ak(Nu),lP=Ak("%checks"),bP=Ak(">>>="),kP=Ak(">>="),dP=Ak("<<="),hP=Ak("^="),pP=Ak("|="),mP=Ak("&="),wP=Ak("%="),yP=Ak("/="),gP=Ak("*="),_P=Ak("**="),TP=Ak("-="),SP=Ak("+="),EP=Ak("="),xP=Ak("?."),AP=Ak("?"),IP=Ak(":"),CP=Ak("||"),NP=Ak("&&"),OP=Ak("|"),RP=Ak("^"),LP=Ak("&"),PP=Ak("=="),UP=Ak("!="),DP=Ak("==="),FP=Ak("!=="),MP=Ak("<="),XP=Ak(">="),jP=Ak("<"),BP=Ak(">"),qP=Ak("<<"),GP=Ak(">>"),YP=Ak(">>>"),JP=Ak(zf),HP=Ak(Cu),WP=Ak(Io),VP=Ak("*"),zP=Ak("**"),KP=Ak("%"),QP=Ak("!"),$P=Ak("~"),ZP=Ak("++"),tU=Ak("--"),eU=Ak(Of),rU=Ak("any"),aU=Ak(ab),nU=Ak(Ia),sU=Ak(jo),cU=Ak(pc),iU=Ak(lo),uU=Ak(Io),fU=Ak(Io),oU=Ak(wr),vU=Ak(If),lU=Ak("T_LCURLY"),bU=Ak("T_RCURLY"),kU=Ak("T_LCURLYBAR"),dU=Ak("T_RCURLYBAR"),hU=Ak("T_LPAREN"),pU=Ak("T_RPAREN"),mU=Ak("T_LBRACKET"),wU=Ak("T_RBRACKET"),yU=Ak("T_SEMICOLON"),gU=Ak("T_COMMA"),_U=Ak("T_PERIOD"),TU=Ak("T_ARROW"),SU=Ak("T_ELLIPSIS"),EU=Ak("T_AT"),xU=Ak("T_POUND"),AU=Ak("T_FUNCTION"),IU=Ak("T_IF"),CU=Ak("T_IN"),NU=Ak("T_INSTANCEOF"),OU=Ak("T_RETURN"),RU=Ak("T_SWITCH"),LU=Ak("T_THIS"),PU=Ak("T_THROW"),UU=Ak("T_TRY"),DU=Ak("T_VAR"),FU=Ak("T_WHILE"),MU=Ak("T_WITH"),XU=Ak("T_CONST"),jU=Ak("T_LET"),BU=Ak("T_NULL"),qU=Ak("T_FALSE"),GU=Ak("T_TRUE"),YU=Ak("T_BREAK"),JU=Ak("T_CASE"),HU=Ak("T_CATCH"),WU=Ak("T_CONTINUE"),VU=Ak("T_DEFAULT"),zU=Ak("T_DO"),KU=Ak("T_FINALLY"),QU=Ak("T_FOR"),$U=Ak("T_CLASS"),ZU=Ak("T_EXTENDS"),tD=Ak("T_STATIC"),eD=Ak("T_ELSE"),rD=Ak("T_NEW"),aD=Ak("T_DELETE"),nD=Ak("T_TYPEOF"),sD=Ak("T_VOID"),cD=Ak("T_ENUM"),iD=Ak("T_EXPORT"),uD=Ak("T_IMPORT"),fD=Ak("T_SUPER"),oD=Ak("T_IMPLEMENTS"),vD=Ak("T_INTERFACE"),lD=Ak("T_PACKAGE"),bD=Ak("T_PRIVATE"),kD=Ak("T_PROTECTED"),dD=Ak("T_PUBLIC"),hD=Ak("T_YIELD"),pD=Ak("T_DEBUGGER"),mD=Ak("T_DECLARE"),wD=Ak("T_TYPE"),yD=Ak("T_OPAQUE"),gD=Ak("T_OF"),_D=Ak("T_ASYNC"),TD=Ak("T_AWAIT"),SD=Ak("T_CHECKS"),ED=Ak("T_RSHIFT3_ASSIGN"),xD=Ak("T_RSHIFT_ASSIGN"),AD=Ak("T_LSHIFT_ASSIGN"),ID=Ak("T_BIT_XOR_ASSIGN"),CD=Ak("T_BIT_OR_ASSIGN"),ND=Ak("T_BIT_AND_ASSIGN"),OD=Ak("T_MOD_ASSIGN"),RD=Ak("T_DIV_ASSIGN"),LD=Ak("T_MULT_ASSIGN"),PD=Ak("T_EXP_ASSIGN"),UD=Ak("T_MINUS_ASSIGN"),DD=Ak("T_PLUS_ASSIGN"),FD=Ak("T_ASSIGN"),MD=Ak("T_PLING_PERIOD"),XD=Ak("T_PLING"),jD=Ak("T_COLON"),BD=Ak("T_OR"),qD=Ak("T_AND"),GD=Ak("T_BIT_OR"),YD=Ak("T_BIT_XOR"),JD=Ak("T_BIT_AND"),HD=Ak("T_EQUAL"),WD=Ak("T_NOT_EQUAL"),VD=Ak("T_STRICT_EQUAL"),zD=Ak("T_STRICT_NOT_EQUAL"),KD=Ak("T_LESS_THAN_EQUAL"),QD=Ak("T_GREATER_THAN_EQUAL"),$D=Ak("T_LESS_THAN"),ZD=Ak("T_GREATER_THAN"),tF=Ak("T_LSHIFT"),eF=Ak("T_RSHIFT"),rF=Ak("T_RSHIFT3"),aF=Ak("T_PLUS"),nF=Ak("T_MINUS"),sF=Ak("T_DIV"),cF=Ak("T_MULT"),iF=Ak("T_EXP"),uF=Ak("T_MOD"),fF=Ak("T_NOT"),oF=Ak("T_BIT_NOT"),vF=Ak("T_INCR"),lF=Ak("T_DECR"),bF=Ak("T_EOF"),kF=Ak("T_ANY_TYPE"),dF=Ak("T_MIXED_TYPE"),hF=Ak("T_EMPTY_TYPE"),pF=Ak("T_NUMBER_TYPE"),mF=Ak("T_STRING_TYPE"),wF=Ak("T_VOID_TYPE"),yF=Ak("T_NUMBER"),gF=Ak("T_STRING"),_F=Ak("T_TEMPLATE_PART"),TF=Ak("T_IDENTIFIER"),SF=Ak("T_REGEXP"),EF=Ak("T_ERROR"),xF=Ak("T_JSX_IDENTIFIER"),AF=Ak("T_JSX_TEXT"),IF=Ak("T_BOOLEAN_TYPE"),CF=Ak("T_NUMBER_SINGLETON_TYPE"),NF=Ak("*-/"),OF=Ak("*/"),RF=Ak("*-/"),LF=Ak(iv),PF=Ak(iv),UF=Ak("\\"),DF=Ak(iv),FF=Ak("${"),MF=Ak("\r\n"),XF=Ak("\r\n"),jF=Ak("\n"),BF=Ak(iv),qF=Ak("\\\\"),GF=Ak(iv),YF=Ak(Of),JF=Ak(Of),HF=Ak(Of),WF=Ak(Of),VF=Ak(iv),zF=Ak(iv),KF=Ak("'"),QF=Ak('"'),$F=Ak("<"),ZF=Ak("{"),tM=Ak(_l),eM=Ak("iexcl"),rM=Ak("aelig"),aM=Ak("Nu"),nM=Ak("Eacute"),sM=Ak("Atilde"),cM=Ak("'int'"),iM=Ak("AElig"),uM=Ak("Aacute"),fM=Ak("Acirc"),oM=Ak("Agrave"),vM=Ak("Alpha"),lM=Ak("Aring"),bM=[0,197],kM=[0,913],dM=[0,Ec],hM=[0,194],pM=[0,193],mM=[0,198],wM=[0,8747],yM=Ak("Auml"),gM=Ak("Beta"),_M=Ak("Ccedil"),TM=Ak("Chi"),SM=Ak("Dagger"),EM=Ak("Delta"),xM=Ak("ETH"),AM=[0,208],IM=[0,916],CM=[0,8225],NM=[0,935],OM=[0,199],RM=[0,914],LM=[0,196],PM=[0,195],UM=Ak("Icirc"),DM=Ak("Ecirc"),FM=Ak("Egrave"),MM=Ak("Epsilon"),XM=Ak("Eta"),jM=Ak("Euml"),BM=Ak("Gamma"),qM=Ak("Iacute"),GM=[0,205],YM=[0,915],JM=[0,203],HM=[0,919],WM=[0,917],VM=[0,200],zM=[0,202],KM=Ak("Igrave"),QM=Ak("Iota"),$M=Ak("Iuml"),ZM=Ak("Kappa"),tX=Ak("Lambda"),eX=Ak("Mu"),rX=Ak("Ntilde"),aX=[0,209],nX=[0,924],sX=[0,923],cX=[0,922],iX=[0,207],uX=[0,921],fX=[0,204],oX=[0,206],vX=[0,201],lX=Ak("Sigma"),bX=Ak("Otilde"),kX=Ak("OElig"),dX=Ak("Oacute"),hX=Ak("Ocirc"),pX=Ak("Ograve"),mX=Ak("Omega"),wX=Ak("Omicron"),yX=Ak("Oslash"),gX=[0,216],_X=[0,927],TX=[0,937],SX=[0,210],EX=[0,212],xX=[0,211],AX=[0,338],IX=Ak("Ouml"),CX=Ak("Phi"),NX=Ak("Pi"),OX=Ak("Prime"),RX=Ak("Psi"),LX=Ak("Rho"),PX=Ak("Scaron"),UX=[0,352],DX=[0,929],FX=[0,936],MX=[0,8243],XX=[0,928],jX=[0,934],BX=[0,214],qX=[0,213],GX=Ak("Uuml"),YX=Ak("THORN"),JX=Ak("Tau"),HX=Ak("Theta"),WX=Ak("Uacute"),VX=Ak("Ucirc"),zX=Ak("Ugrave"),KX=Ak("Upsilon"),QX=[0,933],$X=[0,217],ZX=[0,219],tj=[0,218],ej=[0,920],rj=[0,932],aj=[0,222],nj=Ak("Xi"),sj=Ak("Yacute"),cj=Ak("Yuml"),ij=Ak("Zeta"),uj=Ak("aacute"),fj=Ak("acirc"),oj=Ak("acute"),vj=[0,180],lj=[0,226],bj=[0,225],kj=[0,918],dj=[0,376],hj=[0,221],pj=[0,926],mj=[0,220],wj=[0,931],yj=[0,925],gj=Ak("delta"),_j=Ak("cap"),Tj=Ak("aring"),Sj=Ak("agrave"),Ej=Ak("alefsym"),xj=Ak("alpha"),Aj=Ak("amp"),Ij=Ak("and"),Cj=Ak("ang"),Nj=Ak("apos"),Oj=[0,39],Rj=[0,8736],Lj=[0,8743],Pj=[0,38],Uj=[0,945],Dj=[0,8501],Fj=[0,Qu],Mj=Ak("asymp"),Xj=Ak("atilde"),jj=Ak("auml"),Bj=Ak("bdquo"),qj=Ak("beta"),Gj=Ak("brvbar"),Yj=Ak("bull"),Jj=[0,8226],Hj=[0,166],Wj=[0,946],Vj=[0,8222],zj=[0,228],Kj=[0,227],Qj=[0,8776],$j=[0,229],Zj=Ak("copy"),tB=Ak("ccedil"),eB=Ak("cedil"),rB=Ak("cent"),aB=Ak("chi"),nB=Ak("circ"),sB=Ak("clubs"),cB=Ak("cong"),iB=[0,8773],uB=[0,9827],fB=[0,710],oB=[0,967],vB=[0,162],lB=[0,184],bB=[0,231],kB=Ak("crarr"),dB=Ak("cup"),hB=Ak("curren"),pB=Ak("dArr"),mB=Ak("dagger"),wB=Ak("darr"),yB=Ak("deg"),gB=[0,176],_B=[0,8595],TB=[0,8224],SB=[0,8659],EB=[0,164],xB=[0,8746],AB=[0,8629],IB=[0,169],CB=[0,8745],NB=Ak("fnof"),OB=Ak("ensp"),RB=Ak("diams"),LB=Ak("divide"),PB=Ak("eacute"),UB=Ak("ecirc"),DB=Ak("egrave"),FB=Ak(Ia),MB=Ak("emsp"),XB=[0,8195],jB=[0,8709],BB=[0,232],qB=[0,234],GB=[0,233],YB=[0,247],JB=[0,9830],HB=Ak("epsilon"),WB=Ak("equiv"),VB=Ak("eta"),zB=Ak("eth"),KB=Ak("euml"),QB=Ak("euro"),$B=Ak("exist"),ZB=[0,8707],tq=[0,8364],eq=[0,235],rq=[0,pl],aq=[0,951],nq=[0,8801],sq=[0,949],cq=[0,8194],iq=Ak("gt"),uq=Ak("forall"),fq=Ak("frac12"),oq=Ak("frac14"),vq=Ak("frac34"),lq=Ak("frasl"),bq=Ak("gamma"),kq=Ak("ge"),dq=[0,8805],hq=[0,947],pq=[0,8260],mq=[0,190],wq=[0,188],yq=[0,189],gq=[0,8704],_q=Ak("hArr"),Tq=Ak("harr"),Sq=Ak("hearts"),Eq=Ak("hellip"),xq=Ak("iacute"),Aq=Ak("icirc"),Iq=[0,238],Cq=[0,237],Nq=[0,8230],Oq=[0,9829],Rq=[0,8596],Lq=[0,8660],Pq=[0,62],Uq=[0,402],Dq=[0,948],Fq=[0,230],Mq=Ak("prime"),Xq=Ak("ndash"),jq=Ak("le"),Bq=Ak("kappa"),qq=Ak("igrave"),Gq=Ak("image"),Yq=Ak("infin"),Jq=Ak("iota"),Hq=Ak("iquest"),Wq=Ak("isin"),Vq=Ak("iuml"),zq=[0,239],Kq=[0,8712],Qq=[0,191],$q=[0,953],Zq=[0,8734],tG=[0,8465],eG=[0,236],rG=Ak("lArr"),aG=Ak("lambda"),nG=Ak("lang"),sG=Ak("laquo"),cG=Ak("larr"),iG=Ak("lceil"),uG=Ak("ldquo"),fG=[0,8220],oG=[0,8968],vG=[0,8592],lG=[0,171],bG=[0,10216],kG=[0,955],dG=[0,8656],hG=[0,954],pG=Ak("macr"),mG=Ak("lfloor"),wG=Ak("lowast"),yG=Ak("loz"),gG=Ak("lrm"),_G=Ak("lsaquo"),TG=Ak("lsquo"),SG=Ak("lt"),EG=[0,60],xG=[0,8216],AG=[0,8249],IG=[0,8206],CG=[0,9674],NG=[0,8727],OG=[0,8970],RG=Ak("mdash"),LG=Ak("micro"),PG=Ak("middot"),UG=Ak(Rc),DG=Ak("mu"),FG=Ak("nabla"),MG=Ak("nbsp"),XG=[0,160],jG=[0,8711],BG=[0,956],qG=[0,8722],GG=[0,183],YG=[0,181],JG=[0,8212],HG=[0,175],WG=[0,8804],VG=Ak("or"),zG=Ak("oacute"),KG=Ak("ne"),QG=Ak("ni"),$G=Ak("not"),ZG=Ak("notin"),tY=Ak("nsub"),eY=Ak("ntilde"),rY=Ak("nu"),aY=[0,957],nY=[0,241],sY=[0,8836],cY=[0,8713],iY=[0,172],uY=[0,8715],fY=[0,8800],oY=Ak("ocirc"),vY=Ak("oelig"),lY=Ak("ograve"),bY=Ak("oline"),kY=Ak("omega"),dY=Ak("omicron"),hY=Ak("oplus"),pY=[0,8853],mY=[0,959],wY=[0,969],yY=[0,Ce],gY=[0,242],_Y=[0,339],TY=[0,244],SY=[0,243],EY=Ak("part"),xY=Ak("ordf"),AY=Ak("ordm"),IY=Ak("oslash"),CY=Ak("otilde"),NY=Ak("otimes"),OY=Ak("ouml"),RY=Ak("para"),LY=[0,182],PY=[0,as],UY=[0,8855],DY=[0,Pc],FY=[0,Li],MY=[0,186],XY=[0,170],jY=Ak("permil"),BY=Ak("perp"),qY=Ak("phi"),GY=Ak("pi"),YY=Ak("piv"),JY=Ak("plusmn"),HY=Ak("pound"),WY=[0,163],VY=[0,177],zY=[0,982],KY=[0,960],QY=[0,966],$Y=[0,8869],ZY=[0,8240],tJ=[0,8706],eJ=[0,8744],rJ=[0,8211],aJ=Ak("sup1"),nJ=Ak("rlm"),sJ=Ak("raquo"),cJ=Ak("prod"),iJ=Ak("prop"),uJ=Ak("psi"),fJ=Ak("quot"),oJ=Ak("rArr"),vJ=Ak("radic"),lJ=Ak("rang"),bJ=[0,10217],kJ=[0,8730],dJ=[0,8658],hJ=[0,34],pJ=[0,968],mJ=[0,8733],wJ=[0,8719],yJ=Ak("rarr"),gJ=Ak("rceil"),_J=Ak("rdquo"),TJ=Ak("real"),SJ=Ak("reg"),EJ=Ak("rfloor"),xJ=Ak("rho"),AJ=[0,961],IJ=[0,8971],CJ=[0,174],NJ=[0,8476],OJ=[0,8221],RJ=[0,8969],LJ=[0,8594],PJ=[0,187],UJ=Ak("sigma"),DJ=Ak("rsaquo"),FJ=Ak("rsquo"),MJ=Ak("sbquo"),XJ=Ak("scaron"),jJ=Ak("sdot"),BJ=Ak("sect"),qJ=Ak("shy"),GJ=[0,173],YJ=[0,167],JJ=[0,8901],HJ=[0,353],WJ=[0,8218],VJ=[0,8217],zJ=[0,8250],KJ=Ak("sigmaf"),QJ=Ak("sim"),$J=Ak("spades"),ZJ=Ak("sub"),tH=Ak("sube"),eH=Ak("sum"),rH=Ak("sup"),aH=[0,8835],nH=[0,8721],sH=[0,8838],cH=[0,8834],iH=[0,9824],uH=[0,8764],fH=[0,962],oH=[0,963],vH=[0,8207],lH=Ak("uarr"),bH=Ak("thetasym"),kH=Ak("sup2"),dH=Ak("sup3"),hH=Ak("supe"),pH=Ak("szlig"),mH=Ak("tau"),wH=Ak("there4"),yH=Ak("theta"),gH=[0,952],_H=[0,8756],TH=[0,964],SH=[0,223],EH=[0,8839],xH=[0,179],AH=[0,178],IH=Ak("thinsp"),CH=Ak("thorn"),NH=Ak("tilde"),OH=Ak("times"),RH=Ak("trade"),LH=Ak("uArr"),PH=Ak("uacute"),UH=[0,cf],DH=[0,8657],FH=[0,8482],MH=[0,215],XH=[0,732],jH=[0,a],BH=[0,8201],qH=[0,977],GH=Ak("xi"),YH=Ak("ucirc"),JH=Ak("ugrave"),HH=Ak("uml"),WH=Ak("upsih"),VH=Ak("upsilon"),zH=Ak("uuml"),KH=Ak("weierp"),QH=[0,8472],$H=[0,Xb],ZH=[0,965],tW=[0,978],eW=[0,168],rW=[0,249],aW=[0,251],nW=Ak("yacute"),sW=Ak("yen"),cW=Ak("yuml"),iW=Ak("zeta"),uW=Ak("zwj"),fW=Ak("zwnj"),oW=[0,8204],vW=[0,Ou],lW=[0,950],bW=[0,Ll],kW=[0,165],dW=[0,Eu],hW=[0,958],pW=[0,8593],mW=[0,185],wW=[0,8242],yW=[0,161],gW=Ak(";"),_W=Ak("&"),TW=Ak(iv),SW=Ak("}"),EW=[0,Ak(Of),Ak(Of),Ak(Of)],xW=Ak(iv),AW=Ak(iv),IW=Ak(iv),CW=(Ak("789"),Ak(iv)),NW=Ak(iv),OW=Ak(iv),RW=Ak(iv),LW=Ak(":"),PW=Ak(":"),UW=Ak(mr),DW=(Ak("789"),[8,0]),FW=[8,1],MW=Ak(iv),XW=Ak(iv),jW=Ak("'"),BW=Ak(iv),qW=Ak(iv),GW=Ak(iv),YW=Ak(iv),JW=Ak(iv),HW=Ak(iv),WW=Ak(iv),VW=Ak(":"),zW=Ak(":"),KW=Ak(mr),QW=[5,Ak("#!")],$W=Ak("expected ?"),ZW=Ak(iv),tV=Ak(Ci),eV=Ak(V),rV=Ak(V),aV=Ak(Ci),nV=Ak("b"),sV=Ak(rc),cV=Ak("n"),iV=Ak("r"),uV=Ak("t"),fV=Ak("v"),oV=Ak(V),vV=Ak(_l),lV=Ak(_l),bV=Ak(iv),kV=Ak(_l),dV=Ak(_l),hV=Ak(iv),pV=Ak(V),mV=Ak(Ju),wV=Ak(Dn),yV=Ak(Mt),gV=(Ak("src/parser/lexer.ml"),Ak(Of),[1,Ak("ILLEGAL")]),_V=Ak(""),TV=Ak("\0"),SV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),EV=Ak(""),xV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),AV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),IV=Ak("\b\t\n\v\f\r"),CV=Ak(""),NV=Ak("\0"),OV=Ak(""),RV=Ak(""),LV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),PV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),UV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),DV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),FV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),MV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\b\0\0\0\0\0\b"),XV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),jV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),BV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),qV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),GV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),YV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),JV=Ak("\0\0\0"),HV=Ak("\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-./\t01\t2\t3456\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"),WV=Ak("\b\t\n\v\f\r !\"#$%&'("),VV=Ak(""),zV=Ak(""),KV=Ak("\0\0\0\0"),QV=Ak("\b\t\n\v\f\r"),$V=Ak("\0\0"),ZV=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),tz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),ez=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),rz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),az=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),nz=Ak(""),sz=Ak(""),cz=Ak(""),iz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),uz=Ak("\0"),fz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),oz=Ak("\0\0\0\0\0\0\0"),vz=Ak(""),lz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),bz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),kz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),dz=Ak("\0"),hz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),pz=Ak("\0"),mz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),wz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),yz=Ak(""),gz=Ak(""),_z=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Tz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Sz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Ez=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),xz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Az=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Iz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Cz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Nz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Oz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Rz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Lz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Pz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Uz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Dz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Fz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Mz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Xz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),jz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Bz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),qz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Gz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Yz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Jz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Hz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Wz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Vz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),zz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Kz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Qz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),$z=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),Zz=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),tK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),eK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),rK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),aK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),nK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),sK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),cK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),iK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\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=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),fK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),oK=Ak("\0"),vK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),lK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),bK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),kK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),dK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),hK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\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=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),mK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),wK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),yK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),gK=Ak("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"),_K=Ak("Lexer.FloatOfString.No_good"),TK=Ak(gt),SK=Ak(gt),EK=Ak(Hr),xK=Ak("any"),AK=Ak(If),IK=Ak(wr),CK=Ak(Ia),NK=Ak(vc),OK=Ak(ab),RK=Ak(jo),LK=Ak(cs),PK=Ak(pc),UK=Ak(Wc),DK=Ak(Wu),FK=Ak(lo),MK=Ak(vc),XK=Ak(Hr),jK=Ak(Wc),BK=Ak($n),qK=Ak("eval"),GK=Ak(De),YK=Ak(df),JK=Ak(Kt),HK=Ak(Se),WK=Ak(eu),VK=Ak($u),zK=Ak(cs),KK=Ak(D),QK=Ak(ef),$K=Ak("if"),ZK=Ak(Cf),tQ=Ak(Nu),eQ=Ak(fu),rQ=Ak(Bu),aQ=Ak(Wi),nQ=Ak(Ub),sQ=Ak(cc),cQ=Ak(Fb),iQ=Ak(bi),uQ=Ak(uc),fQ=Ak("do"),oQ=Ak(Jn),vQ=Ak(Ke),lQ=Ak(vk),bQ=Ak(Nl),kQ=Ak("for"),dQ=Ak(Ko),hQ=Ak(kt),pQ=Ak(fi),mQ=Ak("in"),wQ=Ak(Lf),yQ=Ak(bv),gQ=Ak(ca),_Q=Ak(ff),TQ=Ak(Te),SQ=Ak(te),EQ=Ak("try"),xQ=Ak(Wu),AQ=Ak(J),IQ=Ak(lo),CQ=Ak(Nv),NQ=Ak(pv),OQ=Ak(D),RQ=[0,Ak("src/parser/parser_env.ml"),343,2],LQ=Ak("Internal Error: Tried to add_declared_private with outside of class scope."),PQ=Ak("Internal Error: `exit_class` called before a matching `enter_class`"),UQ=Ak(Of),DQ=Ak(Of),FQ=[0,0,0],MQ=Ak(Bn),XQ=Ak(Bn),jQ=Ak("Parser_env.Try.Rollback"),BQ=Ak(Ko),qQ=Ak("if"),GQ=Ak("in"),YQ=Ak(Lf),JQ=Ak(ca),HQ=Ak(Te),WQ=Ak(te),VQ=Ak(kt),zQ=Ak("try"),KQ=Ak(J),QQ=Ak(Nv),$Q=Ak(pv),ZQ=Ak(cc),t$=Ak(ko),e$=Ak(Hr),r$=Ak(vc),a$=Ak(Wc),n$=Ak(fu),s$=Ak(Bu),c$=Ak(Wi),i$=Ak(Fb),u$=Ak(Cf),f$=Ak("do"),o$=Ak(Nl),v$=Ak("for"),l$=Ak(Ub),b$=Ak(vk),k$=Ak(cs),d$=Ak(Jn),h$=Ak(bv),p$=Ak(uc),m$=Ak(Wu),w$=Ak(lo),y$=Ak(ef),g$=Ak(Ke),_$=Ak(fi),T$=Ak(ff),S$=Ak(De),E$=Ak(df),x$=Ak(Kt),A$=Ak(Se),I$=Ak(eu),C$=Ak($u),N$=Ak(D),O$=Ak(bi),R$=Ak(ur),L$=Ak(se),P$=Ak("opaque"),U$=Ak("of"),D$=Ak(Ru),F$=Ak(Nu),M$=Ak("any"),X$=Ak(ab),j$=Ak(Ia),B$=Ak(jo),q$=Ak(pc),G$=Ak(lo),Y$=Ak(wr),J$=Ak(If),H$=Ak(Of),W$=[0,0,0],V$=[0,Ak(Xe),493,6],z$=Ak(cs),K$=Ak($r),Q$=Ak(En),$$=Ak($r),Z$=Ak(cs),tZ=[0,[0,0,0]],eZ=[0,4],rZ=[0,0],aZ=[0,1],nZ=[0,2],sZ=[0,5],cZ=[0,6],iZ=[0,3],uZ=[0,7],fZ=[0,Ak(Xe),90,17],oZ=[0,Ak(Xe),70,17],vZ=[0,36],lZ=[0,36],bZ=[0,0,0],kZ=[0,34],dZ=Ak(Io),hZ=Ak(Io),pZ=[0,Ak(ba),962,13],mZ=[0,Ak(ba),843,17],wZ=[0,[0,Ak(Of),Ak(Of)],1],yZ=Ak(Hr),gZ=Ak(Hr),_Z=Ak(Wc),TZ=Ak(vc),SZ=Ak(V),EZ=Ak(Ju),xZ=Ak(Dn),AZ=Ak(Mt),IZ=[0,36],CZ=[0,1],NZ=[0,1],OZ=[0,1],RZ=[0,1],LZ=[0,0],PZ=Ak(bv),UZ=Ak(q),DZ=[0,0],FZ=[0,80],MZ=[0,0,0],XZ=[0,1,0],jZ=[0,1,1],BZ=Ak(ff),qZ=[0,0],GZ=Ak(ff),YZ=[0,0],JZ=[0,1],HZ=[0,0],WZ=[0,1],VZ=[0,0],zZ=[0,1],KZ=[0,0],QZ=[0,2],$Z=[0,3],ZZ=[0,7],t0=[0,6],e0=[0,4],r0=[0,5],a0=[0,[0,17,[0,2]]],n0=[0,[0,18,[0,3]]],s0=[0,[0,19,[0,4]]],c0=[0,[0,0,[0,5]]],i0=[0,[0,1,[0,5]]],u0=[0,[0,2,[0,5]]],f0=[0,[0,3,[0,5]]],o0=[0,[0,5,[0,6]]],v0=[0,[0,7,[0,6]]],l0=[0,[0,4,[0,6]]],b0=[0,[0,6,[0,6]]],k0=[0,[0,8,[0,7]]],d0=[0,[0,9,[0,7]]],h0=[0,[0,10,[0,7]]],p0=[0,[0,11,[0,8]]],m0=[0,[0,12,[0,8]]],w0=[0,[0,15,[0,9]]],y0=[0,[0,13,[0,9]]],g0=[0,[0,14,[1,10]]],_0=[0,[0,16,[0,9]]],T0=[0,[0,21,[0,6]]],S0=[0,[0,20,[0,6]]],E0=[0,9],x0=[0,8],A0=[0,7],I0=[0,11],C0=[0,10],N0=[0,12],O0=[0,6],R0=[0,5],L0=[0,3],P0=[0,4],U0=[0,2],D0=[0,1],F0=[0,0],M0=Ak(bv),X0=Ak(q),j0=[0,5],B0=Ak(Ru),q0=Ak(bv),G0=Ak(q),Y0=Ak(":"),J0=Ak(Qe),H0=[6,Ak("JSX fragment")],W0=Ak(Of),V0=[0,Ak(Of)],z0=Ak(Of),K0=Ak(P),Q0=Ak(P),$0=Ak($r),Z0=Ak(En),t1=[0,1],e1=[0,1],r1=[0,1],a1=Ak(P),n1=Ak(oi),s1=Ak(oi),c1=Ak("#constructor"),i1=[1,Ak("=")],u1=Ak(D),f1=Ak(Nu),o1=Ak("Internal Error: private name found in object props"),v1=Ak($r),l1=Ak(En),b1=Ak(Nb),k1=Ak(D),d1=Ak(Nu),h1=Ak(D),p1=Ak(Nu),m1=Ak(Nb),w1=[0,1],y1=Ak(Hc),g1=Ak(yn),_1=[0,Ak(Ct),1199,15],T1=Ak(Hc),S1=Ak(Cf),E1=Ak("other than an interface declaration!"),x1=Ak("Internal Flow Error! Parsed `export interface` into something "),A1=Ak(yn),I1=Ak("Internal Flow Error! Unexpected export statement declaration!"),C1=[0,33],N1=Ak(Hc),O1=Ak(yn),R1=[0,Ak(Of),Ak(Of)],L1=Ak("module"),P1=Ak("exports"),U1=[0,1],D1=Ak("module"),F1=[0,1],M1=Ak("mixins"),X1=[0,0],j1=[0,1],B1=Ak(yn),q1=Ak(Hc),G1=[0,73],Y1=[0,73],J1=[0,0],H1=[0,1],W1=Ak(Hc),V1=Ak(Hc),z1=Ak(Hc),K1=Ak(yn),Q1=[0,Ak(Of),Ak(Of)],$1=Ak("Parser error: No such thing as an expression pattern!"),Z1=Ak("Label"),t2=[0,0,0],e2=[0,23],r2=[0,Ak(Ct),210,20],a2=[0,22],n2=[0,Ak(Ct),232,20],s2=Ak(Nu),c2=Ak(ko),i2=Ak(D),u2=Ak("use strict"),f2=[0,0,0],o2=Ak("\n"),v2=Ak("Nooo: "),l2=[0,[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]],b2=[0,Ak("src/parser/parser_flow.ml"),34,28],k2=[0,[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]],d2=Ak("Internal error: ");function h2(t){if("number"==typeof t)return 0;switch(t[0]){case 0:return[0,h2(t[1])];case 1:return[1,h2(t[1])];case 2:return[2,h2(t[1])];case 3:return[3,h2(t[1])];case 4:return[4,h2(t[1])];case 5:return[5,h2(t[1])];case 6:return[6,h2(t[1])];case 7:return[7,h2(t[1])];case 8:return[8,t[1],h2(t[2])];case 9:var e=t[1];return[9,e,e,h2(t[3])];case 10:return[10,h2(t[1])];case 11:return[11,h2(t[1])];case 12:return[12,h2(t[1])];case 13:return[13,h2(t[1])];default:return[14,h2(t[1])]}}function p2(t,e){if("number"==typeof t)return e;switch(t[0]){case 0:return[0,p2(t[1],e)];case 1:return[1,p2(t[1],e)];case 2:return[2,t[1],p2(t[2],e)];case 3:return[3,t[1],p2(t[2],e)];case 4:var r=t[3],a=t[2];return[4,t[1],a,r,p2(t[4],e)];case 5:var n=t[3],s=t[2];return[5,t[1],s,n,p2(t[4],e)];case 6:var c=t[3],i=t[2];return[6,t[1],i,c,p2(t[4],e)];case 7:var u=t[3],f=t[2];return[7,t[1],f,u,p2(t[4],e)];case 8:var o=t[3],v=t[2];return[8,t[1],v,o,p2(t[4],e)];case 9:return[9,p2(t[1],e)];case 10:return[10,p2(t[1],e)];case 11:return[11,t[1],p2(t[2],e)];case 12:return[12,t[1],p2(t[2],e)];case 13:var l=t[2];return[13,t[1],l,p2(t[3],e)];case 14:var b=t[2];return[14,t[1],b,p2(t[3],e)];case 15:return[15,p2(t[1],e)];case 16:return[16,p2(t[1],e)];case 17:return[17,t[1],p2(t[2],e)];case 18:return[18,t[1],p2(t[2],e)];case 19:return[19,p2(t[1],e)];case 20:var k=t[2];return[20,t[1],k,p2(t[3],e)];case 21:return[21,t[1],p2(t[2],e)];case 22:return[22,p2(t[1],e)];case 23:return[23,t[1],p2(t[2],e)];default:var d=t[2];return[24,t[1],d,p2(t[3],e)]}}function m2(t){throw[0,ah,t]}function w2(t){throw[0,nh,t]}function y2(t){return 0<=t?t:0|-t}Hk();var g2=qn;function _2(t,e){var r=sd(t),a=sd(e),n=Dk(r+a|0);return yk(t,0,n,0,r),yk(e,0,n,r,a),n}function T2(t,e){return t?[0,t[1],T2(t[2],e)]:e}!function(t){var e=dk.fds[t];e.flags.wronly&&yd(X+t+" is writeonly");var r={file:e.file,offset:e.offset,fd:t,opened:!0,out:!1,refill:null};gd[r.fd]=r}(0);var S2=Md(1),E2=Md(2),x2=[0,function(t){return function(t){for(var e=t;;){if(!e)return 0;var r=e[2],a=e[1];try{_d(a)}catch(e){}e=r}}(function(){for(var t=0,e=0;e0)if(0==e&&(r>=t.l||2==t.t&&r>=t.c.length))0==a?(t.c=Of,t.t=2):(t.c=_k(r,String.fromCharCode(a)),t.t=r==t.l?0:2);else for(4!=t.t&&wk(t),r+=e;e=1;s--)r[a+s]=t[e+s];return 0}(t,e,r,a,n):w2(Dh)}function K2(t,e){var r=e.length-1-1|0;if(!(r<0))for(var a=0;;){if(Qd(t,e[a+1]),r===a)break;a=a+1|0}return 0}function Q2(t){if(t)for(var e=0,r=t,a=t[2],n=t[1];;)if(r)e=e+1|0,r=r[2];else for(var s=wd(e,n),c=1,i=a;;){if(!i)return s;var u=i[2];s[c+1]=i[1];c=c+1|0,i=u}return[0]}function $2(t){function e(t){return t?t[4]:0}function r(t,e,r){var a=t?t[4]:0,n=r?r[4]:0;return[0,t,e,r,n<=a?a+1|0:n+1|0]}function a(t,a,n){var s=t?t[4]:0,c=n?n[4]:0;if((c+2|0)>1,y=P2(w,e),g=d(w,e),_=d(t-w|0,y),T=0;;){if(g){if(_){var S=_[2],E=_[1],x=g[2],A=g[1],I=$d(b,A,E);if(0===I){g=x,_=S,T=[0,A,T];continue}if(0>1,y=P2(w,e),g=k(w,e),_=k(t-w|0,y),T=0;;){if(g){if(_){var S=_[2],E=_[1],x=g[2],A=g[1],I=$d(b,A,E);if(0===I){g=x,_=S,T=[0,A,T];continue}if(0<=I){_=S,T=[0,E,T];continue}g=x,T=[0,A,T];continue}return C2(g,T)}return C2(_,T)}},h=A2(e),p=2<=h?k(h,e):e,m=function(t,e){if(!(3>>0))switch(t){case 0:return[0,0,e];case 1:if(e)return[0,[0,0,e[1],0,1],e[2]];break;case 2:if(e){var a=e[2];if(a)return[0,[0,[0,0,e[1],0,1],a[1],0,2],a[2]]}break;default:if(e){var n=e[2];if(n){var s=n[2];if(s)return[0,[0,[0,0,e[1],0,1],n[1],[0,0,s[1],0,1],2],s[2]]}}}var c=t/2|0,i=m(c,e),u=i[2],f=i[1];if(u){var o=u[1],v=m((t-c|0)-1|0,u[2]),l=v[2];return[0,r(f,o,v[1]),l]}throw[0,uh,qh]};return m(A2(p),p)[1]}return n(v[1],n(l,n(o,n(u,s(c)))))}return n(l,n(o,n(u,s(c))))}return n(o,n(u,s(c)))}return n(u,s(c))}return s(c)}return 0}]}function Z2(t){var e=1<=t?t:1,r=W2>>0?1:0:65<=n?0:1;else{if(32===n)var c=1;else if(43<=n)switch(n+R|0){case 5:if(a<(r+2|0)&&1>>0)if(93<=n)var s=0;else s=1;else if(56<(n-1|0)>>>0)s=0;else s=1;if(s){e=e+1|0;continue}}else;r=1}if(r){var c=[0,0],i=sd(t)-1|0;if(!(i<0))for(var u=0;;){var f=cd(t,u);if(32<=f){var o=f+Pv|0;if(58>>0)if(93<=o)var v=0,l=0;else l=1;else if(56<(o-1|0)>>>0)v=1,l=0;else l=1;if(l){var b=1;v=2}}else v=11<=f?13===f?1:0:8<=f?1:0;switch(v){case 0:b=4;break;case 1:b=2}if(c[1]=c[1]+b|0,i===u)break;u=u+1|0}if(c[1]===sd(t)){var k=sd(t),d=Dk(k);yk(t,0,d,0,k);var h=d}else{var p=Dk(c[1]);c[1]=0;var m=sd(t)-1|0;if(!(m<0))for(var w=0;;){var y=cd(t,w);if(35<=y)var g=92===y?1:uo<=y?0:2;else if(32<=y)g=34<=y?1:2;else if(14<=y)g=0;else switch(y){case 8:Nd(p,c[1],92),c[1]++,Nd(p,c[1],98);g=3;break;case 9:Nd(p,c[1],92),c[1]++,Nd(p,c[1],Qb);g=3;break;case 10:Nd(p,c[1],92),c[1]++,Nd(p,c[1],ou);g=3;break;case 13:Nd(p,c[1],92),c[1]++,Nd(p,c[1],Br);g=3;break;default:g=0}switch(g){case 0:Nd(p,c[1],92),c[1]++,Nd(p,c[1],48+(y/Uf|0)|0),c[1]++,Nd(p,c[1],48+((y/10|0)%10|0)|0),c[1]++,Nd(p,c[1],48+(y%10|0)|0);break;case 1:Nd(p,c[1],92),c[1]++,Nd(p,c[1],y);break;case 2:Nd(p,c[1],y)}if(c[1]++,m===w)break;w=w+1|0}h=p}}else h=t;var _=sd(h),T=F2(_+2|0,34);return yk(h,0,T,1,_),T}}function T3(t,e){switch(t){case 0:var r=Am;break;case 1:r=Im;break;case 2:r=Cm;break;case 3:r=Nm;break;case 4:r=Om;break;case 5:r=Rm;break;case 6:r=Lm;break;case 7:r=Pm;break;case 8:r=Um;break;case 9:r=Dm;break;case 10:r=Fm;break;case 11:r=Mm;break;default:r=Xm}return Yk(r,e)}function S3(t,e){switch(t){case 0:var r=em;break;case 1:r=rm;break;case 2:r=am;break;case 3:r=nm;break;case 4:r=sm;break;case 5:r=cm;break;case 6:r=im;break;case 7:r=um;break;case 8:r=fm;break;case 9:r=om;break;case 10:r=vm;break;case 11:r=lm;break;default:r=bm}return Yk(r,e)}function E3(t,e){switch(t){case 0:var r=qp;break;case 1:r=Gp;break;case 2:r=Yp;break;case 3:r=Jp;break;case 4:r=Hp;break;case 5:r=Wp;break;case 6:r=Vp;break;case 7:r=zp;break;case 8:r=Kp;break;case 9:r=Qp;break;case 10:r=$p;break;case 11:r=Zp;break;default:r=tm}return Yk(r,e)}function x3(t,e){switch(t){case 0:var r=km;break;case 1:r=dm;break;case 2:r=hm;break;case 3:r=pm;break;case 4:r=mm;break;case 5:r=wm;break;case 6:r=ym;break;case 7:r=gm;break;case 8:r=_m;break;case 9:r=Tm;break;case 10:r=Sm;break;case 11:r=Em;break;default:r=xm}return function(t,e){var r=Bk(t);r.signedconv&&function(t){return t[3]<<16<0}(e)&&(r.sign=-1,e=nd(e));var a=Of,n=Kk(r.base);do{var s=rd(e,n);e=s[1],a="0123456789abcdef".charAt(ad(s[2]))+a}while(!zk(e));if(r.prec>=0){r.filler=qb;var c=r.prec-a.length;c>0&&(a=_k(c,Ci)+a)}return qk(r,a)}(r,e)}function A3(t,e,r){if(16<=t){if(17<=t)switch(t+jf|0){case 2:var a=0;break;case 0:case 3:var n=43;a=1;break;default:n=32,a=1}else a=0;if(!a)n=45;var s=function(t,e,r){if(!isFinite(t))return isNaN(t)?Vk(mo):Vk(t>0?ge:"-infinity");var a=0==t&&1/t==-1/0?1:t>=0?0:1;a&&(t=-t);var n=0;if(0==t);else if(t<1)for(;t<1&&n>-1022;)t*=2,n--;else for(;t>=2;)t/=2,n++;var s=n<0?Of:zf,c=Of;if(a)c=Cu;else switch(r){case 43:c=zf;break;case 32:c=qb}if(e>=0&&e<13){var i=Math.pow(2,4*e);t=Math.round(t*i)/i}var u=t.toString(16);if(e>=0){var f=u.indexOf(Qe);if(f<0)u+=Qe+_k(e,Ci);else{var o=f+1+e;u.length=2.2250738585072014e-308?0:0!=t?1:2:isNaN(t)?4:3}(r),w=sd(p);if(3===m)return r<0?Xp:jp;if(4<=m)return Fp;for(var y=0;;){if(y===w)var g=0;else{var _=Ed(p,y)+Ms|0;if(!(23<_>>>0?55===_?1:0:21<(_-1|0)>>>0?1:0)){y=y+1|0;continue}g=1}return g?p:_2(p,Mp)}}return p}function I3(t,e,r,a,n,s,c,i){if("number"==typeof n){if("number"==typeof s)return 0===s?function(n){return P3(t,e,[4,r,$d(c,i,n)],a)}:function(n,s){return P3(t,e,[4,r,g3(n,$d(c,i,s))],a)};var u=s[1];return function(n){return P3(t,e,[4,r,g3(u,$d(c,i,n))],a)}}if(0===n[0]){var f=n[2],o=n[1];if("number"==typeof s)return 0===s?function(n){return P3(t,e,[4,r,y3(o,f,$d(c,i,n))],a)}:function(n,s){return P3(t,e,[4,r,y3(o,f,g3(n,$d(c,i,s)))],a)};var v=s[1];return function(n){return P3(t,e,[4,r,y3(o,f,g3(v,$d(c,i,n)))],a)}}var l=n[1];if("number"==typeof s)return 0===s?function(n,s){return P3(t,e,[4,r,y3(l,n,$d(c,i,s))],a)}:function(n,s,u){return P3(t,e,[4,r,y3(l,n,g3(s,$d(c,i,u)))],a)};var b=s[1];return function(n,s){return P3(t,e,[4,r,y3(l,n,g3(b,$d(c,i,s)))],a)}}function C3(t,e,r,a,n,s){if("number"==typeof n)return function(n){return P3(t,e,[4,r,Qd(s,n)],a)};if(0===n[0]){var c=n[2],i=n[1];return function(n){return P3(t,e,[4,r,y3(i,c,Qd(s,n))],a)}}var u=n[1];return function(n,c){return P3(t,e,[4,r,y3(u,n,Qd(s,c))],a)}}function N3(t,e,r,a,n){for(var s=e,c=a,i=n;;){if("number"==typeof i)return $d(s,r,c);switch(i[0]){case 0:var u=i[1];return function(t){return P3(s,r,[5,c,t],u)};case 1:var f=i[1];return function(t){var e=D2(t),a=sd(e),n=F2(a+2|0,39);return yk(e,0,n,1,a),P3(s,r,[4,c,n],f)};case 2:var o=i[2],v=i[1];return C3(s,r,c,o,v,function(t){return t});case 3:return C3(s,r,c,i[2],i[1],_3);case 4:return I3(s,r,c,i[4],i[2],i[3],T3,i[1]);case 5:return I3(s,r,c,i[4],i[2],i[3],S3,i[1]);case 6:return I3(s,r,c,i[4],i[2],i[3],E3,i[1]);case 7:return I3(s,r,c,i[4],i[2],i[3],x3,i[1]);case 8:var l=i[4],b=i[3],k=i[2],d=i[1];if("number"==typeof k){if("number"==typeof b)return 0===b?function(t){return P3(s,r,[4,c,A3(d,n3,t)],l)}:function(t,e){return P3(s,r,[4,c,A3(d,t,e)],l)};var h=b[1];return function(t){return P3(s,r,[4,c,A3(d,h,t)],l)}}if(0===k[0]){var p=k[2],m=k[1];if("number"==typeof b)return 0===b?function(t){return P3(s,r,[4,c,y3(m,p,A3(d,n3,t))],l)}:function(t,e){return P3(s,r,[4,c,y3(m,p,A3(d,t,e))],l)};var w=b[1];return function(t){return P3(s,r,[4,c,y3(m,p,A3(d,w,t))],l)}}var y=k[1];if("number"==typeof b)return 0===b?function(t,e){return P3(s,r,[4,c,y3(y,t,A3(d,n3,e))],l)}:function(t,e,a){return P3(s,r,[4,c,y3(y,t,A3(d,e,a))],l)};var g=b[1];return function(t,e){return P3(s,r,[4,c,y3(y,t,A3(d,g,e))],l)};case 9:var _=i[1];return function(t){return P3(s,r,[4,c,t?gh:_h],_)};case 10:c=[7,c],i=i[1];continue;case 11:c=[2,c,i[1]],i=i[2];continue;case 12:c=[3,c,i[1]],i=i[2];continue;case 13:var T=i[3],S=i[2],E=s3(16);o3(E,S);var x=f3(E);return function(t){return P3(s,r,[4,c,x],T)};case 14:var A=i[3],I=i[2];return function(t){var e=m3(t[1],h2(v3(I)));if("number"==typeof e[2])return P3(s,r,c,p2(e[1],A));throw k3};case 15:var C=i[1];return function(t,e){return P3(s,r,[6,c,function(r){return $d(t,r,e)}],C)};case 16:var N=i[1];return function(t){return P3(s,r,[6,c,t],N)};case 17:c=[0,c,i[1]],i=i[2];continue;case 18:var O=i[1];if(0===O[0]){var R=i[2],L=O[1][1];s=function(t,e,r){return function(a,n){return P3(e,a,[1,t,[0,n]],r)}}(c,s,R),c=0,i=L;continue}var P=i[2],U=O[1][1];s=function(t,e,r){return function(a,n){return P3(e,a,[1,t,[1,n]],r)}}(c,s,P),c=0,i=U;continue;case 19:throw[0,uh,Cp];case 20:var D=i[3],F=[8,c,Np];return function(t){return P3(s,r,F,D)};case 21:var M=i[2];return function(t){return P3(s,r,[4,c,Yk(Ip,t)],M)};case 22:var X=i[1];return function(t){return P3(s,r,[5,c,t],X)};case 23:var j=i[2],B=i[1];if("number"==typeof B)switch(B){case 0:case 1:case 2:return t<50?R3(t+1|0,s,r,c,j):Wd(R3,[0,s,r,c,j]);case 3:throw[0,uh,Op];default:return t<50?R3(t+1|0,s,r,c,j):Wd(R3,[0,s,r,c,j])}else switch(B[0]){case 0:case 1:case 2:case 3:case 4:case 5:case 6:case 7:return t<50?R3(t+1|0,s,r,c,j):Wd(R3,[0,s,r,c,j]);case 8:var q=B[2];return t<50?O3(t+1|0,s,r,c,q,j):Wd(O3,[0,s,r,c,q,j]);case 9:default:return t<50?R3(t+1|0,s,r,c,j):Wd(R3,[0,s,r,c,j])}default:var G=i[3],Y=i[1],J=Qd(i[2],0);return t<50?L3(t+1|0,s,r,c,G,Y,J):Wd(L3,[0,s,r,c,G,Y,J])}}}function O3(t,e,r,a,n,s){if("number"==typeof n)return t<50?R3(t+1|0,e,r,a,s):Wd(R3,[0,e,r,a,s]);switch(n[0]){case 0:var c=n[1];return function(t){return U3(e,r,a,c,s)};case 1:var i=n[1];return function(t){return U3(e,r,a,i,s)};case 2:var u=n[1];return function(t){return U3(e,r,a,u,s)};case 3:var f=n[1];return function(t){return U3(e,r,a,f,s)};case 4:var o=n[1];return function(t){return U3(e,r,a,o,s)};case 5:var v=n[1];return function(t){return U3(e,r,a,v,s)};case 6:var l=n[1];return function(t){return U3(e,r,a,l,s)};case 7:var b=n[1];return function(t){return U3(e,r,a,b,s)};case 8:var k=n[2];return function(t){return U3(e,r,a,k,s)};case 9:var d=n[3],h=n[2],p=b3(v3(n[1]),h);return function(t){return U3(e,r,a,function t(e,r){if("number"==typeof e)return r;switch(e[0]){case 0:return[0,t(e[1],r)];case 1:return[1,t(e[1],r)];case 2:return[2,t(e[1],r)];case 3:return[3,t(e[1],r)];case 4:return[4,t(e[1],r)];case 5:return[5,t(e[1],r)];case 6:return[6,t(e[1],r)];case 7:return[7,t(e[1],r)];case 8:return[8,e[1],t(e[2],r)];case 9:var a=e[2];return[9,e[1],a,t(e[3],r)];case 10:return[10,t(e[1],r)];case 11:return[11,t(e[1],r)];case 12:return[12,t(e[1],r)];case 13:return[13,t(e[1],r)];default:return[14,t(e[1],r)]}}(p,d),s)};case 10:var m=n[1];return function(t,n){return U3(e,r,a,m,s)};case 11:var w=n[1];return function(t){return U3(e,r,a,w,s)};case 12:var y=n[1];return function(t){return U3(e,r,a,y,s)};case 13:throw[0,uh,Rp];default:throw[0,uh,Lp]}}function R3(t,e,r,a,n){var s=[8,a,Pp];return t<50?N3(t+1|0,e,r,s,n):Wd(N3,[0,e,r,s,n])}function L3(t,e,r,a,n,s,c){if(s){var i=s[1];return function(t){return function(t,e,r,a,n,s){return Hd(L3(0,t,e,r,a,n,s))}(e,r,a,n,i,Qd(c,t))}}var u=[4,a,c];return t<50?N3(t+1|0,e,r,u,n):Wd(N3,[0,e,r,u,n])}function P3(t,e,r,a){return Hd(N3(0,t,e,r,a))}function U3(t,e,r,a,n){return Hd(O3(0,t,e,r,a,n))}function D3(t,e){for(var r=e;;){if("number"==typeof r)return 0;switch(r[0]){case 0:var a=r[2],n=r[1];if("number"==typeof a)switch(a){case 0:var s=jm;break;case 1:s=Bm;break;case 2:s=qm;break;case 3:s=Gm;break;case 4:s=Ym;break;case 5:s=Jm;break;default:s=Hm}else switch(a[0]){case 0:case 1:s=a[1];break;default:s=_2(Wm,q2(1,a[1]))}return D3(t,n),a3(t,s);case 1:var c=r[2],i=r[1];if(0===c[0]){var u=c[1];D3(t,i),a3(t,Up);r=u;continue}var f=c[1];D3(t,i),a3(t,Dp);r=f;continue;case 6:var o=r[2];return D3(t,r[1]),a3(t,Qd(o,0));case 7:r=r[1];continue;case 8:var v=r[2];return D3(t,r[1]),w2(v);case 2:case 4:var l=r[2];return D3(t,r[1]),a3(t,l);default:var b=r[2];return D3(t,r[1]),r3(t,b)}}}function F3(t){return P3(function(t,e){var r=Z2(64);return D3(r,e),t3(r)},0,0,t[1])}var M3=[0,0];function X3(t,e){var r=t[e+1];if(function(t){return+(t instanceof Array)}(r)){if(jd(r)===Xb)return Qd(F3(iw),r);if(jd(r)===Eu)for(var a=Gk(wh,r),n=0,s=sd(a);;){if(s<=n)return _2(a,yh);var c=Ed(a,n);if(!(48<=c?58<=c?0:1:45===c?1:0))return a;n=n+1|0}return uw}return Qd(F3(cw),r)}function j3(t){var e=t.length-1;if(2>>0){var r=function t(e,r){if(e.length-1<=r)return zm;var a=t(e,r+1|0),n=X3(e,r);return $d(F3(Km),n,a)}(t,2),a=X3(t,1);return $d(F3(rw),a,r)}switch(e){case 0:return aw;case 1:return nw;default:var n=X3(t,1);return Qd(F3(sw),n)}}function B3(t){return M3[1]=[0,t,M3[1]],0}function q3(t,e){var r=[0,[0,t,0]],a=e[1];if(a){var n=a[1];return e[1]=r,n[2]=r,0}return e[1]=r,e[2]=r,0}var G3=[Li,hw,Hk()];function Y3(t){var e=t[2];if(e){var r=e[1],a=r[2],n=r[1];return t[2]=a,0===a&&(t[1]=0),n}throw G3}function J3(t,e){return t[13]=t[13]+e[3]|0,q3(e,t[27])}var H3=1000000010;function W3(t,e){return Zd(t[17],e,0,sd(e))}function V3(t){return Qd(t[19],0)}function z3(t,e){return Qd(t[20],e)}function K3(t,e,r){V3(t),t[11]=1;var a=(t[6]-r|0)+e|0,n=t[8],s=function(t,e){return+(Pk(t,e,!1)<=0)}(n,a)?n:a;return t[10]=s,t[9]=t[6]-t[10]|0,z3(t,t[10])}function Q3(t,e){return K3(t,0,e)}function $3(t,e){return t[9]=t[9]-e|0,z3(t,e)}function Z3(t,e,r){if("number"==typeof r)switch(r){case 0:var a=t[3];if(a){var n=a[1][1],s=function(t,e){if(e){var r=e[1],a=e[2];return function(t,e){return+(Pk(t,e,!1)<0)}(t,r)?[0,t,e]:[0,r,s(t,a)]}return[0,t,0]};return n[1]=s(t[6]-t[9]|0,n[1]),0}return 0;case 1:var c=t[2];return c?(t[2]=c[2],0):0;case 2:var i=t[3];return i?(t[3]=i[2],0):0;case 3:var u=t[2];return u?Q3(t,u[1][2]):V3(t);case 4:var f=t[10]!==(t[6]-t[9]|0)?1:0;return f?function(t){var e=Y3(t[27]),r=e[1];return t[12]=t[12]-e[3]|0,t[9]=t[9]+r|0,0}(t):f;default:var o=t[5];if(o){var v=o[2];return W3(t,Qd(t[24],o[1])),t[5]=v,0}return 0}else switch(r[0]){case 0:var l=r[1];return t[9]=t[9]-e|0,W3(t,l),t[11]=0,0;case 1:var b=r[2],k=r[1],d=t[2];if(d){var h=d[1],p=h[2];switch(h[1]){case 0:return $3(t,k);case 1:case 2:return K3(t,b,p);case 3:return t[9]>>6|0)?1:0;if(b)var k=b;else k=(2!=(v>>>6|0)?1:0)||(2!=(l>>>6|0)?1:0);if(k)throw h6;var d=(7&u)<<18|(63&o)<<12|(63&v)<<6|63&l;f=1}else if(Qu<=u){var h=Ed(t,s+1|0),p=Ed(t,s+2|0);if((2!=(h>>>6|0)?1:0)||(2!=(p>>>6|0)?1:0))throw h6;var m=(15&u)<<12|(63&h)<<6|63&p,w=Ue<=m?1:0;if(w?m<=57088?1:0:w)throw h6;d=m,f=1}else{var y=Ed(t,s+1|0);if(2!=(y>>>6|0))throw h6;d=(31&u)<<6|63&y,f=1}else if(I<=u)f=0;else d=u,f=1;if(f){Nk(n,c)[c+1]=d;var g=Ed(t,s);s=s+Nk(U6,g)[g+1]|0,c=c+1|0,i=i-1|0;continue}throw h6}return E6(n)}throw h6}var _=Ed(t,a),T=Nk(U6,_)[_+1];if(!(0>>18|0)),r3(s,U2(I|63&(u>>>12|0))),r3(s,U2(I|63&(u>>>6|0))),r3(s,U2(I|63&u))}else{var f=Ue<=u?1:0;if(f?u>>12|0)),r3(s,U2(I|63&(u>>>6|0))),r3(s,U2(I|63&u))}else r3(s,U2(Ec|u>>>6|0)),r3(s,U2(I|63&u));else r3(s,U2(u));c=c+1|0,i=i-1|0}},H6=function(t){return J6(t,0,t[5]-t[6]|0)},W6=function(t,e){function r(e){return r3(t,e)}return Hn<=e?(r(pl|e>>>18|0),r(I|63&(e>>>12|0)),r(I|63&(e>>>6|0)),r(I|63&e)):An<=e?(r(Qu|e>>>12|0),r(I|63&(e>>>6|0)),r(I|63&e)):I<=e?(r(Ec|e>>>6|0),r(I|63&e)):r(e)},V6=r,z6=null,K6=function(t){return void 0!==t?1:0},Q6=V6.Array,$6=[Li,xw,Hk()],Z6=V6.Error;d6(Aw,[0,$6,{}]);var t4=function(t){throw t};B3(function(t){return t[1]===$6?[0,Vk(t[2].toString())]:0}),B3(function(t){return t instanceof Q6?0:[0,Vk(t.toString())]});var e4=$d(k6,Cw,Iw),r4=$d(k6,Ow,Nw),a4=$d(k6,Lw,Rw),n4=$d(k6,Uw,Pw),s4=$d(k6,Fw,Dw),c4=$d(k6,Xw,Mw),i4=$d(k6,Bw,jw),u4=$d(k6,Gw,qw),f4=$d(k6,Jw,Yw),o4=$d(k6,Ww,Hw),v4=$d(k6,zw,Vw),l4=$d(k6,Qw,Kw),b4=$d(k6,Zw,$w),k4=$d(k6,ey,ty);Zd(b6,ry,e4,e4),Zd(b6,ay,r4,r4),Zd(b6,ny,a4,a4),Zd(b6,sy,n4,n4),Zd(b6,cy,s4,s4),Zd(b6,iy,c4,c4),Zd(b6,uy,i4,i4),Zd(b6,fy,u4,u4),Zd(b6,oy,f4,f4),Zd(b6,vy,o4,o4),Zd(b6,ly,v4,v4),Zd(b6,by,l4,l4),Zd(b6,ky,b4,b4),Zd(b6,dy,k4,k4);var d4=function(t){return"number"==typeof t?hy:t[1]},h4=function(t){if("number"==typeof t)return 1;switch(t[0]){case 0:return 2;case 3:return 4;default:return 3}},p4=function(t,e){return[0,t[1],t[2],e[3]]},m4=function(t,e){var r=t[1]-e[1]|0;return 0===r?t[2]-e[2]|0:r},w4=[Li,L_,Hk()],y4=function(t,e){var r=e.slice();return r[2]=t,r},g4=function(t){return t[3][1]},_4=function(t){return t[3][2]},T4=function(t,e){if(t!==e[4]){var r=e.slice();return r[4]=t,r}return e},S4=function(t){return 35>>0)var f=C6(a);else switch(u){case 0:f=2;break;case 1:f=0;break;case 2:f=1;break;default:if(I6(a,2),0===H8(x6(a))){var l=I8(x6(a));if(0===l)f=0===P4(x6(a))&&0===P4(x6(a))&&0===P4(x6(a))?0:C6(a);else if(1===l)if(0===P4(x6(a)))for(;;){var b=j4(x6(a));if(0!==b){f=1===b?0:C6(a);break}}else f=C6(a);else f=C6(a)}else f=C6(a)}if(2<=f){if(!(3<=f))return Z8(t,e,30)}else if(0<=f)return t;return m2(hV)},i5=function(t,e,r){var a=e+O6(r)|0;return[0,K8(t,a,e+R6(r)|0),H6(r)]},u5=function(t,e){for(var r=O6(t[2]),a=Y6(e),n=Z2(sd(e)),s=t;;){A6(a);var c=x6(a),i=92>>0)var u=C6(a);else switch(i){case 0:u=2;break;case 1:u=3;break;default:if(I6(a,3),0===H8(x6(a))){var f=I8(x6(a));if(0===f)u=0===P4(x6(a))&&0===P4(x6(a))&&0===P4(x6(a))?0:C6(a);else if(1===f)if(0===P4(x6(a)))for(;;){var o=j4(x6(a));if(0!==o){u=1===o?1:C6(a);break}}else u=C6(a);else u=C6(a)}else u=C6(a)}if(3>>0)return m2(bV);switch(u){case 0:var v=i5(s,r,a),l=v[2],b=dd(_2(kV,G2(l,2,sd(l)-2|0))),k=c5(s,v[1],b);W6(n,b);s=k;continue;case 1:var d=i5(s,r,a),h=d[2],p=dd(_2(dV,G2(h,3,sd(h)-4|0))),m=c5(s,d[1],p);W6(n,p);s=m;continue;case 2:return[0,s,t3(n)];default:a3(n,H6(a));continue}}},f5=function(t,e,r){var a=e5(t,Q8(t,e));return N6(e),$d(r,a,e)},o5=function(t,e,r){for(var a=t;;){A6(r);var n=x6(r),s=-1>>0)var c=C6(r);else switch(s){case 0:c=3;break;case 1:c=0;break;case 2:I6(r,0);c=0===C8(x6(r))?0:C6(r);break;default:I6(r,3);var i=x6(r),u=44>>0){var f=e5(a,Q8(a,r));return[0,f,Q8(f,r)]}switch(c){case 0:var o=r5(a,r);a3(e,H6(r));a=o;continue;case 1:var v=Q8(a,r);return[0,a[4]?Z8(a,v,[2,OF,NF]):a,v];case 2:if(a[4])return[0,a,Q8(a,r)];a3(e,RF);continue;default:a3(e,H6(r));continue}}},v5=function(t,e,r){for(;;){A6(r);var a=x6(r),n=13>>0)var s=C6(r);else switch(n){case 0:s=0;break;case 1:s=2;break;case 2:s=1;break;default:I6(r,1);s=0===C8(x6(r))?1:C6(r)}if(2>>0)return m2(LF);switch(s){case 0:return[0,t,Q8(t,r)];case 1:var c=Q8(t,r),i=c[3],u=r5(t,r),f=L6(r);return[0,u,[0,c[1],c[2],[0,i[1],i[2]-f|0,i[3]-f|0]]];default:a3(e,H6(r));continue}}},l5=function(t,e){function r(t){return I6(t,3),0===a8(x6(t))?2:C6(t)}A6(e);var a=x6(e),n=ya>>0)var s=C6(e);else switch(n){case 1:s=16;break;case 2:s=15;break;case 3:I6(e,15);s=0===C8(x6(e))?15:C6(e);break;case 4:I6(e,4);s=0===a8(x6(e))?r(e):C6(e);break;case 5:I6(e,11);s=0===a8(x6(e))?r(e):C6(e);break;case 7:s=5;break;case 8:s=6;break;case 9:s=7;break;case 10:s=8;break;case 11:s=9;break;case 12:I6(e,14);var c=I8(x6(e));if(0===c)s=0===P4(x6(e))&&0===P4(x6(e))&&0===P4(x6(e))?12:C6(e);else if(1===c)if(0===P4(x6(e)))for(;;){var i=j4(x6(e));if(0!==i){s=1===i?13:C6(e);break}}else s=C6(e);else s=C6(e);break;case 13:s=10;break;case 14:I6(e,14);s=0===P4(x6(e))&&0===P4(x6(e))?1:C6(e);break;default:s=0}if(16>>0)return m2(ZW);switch(s){case 1:var u=H6(e);return[0,t,u,[0,dd(_2(tV,u))],0];case 2:var f=H6(e),o=dd(_2(eV,f));return 256<=o?[0,t,f,[0,o>>>3|0,48+(7&o)|0],1]:[0,t,f,[0,o],1];case 3:var v=H6(e);return[0,t,v,[0,dd(_2(rV,v))],1];case 4:return[0,t,aV,[0,0],0];case 5:return[0,t,nV,[0,8],0];case 6:return[0,t,sV,[0,12],0];case 7:return[0,t,cV,[0,10],0];case 8:return[0,t,iV,[0,13],0];case 9:return[0,t,uV,[0,9],0];case 10:return[0,t,fV,[0,11],0];case 11:var l=H6(e);return[0,t,l,[0,dd(_2(oV,l))],1];case 12:var b=H6(e);return[0,t,b,[0,dd(_2(vV,G2(b,1,sd(b)-1|0)))],0];case 13:var k=H6(e),d=dd(_2(lV,G2(k,2,sd(k)-3|0)));return[0,au>>0)var o=C6(s);else switch(f){case 1:o=3;break;case 3:o=0;break;case 4:o=1;break;default:o=2}if(3>>0)return m2(PF);switch(o){case 0:var v=H6(s);if(a3(a,v),Gd(e,v))return[0,c,Q8(c,s),i];a3(r,v);continue;case 1:a3(a,UF);var l=l5(c,s),b=l[4]||i;a3(a,l[2]),K2(function(t){return W6(r,t)},l[3]);c=l[1],i=b;continue;case 2:var k=H6(s);a3(a,k);var d=e5(c,Q8(c,s));return a3(r,k),[0,d,Q8(d,s),i];default:var h=H6(s);a3(a,h),a3(r,h);continue}}},k5=function(t,e,r,a,n,s){for(var c=t;;){A6(s);var i=x6(s),u=96>>0)var f=C6(s);else switch(u){case 0:f=0;break;case 1:f=6;break;case 2:f=5;break;case 3:I6(s,5);f=0===C8(x6(s))?4:C6(s);break;case 4:I6(s,6);var o=x6(s);f=0===(ws>>0)return m2(DF);switch(f){case 0:var v=e5(c,Q8(c,s));return[0,v,p4(e,Q8(v,s)),1];case 1:return r3(n,96),[0,c,p4(e,Q8(c,s)),1];case 2:return a3(n,FF),[0,c,p4(e,Q8(c,s)),0];case 3:r3(a,92),r3(n,92);var l=l5(c,s),b=l[2];a3(a,b),a3(n,b),K2(function(t){return W6(r,t)},l[3]);c=l[1];continue;case 4:a3(a,MF),a3(n,XF),a3(r,jF);c=r5(c,s);continue;case 5:var k=H6(s);a3(a,k),a3(n,k),r3(r,10);c=r5(c,s);continue;default:var d=H6(s);a3(a,d),a3(n,d),a3(r,d);continue}}},d5=function(t,e,r,a,n){for(var s=t;;){A6(n);var c=x6(n),i=zr>>0)var u=C6(n);else switch(i){case 0:u=1;break;case 1:u=6;break;case 2:u=2;break;case 3:I6(n,2);u=0===C8(x6(n))?2:C6(n);break;case 4:u=0;break;default:I6(n,6);var f=x6(n),o=34>>0)return m2(zF);switch(u){case 0:var S=H6(n);switch(e){case 0:var E=Yd(S,KF)?0:1;break;case 1:E=Yd(S,QF)?0:1;break;default:if(Yd(S,$F))if(Yd(S,ZF)){E=0;var x=0}else x=1;else x=1;if(x)return N6(n),[0,s,Q8(s,n)]}if(E)return[0,s,Q8(s,n)];a3(a,S),a3(r,S);continue;case 1:var A=e5(s,Q8(s,n));return[0,A,Q8(A,n)];case 2:var I=H6(n);a3(a,I),a3(r,I);s=r5(s,n);continue;case 3:var C=H6(n),N=G2(C,3,sd(C)-4|0);a3(a,C),W6(r,dd(_2(tM,N)));continue;case 4:var O=H6(n),R=G2(O,2,sd(O)-3|0);a3(a,O),W6(r,dd(R));continue;case 5:var L=H6(n),P=G2(L,1,sd(L)-2|0);a3(a,L);var U=Lk(P,eM);if(0<=U)if(0>>0)return C6(t);switch(e){case 0:return i(t);case 1:if(0===O4(x6(t)))for(;;){I6(t,16);var r=S4(x6(t));if(0===r)for(;;)if(I6(t,15),0!==G4(x6(t)))return C6(t);if(1!==r)return C6(t)}return C6(t);default:for(;;){I6(t,16);var a=S4(x6(t));if(0===a)for(;;)if(I6(t,15),0!==G4(x6(t)))return C6(t);if(1!==a)return C6(t)}}}function f(t){I6(t,18);var e=d8(x6(t));if(2>>0)return C6(t);switch(e){case 0:return i(t);case 1:for(;;){I6(t,18);var r=d8(x6(t));if(2>>0)return C6(t);switch(r){case 0:return i(t);case 1:continue;default:return u(t)}}default:return u(t)}}function b(t){for(;;){I6(t,18);var e=p8(x6(t));if(3>>0)return C6(t);switch(e){case 0:return i(t);case 1:return f(t);case 2:continue;default:return u(t)}}}function y(t){I6(t,17);var e=U4(x6(t));if(0===e)return i(t);if(1===e)for(;;){I6(t,14);var r=U4(x6(t));if(0===r)for(;;)if(I6(t,13),0!==G4(x6(t)))return C6(t);if(1!==r)return C6(t)}return C6(t)}function g(t){I6(t,17);var e=h8(x6(t));if(0===e)return i(t);if(1===e)for(;;){I6(t,10);var r=h8(x6(t));if(0===r)for(;;)if(I6(t,9),0!==G4(x6(t)))return C6(t);if(1!==r)return C6(t)}return C6(t)}function A(t){I6(t,17);var e=Y8(x6(t));if(0===e)return i(t);if(1===e)for(;;){I6(t,8);var r=Y8(x6(t));if(0===r)for(;;)if(I6(t,7),0!==G4(x6(t)))return C6(t);if(1!==r)return C6(t)}return C6(t)}function I(t){I6(t,18);var e=S4(x6(t));if(0===e)return i(t);if(1===e)for(;;){I6(t,18);var r=S4(x6(t));if(0===r)return i(t);if(1!==r)return C6(t)}return C6(t)}function R(t){for(;;){I6(t,18);var e=X8(x6(t));if(2>>0)return C6(t);switch(e){case 0:return i(t);case 1:return I(t);default:continue}}}function P(t){for(;;)if(I6(t,11),0!==G4(x6(t)))return C6(t)}function D(t){for(;;){I6(t,12);var e=L8(x6(t));if(3>>0)return C6(t);switch(e){case 0:return P(t);case 1:return I(t);case 2:continue;default:for(;;){I6(t,11);var r=X8(x6(t));if(2>>0)return C6(t);switch(r){case 0:return P(t);case 1:return I(t);default:continue}}}}}function M(t){I6(t,18);var e=J4(x6(t));if(7>>0)return C6(t);switch(e){case 0:return i(t);case 1:return f(t);case 2:return D(t);case 3:return R(t);case 4:return A(t);case 5:return u(t);case 6:return g(t);default:return y(t)}}function X(t){for(;;){I6(t,18);var e=d8(x6(t));if(2>>0)return C6(t);switch(e){case 0:return i(t);case 1:continue;default:return u(t)}}}function q(t){return 0===O4(x6(t))?X(t):C6(t)}function J(t,e){for(;;){I6(e,32);var r=X4(x6(e));if(0!==r)return 1===r?t<50?V(t+1|0,e):Wd(V,[0,e]):C6(e)}}function V(t,e){if(0===H8(x6(e))){var r=I8(x6(e));if(0===r)return 0===P4(x6(e))&&0===P4(x6(e))&&0===P4(x6(e))?t<50?J(t+1|0,e):Wd(J,[0,e]):C6(e);if(1===r){if(0===P4(x6(e)))for(;;){var a=j4(x6(e));if(0!==a)return 1===a?t<50?J(t+1|0,e):Wd(J,[0,e]):C6(e)}return C6(e)}return C6(e)}return C6(e)}function tt(t){return Hd(J(0,t))}function lt(t){return Hd(V(0,t))}A6(e);var kt=function(t){var e=x6(t),I=Uc>>0)return C6(t);switch(I){case 0:return 63;case 1:return 64;case 2:if(I6(t,1),0===C4(x6(t)))for(;;)if(I6(t,1),0!==C4(x6(t)))return C6(t);return C6(t);case 3:return 0;case 4:return I6(t,0),0===C8(x6(t))?0:C6(t);case 5:return 6;case 6:I6(t,32);var P=X4(x6(t));return 0===P?tt(t):1===P?lt(t):C6(t);case 7:if(I6(t,64),0===c8(x6(t))){var J=x6(t);if(0==(je>>0)return C6(t);switch(kt){case 0:for(;;){var gt=u8(x6(t));if(3>>0)return C6(t);switch(gt){case 0:continue;case 1:return q(t);case 2:return M(t);default:return b(t)}}case 1:return q(t);case 2:return M(t);default:return b(t)}case 15:I6(t,43);var Et=A8(x6(t));return 0===Et?0===A4(x6(t))?42:C6(t):1===Et?X(t):C6(t);case 16:I6(t,64);var At=F8(x6(t));if(0===At){I6(t,2);var It=H4(x6(t));if(2>>0)return C6(t);switch(It){case 0:for(;;){var Ct=H4(x6(t));if(2>>0)return C6(t);switch(Ct){case 0:continue;case 1:return a(t);default:return r(t)}}case 1:return a(t);default:return r(t)}}return 1===At?5:C6(t);case 17:I6(t,18);var Ot=J4(x6(t));if(7>>0)return C6(t);switch(Ot){case 0:return i(t);case 1:return f(t);case 2:return D(t);case 3:return R(t);case 4:return A(t);case 5:return u(t);case 6:return g(t);default:return y(t)}case 18:I6(t,18);var Mt=p8(x6(t));if(3>>0)return C6(t);switch(Mt){case 0:return i(t);case 1:return f(t);case 2:return b(t);default:return u(t)}case 19:return 46;case 20:return 44;case 21:return 50;case 22:I6(t,52);var Bt=x6(t);return 0==(61>>0)return C6(t);switch(Kt){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var te=f8(x6(t));if(2>>0)return C6(t);switch(te){case 0:return tt(t);case 1:return lt(t);default:I6(t,19);var se=X4(x6(t));return 0===se?tt(t):1===se?lt(t):C6(t)}}case 29:I6(t,32);var ve=q8(x6(t));if(2>>0)return C6(t);switch(ve){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var ge=q8(x6(t));if(2>>0)return C6(t);switch(ge){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Te=v8(x6(t));if(2>>0)return C6(t);switch(Te){case 0:return tt(t);case 1:return lt(t);default:I6(t,20);var Se=N4(x6(t));if(2>>0)return C6(t);switch(Se){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Le=Q4(x6(t));if(2>>0)return C6(t);switch(Le){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Ue=W4(x6(t));if(2>>0)return C6(t);switch(Ue){case 0:return tt(t);case 1:return lt(t);default:I6(t,21);var De=X4(x6(t));return 0===De?tt(t):1===De?lt(t):C6(t)}}}}}}case 30:I6(t,32);var Xe=O8(x6(t));if(2>>0)return C6(t);switch(Xe){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Be=M4(x6(t));if(2>>0)return C6(t);switch(Be){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var qe=R8(x6(t));if(2>>0)return C6(t);switch(qe){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Je=f8(x6(t));if(2>>0)return C6(t);switch(Je){case 0:return tt(t);case 1:return lt(t);default:I6(t,22);var Ke=X4(x6(t));return 0===Ke?tt(t):1===Ke?lt(t):C6(t)}}}}case 31:I6(t,32);var Qe=Q4(x6(t));if(2>>0)return C6(t);switch(Qe){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var tr=v8(x6(t));if(2>>0)return C6(t);switch(tr){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var ur=j8(x6(t));if(2>>0)return C6(t);switch(ur){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var mr=N4(x6(t));if(2>>0)return C6(t);switch(mr){case 0:return tt(t);case 1:return lt(t);default:I6(t,23);var wr=X4(x6(t));return 0===wr?tt(t):1===wr?lt(t):C6(t)}}}}case 32:I6(t,32);var Ar=G8(x6(t));if(2>>0)return C6(t);switch(Ar){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Cr=x6(t),Or=35>>0)return C6(t);switch(Or){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Mr=N4(x6(t));if(2>>0)return C6(t);switch(Mr){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Br=L4(x6(t));if(2
>>0)return C6(t);switch(Br){case 0:return tt(t);case 1:return lt(t);default:I6(t,24);var Hr=X4(x6(t));return 0===Hr?tt(t):1===Hr?lt(t):C6(t)}}}}case 33:I6(t,32);var Kr=I4(x6(t));if(2>>0)return C6(t);switch(Kr){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var $r=x6(t),ta=35<$r?hn<$r?ml<$r?nf<$r?-1:Co<$r?yl<$r?Ic<$r?rk<$r?wt<$r?zc<$r?ps<$r?cl<$r?0:-1:0:-1:G<$r?Eo<$r?0:-1:0:-1:bu<$r?pe<$r?ik<$r?Fs<$r?0:-1:0:-1:Ul<$r?Ku<$r?0:-1:0:-1:wi<$r?ns<$r?Di<$r?xv<$r?uf<$r?Tt<$r?Lu<$r?sv<$r?$o<$r?Fn<$r?qs<$r?Xv<$r?Us<$r?Qn<$r?wo<$r?ys<$r?0:-1:0:-1:pf<$r?Qt<$r?0:-1:0:-1:jv<$r?rs<$r?ht<$r?jc<$r?0:-1:0:-1:Rs<$r?Ff<$r?0:-1:0:-1:Hi<$r?Lr<$r?Fr<$r?Mf<$r?sr<$r?B<$r?0:-1:0:-1:_a<$r?bc<$r?0:-1:0:-1:Rb<$r?Pu<$r?Oe<$r?ri<$r?0:-1:0:-1:ol<$r?xo<$r?0:-1:0:-1:Zv<$r?ru<$r?Js<$r?wa<$r?Gf<$r?Za<$r?Es<$r?Au<$r?0:-1:0:-1:xa<$r?Vl<$r?0:-1:0:-1:oe<$r?Ri<$r?Gc<$r?ct<$r?0:-1:0:-1:la<$r?Ua<$r?0:-1:0:-1:jb<$r?Er<$r?es<$r?Tn<$r?U<$r?nn<$r?0:-1:0:-1:el<$r?Il<$r?0:-1:0:-1:ja<$r?vf<$r?v<$r?Da<$r?0:-1:0:-1:rn<$r?si<$r?0:-1:0:-1:Ro<$r?Nn<$r?ho<$r?E<$r?ee<$r?cr<$r?Ni<$r?io<$r?j<$r?Ls<$r?0:-1:0:-1:Vf<$r?Is<$r?0:-1:0:-1:Fu<$r?os<$r?hb<$r?Ef<$r?0:-1:0:-1:Ab<$r?ss<$r?0:-1:0:-1:Ca<$r?ot<$r?hi<$r?xc<$r?Z<$r?nk<$r?0:-1:0:-1:_e<$r?xr<$r?0:-1:0:-1:oa<$r?Qf<$r?As<$r?Ql<$r?0:-1:0:-1:Gu<$r?Uo<$r?0:-1:0:-1:Ui<$r?Nf<$r?ku<$r?Vn<$r?Oc<$r?al<$r?fa<$r?ar<$r?0:-1:0:-1:Pl<$r?po<$r?0:-1:0:-1:le<$r?Ml<$r?Xf<$r?Qc<$r?0:-1:0:-1:kn<$r?Ja<$r?0:-1:0:-1:ie<$r?sl<$r?hr<$r?m<$r?Qv<$r?xt<$r?0:-1:0:-1:Rr<$r?Un<$r?0:-1:0:-1:ib<$r?re<$r?xe<$r?ut<$r?0:-1:0:-1:kf<$r?zl<$r?0:-1:0:-1:N<$r?Pa<$r?oo<$r?ha<$r?qt<$r?$b<$r?fk<$r?Qi<$r?_u<$r?Os<$r?hl<$r?Xr<$r?0:-1:0:-1:wc<$r?Pr<$r?0:-1:0:-1:So<$r?Pt<$r?tf<$r?Kb<$r?0:-1:0:-1:Cl<$r?Xl<$r?0:-1:0:-1:Tu<$r?Dc<$r?Zl<$r?hs<$r?Gs<$r?bs<$r?0:-1:0:-1:uk<$r?vv<$r?0:-1:0:-1:Oa<$r?zo<$r?Ee<$r?ev<$r?0:-1:0:-1:Vs<$r?tn<$r?0:-1:0:-1:Tr<$r?ea<$r?ne<$r?to<$r?Ra<$r?gf<$r?Aa<$r?El<$r?0:-1:0:-1:gs<$r?sa<$r?0:-1:0:-1:lb<$r?rr<$r?Zu<$r?Lb<$r?0:-1:0:-1:lv<$r?Db<$r?0:-1:0:-1:_v<$r?Mv<$r?go<$r?za<$r?Dr<$r?mf<$r?0:-1:0:-1:pr<$r?cn<$r?0:-1:0:-1:Ka<$r?Vb<$r?Ei<$r?Re<$r?0:-1:0:-1:at<$r?Tl<$r?0:-1:0:-1:vu<$r?Qs<$r?$i<$r?Mi<$r?xi<$r?mn<$r?Av<$r?Yi<$r?Fl<$r?qf<$r?0:-1:0:-1:vb<$r?xl<$r?0:-1:0:-1:Ut<$r?Po<$r?jr<$r?Sr<$r?0:-1:0:-1:Ti<$r?Ta<$r?0:-1:0:-1:Ib<$r?tb<$r?st<$r?ye<$r?ae<$r?Va<$r?0:-1:0:-1:St<$r?on<$r?0:-1:0:-1:ts<$r?$c<$r?rb<$r?hu<$r?0:-1:0:-1:qu<$r?hf<$r?0:-1:0:-1:du<$r?H<$r?or<$r?Hl<$r?Vr<$r?il<$r?ek<$r?wb<$r?0:-1:0:-1:rt<$r?eb<$r?0:-1:0:-1:Ir<$r?zu<$r?S<$r?ms<$r?0:-1:0:-1:li<$r?ds<$r?0:-1:0:-1:bb<$r?dt<$r?$f<$r?oc<$r?Sa<$r?Yr<$r?0:-1:0:-1:ob<$r?Rt<$r?0:-1:0:-1:$v<$r?no<$r?Jr<$r?pi<$r?0:-1:0:-1:ro<$r?$e<$r?0:-1:0:-1:gb<$r?gn<$r?ma<$r?na<$r?ll<$r?ti<$r?tl<$r?Bv<$r?d<$r?Vc<$r?vr<$r?gv<$r?gu<$r?Ks<$r?0:-1:0:-1:Ye<$r?Gi<$r?0:-1:0:-1:bk<$r?Ma<$r?Mb<$r?rv<$r?0:-1:0:-1:zi<$r?lu<$r?0:-1:0:-1:Yl<$r?Cc<$r?Yo<$r?Jl<$r?Wa<$r?yv<$r?0:-1:0:-1:Ea<$r?Zf<$r?0:-1:0:-1:No<$r?fr<$r?Jo<$r?Gl<$r?0:-1:0:-1:Ac<$r?p<$r?0:-1:0:-1:Mn<$r?x<$r?ac<$r?pt<$r?yr<$r?yi<$r?uv<$r?hc<$r?0:-1:0:-1:nt<$r?ju<$r?0:-1:0:-1:Eb<$r?tu<$r?vo<$r?Bl<$r?0:-1:0:-1:ua<$r?Cs<$r?0:-1:0:-1:cv<$r?Wr<$r?vs<$r?Ho<$r?_<$r?Zi<$r?0:-1:0:-1:Yc<$r?nb<$r?0:-1:0:-1:Tc<$r?ni<$r?vn<$r?xn<$r?0:-1:0:-1:_f<$r?Sf<$r?0:-1:0:-1:Iv<$r?Dt<$r?Xn<$r?W<$r?kb<$r?Yn<$r?Ds<$r?qo<$r?xf<$r?Y<$r?0:-1:0:-1:Vv<$r?xb<$r?0:-1:0:-1:Jf<$r?Ur<$r?Yt<$r?qr<$r?0:-1:0:-1:ok<$r?it<$r?0:-1:0:-1:Fc<$r?zb<$r?Nc<$r?Ln<$r?js<$r?Fo<$r?0:-1:0:-1:ui<$r?Ha<$r?0:-1:0:-1:eo<$r?Xa<$r?sc<$r?Oi<$r?0:-1:0:-1:yo<$r?pn<$r?0:-1:0:-1:Tb<$r?Bo<$r?o<$r?Ga<$r?mc<$r?ze<$r?dl<$r?Fa<$r?0:-1:0:-1:$a<$r?Bc<$r?0:-1:0:-1:Cv<$r?we<$r?lf<$r?Ol<$r?0:-1:0:-1:Fe<$r?Qo<$r?0:-1:0:-1:Wt<$r?O<$r?c<$r?he<$r?gi<$r?z<$r?0:-1:0:-1:Ys<$r?w<$r?0:-1:0:-1:ue<$r?rf<$r?qa<$r?sf<$r?0:-1:0:-1:Pe<$r?Do<$r?0:-1:0:-1:Gn<$r?ce<$r?yc<$r?Ii<$r?$<$r?To<$r?Zb<$r?co<$r?ak<$r?Ba<$r?wl<$r?gr<$r?0:-1:0:-1:Oo<$r?lr<$r?0:-1:0:-1:Sb<$r?pa<$r?Cb<$r?bf<$r?0:-1:0:-1:s<$r?jt<$r?0:-1:0:-1:us<$r?mv<$r?Ev<$r?Gr<$r?Hs<$r?Ht<$r?0:-1:0:-1:Pn<$r?Zs<$r?0:-1:0:-1:L<$r?K<$r?an<$r?La<$r?0:-1:0:-1:Ws<$r?Lc<$r?0:-1:0:-1:Ss<$r?nr<$r?Tv<$r?Na<$r?$t<$r?Bi<$r?Wl<$r?ei<$r?0:-1:0:-1:Nr<$r?ci<$r?0:-1:0:-1:ii<$r?mb<$r?k<$r?Q<$r?0:-1:0:-1:_n<$r?Sc<$r?0:-1:0:-1:be<$r?kr<$r?Su<$r?ln<$r?Wb<$r?mt<$r?0:-1:0:-1:lc<$r?Zn<$r?0:-1:0:-1:fo<$r?$s<$r?ov<$r?Qr<$r?0:-1:0:-1:He<$r?Gt<$r?0:-1:0:-1:On<$r?yt<$r?wv<$r?Ae<$r?Ne<$r?_r<$r?kc<$r?ra<$r?cu<$r?Xu<$r?0:-1:0:-1:Ao<$r?nc<$r?0:-1:0:-1:Tf<$r?aa<$r?bn<$r?qc<$r?0:-1:0:-1:yu<$r?Go<$r?0:-1:0:-1:er<$r?gl<$r?bo<$r?Gv<$r?br<$r?fe<$r?0:-1:0:-1:Ai<$r?ke<$r?0:-1:0:-1:Wf<$r?gc<$r?pu<$r?Ie<$r?0:-1:0:-1:C<$r?et<$r?0:-1:0:-1:Kn<$r?ls<$r?Xs<$r?Ge<$r?sb<$r?Ob<$r?de<$r?T<$r?0:-1:0:-1:Ze<$r?qi<$r?0:-1:0:-1:Pi<$r?Vt<$r?Pb<$r?Dl<$r?0:-1:0:-1:xs<$r?en<$r?0:-1:0:-1:dr<$r?ub<$r?Ft<$r?Me<$r?_o<$r?af<$r?0:-1:0:-1:wn<$r?va<$r?0:-1:0:-1:Mo<$r?jn<$r?_s<$r?ft<$r?0:-1:0:-1:Ou<$r?Ce<$r?0:-1:0:-1:Ed(nK,$r+_c|0)-1|0:-1;if(3>>0)return C6(t);switch(ta){case 0:return tt(t);case 1:return lt(t);case 2:I6(t,32);var ca=v8(x6(t));if(2>>0)return C6(t);switch(ca){case 0:return tt(t);case 1:return lt(t);default:I6(t,25);var ba=X4(x6(t));return 0===ba?tt(t):1===ba?lt(t):C6(t)}default:I6(t,32);var ka=P8(x6(t));if(2>>0)return C6(t);switch(ka){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var ya=N4(x6(t));if(2>>0)return C6(t);switch(ya){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Ia=Z4(x6(t));if(2>>0)return C6(t);switch(Ia){case 0:return tt(t);case 1:return lt(t);default:I6(t,26);var Ya=X4(x6(t));return 0===Ya?tt(t):1===Ya?lt(t):C6(t)}}}}}case 34:I6(t,32);var Qa=R8(x6(t));if(2>>0)return C6(t);switch(Qa){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var sn=x6(t),fn=35>>0)return C6(t);switch(fn){case 0:return tt(t);case 1:return lt(t);case 2:I6(t,32);var yn=R8(x6(t));if(2>>0)return C6(t);switch(yn){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var En=G8(x6(t));if(2>>0)return C6(t);switch(En){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var An=E8(x6(t));if(2>>0)return C6(t);switch(An){case 0:return tt(t);case 1:return lt(t);default:I6(t,27);var Cn=X4(x6(t));return 0===Cn?tt(t):1===Cn?lt(t):C6(t)}}}default:I6(t,32);var Rn=G8(x6(t));if(2>>0)return C6(t);switch(Rn){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Dn=W4(x6(t));if(2>>0)return C6(t);switch(Dn){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Bn=D4(x6(t));if(2>>0)return C6(t);switch(Bn){case 0:return tt(t);case 1:return lt(t);default:I6(t,28);var qn=X4(x6(t));return 0===qn?tt(t):1===qn?lt(t):C6(t)}}}}}case 35:I6(t,32);var Jn=x6(t),Hn=35>>0)return C6(t);switch(Hn){case 0:return tt(t);case 1:return lt(t);case 2:I6(t,32);var Wn=I4(x6(t));if(2>>0)return C6(t);switch(Wn){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var $n=N4(x6(t));if(2<$n>>>0)return C6(t);switch($n){case 0:return tt(t);case 1:return lt(t);default:I6(t,29);var as=X4(x6(t));return 0===as?tt(t):1===as?lt(t):C6(t)}}default:I6(t,32);var cs=M4(x6(t));if(2>>0)return C6(t);switch(cs){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var is=N4(x6(t));if(2>>0)return C6(t);switch(is){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var fs=q8(x6(t));if(2>>0)return C6(t);switch(fs){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var ks=B8(x6(t));if(2>>0)return C6(t);switch(ks){case 0:return tt(t);case 1:return lt(t);default:I6(t,30);var ws=X4(x6(t));return 0===ws?tt(t):1===ws?lt(t):C6(t)}}}}}case 36:I6(t,32);var Ts=q8(x6(t));if(2>>0)return C6(t);switch(Ts){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Ps=G8(x6(t));if(2>>0)return C6(t);switch(Ps){case 0:return tt(t);case 1:return lt(t);default:I6(t,32);var Ms=L4(x6(t));if(2>>0)return C6(t);switch(Ms){case 0:return tt(t);case 1:return lt(t);default:I6(t,31);var Bs=X4(x6(t));return 0===Bs?tt(t):1===Bs?lt(t):C6(t)}}}case 37:I6(t,36);var ec=x6(t);return 0==(zr>>0)return m2(RW);var gt=kt;if(33<=gt)switch(gt){case 33:return[0,t,66];case 36:return[0,t,0];case 37:return[0,t,1];case 38:return[0,t,2];case 39:return[0,t,3];case 40:return[0,t,4];case 41:return[0,t,5];case 42:return[0,t,12];case 43:return[0,t,10];case 44:return[0,t,8];case 45:return[0,t,9];case 50:return[0,t,94];case 51:return[0,t,95];case 54:return[0,t,wf];case 56:return[0,t,85];case 57:return[0,t,87];case 59:return[0,t,11];case 61:return[0,t,99];case 62:return[0,t,Uf];case 63:return[0,t[4]?Z8(t,Q8(t,e),7):t,Ot];case 64:return[0,t,[5,H6(e)]];case 58:break;case 34:case 48:return[0,t,6];case 35:case 49:return[0,t,7];case 46:case 55:return[0,t,82];case 47:case 53:return[0,t,81];default:return[0,t,79]}else switch(gt){case 0:return[1,r5(t,e)];case 1:return[1,t];case 2:var Et=Q8(t,e),At=Z2(uo),It=o5(t,At,e);return[1,n5(It[1],Et,It[2],At,1)];case 3:var Ct=H6(e);if(t[5]){var Mt=t[4]?t5(t,Q8(t,e),Ct):t,Bt=T4(1,Mt),Jt=L6(e);return Gd(J6(e,Jt-1|0,1),LW)&&Yd(J6(e,Jt-2|0,1),PW)?[0,Bt,82]:[1,Bt]}var zt=Q8(t,e),Kt=Z2(uo);a3(Kt,Ct);var te=o5(t,Kt,e);return[1,n5(te[1],zt,te[2],Kt,1)];case 4:if(t[4])return[1,T4(0,t)];N6(e);return A6(e),0===function(t){return 0===b8(x6(t))?0:C6(t)}(e)?[0,t,wf]:m2(UW);case 5:var se=Q8(t,e),ve=Z2(uo),ge=v5(t,ve,e);return[1,n5(ge[1],se,ge[2],ve,0)];case 6:var Te=H6(e),Se=Q8(t,e),Le=Z2(uo),Ue=Z2(uo);a3(Ue,Te);var De=b5(t,Te,Le,Ue,0,e),Xe=p4(Se,De[2]),Be=De[3],qe=t3(Ue),Je=[1,[0,Xe,t3(Le),qe,Be]];return[0,De[1],Je];case 7:return f5(t,e,function(t,e){function r(t){if(0===t8(x6(t))){if(0===V4(x6(t)))for(;;)if(I6(t,0),0!==V4(x6(t)))return C6(t);return C6(t)}return C6(t)}A6(e);var a=y8(x6(e));if(0===a)for(;;){var n=B4(x6(e));if(0!==n){var s=1===n?r(e):C6(e);break}}else s=1===a?r(e):C6(e);return 0===s?[0,t,s5(0,H6(e))]:m2(OW)});case 8:return[0,t,s5(0,H6(e))];case 9:return f5(t,e,function(t,e){function r(t){if(0===l8(x6(t))){if(0===a8(x6(t)))for(;;)if(I6(t,0),0!==a8(x6(t)))return C6(t);return C6(t)}return C6(t)}A6(e);var a=y8(x6(e));if(0===a)for(;;){var n=B4(x6(e));if(0!==n){var s=1===n?r(e):C6(e);break}}else s=1===a?r(e):C6(e);return 0===s?[0,t,s5(2,H6(e))]:m2(NW)});case 10:return[0,t,s5(2,H6(e))];case 11:return f5(t,e,function(t,e){function r(t){if(0===a8(x6(t)))for(;;)if(I6(t,0),0!==a8(x6(t)))return C6(t);return C6(t)}A6(e);var a=y8(x6(e));if(0===a)for(;;){var n=B4(x6(e));if(0!==n){var s=1===n?r(e):C6(e);break}}else s=1===a?r(e):C6(e);return 0===s?[0,t,s5(1,H6(e))]:m2(CW)});case 12:return[0,t,s5(1,H6(e))];case 13:return f5(t,e,function(t,e){function r(t){if(0===F4(x6(t))){if(0===P4(x6(t)))for(;;)if(I6(t,0),0!==P4(x6(t)))return C6(t);return C6(t)}return C6(t)}if(A6(e),0===function(t){var e=y8(x6(t));if(0===e)for(;;){var a=B4(x6(t));if(0!==a)return 1===a?r(t):C6(t)}return 1===e?r(t):C6(t)}(e)){var a=H6(e);try{return[0,t,s5(3,a)]}catch(t){throw t=Kd(t)}}return m2(IW)});case 14:var Ke=H6(e);try{return[0,t,s5(3,Ke)]}catch(t){throw t=Kd(t)}case 15:return f5(t,e,function(t,e){function r(t){for(;;)if(I6(t,0),0!==O4(x6(t)))return C6(t)}function a(t){var e=R4(x6(t));return 0===e?0===O4(x6(t))?r(t):C6(t):1===e?r(t):C6(t)}function n(t){if(0===O4(x6(t)))for(;;){var e=m8(x6(t));if(0!==e)return 1===e?a(t):C6(t)}return C6(t)}function s(t){for(;;){var e=m8(x6(t));if(0!==e)return 1===e?a(t):C6(t)}}function c(t){var e=q4(x6(t));return 0===e?s(t):1===e?a(t):C6(t)}function i(t){for(;;){var e=o8(x6(t));if(2>>0)return C6(t);switch(e){case 0:return s(t);case 1:continue;default:return a(t)}}}A6(e);var u=x6(e),f=44>>0)var o=C6(e);else switch(f){case 0:for(;;){var v=u8(x6(e));if(3>>0)o=C6(e);else switch(v){case 0:continue;case 1:o=n(e);break;case 2:o=c(e);break;default:o=i(e)}break}break;case 1:o=n(e);break;case 2:o=c(e);break;default:o=i(e)}return 0===o?[0,t,s5(3,H6(e))]:m2(AW)});case 17:return f5(t,e,function(t,e){function r(t){for(;;)if(I6(t,0),0!==O4(x6(t)))return C6(t)}A6(e);var a=x6(e),n=44>>0)var s=C6(e);else switch(n){case 0:for(;;){var c=x6(e),i=8>>0)return C6(e);switch(r){case 0:return t(e);case 1:if(0===O4(x6(e)))for(;;){I6(e,19);var a=S4(x6(e));if(0===a)for(;;)if(I6(e,18),0!==G4(x6(e)))return C6(e);if(1!==a)return C6(e)}return C6(e);default:for(;;){I6(e,19);var n=S4(x6(e));if(0===n)for(;;)if(I6(e,18),0!==G4(x6(e)))return C6(e);if(1!==n)return C6(e)}}}}(P),M=function(t){return I6(t,4),0===z8(x6(t))?4:C6(t)},X=function(t){return 0===T8(x6(t))&&0===s8(x6(t))&&0===M8(x6(t))&&0===g8(x6(t))&&0===_8(x6(t))&&0===n8(x6(t))&&0===c8(x6(t))&&0===T8(x6(t))&&0===H8(x6(t))&&0===S8(x6(t))&&0===D8(x6(t))?4:C6(t)},q=function(t,e){return function(r){I6(r,21);var a=d8(x6(r));if(2>>0)return C6(r);switch(a){case 0:return t(r);case 1:for(;;){I6(r,21);var n=d8(x6(r));if(2>>0)return C6(r);switch(n){case 0:return t(r);case 1:continue;default:return e(r)}}default:return e(r)}}}(P,D),J=function(t){for(;;)if(I6(t,14),0!==G4(x6(t)))return C6(t)},V=function(t){return function(e){I6(e,21);var r=S4(x6(e));if(0===r)return t(e);if(1===r)for(;;){I6(e,21);var a=S4(x6(e));if(0===a)return t(e);if(1!==a)return C6(e)}return C6(e)}}(P);A6(f);var tt=x6(f),lt=Uc>>0)var kt=C6(f);else switch(lt){case 0:kt=131;break;case 1:kt=132;break;case 2:if(I6(f,2),0===C4(x6(f))){for(;;)if(I6(f,2),0!==C4(x6(f))){kt=C6(f);break}}else kt=C6(f);break;case 3:kt=0;break;case 4:I6(f,0);kt=0===C8(x6(f))?0:C6(f);break;case 5:I6(f,zr);kt=0===K4(x6(f))?(I6(f,96),0===K4(x6(f))?92:C6(f)):C6(f);break;case 6:kt=8;break;case 7:I6(f,130);var gt=x6(f);kt=0===(32>>0)kt=C6(f);else switch(Ct){case 0:I6(f,118);kt=0===K4(x6(f))?108:C6(f);break;case 1:kt=5;break;default:kt=Vi}break;case 14:I6(f,115);var Mt=x6(f),Bt=42>>0)kt=C6(f);else switch(se){case 0:kt=P(f);break;case 1:continue;default:kt=D(f)}break}else kt=C6(f);break;case 18:I6(f,I);var ve=w8(x6(f));if(2>>0)kt=C6(f);else switch(ve){case 0:I6(f,3);var ge=H4(x6(f));if(2>>0)kt=C6(f);else switch(ge){case 0:for(;;){var Te=H4(x6(f));if(2>>0)kt=C6(f);else switch(Te){case 0:continue;case 1:kt=M(f);break;default:kt=X(f)}break}break;case 1:kt=M(f);break;default:kt=X(f)}break;case 1:kt=6;break;default:kt=uo}break;case 19:I6(f,21);var Se=J4(x6(f));if(7>>0)kt=C6(f);else switch(Se){case 0:kt=P(f);break;case 1:kt=q(f);break;case 2:for(;;){I6(f,15);var Le=L8(x6(f));if(3>>0)kt=C6(f);else switch(Le){case 0:kt=J(f);break;case 1:kt=V(f);break;case 2:continue;default:for(;;){I6(f,14);var Ue=X8(x6(f));if(2>>0)kt=C6(f);else switch(Ue){case 0:kt=J(f);break;case 1:kt=V(f);break;default:continue}break}}break}break;case 3:for(;;){I6(f,21);var De=X8(x6(f));if(2>>0)kt=C6(f);else switch(De){case 0:kt=P(f);break;case 1:kt=V(f);break;default:continue}break}break;case 4:I6(f,20);var Xe=Y8(x6(f));if(0===Xe)kt=P(f);else if(1===Xe)for(;;){I6(f,11);var Be=Y8(x6(f));if(0===Be){for(;;)if(I6(f,10),0!==G4(x6(f))){kt=C6(f);break}}else{if(1===Be)continue;kt=C6(f)}break}else kt=C6(f);break;case 5:kt=D(f);break;case 6:I6(f,20);var qe=h8(x6(f));if(0===qe)kt=P(f);else if(1===qe)for(;;){I6(f,13);var Je=h8(x6(f));if(0===Je){for(;;)if(I6(f,12),0!==G4(x6(f))){kt=C6(f);break}}else{if(1===Je)continue;kt=C6(f)}break}else kt=C6(f);break;default:I6(f,20);var Ke=U4(x6(f));if(0===Ke)kt=P(f);else if(1===Ke)for(;;){I6(f,17);var Qe=U4(x6(f));if(0===Qe){for(;;)if(I6(f,16),0!==G4(x6(f))){kt=C6(f);break}}else{if(1===Qe)continue;kt=C6(f)}break}else kt=C6(f)}break;case 20:I6(f,21);var tr=p8(x6(f));if(3>>0)kt=C6(f);else switch(tr){case 0:kt=P(f);break;case 1:kt=q(f);break;case 2:for(;;){I6(f,21);var ur=p8(x6(f));if(3>>0)kt=C6(f);else switch(ur){case 0:kt=P(f);break;case 1:kt=q(f);break;case 2:continue;default:kt=D(f)}break}break;default:kt=D(f)}break;case 21:kt=85;break;case 22:kt=83;break;case 23:I6(f,113);var mr=x6(f),wr=59>>0)kt=C6(f);else switch(Ia){case 0:kt=g(f);break;case 1:kt=A(f);break;case 2:I6(f,73);var Ya=f8(x6(f));if(2>>0)kt=C6(f);else switch(Ya){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Qa=W4(x6(f));if(2>>0)kt=C6(f);else switch(Qa){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var sn=E8(x6(f));if(2>>0)kt=C6(f);else switch(sn){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,22);var fn=X4(x6(f));kt=0===fn?g(f):1===fn?A(f):C6(f)}}}break;default:I6(f,73);var yn=Q4(x6(f));if(2>>0)kt=C6(f);else switch(yn){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var En=G8(x6(f));if(2>>0)kt=C6(f);else switch(En){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var An=R8(x6(f));if(2>>0)kt=C6(f);else switch(An){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,23);var Cn=X4(x6(f));kt=0===Cn?g(f):1===Cn?A(f):C6(f)}}}}break;case 34:I6(f,73);var Rn=Z4(x6(f));if(2>>0)kt=C6(f);else switch(Rn){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Dn=N4(x6(f));if(2>>0)kt=C6(f);else switch(Dn){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Bn=Q4(x6(f));if(2>>0)kt=C6(f);else switch(Bn){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var qn=x4(x6(f));if(2>>0)kt=C6(f);else switch(qn){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,24);var Jn=X4(x6(f));kt=0===Jn?g(f):1===Jn?A(f):C6(f)}}}}break;case 35:I6(f,73);var Hn=x6(f),Wn=35>>0)kt=C6(f);else switch(Wn){case 0:kt=g(f);break;case 1:kt=A(f);break;case 2:I6(f,73);var $n=U8(x6(f));if(3<$n>>>0)kt=C6(f);else switch($n){case 0:kt=g(f);break;case 1:kt=A(f);break;case 2:I6(f,73);var as=N4(x6(f));if(2>>0)kt=C6(f);else switch(as){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,25);var cs=X4(x6(f));kt=0===cs?g(f):1===cs?A(f):C6(f)}break;default:I6(f,73);var is=E8(x6(f));if(2>>0)kt=C6(f);else switch(is){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var fs=J8(x6(f));if(2>>0)kt=C6(f);else switch(fs){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,26);var ks=X4(x6(f));kt=0===ks?g(f):1===ks?A(f):C6(f)}}}break;case 3:I6(f,73);var Ts=Q4(x6(f));if(2>>0)kt=C6(f);else switch(Ts){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Ps=j8(x6(f));if(2>>0)kt=C6(f);else switch(Ps){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Bs=j8(x6(f));if(2>>0)kt=C6(f);else switch(Bs){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,27);var ec=X4(x6(f));kt=0===ec?g(f):1===ec?A(f):C6(f)}}}break;default:I6(f,73);var rc=W4(x6(f));if(2>>0)kt=C6(f);else switch(rc){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var cc=U8(x6(f));if(3>>0)kt=C6(f);else switch(cc){case 0:kt=g(f);break;case 1:kt=A(f);break;case 2:I6(f,73);var ic=R8(x6(f));if(2>>0)kt=C6(f);else switch(ic){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,28);var uc=X4(x6(f));kt=0===uc?g(f):1===uc?A(f):C6(f)}break;default:I6(f,73);var vc=G8(x6(f));if(2>>0)kt=C6(f);else switch(vc){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var dc=W4(x6(f));if(2>>0)kt=C6(f);else switch(dc){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var pc=I4(x6(f));if(2>>0)kt=C6(f);else switch(pc){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Ec=N4(x6(f));if(2>>0)kt=C6(f);else switch(Ec){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,29);var Rc=X4(x6(f));kt=0===Rc?g(f):1===Rc?A(f):C6(f)}}}}}}}break;case 36:I6(f,73);var Pc=x6(f),Xc=35>>0)kt=C6(f);else switch(Xc){case 0:kt=g(f);break;case 1:kt=A(f);break;case 2:I6(f,73);var Jc=x6(f),Hc=35>>0)kt=C6(f);else switch(Hc){case 0:kt=g(f);break;case 1:kt=A(f);break;case 2:I6(f,73);var Wc=I4(x6(f));if(2>>0)kt=C6(f);else switch(Wc){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Zc=D4(x6(f));if(2>>0)kt=C6(f);else switch(Zc){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var fi=D4(x6(f));if(2>>0)kt=C6(f);else switch(fi){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var oi=N4(x6(f));if(2>>0)kt=C6(f);else switch(oi){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var vi=Z4(x6(f));if(2>>0)kt=C6(f);else switch(vi){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,30);var bi=X4(x6(f));kt=0===bi?g(f):1===bi?A(f):C6(f)}}}}}break;case 3:I6(f,73);var ki=v8(x6(f));if(2>>0)kt=C6(f);else switch(ki){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var mi=Q4(x6(f));if(2>>0)kt=C6(f);else switch(mi){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Si=Z4(x6(f));if(2>>0)kt=C6(f);else switch(Si){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Ci=N4(x6(f));if(2>>0)kt=C6(f);else switch(Ci){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,31);var Li=X4(x6(f));kt=0===Li?g(f):1===Li?A(f):C6(f)}}}}break;case 4:I6(f,73);var Fi=Q4(x6(f));if(2>>0)kt=C6(f);else switch(Fi){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Xi=I4(x6(f));if(2>>0)kt=C6(f);else switch(Xi){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Wi=v8(x6(f));if(2>>0)kt=C6(f);else switch(Wi){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var eu=R8(x6(f));if(2>>0)kt=C6(f);else switch(eu){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,32);var au=X4(x6(f));kt=0===au?g(f):1===au?A(f):C6(f)}}}}break;default:I6(f,73);var uu=N4(x6(f));if(2>>0)kt=C6(f);else switch(uu){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var fu=R8(x6(f));if(2>>0)kt=C6(f);else switch(fu){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var wu=N4(x6(f));if(2>>0)kt=C6(f);else switch(wu){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,33);var Eu=X4(x6(f));kt=0===Eu?g(f):1===Eu?A(f):C6(f)}}}}break;default:I6(f,34);var xu=X4(x6(f));kt=0===xu?g(f):1===xu?A(f):C6(f)}break;case 37:I6(f,73);var Iu=x6(f),Cu=35>>0)kt=C6(f);else switch(Cu){case 0:kt=g(f);break;case 1:kt=A(f);break;case 2:I6(f,73);var Nu=j8(x6(f));if(2>>0)kt=C6(f);else switch(Nu){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Ru=N4(x6(f));if(2>>0)kt=C6(f);else switch(Ru){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,35);var Uu=X4(x6(f));kt=0===Uu?g(f):1===Uu?A(f):C6(f)}}break;case 3:I6(f,73);var Du=I4(x6(f));if(2>>0)kt=C6(f);else switch(Du){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Bu=O8(x6(f));if(2>>0)kt=C6(f);else switch(Bu){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,36);var Ju=X4(x6(f));kt=0===Ju?g(f):1===Ju?A(f):C6(f)}}break;default:I6(f,73);var Wu=x6(f),Qu=35>>0)kt=C6(f);else switch(Qu){case 0:kt=g(f);break;case 1:kt=A(f);break;case 2:I6(f,73);var $u=q8(x6(f));if(2<$u>>>0)kt=C6(f);else switch($u){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var ef=Z4(x6(f));if(2>>0)kt=C6(f);else switch(ef){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var cf=R8(x6(f));if(2>>0)kt=C6(f);else switch(cf){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,37);var ff=X4(x6(f));kt=0===ff?g(f):1===ff?A(f):C6(f)}}}break;default:I6(f,73);var of=N4(x6(f));if(2>>0)kt=C6(f);else switch(of){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var df=W4(x6(f));if(2>>0)kt=C6(f);else switch(df){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var Af=L4(x6(f));if(2>>0)kt=C6(f);else switch(Af){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,73);var If=j8(x6(f));if(2>>0)kt=C6(f);else switch(If){case 0:kt=g(f);break;case 1:kt=A(f);break;default:I6(f,38);var Cf=X4(x6(f));kt=0===Cf?g(f):1===Cf?A(f):C6(f)}}}}}}break;case 38:I6(f,73);var Of=x6(f),Rf=35
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+