{ "version": 3, "sources": ["../_p/ui/query/angular-services/qw.http.js", "../_p/ui/query/angular-services/qw.metadata.service.js", "../_p/ui/query/angular-directives/dialogs/qw.doc.editor.dialog.component.js", "../_p/ui/query/angular-directives/dialogs/qw.error.dialog.component.js", "../_p/ui/query/angular-directives/dialogs/qw.input.dialog.component.js", "../_p/ui/query/angular-directives/dialogs/qw.notice.dialog.component.js", "../ui/web_modules/js-beautify.js", "../_p/ui/query/angular-directives/qw.dialog.service.js"], "sourcesContent": ["/*\nCopyright 2020-Present Couchbase, Inc.\n\nUse of this software is governed by the Business Source License included in\nthe file licenses/BSL-Couchbase.txt. As of the Change Date specified in that\nfile, in accordance with the Business Source License, use of this software will\nbe governed by the Apache License, Version 2.0, included in the file\nlicenses/APL2.txt.\n*/\n\nimport angular from \"angular\";\n\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\n\nimport _ from \"lodash\";\n\nexport { QwHttp };\n\nclass QwHttp {\n static get annotations() { return [\n new Injectable()\n ]}\n\n static get parameters() { return [\n HttpClient,\n ]}\n\n constructor(http) {\n this.http = http;\n }\n\n // for transition to using RXJS, unpack the HttpRequest and send it\n // using HttpClient, returning an observable\n do_request(config) {\n switch (config.method) {\n case 'GET':\n return(this.http.get(config.url,this.configToOptions(config)));\n case 'POST':\n return(this.http.post(config.url,config.data,this.configToOptions(config)));\n case 'PUT':\n return(this.http.put(config.url,config.data,this.configToOptions(config)));\n case 'DELETE':\n return(this.http.delete(config.url,this.configToOptions(config)));\n }\n }\n\n //simulate old $http from angular 1.x\n do(config) {\n\n if (!config || !config.url || !config.method)\n return(null);\n\n switch (config.method) {\n case 'GET':\n return this.get(config.url,config);\n case 'POST':\n return this.post(config.url,config.data,config);\n case 'PUT':\n return this.put(config.url,config.data,config);\n case 'DELETE':\n return this.delete(config.url,config);\n }\n\n // shouldn't get here\n return(Promise.reject(new Error('unable to handle http request: ' + JSON.stringify(config))));\n }\n\n // convert the $http config to an HttpClient options object\n // config object might have:\n // method - 'GET', 'POST' etc\n // url\n // params - map to use as parameters for GET\n // data - for POST\n // headers - HTTP header\n // transformResponse - method to call on response\n\n configToOptions(config) {\n var options = {observe: 'response'};\n if (config.headers) {\n // can't pass options to HttpHeaders constructor, because it can't\n // handle headers with numeric values\n options.headers = new HttpHeaders();\n Object.keys(config.headers).forEach(key =>\n options.headers = options.headers.set(key,config.headers[key]));\n }\n\n if (config.params)\n options.params = config.params;\n return(options);\n }\n\n get(url, config) {\n config = config || {};\n config.url = url;\n config.method = 'GET';\n\n return(this.http.get(url,this.configToOptions(config)).toPromise().then(this.handleSuccess,this.handleFailure));\n };\n\n\n post(url, data, config) {\n config = config || {};\n config.url = url;\n config.method = 'POST';\n\n return(this.http.post(config.url,data,this.configToOptions(config)).toPromise().then(this.handleSuccess,this.handleFailure));\n }\n\n put(url, data, config) {\n config = config || {};\n config.url = url;\n config.method = 'PUT';\n\n return(this.http.post(config.url,data,this.configToOptions(config)).toPromise().then(this.handleSuccess,this.handleFailure));\n }\n\n delete(url, config) {\n config = config || {};\n config.url = url;\n config.method = 'DELETE';\n\n return(this.http.delete(config.url,this.configToOptions(config)).toPromise().then(this.handleSuccess,this.handleFailure));\n }\n\n\n handleSuccess(resp) {\n if (resp && resp.status == 200 && resp.body) {\n if (_.isString(resp.body)) try {\n resp.data = JSON.parse(resp.body);\n } catch (e) {}\n else\n resp.data = resp.body;\n }\n return(resp);\n }\n\n handleFailure(resp) {\n if (_.isString(resp.error)) try {\n resp.data = JSON.parse(resp.error);\n } catch (e) {}\n\n return(Promise.reject(resp));\n }\n\n}\n", "/*\nCopyright 2022-Present Couchbase, Inc.\n\nUse of this software is governed by the Business Source License included in\nthe file licenses/BSL-Couchbase.txt. As of the Change Date specified in that\nfile, in accordance with the Business Source License, use of this software will\nbe governed by the Apache License, Version 2.0, included in the file\nlicenses/APL2.txt.\n*/\n\nimport { QwHttp } from '../angular-services/qw.http.js';\nimport { QwQueryService} from \"./qw.query.service.js\";\nimport _ from 'lodash';\n\nexport { QwMetadataService };\n\n//\n// replace validateQueryService, mnPools, MnPoolsDefault, and mnPermissions\n//\n\nclass QwMetadataService {\n static get annotations() {\n return [\n new Injectable()\n ]\n }\n\n static get parameters() {\n return [\n QwHttp,\n QwQueryService,\n ]\n }\n \n constructor(\n qwHttp,\n qwQueryService,\n ) {\n this.qwHttp = qwHttp;\n this.qqs = qwQueryService;\n this.compat = {init:false};\n this.pools = {init:false};\n this.rbac = {init:false};\n this.queryNodes = [];\n this.bucketList = [];\n this.permittedBucketList = [];\n this.indexes = {};\n this.errors = [];\n this.metaReady = this.updateBuckets();\n\n qwHttp.get('/pools')\n .then(pools => {this.pools.export = pools.data; this.pools.init=true;},\n error => {this.pools = {err: error}});\n }\n\n valid() {\n return this.queryNodes && this.queryNodes.length > 0\n };\n\n isEnterprise() {\n return this.pools.export && this.pools.export.isEnterprise;\n };\n\n monitoringAllowed() {\n return this.rbac.init && this.rbac.cluster.n1ql.meta.read;\n }\n\n updateBuckets() {\n let This = this;\n return this.qwHttp.get('/pools/default')\n .then(poolsDefault => This.decodePoolsDefault(poolsDefault.data),\n error => {This.compat = {err: error}});\n }\n\n decodePoolsDefault(poolDefault) {\n let This = this;\n // figure out compat version\n let thisNode = poolDefault.nodes.find(node => node.thisNode);\n\n this.compat.atLeast51 = thisNode.clusterCompatibility >= encodeCompatVersion(5, 1);\n this.compat.atLeast55 = thisNode.clusterCompatibility >= encodeCompatVersion(5, 5);\n this.compat.atLeast65 = thisNode.clusterCompatibility >= encodeCompatVersion(6, 5);\n this.compat.atLeast66 = thisNode.clusterCompatibility >= encodeCompatVersion(6, 6);\n this.compat.atLeast70 = thisNode.clusterCompatibility >= encodeCompatVersion(7, 0);\n this.compat.atLeast71 = thisNode.clusterCompatibility >= encodeCompatVersion(7, 1);\n this.compat.init = true;\n\n // figure out which nodes are running query service\n this.queryNodes = poolDefault.nodes.filter(node => node.services.includes('n1ql'))\n .map(node => node.hostname);\n\n // get bucket names\n this.bucketList.length = 0;\n if (_.isArray(poolDefault.bucketNames)) {\n this.bucketList.push(...poolDefault.bucketNames.map(bucket => bucket.bucketName));\n this.bucketList.sort();\n }\n\n // permissions that the workbench needs to know about\n let perms = [\n 'cluster.collection[.:.:.].collections!read',\n 'cluster.collection[.:.:.].data.docs!read',\n 'cluster.collection[.:.:.].data.docs!upsert',\n 'cluster.collection[.:.:.].n1ql.index!all',\n 'cluster.collection[.:.:.].n1ql.select!execute',\n 'cluster.collection[.:.:.].n1ql.udf_external!manage',\n 'cluster.collection[.:.:.].n1ql.udf!manage',\n 'cluster.collection[.:.:.].stats!read',\n 'cluster.n1ql.meta!read',\n 'cluster.n1ql.udf!manage',\n 'cluster.n1ql.udf_external!manage',\n ...this.bucketList.map(bucketName => 'cluster.bucket[' + bucketName + '].data.docs!read'),\n ...this.bucketList.map(bucketName => 'cluster.bucket[' + bucketName + '].data.docs!upsert'),\n ...this.bucketList.map(bucketName => 'cluster.bucket[' + bucketName + '].data.docs!delete'),\n\n ...this.bucketList.map(bucketName => 'cluster.collection[' + bucketName + ':.:.].data.docs!read'),\n ...this.bucketList.map(bucketName => 'cluster.collection[' + bucketName + ':.:.].data.docs!upsert'),\n ...this.bucketList.map(bucketName => 'cluster.collection[' + bucketName + ':.:.].data.docs!delete'),\n\n ...this.bucketList.map(bucketName => 'cluster.collection[' + bucketName + ':.:.].n1ql.udf!manage'),\n ...this.bucketList.map(bucketName => 'cluster.collection[' + bucketName + ':.:.].n1ql.udf_external!manage'),\n ];\n\n let promise = this.qwHttp.post('/pools/default/checkPermissions',perms.join(','))\n .then(result => This.decodePermissions(result.data),\n err => {this.rbac = err});\n\n return(promise);\n }\n\n\n // decode permissions from the array of 'name': to a tree\n decodePermissions(permissions) {\n //console.log(\"Got permissions: \" + JSON.stringify(permissions,null,2));\n\n this.rbac.init = true;\n Object.keys(permissions).forEach(key => {\n let value = permissions[key];\n var path = [];\n let sections = key.split(/[[\\]]+/);\n for (var i=0; i < sections.length; i++)\n if (i==1)\n path.push(sections[i]); // bucket/coll info inside brackets\n else\n path.push(...sections[i].split(/[.!]+/));\n\n let perm = this.rbac;\n // fill out the path as needed\n path.forEach((pName,i) => {\n if (pName.length)\n {perm[pName] = perm[pName] || (i < path.length - 1 ? {} : value); perm = perm[pName];}\n });\n });\n\n // need to record which buckets we are allowed to access the data\n\n this.permittedBucketList.length = 0;\n this.bucketList.forEach(bucketName => {\n if (this.rbac.cluster.bucket[bucketName].data.docs.read ||\n this.rbac.cluster.bucket[bucketName].data.docs.upsert ||\n this.rbac.cluster.bucket[bucketName].data.docs.delete ||\n this.rbac.cluster.collection[bucketName + ':.:.'].data.docs.read ||\n this.rbac.cluster.collection[bucketName + ':.:.'].data.docs.upsert ||\n this.rbac.cluster.collection[bucketName + ':.:.'].data.docs.delete ||\n this.rbac.cluster.collection[bucketName + ':.:.'].n1ql.udf.manage ||\n this.rbac.cluster.collection[bucketName + ':.:.'].n1ql.udf_external.manage)\n this.permittedBucketList.push(bucketName);\n });\n\n // get index info, if possible. If query nodes exist, use a query,\n // which works even if /indexStatus API is forbidden\n if (this.queryNodes.length > 0)\n return this.getIndexesN1QL();\n else\n return this.getIndexesREST();\n }\n\n // do we have enough permissions to run queries?\n queryPermitted() {\n return this.rbac.init && ((this.rbac.cluster.collection['.:.:.'].data.docs.read &&\n this.rbac.cluster.collection['.:.:.'].n1ql.select.execute) ||\n this.rbac.cluster.collection['.:.:.'].n1ql.index.all);\n }\n\n // get indexes via N1QL (preferable if possible)\n getIndexesN1QL() {\n return this.qqs.executeQueryUtil('select indexes.* from system:indexes')\n .then(success_resp => {\n Object.keys(this.indexes).forEach(key => {delete this.indexes[key]});\n if (success_resp.status == 200 && success_resp.data && Array.isArray(success_resp.data.results))\n success_resp.data.results.forEach(index => {\n // indexes on default collections have bucket name in the keyspace_id\n if (!index.bucket_id)\n this.addIndexToMetadata(index.keyspace_id,\"_default\",\"_default\",index.is_primary);\n else\n this.addIndexToMetadata(index.bucket_id,index.scope_id,index.keyspace_id,index.is_primary);\n });\n },\n error_resp => {\n Object.keys(this.indexes).forEach(key => {delete this.indexes[key]});\n this.errors.push(JSON.stringify(error_resp));\n console.log(\"Error getting indexes via n1ql: \" + JSON.stringify(error_resp));\n });\n\n }\n\n // get indexes from REST API (which doesn't work for less privileged users)\n getIndexesREST() {\n let This = this;\n return this.qwHttp.do({\n url: \"../indexStatus\",\n method: \"GET\"\n }).then(success_resp => {\n Object.keys(This.indexes).forEach(key => {delete This.indexes[key]});\n if (success_resp.status == 200 && success_resp.body && _.isArray(success_resp.body.indexes)) {\n success_resp.body.indexes.forEach(index =>\n This.addIndexToMetadata(index.bucket,index.scope,index.collection,index.definition.startsWith(\"CREATE PRIMARY\")));\n }\n }, error_resp => {\n Object.keys(This.indexes).forEach(key => {delete This.indexes[key]});\n console.log(\"Error getting indexes via REST: \" + JSON.stringify(error_resp));\n })\n }\n\n // add an index to the metadata\n addIndexToMetadata(bucketName,scopeName,collName,primary) {\n this.indexes[bucketName] = this.indexes[bucketName] || {};\n this.indexes[bucketName][scopeName] = this.indexes[bucketName][scopeName] || {};\n this.indexes[bucketName][scopeName][collName] = this.indexes[bucketName][scopeName][collName] || {};\n if (primary)\n this.indexes[bucketName][scopeName][collName].primary = true;\n else\n this.indexes[bucketName][scopeName][collName].secondary = true;\n }\n}\n\n// counterpart of ns_heart:effective_cluster_compat_version/0\nfunction encodeCompatVersion(major, minor) {\n if (major < 2) {\n return 1;\n }\n return major * 0x10000 + minor;\n}\n", "/*\nCopyright 2020-Present Couchbase, Inc.\n\nUse of this software is governed by the Business Source License included in\nthe file licenses/BSL-Couchbase.txt. As of the Change Date specified in that\nfile, in accordance with the Business Source License, use of this software will\nbe governed by the Apache License, Version 2.0, included in the file\nlicenses/APL2.txt.\n*/\n\nimport {MnLifeCycleHooksToStream} from 'mn.core';\nimport {NgbActiveModal} from '@ng-bootstrap/ng-bootstrap';\nimport {Component, ViewEncapsulation} from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nimport template from \"./qw.doc.editor.dialog.html\";\n\nexport { QwDocEditorDialog };\n\nclass QwDocEditorDialog extends MnLifeCycleHooksToStream {\n static get annotations() {\n return [\n new Component({\n template,\n styleUrls: [\"../_p/ui/query/angular-directives/qw.directives.css\"],\n imports: [ CommonModule ],\n inputs: [\"readonly\", \"header\", \"doc_id\",\"doc_json\", \"doc_meta\", \"new_doc\"],\n encapsulation: ViewEncapsulation.None,\n })\n ]}\n\n static get parameters() {\n return [\n NgbActiveModal,\n ];\n }\n\n ngOnInit() {\n }\n\n constructor(activeModal) {\n super();\n\n this.activeModal = activeModal;\n this.showData = true;\n this.config = ace.require(\"ace/config\" );\n\n // unbind ^F for all ACE editors\n var default_commands = ace.require(\"ace/commands/default_commands\");\n for (var i=0; i< default_commands.commands.length; i++)\n if (default_commands.commands[i].name.startsWith(\"find\")) {\n default_commands.commands.splice(i,1);\n i--;\n }\n }\n\n searchDoc() {\n var This = this;\n this.config.loadModule(\"ace/ext/cb-searchbox\",\n function(e) {\n if (This.showData && This.mainEditor) e.Search(This.mainEditor,true,true);\n else if (!This.showData && This.metaEditor) e.Search(This.metaEditor);\n });\n\n }\n\n setShowData(setting) {\n this.showData = setting;\n }\n\n getShowData() {\n return(this.showData);\n }\n\n errors() {\n if (this.mainEditor) {\n var annot_list = this.mainEditor.getSession().getAnnotations();\n if (annot_list && annot_list.length)\n for (var i=0; i < annot_list.length; i++)\n if (annot_list[i].type == \"error\") {\n return true;\n }\n\n // don't allow empty documents or documents > 10MB\n if ((this.mainEditor.getSession().getValue().trim().length == 0) ||\n (this.mainEditor.getSession().getValue().trim().length > 10*1024*1024))\n return true;\n\n // don't allow empty doc id\n if (!this.doc_id)\n return true;\n }\n return false;\n }\n\n onMainEditorReady(editor) {\n var This = this;\n this.mainEditor = editor;\n editor.$blockScrolling = Infinity;\n editor.renderer.setPrintMarginColumn(false); // hide page boundary lines\n editor.setReadOnly(this.readonly);\n editor.getSession().on(\"changeAnnotation\", function() {\n var annot_list = editor.getSession().getAnnotations();\n if (annot_list && annot_list.length) for (var i=0; i < annot_list.length; i++)\n if (annot_list[i].type == \"error\") {\n This.error_message = \"Error on row: \" + annot_list[i].row + \": \" + annot_list[i].text;\n //dialogScope.$applyAsync(function() {});\n return;\n }\n if (editor) {\n This.error_message = null; // no errors found\n //dialogScope.$applyAsync(function() {});\n }\n });\n if (/^((?!chrome).)*safari/i.test(navigator.userAgent))\n editor.renderer.scrollBarV.width = 20; // fix for missing scrollbars in Safari\n\n editor.setOptions({\n mode: 'ace/mode/json',\n showGutter: true,\n wrap: true,\n });\n }\n\n onMetaEditorReady(editor) {\n this.metaEditor = editor;\n editor.$blockScrolling = Infinity;\n editor.renderer.setPrintMarginColumn(false); // hide page boundary lines\n editor.setReadOnly(true);\n if (/^((?!chrome).)*safari/i.test(navigator.userAgent))\n editor.renderer.scrollBarV.width = 20; // fix for missing scrollbars in Safari\n\n editor.setOptions({\n mode: 'ace/mode/json',\n showGutter: true,\n wrap: true\n });\n }\n\n}\n", "/*\nCopyright 2020-Present Couchbase, Inc.\n\nUse of this software is governed by the Business Source License included in\nthe file licenses/BSL-Couchbase.txt. As of the Change Date specified in that\nfile, in accordance with the Business Source License, use of this software will\nbe governed by the Apache License, Version 2.0, included in the file\nlicenses/APL2.txt.\n*/\n\nimport {MnLifeCycleHooksToStream} from 'mn.core';\nimport {NgbActiveModal} from '@ng-bootstrap/ng-bootstrap';\nimport {Component, ViewEncapsulation} from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nimport template from \"./qw.error.dialog.html\";\n\nexport { QwErrorDialog };\n\nclass QwErrorDialog extends MnLifeCycleHooksToStream {\n static get annotations() {\n return [\n new Component({\n template,\n styleUrls: [\"../_p/ui/query/angular-directives/qw.directives.css\"],\n imports: [ CommonModule ],\n inputs: [\"error_title\", \"error_detail\", \"error_detail_array\", \"hide_cancel\"],\n encapsulation: ViewEncapsulation.None,\n })\n ]}\n\n static get parameters() {\n return [\n NgbActiveModal,\n ];\n }\n\n ngOnInit() {\n }\n\n constructor(activeModal) {\n super();\n\n this.activeModal = activeModal;\n }\n\n}\n", "/*\nCopyright 2020-Present Couchbase, Inc.\n\nUse of this software is governed by the Business Source License included in\nthe file licenses/BSL-Couchbase.txt. As of the Change Date specified in that\nfile, in accordance with the Business Source License, use of this software will\nbe governed by the Apache License, Version 2.0, included in the file\nlicenses/APL2.txt.\n*/\n\nimport {MnLifeCycleHooksToStream} from 'mn.core';\nimport {NgbActiveModal} from '@ng-bootstrap/ng-bootstrap';\nimport {Component, ViewEncapsulation} from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nimport template from \"./qw.input.dialog.html\";\n\nexport { QwInputDialog };\n\nclass QwInputDialog extends MnLifeCycleHooksToStream {\n static get annotations() {\n return [\n new Component({\n template,\n styleUrls: [\"../_p/ui/query/angular-directives/qw.directives.css\"],\n imports: [ CommonModule ],\n inputs: [\"header_message\", \"body_message\", \"input_value\"],\n encapsulation: ViewEncapsulation.None,\n })\n ]}\n\n static get parameters() {\n return [\n NgbActiveModal,\n ];\n }\n\n ngOnInit() {\n }\n\n constructor(activeModal) {\n super();\n\n this.activeModal = activeModal;\n\n if (!this.input_value)\n this.input_value = '';\n }\n\n}\n", "/*\nCopyright 2021-Present Couchbase, Inc.\n\nUse of this software is governed by the Business Source License included in\nthe file licenses/BSL-Couchbase.txt. As of the Change Date specified in that\nfile, in accordance with the Business Source License, use of this software will\nbe governed by the Apache License, Version 2.0, included in the file\nlicenses/APL2.txt.\n*/\n\nimport {MnLifeCycleHooksToStream} from 'mn.core';\nimport {NgbActiveModal} from '@ng-bootstrap/ng-bootstrap';\nimport {Component, ViewEncapsulation} from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nimport template from \"./qw.notice.dialog.html\";\n\nexport { QwNoticeDialog };\n\nclass QwNoticeDialog extends MnLifeCycleHooksToStream {\n static get annotations() {\n return [\n new Component({\n template,\n styleUrls: [\"../_p/ui/query/angular-directives/qw.directives.css\"],\n imports: [ CommonModule ],\n inputs: [\"header_message\", \"body_message\", \"body_message_array\"],\n encapsulation: ViewEncapsulation.None,\n })\n ]}\n\n static get parameters() {\n return [\n NgbActiveModal,\n ];\n }\n\n ngOnInit() {\n }\n\n constructor(activeModal) {\n super();\n\n this.activeModal = activeModal;\n }\n\n}\n", "import { c as createCommonjsModule } from './common/_commonjsHelpers-6a48b99e.js';\n\n/*jshint node:true */\n\nfunction OutputLine(parent) {\n this.__parent = parent;\n this.__character_count = 0;\n // use indent_count as a marker for this.__lines that have preserved indentation\n this.__indent_count = -1;\n this.__alignment_count = 0;\n this.__wrap_point_index = 0;\n this.__wrap_point_character_count = 0;\n this.__wrap_point_indent_count = -1;\n this.__wrap_point_alignment_count = 0;\n\n this.__items = [];\n}\n\nOutputLine.prototype.clone_empty = function() {\n var line = new OutputLine(this.__parent);\n line.set_indent(this.__indent_count, this.__alignment_count);\n return line;\n};\n\nOutputLine.prototype.item = function(index) {\n if (index < 0) {\n return this.__items[this.__items.length + index];\n } else {\n return this.__items[index];\n }\n};\n\nOutputLine.prototype.has_match = function(pattern) {\n for (var lastCheckedOutput = this.__items.length - 1; lastCheckedOutput >= 0; lastCheckedOutput--) {\n if (this.__items[lastCheckedOutput].match(pattern)) {\n return true;\n }\n }\n return false;\n};\n\nOutputLine.prototype.set_indent = function(indent, alignment) {\n if (this.is_empty()) {\n this.__indent_count = indent || 0;\n this.__alignment_count = alignment || 0;\n this.__character_count = this.__parent.get_indent_size(this.__indent_count, this.__alignment_count);\n }\n};\n\nOutputLine.prototype._set_wrap_point = function() {\n if (this.__parent.wrap_line_length) {\n this.__wrap_point_index = this.__items.length;\n this.__wrap_point_character_count = this.__character_count;\n this.__wrap_point_indent_count = this.__parent.next_line.__indent_count;\n this.__wrap_point_alignment_count = this.__parent.next_line.__alignment_count;\n }\n};\n\nOutputLine.prototype._should_wrap = function() {\n return this.__wrap_point_index &&\n this.__character_count > this.__parent.wrap_line_length &&\n this.__wrap_point_character_count > this.__parent.next_line.__character_count;\n};\n\nOutputLine.prototype._allow_wrap = function() {\n if (this._should_wrap()) {\n this.__parent.add_new_line();\n var next = this.__parent.current_line;\n next.set_indent(this.__wrap_point_indent_count, this.__wrap_point_alignment_count);\n next.__items = this.__items.slice(this.__wrap_point_index);\n this.__items = this.__items.slice(0, this.__wrap_point_index);\n\n next.__character_count += this.__character_count - this.__wrap_point_character_count;\n this.__character_count = this.__wrap_point_character_count;\n\n if (next.__items[0] === \" \") {\n next.__items.splice(0, 1);\n next.__character_count -= 1;\n }\n return true;\n }\n return false;\n};\n\nOutputLine.prototype.is_empty = function() {\n return this.__items.length === 0;\n};\n\nOutputLine.prototype.last = function() {\n if (!this.is_empty()) {\n return this.__items[this.__items.length - 1];\n } else {\n return null;\n }\n};\n\nOutputLine.prototype.push = function(item) {\n this.__items.push(item);\n var last_newline_index = item.lastIndexOf('\\n');\n if (last_newline_index !== -1) {\n this.__character_count = item.length - last_newline_index;\n } else {\n this.__character_count += item.length;\n }\n};\n\nOutputLine.prototype.pop = function() {\n var item = null;\n if (!this.is_empty()) {\n item = this.__items.pop();\n this.__character_count -= item.length;\n }\n return item;\n};\n\n\nOutputLine.prototype._remove_indent = function() {\n if (this.__indent_count > 0) {\n this.__indent_count -= 1;\n this.__character_count -= this.__parent.indent_size;\n }\n};\n\nOutputLine.prototype._remove_wrap_indent = function() {\n if (this.__wrap_point_indent_count > 0) {\n this.__wrap_point_indent_count -= 1;\n }\n};\nOutputLine.prototype.trim = function() {\n while (this.last() === ' ') {\n this.__items.pop();\n this.__character_count -= 1;\n }\n};\n\nOutputLine.prototype.toString = function() {\n var result = '';\n if (this.is_empty()) {\n if (this.__parent.indent_empty_lines) {\n result = this.__parent.get_indent_string(this.__indent_count);\n }\n } else {\n result = this.__parent.get_indent_string(this.__indent_count, this.__alignment_count);\n result += this.__items.join('');\n }\n return result;\n};\n\nfunction IndentStringCache(options, baseIndentString) {\n this.__cache = [''];\n this.__indent_size = options.indent_size;\n this.__indent_string = options.indent_char;\n if (!options.indent_with_tabs) {\n this.__indent_string = new Array(options.indent_size + 1).join(options.indent_char);\n }\n\n // Set to null to continue support for auto detection of base indent\n baseIndentString = baseIndentString || '';\n if (options.indent_level > 0) {\n baseIndentString = new Array(options.indent_level + 1).join(this.__indent_string);\n }\n\n this.__base_string = baseIndentString;\n this.__base_string_length = baseIndentString.length;\n}\n\nIndentStringCache.prototype.get_indent_size = function(indent, column) {\n var result = this.__base_string_length;\n column = column || 0;\n if (indent < 0) {\n result = 0;\n }\n result += indent * this.__indent_size;\n result += column;\n return result;\n};\n\nIndentStringCache.prototype.get_indent_string = function(indent_level, column) {\n var result = this.__base_string;\n column = column || 0;\n if (indent_level < 0) {\n indent_level = 0;\n result = '';\n }\n column += indent_level * this.__indent_size;\n this.__ensure_cache(column);\n result += this.__cache[column];\n return result;\n};\n\nIndentStringCache.prototype.__ensure_cache = function(column) {\n while (column >= this.__cache.length) {\n this.__add_column();\n }\n};\n\nIndentStringCache.prototype.__add_column = function() {\n var column = this.__cache.length;\n var indent = 0;\n var result = '';\n if (this.__indent_size && column >= this.__indent_size) {\n indent = Math.floor(column / this.__indent_size);\n column -= indent * this.__indent_size;\n result = new Array(indent + 1).join(this.__indent_string);\n }\n if (column) {\n result += new Array(column + 1).join(' ');\n }\n\n this.__cache.push(result);\n};\n\nfunction Output(options, baseIndentString) {\n this.__indent_cache = new IndentStringCache(options, baseIndentString);\n this.raw = false;\n this._end_with_newline = options.end_with_newline;\n this.indent_size = options.indent_size;\n this.wrap_line_length = options.wrap_line_length;\n this.indent_empty_lines = options.indent_empty_lines;\n this.__lines = [];\n this.previous_line = null;\n this.current_line = null;\n this.next_line = new OutputLine(this);\n this.space_before_token = false;\n this.non_breaking_space = false;\n this.previous_token_wrapped = false;\n // initialize\n this.__add_outputline();\n}\n\nOutput.prototype.__add_outputline = function() {\n this.previous_line = this.current_line;\n this.current_line = this.next_line.clone_empty();\n this.__lines.push(this.current_line);\n};\n\nOutput.prototype.get_line_number = function() {\n return this.__lines.length;\n};\n\nOutput.prototype.get_indent_string = function(indent, column) {\n return this.__indent_cache.get_indent_string(indent, column);\n};\n\nOutput.prototype.get_indent_size = function(indent, column) {\n return this.__indent_cache.get_indent_size(indent, column);\n};\n\nOutput.prototype.is_empty = function() {\n return !this.previous_line && this.current_line.is_empty();\n};\n\nOutput.prototype.add_new_line = function(force_newline) {\n // never newline at the start of file\n // otherwise, newline only if we didn't just add one or we're forced\n if (this.is_empty() ||\n (!force_newline && this.just_added_newline())) {\n return false;\n }\n\n // if raw output is enabled, don't print additional newlines,\n // but still return True as though you had\n if (!this.raw) {\n this.__add_outputline();\n }\n return true;\n};\n\nOutput.prototype.get_code = function(eol) {\n this.trim(true);\n\n // handle some edge cases where the last tokens\n // has text that ends with newline(s)\n var last_item = this.current_line.pop();\n if (last_item) {\n if (last_item[last_item.length - 1] === '\\n') {\n last_item = last_item.replace(/\\n+$/g, '');\n }\n this.current_line.push(last_item);\n }\n\n if (this._end_with_newline) {\n this.__add_outputline();\n }\n\n var sweet_code = this.__lines.join('\\n');\n\n if (eol !== '\\n') {\n sweet_code = sweet_code.replace(/[\\n]/g, eol);\n }\n return sweet_code;\n};\n\nOutput.prototype.set_wrap_point = function() {\n this.current_line._set_wrap_point();\n};\n\nOutput.prototype.set_indent = function(indent, alignment) {\n indent = indent || 0;\n alignment = alignment || 0;\n\n // Next line stores alignment values\n this.next_line.set_indent(indent, alignment);\n\n // Never indent your first output indent at the start of the file\n if (this.__lines.length > 1) {\n this.current_line.set_indent(indent, alignment);\n return true;\n }\n\n this.current_line.set_indent();\n return false;\n};\n\nOutput.prototype.add_raw_token = function(token) {\n for (var x = 0; x < token.newlines; x++) {\n this.__add_outputline();\n }\n this.current_line.set_indent(-1);\n this.current_line.push(token.whitespace_before);\n this.current_line.push(token.text);\n this.space_before_token = false;\n this.non_breaking_space = false;\n this.previous_token_wrapped = false;\n};\n\nOutput.prototype.add_token = function(printable_token) {\n this.__add_space_before_token();\n this.current_line.push(printable_token);\n this.space_before_token = false;\n this.non_breaking_space = false;\n this.previous_token_wrapped = this.current_line._allow_wrap();\n};\n\nOutput.prototype.__add_space_before_token = function() {\n if (this.space_before_token && !this.just_added_newline()) {\n if (!this.non_breaking_space) {\n this.set_wrap_point();\n }\n this.current_line.push(' ');\n }\n};\n\nOutput.prototype.remove_indent = function(index) {\n var output_length = this.__lines.length;\n while (index < output_length) {\n this.__lines[index]._remove_indent();\n index++;\n }\n this.current_line._remove_wrap_indent();\n};\n\nOutput.prototype.trim = function(eat_newlines) {\n eat_newlines = (eat_newlines === undefined) ? false : eat_newlines;\n\n this.current_line.trim();\n\n while (eat_newlines && this.__lines.length > 1 &&\n this.current_line.is_empty()) {\n this.__lines.pop();\n this.current_line = this.__lines[this.__lines.length - 1];\n this.current_line.trim();\n }\n\n this.previous_line = this.__lines.length > 1 ?\n this.__lines[this.__lines.length - 2] : null;\n};\n\nOutput.prototype.just_added_newline = function() {\n return this.current_line.is_empty();\n};\n\nOutput.prototype.just_added_blankline = function() {\n return this.is_empty() ||\n (this.current_line.is_empty() && this.previous_line.is_empty());\n};\n\nOutput.prototype.ensure_empty_line_above = function(starts_with, ends_with) {\n var index = this.__lines.length - 2;\n while (index >= 0) {\n var potentialEmptyLine = this.__lines[index];\n if (potentialEmptyLine.is_empty()) {\n break;\n } else if (potentialEmptyLine.item(0).indexOf(starts_with) !== 0 &&\n potentialEmptyLine.item(-1) !== ends_with) {\n this.__lines.splice(index + 1, 0, new OutputLine(this));\n this.previous_line = this.__lines[this.__lines.length - 2];\n break;\n }\n index--;\n }\n};\n\nvar Output_1 = Output;\n\nvar output = {\n\tOutput: Output_1\n};\n\n/*jshint node:true */\n\nfunction Token(type, text, newlines, whitespace_before) {\n this.type = type;\n this.text = text;\n\n // comments_before are\n // comments that have a new line before them\n // and may or may not have a newline after\n // this is a set of comments before\n this.comments_before = null; /* inline comment*/\n\n\n // this.comments_after = new TokenStream(); // no new line before and newline after\n this.newlines = newlines || 0;\n this.whitespace_before = whitespace_before || '';\n this.parent = null;\n this.next = null;\n this.previous = null;\n this.opened = null;\n this.closed = null;\n this.directives = null;\n}\n\n\nvar Token_1 = Token;\n\nvar token = {\n\tToken: Token_1\n};\n\nvar acorn = createCommonjsModule(function (module, exports) {\n\n// acorn used char codes to squeeze the last bit of performance out\n// Beautifier is okay without that, so we're using regex\n// permit # (23), $ (36), and @ (64). @ is used in ES7 decorators.\n// 65 through 91 are uppercase letters.\n// permit _ (95).\n// 97 through 123 are lowercase letters.\nvar baseASCIIidentifierStartChars = \"\\\\x23\\\\x24\\\\x40\\\\x41-\\\\x5a\\\\x5f\\\\x61-\\\\x7a\";\n\n// inside an identifier @ is not allowed but 0-9 are.\nvar baseASCIIidentifierChars = \"\\\\x24\\\\x30-\\\\x39\\\\x41-\\\\x5a\\\\x5f\\\\x61-\\\\x7a\";\n\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point above 128.\nvar nonASCIIidentifierStartChars = \"\\\\xaa\\\\xb5\\\\xba\\\\xc0-\\\\xd6\\\\xd8-\\\\xf6\\\\xf8-\\\\u02c1\\\\u02c6-\\\\u02d1\\\\u02e0-\\\\u02e4\\\\u02ec\\\\u02ee\\\\u0370-\\\\u0374\\\\u0376\\\\u0377\\\\u037a-\\\\u037d\\\\u0386\\\\u0388-\\\\u038a\\\\u038c\\\\u038e-\\\\u03a1\\\\u03a3-\\\\u03f5\\\\u03f7-\\\\u0481\\\\u048a-\\\\u0527\\\\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\\\\u08a2-\\\\u08ac\\\\u0904-\\\\u0939\\\\u093d\\\\u0950\\\\u0958-\\\\u0961\\\\u0971-\\\\u0977\\\\u0979-\\\\u097f\\\\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-\\\\u0c33\\\\u0c35-\\\\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-\\\\u16f0\\\\u1700-\\\\u170c\\\\u170e-\\\\u1711\\\\u1720-\\\\u1731\\\\u1740-\\\\u1751\\\\u1760-\\\\u176c\\\\u176e-\\\\u1770\\\\u1780-\\\\u17b3\\\\u17d7\\\\u17dc\\\\u1820-\\\\u1877\\\\u1880-\\\\u18a8\\\\u18aa\\\\u18b0-\\\\u18f5\\\\u1900-\\\\u191c\\\\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-\\\\ua697\\\\ua6a0-\\\\ua6ef\\\\ua717-\\\\ua71f\\\\ua722-\\\\ua788\\\\ua78b-\\\\ua78e\\\\ua790-\\\\ua793\\\\ua7a0-\\\\ua7aa\\\\ua7f8-\\\\ua801\\\\ua803-\\\\ua805\\\\ua807-\\\\ua80a\\\\ua80c-\\\\ua822\\\\ua840-\\\\ua873\\\\ua882-\\\\ua8b3\\\\ua8f2-\\\\ua8f7\\\\ua8fb\\\\ua90a-\\\\ua925\\\\ua930-\\\\ua946\\\\ua960-\\\\ua97c\\\\ua984-\\\\ua9b2\\\\ua9cf\\\\uaa00-\\\\uaa28\\\\uaa40-\\\\uaa42\\\\uaa44-\\\\uaa4b\\\\uaa60-\\\\uaa76\\\\uaa7a\\\\uaa80-\\\\uaaaf\\\\uaab1\\\\uaab5\\\\uaab6\\\\uaab9-\\\\uaabd\\\\uaac0\\\\uaac2\\\\uaadb-\\\\uaadd\\\\uaae0-\\\\uaaea\\\\uaaf2-\\\\uaaf4\\\\uab01-\\\\uab06\\\\uab09-\\\\uab0e\\\\uab11-\\\\uab16\\\\uab20-\\\\uab26\\\\uab28-\\\\uab2e\\\\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\";\nvar nonASCIIidentifierChars = \"\\\\u0300-\\\\u036f\\\\u0483-\\\\u0487\\\\u0591-\\\\u05bd\\\\u05bf\\\\u05c1\\\\u05c2\\\\u05c4\\\\u05c5\\\\u05c7\\\\u0610-\\\\u061a\\\\u0620-\\\\u0649\\\\u0672-\\\\u06d3\\\\u06e7-\\\\u06e8\\\\u06fb-\\\\u06fc\\\\u0730-\\\\u074a\\\\u0800-\\\\u0814\\\\u081b-\\\\u0823\\\\u0825-\\\\u0827\\\\u0829-\\\\u082d\\\\u0840-\\\\u0857\\\\u08e4-\\\\u08fe\\\\u0900-\\\\u0903\\\\u093a-\\\\u093c\\\\u093e-\\\\u094f\\\\u0951-\\\\u0957\\\\u0962-\\\\u0963\\\\u0966-\\\\u096f\\\\u0981-\\\\u0983\\\\u09bc\\\\u09be-\\\\u09c4\\\\u09c7\\\\u09c8\\\\u09d7\\\\u09df-\\\\u09e0\\\\u0a01-\\\\u0a03\\\\u0a3c\\\\u0a3e-\\\\u0a42\\\\u0a47\\\\u0a48\\\\u0a4b-\\\\u0a4d\\\\u0a51\\\\u0a66-\\\\u0a71\\\\u0a75\\\\u0a81-\\\\u0a83\\\\u0abc\\\\u0abe-\\\\u0ac5\\\\u0ac7-\\\\u0ac9\\\\u0acb-\\\\u0acd\\\\u0ae2-\\\\u0ae3\\\\u0ae6-\\\\u0aef\\\\u0b01-\\\\u0b03\\\\u0b3c\\\\u0b3e-\\\\u0b44\\\\u0b47\\\\u0b48\\\\u0b4b-\\\\u0b4d\\\\u0b56\\\\u0b57\\\\u0b5f-\\\\u0b60\\\\u0b66-\\\\u0b6f\\\\u0b82\\\\u0bbe-\\\\u0bc2\\\\u0bc6-\\\\u0bc8\\\\u0bca-\\\\u0bcd\\\\u0bd7\\\\u0be6-\\\\u0bef\\\\u0c01-\\\\u0c03\\\\u0c46-\\\\u0c48\\\\u0c4a-\\\\u0c4d\\\\u0c55\\\\u0c56\\\\u0c62-\\\\u0c63\\\\u0c66-\\\\u0c6f\\\\u0c82\\\\u0c83\\\\u0cbc\\\\u0cbe-\\\\u0cc4\\\\u0cc6-\\\\u0cc8\\\\u0cca-\\\\u0ccd\\\\u0cd5\\\\u0cd6\\\\u0ce2-\\\\u0ce3\\\\u0ce6-\\\\u0cef\\\\u0d02\\\\u0d03\\\\u0d46-\\\\u0d48\\\\u0d57\\\\u0d62-\\\\u0d63\\\\u0d66-\\\\u0d6f\\\\u0d82\\\\u0d83\\\\u0dca\\\\u0dcf-\\\\u0dd4\\\\u0dd6\\\\u0dd8-\\\\u0ddf\\\\u0df2\\\\u0df3\\\\u0e34-\\\\u0e3a\\\\u0e40-\\\\u0e45\\\\u0e50-\\\\u0e59\\\\u0eb4-\\\\u0eb9\\\\u0ec8-\\\\u0ecd\\\\u0ed0-\\\\u0ed9\\\\u0f18\\\\u0f19\\\\u0f20-\\\\u0f29\\\\u0f35\\\\u0f37\\\\u0f39\\\\u0f41-\\\\u0f47\\\\u0f71-\\\\u0f84\\\\u0f86-\\\\u0f87\\\\u0f8d-\\\\u0f97\\\\u0f99-\\\\u0fbc\\\\u0fc6\\\\u1000-\\\\u1029\\\\u1040-\\\\u1049\\\\u1067-\\\\u106d\\\\u1071-\\\\u1074\\\\u1082-\\\\u108d\\\\u108f-\\\\u109d\\\\u135d-\\\\u135f\\\\u170e-\\\\u1710\\\\u1720-\\\\u1730\\\\u1740-\\\\u1750\\\\u1772\\\\u1773\\\\u1780-\\\\u17b2\\\\u17dd\\\\u17e0-\\\\u17e9\\\\u180b-\\\\u180d\\\\u1810-\\\\u1819\\\\u1920-\\\\u192b\\\\u1930-\\\\u193b\\\\u1951-\\\\u196d\\\\u19b0-\\\\u19c0\\\\u19c8-\\\\u19c9\\\\u19d0-\\\\u19d9\\\\u1a00-\\\\u1a15\\\\u1a20-\\\\u1a53\\\\u1a60-\\\\u1a7c\\\\u1a7f-\\\\u1a89\\\\u1a90-\\\\u1a99\\\\u1b46-\\\\u1b4b\\\\u1b50-\\\\u1b59\\\\u1b6b-\\\\u1b73\\\\u1bb0-\\\\u1bb9\\\\u1be6-\\\\u1bf3\\\\u1c00-\\\\u1c22\\\\u1c40-\\\\u1c49\\\\u1c5b-\\\\u1c7d\\\\u1cd0-\\\\u1cd2\\\\u1d00-\\\\u1dbe\\\\u1e01-\\\\u1f15\\\\u200c\\\\u200d\\\\u203f\\\\u2040\\\\u2054\\\\u20d0-\\\\u20dc\\\\u20e1\\\\u20e5-\\\\u20f0\\\\u2d81-\\\\u2d96\\\\u2de0-\\\\u2dff\\\\u3021-\\\\u3028\\\\u3099\\\\u309a\\\\ua640-\\\\ua66d\\\\ua674-\\\\ua67d\\\\ua69f\\\\ua6f0-\\\\ua6f1\\\\ua7f8-\\\\ua800\\\\ua806\\\\ua80b\\\\ua823-\\\\ua827\\\\ua880-\\\\ua881\\\\ua8b4-\\\\ua8c4\\\\ua8d0-\\\\ua8d9\\\\ua8f3-\\\\ua8f7\\\\ua900-\\\\ua909\\\\ua926-\\\\ua92d\\\\ua930-\\\\ua945\\\\ua980-\\\\ua983\\\\ua9b3-\\\\ua9c0\\\\uaa00-\\\\uaa27\\\\uaa40-\\\\uaa41\\\\uaa4c-\\\\uaa4d\\\\uaa50-\\\\uaa59\\\\uaa7b\\\\uaae0-\\\\uaae9\\\\uaaf2-\\\\uaaf3\\\\uabc0-\\\\uabe1\\\\uabec\\\\uabed\\\\uabf0-\\\\uabf9\\\\ufb20-\\\\ufb28\\\\ufe00-\\\\ufe0f\\\\ufe20-\\\\ufe26\\\\ufe33\\\\ufe34\\\\ufe4d-\\\\ufe4f\\\\uff10-\\\\uff19\\\\uff3f\";\n//var nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\");\n//var nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\");\n\nvar identifierStart = \"(?:\\\\\\\\u[0-9a-fA-F]{4}|[\" + baseASCIIidentifierStartChars + nonASCIIidentifierStartChars + \"])\";\nvar identifierChars = \"(?:\\\\\\\\u[0-9a-fA-F]{4}|[\" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"])*\";\n\nexports.identifier = new RegExp(identifierStart + identifierChars, 'g');\nexports.identifierStart = new RegExp(identifierStart);\nexports.identifierMatch = new RegExp(\"(?:\\\\\\\\u[0-9a-fA-F]{4}|[\" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"])+\");\n\n// Whether a single character denotes a newline.\n\nexports.newline = /[\\n\\r\\u2028\\u2029]/;\n\n// Matches a whole line break (where CRLF is considered a single\n// line break). Used to count lines.\n\n// in javascript, these two differ\n// in python they are the same, different methods are called on them\nexports.lineBreak = new RegExp('\\r\\n|' + exports.newline.source);\nexports.allLineBreaks = new RegExp(exports.lineBreak.source, 'g');\n});\nvar acorn_1 = acorn.identifier;\nvar acorn_2 = acorn.identifierStart;\nvar acorn_3 = acorn.identifierMatch;\nvar acorn_4 = acorn.newline;\nvar acorn_5 = acorn.lineBreak;\nvar acorn_6 = acorn.allLineBreaks;\n\n/*jshint node:true */\n\nfunction Options(options, merge_child_field) {\n this.raw_options = _mergeOpts(options, merge_child_field);\n\n // Support passing the source text back with no change\n this.disabled = this._get_boolean('disabled');\n\n this.eol = this._get_characters('eol', 'auto');\n this.end_with_newline = this._get_boolean('end_with_newline');\n this.indent_size = this._get_number('indent_size', 4);\n this.indent_char = this._get_characters('indent_char', ' ');\n this.indent_level = this._get_number('indent_level');\n\n this.preserve_newlines = this._get_boolean('preserve_newlines', true);\n this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786);\n if (!this.preserve_newlines) {\n this.max_preserve_newlines = 0;\n }\n\n this.indent_with_tabs = this._get_boolean('indent_with_tabs', this.indent_char === '\\t');\n if (this.indent_with_tabs) {\n this.indent_char = '\\t';\n\n // indent_size behavior changed after 1.8.6\n // It used to be that indent_size would be\n // set to 1 for indent_with_tabs. That is no longer needed and\n // actually doesn't make sense - why not use spaces? Further,\n // that might produce unexpected behavior - tabs being used\n // for single-column alignment. So, when indent_with_tabs is true\n // and indent_size is 1, reset indent_size to 4.\n if (this.indent_size === 1) {\n this.indent_size = 4;\n }\n }\n\n // Backwards compat with 1.3.x\n this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char'));\n\n this.indent_empty_lines = this._get_boolean('indent_empty_lines');\n\n // valid templating languages ['django', 'erb', 'handlebars', 'php', 'smarty']\n // For now, 'auto' = all off for javascript, all on for html (and inline javascript).\n // other values ignored\n this.templating = this._get_selection_list('templating', ['auto', 'none', 'django', 'erb', 'handlebars', 'php', 'smarty'], ['auto']);\n}\n\nOptions.prototype._get_array = function(name, default_value) {\n var option_value = this.raw_options[name];\n var result = default_value || [];\n if (typeof option_value === 'object') {\n if (option_value !== null && typeof option_value.concat === 'function') {\n result = option_value.concat();\n }\n } else if (typeof option_value === 'string') {\n result = option_value.split(/[^a-zA-Z0-9_\\/\\-]+/);\n }\n return result;\n};\n\nOptions.prototype._get_boolean = function(name, default_value) {\n var option_value = this.raw_options[name];\n var result = option_value === undefined ? !!default_value : !!option_value;\n return result;\n};\n\nOptions.prototype._get_characters = function(name, default_value) {\n var option_value = this.raw_options[name];\n var result = default_value || '';\n if (typeof option_value === 'string') {\n result = option_value.replace(/\\\\r/, '\\r').replace(/\\\\n/, '\\n').replace(/\\\\t/, '\\t');\n }\n return result;\n};\n\nOptions.prototype._get_number = function(name, default_value) {\n var option_value = this.raw_options[name];\n default_value = parseInt(default_value, 10);\n if (isNaN(default_value)) {\n default_value = 0;\n }\n var result = parseInt(option_value, 10);\n if (isNaN(result)) {\n result = default_value;\n }\n return result;\n};\n\nOptions.prototype._get_selection = function(name, selection_list, default_value) {\n var result = this._get_selection_list(name, selection_list, default_value);\n if (result.length !== 1) {\n throw new Error(\n \"Invalid Option Value: The option '\" + name + \"' can only be one of the following values:\\n\" +\n selection_list + \"\\nYou passed in: '\" + this.raw_options[name] + \"'\");\n }\n\n return result[0];\n};\n\n\nOptions.prototype._get_selection_list = function(name, selection_list, default_value) {\n if (!selection_list || selection_list.length === 0) {\n throw new Error(\"Selection list cannot be empty.\");\n }\n\n default_value = default_value || [selection_list[0]];\n if (!this._is_valid_selection(default_value, selection_list)) {\n throw new Error(\"Invalid Default Value!\");\n }\n\n var result = this._get_array(name, default_value);\n if (!this._is_valid_selection(result, selection_list)) {\n throw new Error(\n \"Invalid Option Value: The option '\" + name + \"' can contain only the following values:\\n\" +\n selection_list + \"\\nYou passed in: '\" + this.raw_options[name] + \"'\");\n }\n\n return result;\n};\n\nOptions.prototype._is_valid_selection = function(result, selection_list) {\n return result.length && selection_list.length &&\n !result.some(function(item) { return selection_list.indexOf(item) === -1; });\n};\n\n\n// merges child options up with the parent options object\n// Example: obj = {a: 1, b: {a: 2}}\n// mergeOpts(obj, 'b')\n//\n// Returns: {a: 2}\nfunction _mergeOpts(allOptions, childFieldName) {\n var finalOpts = {};\n allOptions = _normalizeOpts(allOptions);\n var name;\n\n for (name in allOptions) {\n if (name !== childFieldName) {\n finalOpts[name] = allOptions[name];\n }\n }\n\n //merge in the per type settings for the childFieldName\n if (childFieldName && allOptions[childFieldName]) {\n for (name in allOptions[childFieldName]) {\n finalOpts[name] = allOptions[childFieldName][name];\n }\n }\n return finalOpts;\n}\n\nfunction _normalizeOpts(options) {\n var convertedOpts = {};\n var key;\n\n for (key in options) {\n var newKey = key.replace(/-/g, \"_\");\n convertedOpts[newKey] = options[key];\n }\n return convertedOpts;\n}\n\nvar Options_1 = Options;\nvar normalizeOpts = _normalizeOpts;\nvar mergeOpts = _mergeOpts;\n\nvar options = {\n\tOptions: Options_1,\n\tnormalizeOpts: normalizeOpts,\n\tmergeOpts: mergeOpts\n};\n\nvar BaseOptions = options.Options;\n\nvar validPositionValues = ['before-newline', 'after-newline', 'preserve-newline'];\n\nfunction Options$1(options) {\n BaseOptions.call(this, options, 'js');\n\n // compatibility, re\n var raw_brace_style = this.raw_options.brace_style || null;\n if (raw_brace_style === \"expand-strict\") { //graceful handling of deprecated option\n this.raw_options.brace_style = \"expand\";\n } else if (raw_brace_style === \"collapse-preserve-inline\") { //graceful handling of deprecated option\n this.raw_options.brace_style = \"collapse,preserve-inline\";\n } else if (this.raw_options.braces_on_own_line !== undefined) { //graceful handling of deprecated option\n this.raw_options.brace_style = this.raw_options.braces_on_own_line ? \"expand\" : \"collapse\";\n // } else if (!raw_brace_style) { //Nothing exists to set it\n // raw_brace_style = \"collapse\";\n }\n\n //preserve-inline in delimited string will trigger brace_preserve_inline, everything\n //else is considered a brace_style and the last one only will have an effect\n\n var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']);\n\n this.brace_preserve_inline = false; //Defaults in case one or other was not specified in meta-option\n this.brace_style = \"collapse\";\n\n for (var bs = 0; bs < brace_style_split.length; bs++) {\n if (brace_style_split[bs] === \"preserve-inline\") {\n this.brace_preserve_inline = true;\n } else {\n this.brace_style = brace_style_split[bs];\n }\n }\n\n this.unindent_chained_methods = this._get_boolean('unindent_chained_methods');\n this.break_chained_methods = this._get_boolean('break_chained_methods');\n this.space_in_paren = this._get_boolean('space_in_paren');\n this.space_in_empty_paren = this._get_boolean('space_in_empty_paren');\n this.jslint_happy = this._get_boolean('jslint_happy');\n this.space_after_anon_function = this._get_boolean('space_after_anon_function');\n this.space_after_named_function = this._get_boolean('space_after_named_function');\n this.keep_array_indentation = this._get_boolean('keep_array_indentation');\n this.space_before_conditional = this._get_boolean('space_before_conditional', true);\n this.unescape_strings = this._get_boolean('unescape_strings');\n this.e4x = this._get_boolean('e4x');\n this.comma_first = this._get_boolean('comma_first');\n this.operator_position = this._get_selection('operator_position', validPositionValues);\n\n // For testing of beautify preserve:start directive\n this.test_output_raw = this._get_boolean('test_output_raw');\n\n // force this._options.space_after_anon_function to true if this._options.jslint_happy\n if (this.jslint_happy) {\n this.space_after_anon_function = true;\n }\n\n}\nOptions$1.prototype = new BaseOptions();\n\n\n\nvar Options_1$1 = Options$1;\n\nvar options$1 = {\n\tOptions: Options_1$1\n};\n\n/*jshint node:true */\n\nvar regexp_has_sticky = RegExp.prototype.hasOwnProperty('sticky');\n\nfunction InputScanner(input_string) {\n this.__input = input_string || '';\n this.__input_length = this.__input.length;\n this.__position = 0;\n}\n\nInputScanner.prototype.restart = function() {\n this.__position = 0;\n};\n\nInputScanner.prototype.back = function() {\n if (this.__position > 0) {\n this.__position -= 1;\n }\n};\n\nInputScanner.prototype.hasNext = function() {\n return this.__position < this.__input_length;\n};\n\nInputScanner.prototype.next = function() {\n var val = null;\n if (this.hasNext()) {\n val = this.__input.charAt(this.__position);\n this.__position += 1;\n }\n return val;\n};\n\nInputScanner.prototype.peek = function(index) {\n var val = null;\n index = index || 0;\n index += this.__position;\n if (index >= 0 && index < this.__input_length) {\n val = this.__input.charAt(index);\n }\n return val;\n};\n\n// This is a JavaScript only helper function (not in python)\n// Javascript doesn't have a match method\n// and not all implementation support \"sticky\" flag.\n// If they do not support sticky then both this.match() and this.test() method\n// must get the match and check the index of the match.\n// If sticky is supported and set, this method will use it.\n// Otherwise it will check that global is set, and fall back to the slower method.\nInputScanner.prototype.__match = function(pattern, index) {\n pattern.lastIndex = index;\n var pattern_match = pattern.exec(this.__input);\n\n if (pattern_match && !(regexp_has_sticky && pattern.sticky)) {\n if (pattern_match.index !== index) {\n pattern_match = null;\n }\n }\n\n return pattern_match;\n};\n\nInputScanner.prototype.test = function(pattern, index) {\n index = index || 0;\n index += this.__position;\n\n if (index >= 0 && index < this.__input_length) {\n return !!this.__match(pattern, index);\n } else {\n return false;\n }\n};\n\nInputScanner.prototype.testChar = function(pattern, index) {\n // test one character regex match\n var val = this.peek(index);\n pattern.lastIndex = 0;\n return val !== null && pattern.test(val);\n};\n\nInputScanner.prototype.match = function(pattern) {\n var pattern_match = this.__match(pattern, this.__position);\n if (pattern_match) {\n this.__position += pattern_match[0].length;\n } else {\n pattern_match = null;\n }\n return pattern_match;\n};\n\nInputScanner.prototype.read = function(starting_pattern, until_pattern, until_after) {\n var val = '';\n var match;\n if (starting_pattern) {\n match = this.match(starting_pattern);\n if (match) {\n val += match[0];\n }\n }\n if (until_pattern && (match || !starting_pattern)) {\n val += this.readUntil(until_pattern, until_after);\n }\n return val;\n};\n\nInputScanner.prototype.readUntil = function(pattern, until_after) {\n var val = '';\n var match_index = this.__position;\n pattern.lastIndex = this.__position;\n var pattern_match = pattern.exec(this.__input);\n if (pattern_match) {\n match_index = pattern_match.index;\n if (until_after) {\n match_index += pattern_match[0].length;\n }\n } else {\n match_index = this.__input_length;\n }\n\n val = this.__input.substring(this.__position, match_index);\n this.__position = match_index;\n return val;\n};\n\nInputScanner.prototype.readUntilAfter = function(pattern) {\n return this.readUntil(pattern, true);\n};\n\nInputScanner.prototype.get_regexp = function(pattern, match_from) {\n var result = null;\n var flags = 'g';\n if (match_from && regexp_has_sticky) {\n flags = 'y';\n }\n // strings are converted to regexp\n if (typeof pattern === \"string\" && pattern !== '') {\n // result = new RegExp(pattern.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&'), flags);\n result = new RegExp(pattern, flags);\n } else if (pattern) {\n result = new RegExp(pattern.source, flags);\n }\n return result;\n};\n\nInputScanner.prototype.get_literal_regexp = function(literal_string) {\n return RegExp(literal_string.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&'));\n};\n\n/* css beautifier legacy helpers */\nInputScanner.prototype.peekUntilAfter = function(pattern) {\n var start = this.__position;\n var val = this.readUntilAfter(pattern);\n this.__position = start;\n return val;\n};\n\nInputScanner.prototype.lookBack = function(testVal) {\n var start = this.__position - 1;\n return start >= testVal.length && this.__input.substring(start - testVal.length, start)\n .toLowerCase() === testVal;\n};\n\nvar InputScanner_1 = InputScanner;\n\nvar inputscanner = {\n\tInputScanner: InputScanner_1\n};\n\n/*jshint node:true */\n\nfunction TokenStream(parent_token) {\n // private\n this.__tokens = [];\n this.__tokens_length = this.__tokens.length;\n this.__position = 0;\n this.__parent_token = parent_token;\n}\n\nTokenStream.prototype.restart = function() {\n this.__position = 0;\n};\n\nTokenStream.prototype.isEmpty = function() {\n return this.__tokens_length === 0;\n};\n\nTokenStream.prototype.hasNext = function() {\n return this.__position < this.__tokens_length;\n};\n\nTokenStream.prototype.next = function() {\n var val = null;\n if (this.hasNext()) {\n val = this.__tokens[this.__position];\n this.__position += 1;\n }\n return val;\n};\n\nTokenStream.prototype.peek = function(index) {\n var val = null;\n index = index || 0;\n index += this.__position;\n if (index >= 0 && index < this.__tokens_length) {\n val = this.__tokens[index];\n }\n return val;\n};\n\nTokenStream.prototype.add = function(token) {\n if (this.__parent_token) {\n token.parent = this.__parent_token;\n }\n this.__tokens.push(token);\n this.__tokens_length += 1;\n};\n\nvar TokenStream_1 = TokenStream;\n\nvar tokenstream = {\n\tTokenStream: TokenStream_1\n};\n\n/*jshint node:true */\n\nfunction Pattern(input_scanner, parent) {\n this._input = input_scanner;\n this._starting_pattern = null;\n this._match_pattern = null;\n this._until_pattern = null;\n this._until_after = false;\n\n if (parent) {\n this._starting_pattern = this._input.get_regexp(parent._starting_pattern, true);\n this._match_pattern = this._input.get_regexp(parent._match_pattern, true);\n this._until_pattern = this._input.get_regexp(parent._until_pattern);\n this._until_after = parent._until_after;\n }\n}\n\nPattern.prototype.read = function() {\n var result = this._input.read(this._starting_pattern);\n if (!this._starting_pattern || result) {\n result += this._input.read(this._match_pattern, this._until_pattern, this._until_after);\n }\n return result;\n};\n\nPattern.prototype.read_match = function() {\n return this._input.match(this._match_pattern);\n};\n\nPattern.prototype.until_after = function(pattern) {\n var result = this._create();\n result._until_after = true;\n result._until_pattern = this._input.get_regexp(pattern);\n result._update();\n return result;\n};\n\nPattern.prototype.until = function(pattern) {\n var result = this._create();\n result._until_after = false;\n result._until_pattern = this._input.get_regexp(pattern);\n result._update();\n return result;\n};\n\nPattern.prototype.starting_with = function(pattern) {\n var result = this._create();\n result._starting_pattern = this._input.get_regexp(pattern, true);\n result._update();\n return result;\n};\n\nPattern.prototype.matching = function(pattern) {\n var result = this._create();\n result._match_pattern = this._input.get_regexp(pattern, true);\n result._update();\n return result;\n};\n\nPattern.prototype._create = function() {\n return new Pattern(this._input, this);\n};\n\nPattern.prototype._update = function() {};\n\nvar Pattern_1 = Pattern;\n\nvar pattern = {\n\tPattern: Pattern_1\n};\n\nvar Pattern$1 = pattern.Pattern;\n\nfunction WhitespacePattern(input_scanner, parent) {\n Pattern$1.call(this, input_scanner, parent);\n if (parent) {\n this._line_regexp = this._input.get_regexp(parent._line_regexp);\n } else {\n this.__set_whitespace_patterns('', '');\n }\n\n this.newline_count = 0;\n this.whitespace_before_token = '';\n}\nWhitespacePattern.prototype = new Pattern$1();\n\nWhitespacePattern.prototype.__set_whitespace_patterns = function(whitespace_chars, newline_chars) {\n whitespace_chars += '\\\\t ';\n newline_chars += '\\\\n\\\\r';\n\n this._match_pattern = this._input.get_regexp(\n '[' + whitespace_chars + newline_chars + ']+', true);\n this._newline_regexp = this._input.get_regexp(\n '\\\\r\\\\n|[' + newline_chars + ']');\n};\n\nWhitespacePattern.prototype.read = function() {\n this.newline_count = 0;\n this.whitespace_before_token = '';\n\n var resulting_string = this._input.read(this._match_pattern);\n if (resulting_string === ' ') {\n this.whitespace_before_token = ' ';\n } else if (resulting_string) {\n var matches = this.__split(this._newline_regexp, resulting_string);\n this.newline_count = matches.length - 1;\n this.whitespace_before_token = matches[this.newline_count];\n }\n\n return resulting_string;\n};\n\nWhitespacePattern.prototype.matching = function(whitespace_chars, newline_chars) {\n var result = this._create();\n result.__set_whitespace_patterns(whitespace_chars, newline_chars);\n result._update();\n return result;\n};\n\nWhitespacePattern.prototype._create = function() {\n return new WhitespacePattern(this._input, this);\n};\n\nWhitespacePattern.prototype.__split = function(regexp, input_string) {\n regexp.lastIndex = 0;\n var start_index = 0;\n var result = [];\n var next_match = regexp.exec(input_string);\n while (next_match) {\n result.push(input_string.substring(start_index, next_match.index));\n start_index = next_match.index + next_match[0].length;\n next_match = regexp.exec(input_string);\n }\n\n if (start_index < input_string.length) {\n result.push(input_string.substring(start_index, input_string.length));\n } else {\n result.push('');\n }\n\n return result;\n};\n\n\n\nvar WhitespacePattern_1 = WhitespacePattern;\n\nvar whitespacepattern = {\n\tWhitespacePattern: WhitespacePattern_1\n};\n\nvar InputScanner$1 = inputscanner.InputScanner;\nvar Token$1 = token.Token;\nvar TokenStream$1 = tokenstream.TokenStream;\nvar WhitespacePattern$1 = whitespacepattern.WhitespacePattern;\n\nvar TOKEN = {\n START: 'TK_START',\n RAW: 'TK_RAW',\n EOF: 'TK_EOF'\n};\n\nvar Tokenizer = function(input_string, options) {\n this._input = new InputScanner$1(input_string);\n this._options = options || {};\n this.__tokens = null;\n\n this._patterns = {};\n this._patterns.whitespace = new WhitespacePattern$1(this._input);\n};\n\nTokenizer.prototype.tokenize = function() {\n this._input.restart();\n this.__tokens = new TokenStream$1();\n\n this._reset();\n\n var current;\n var previous = new Token$1(TOKEN.START, '');\n var open_token = null;\n var open_stack = [];\n var comments = new TokenStream$1();\n\n while (previous.type !== TOKEN.EOF) {\n current = this._get_next_token(previous, open_token);\n while (this._is_comment(current)) {\n comments.add(current);\n current = this._get_next_token(previous, open_token);\n }\n\n if (!comments.isEmpty()) {\n current.comments_before = comments;\n comments = new TokenStream$1();\n }\n\n current.parent = open_token;\n\n if (this._is_opening(current)) {\n open_stack.push(open_token);\n open_token = current;\n } else if (open_token && this._is_closing(current, open_token)) {\n current.opened = open_token;\n open_token.closed = current;\n open_token = open_stack.pop();\n current.parent = open_token;\n }\n\n current.previous = previous;\n previous.next = current;\n\n this.__tokens.add(current);\n previous = current;\n }\n\n return this.__tokens;\n};\n\n\nTokenizer.prototype._is_first_token = function() {\n return this.__tokens.isEmpty();\n};\n\nTokenizer.prototype._reset = function() {};\n\nTokenizer.prototype._get_next_token = function(previous_token, open_token) { // jshint unused:false\n this._readWhitespace();\n var resulting_string = this._input.read(/.+/g);\n if (resulting_string) {\n return this._create_token(TOKEN.RAW, resulting_string);\n } else {\n return this._create_token(TOKEN.EOF, '');\n }\n};\n\nTokenizer.prototype._is_comment = function(current_token) { // jshint unused:false\n return false;\n};\n\nTokenizer.prototype._is_opening = function(current_token) { // jshint unused:false\n return false;\n};\n\nTokenizer.prototype._is_closing = function(current_token, open_token) { // jshint unused:false\n return false;\n};\n\nTokenizer.prototype._create_token = function(type, text) {\n var token = new Token$1(type, text,\n this._patterns.whitespace.newline_count,\n this._patterns.whitespace.whitespace_before_token);\n return token;\n};\n\nTokenizer.prototype._readWhitespace = function() {\n return this._patterns.whitespace.read();\n};\n\n\n\nvar Tokenizer_1 = Tokenizer;\nvar TOKEN_1 = TOKEN;\n\nvar tokenizer = {\n\tTokenizer: Tokenizer_1,\n\tTOKEN: TOKEN_1\n};\n\n/*jshint node:true */\n\nfunction Directives(start_block_pattern, end_block_pattern) {\n start_block_pattern = typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source;\n end_block_pattern = typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source;\n this.__directives_block_pattern = new RegExp(start_block_pattern + / beautify( \\w+[:]\\w+)+ /.source + end_block_pattern, 'g');\n this.__directive_pattern = / (\\w+)[:](\\w+)/g;\n\n this.__directives_end_ignore_pattern = new RegExp(start_block_pattern + /\\sbeautify\\signore:end\\s/.source + end_block_pattern, 'g');\n}\n\nDirectives.prototype.get_directives = function(text) {\n if (!text.match(this.__directives_block_pattern)) {\n return null;\n }\n\n var directives = {};\n this.__directive_pattern.lastIndex = 0;\n var directive_match = this.__directive_pattern.exec(text);\n\n while (directive_match) {\n directives[directive_match[1]] = directive_match[2];\n directive_match = this.__directive_pattern.exec(text);\n }\n\n return directives;\n};\n\nDirectives.prototype.readIgnored = function(input) {\n return input.readUntilAfter(this.__directives_end_ignore_pattern);\n};\n\n\nvar Directives_1 = Directives;\n\nvar directives = {\n\tDirectives: Directives_1\n};\n\nvar Pattern$2 = pattern.Pattern;\n\n\nvar template_names = {\n django: false,\n erb: false,\n handlebars: false,\n php: false,\n smarty: false\n};\n\n// This lets templates appear anywhere we would do a readUntil\n// The cost is higher but it is pay to play.\nfunction TemplatablePattern(input_scanner, parent) {\n Pattern$2.call(this, input_scanner, parent);\n this.__template_pattern = null;\n this._disabled = Object.assign({}, template_names);\n this._excluded = Object.assign({}, template_names);\n\n if (parent) {\n this.__template_pattern = this._input.get_regexp(parent.__template_pattern);\n this._excluded = Object.assign(this._excluded, parent._excluded);\n this._disabled = Object.assign(this._disabled, parent._disabled);\n }\n var pattern = new Pattern$2(input_scanner);\n this.__patterns = {\n handlebars_comment: pattern.starting_with(/{{!--/).until_after(/--}}/),\n handlebars_unescaped: pattern.starting_with(/{{{/).until_after(/}}}/),\n handlebars: pattern.starting_with(/{{/).until_after(/}}/),\n php: pattern.starting_with(/<\\?(?:[= ]|php)/).until_after(/\\?>/),\n erb: pattern.starting_with(/<%[^%]/).until_after(/[^%]%>/),\n // django coflicts with handlebars a bit.\n django: pattern.starting_with(/{%/).until_after(/%}/),\n django_value: pattern.starting_with(/{{/).until_after(/}}/),\n django_comment: pattern.starting_with(/{#/).until_after(/#}/),\n smarty: pattern.starting_with(/{(?=[^}{\\s\\n])/).until_after(/[^\\s\\n]}/),\n smarty_comment: pattern.starting_with(/{\\*/).until_after(/\\*}/),\n smarty_literal: pattern.starting_with(/{literal}/).until_after(/{\\/literal}/)\n };\n}\nTemplatablePattern.prototype = new Pattern$2();\n\nTemplatablePattern.prototype._create = function() {\n return new TemplatablePattern(this._input, this);\n};\n\nTemplatablePattern.prototype._update = function() {\n this.__set_templated_pattern();\n};\n\nTemplatablePattern.prototype.disable = function(language) {\n var result = this._create();\n result._disabled[language] = true;\n result._update();\n return result;\n};\n\nTemplatablePattern.prototype.read_options = function(options) {\n var result = this._create();\n for (var language in template_names) {\n result._disabled[language] = options.templating.indexOf(language) === -1;\n }\n result._update();\n return result;\n};\n\nTemplatablePattern.prototype.exclude = function(language) {\n var result = this._create();\n result._excluded[language] = true;\n result._update();\n return result;\n};\n\nTemplatablePattern.prototype.read = function() {\n var result = '';\n if (this._match_pattern) {\n result = this._input.read(this._starting_pattern);\n } else {\n result = this._input.read(this._starting_pattern, this.__template_pattern);\n }\n var next = this._read_template();\n while (next) {\n if (this._match_pattern) {\n next += this._input.read(this._match_pattern);\n } else {\n next += this._input.readUntil(this.__template_pattern);\n }\n result += next;\n next = this._read_template();\n }\n\n if (this._until_after) {\n result += this._input.readUntilAfter(this._until_pattern);\n }\n return result;\n};\n\nTemplatablePattern.prototype.__set_templated_pattern = function() {\n var items = [];\n\n if (!this._disabled.php) {\n items.push(this.__patterns.php._starting_pattern.source);\n }\n if (!this._disabled.handlebars) {\n items.push(this.__patterns.handlebars._starting_pattern.source);\n }\n if (!this._disabled.erb) {\n items.push(this.__patterns.erb._starting_pattern.source);\n }\n if (!this._disabled.django) {\n items.push(this.__patterns.django._starting_pattern.source);\n // The starting pattern for django is more complex because it has different\n // patterns for value, comment, and other sections\n items.push(this.__patterns.django_value._starting_pattern.source);\n items.push(this.__patterns.django_comment._starting_pattern.source);\n }\n if (!this._disabled.smarty) {\n items.push(this.__patterns.smarty._starting_pattern.source);\n }\n\n if (this._until_pattern) {\n items.push(this._until_pattern.source);\n }\n this.__template_pattern = this._input.get_regexp('(?:' + items.join('|') + ')');\n};\n\nTemplatablePattern.prototype._read_template = function() {\n var resulting_string = '';\n var c = this._input.peek();\n if (c === '<') {\n var peek1 = this._input.peek(1);\n //if we're in a comment, do something special\n // We treat all comments as literals, even more than preformatted tags\n // we just look for the appropriate close tag\n if (!this._disabled.php && !this._excluded.php && peek1 === '?') {\n resulting_string = resulting_string ||\n this.__patterns.php.read();\n }\n if (!this._disabled.erb && !this._excluded.erb && peek1 === '%') {\n resulting_string = resulting_string ||\n this.__patterns.erb.read();\n }\n } else if (c === '{') {\n if (!this._disabled.handlebars && !this._excluded.handlebars) {\n resulting_string = resulting_string ||\n this.__patterns.handlebars_comment.read();\n resulting_string = resulting_string ||\n this.__patterns.handlebars_unescaped.read();\n resulting_string = resulting_string ||\n this.__patterns.handlebars.read();\n }\n if (!this._disabled.django) {\n // django coflicts with handlebars a bit.\n if (!this._excluded.django && !this._excluded.handlebars) {\n resulting_string = resulting_string ||\n this.__patterns.django_value.read();\n }\n if (!this._excluded.django) {\n resulting_string = resulting_string ||\n this.__patterns.django_comment.read();\n resulting_string = resulting_string ||\n this.__patterns.django.read();\n }\n }\n if (!this._disabled.smarty) {\n // smarty cannot be enabled with django or handlebars enabled\n if (this._disabled.django && this._disabled.handlebars) {\n resulting_string = resulting_string ||\n this.__patterns.smarty_comment.read();\n resulting_string = resulting_string ||\n this.__patterns.smarty_literal.read();\n resulting_string = resulting_string ||\n this.__patterns.smarty.read();\n }\n }\n }\n return resulting_string;\n};\n\n\nvar TemplatablePattern_1 = TemplatablePattern;\n\nvar templatablepattern = {\n\tTemplatablePattern: TemplatablePattern_1\n};\n\nvar InputScanner$2 = inputscanner.InputScanner;\nvar BaseTokenizer = tokenizer.Tokenizer;\nvar BASETOKEN = tokenizer.TOKEN;\nvar Directives$1 = directives.Directives;\n\nvar Pattern$3 = pattern.Pattern;\nvar TemplatablePattern$1 = templatablepattern.TemplatablePattern;\n\n\nfunction in_array(what, arr) {\n return arr.indexOf(what) !== -1;\n}\n\n\nvar TOKEN$1 = {\n START_EXPR: 'TK_START_EXPR',\n END_EXPR: 'TK_END_EXPR',\n START_BLOCK: 'TK_START_BLOCK',\n END_BLOCK: 'TK_END_BLOCK',\n WORD: 'TK_WORD',\n RESERVED: 'TK_RESERVED',\n SEMICOLON: 'TK_SEMICOLON',\n STRING: 'TK_STRING',\n EQUALS: 'TK_EQUALS',\n OPERATOR: 'TK_OPERATOR',\n COMMA: 'TK_COMMA',\n BLOCK_COMMENT: 'TK_BLOCK_COMMENT',\n COMMENT: 'TK_COMMENT',\n DOT: 'TK_DOT',\n UNKNOWN: 'TK_UNKNOWN',\n START: BASETOKEN.START,\n RAW: BASETOKEN.RAW,\n EOF: BASETOKEN.EOF\n};\n\n\nvar directives_core = new Directives$1(/\\/\\*/, /\\*\\//);\n\nvar number_pattern = /0[xX][0123456789abcdefABCDEF_]*n?|0[oO][01234567_]*n?|0[bB][01_]*n?|\\d[\\d_]*n|(?:\\.\\d[\\d_]*|\\d[\\d_]*\\.?[\\d_]*)(?:[eE][+-]?[\\d_]+)?/;\n\nvar digit = /[0-9]/;\n\n// Dot \".\" must be distinguished from \"...\" and decimal\nvar dot_pattern = /[^\\d\\.]/;\n\nvar positionable_operators = (\n \">>> === !== &&= ??= ||= \" +\n \"<< && >= ** != == <= >> || ?? |> \" +\n \"< / - + > : & % ? ^ | *\").split(' ');\n\n// IMPORTANT: this must be sorted longest to shortest or tokenizing many not work.\n// Also, you must update possitionable operators separately from punct\nvar punct =\n \">>>= \" +\n \"... >>= <<= === >>> !== **= &&= ??= ||= \" +\n \"=> ^= :: /= << <= == && -= >= >> != -- += ** || ?? ++ %= &= *= |= |> \" +\n \"= ! ? > < : / ^ - + * & % ~ |\";\n\npunct = punct.replace(/[-[\\]{}()*+?.,\\\\^$|#]/g, \"\\\\$&\");\n// ?. but not if followed by a number \npunct = '\\\\?\\\\.(?!\\\\d) ' + punct;\npunct = punct.replace(/ /g, '|');\n\nvar punct_pattern = new RegExp(punct);\n\n// words which should always start on new line.\nvar line_starters = 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export'.split(',');\nvar reserved_words = line_starters.concat(['do', 'in', 'of', 'else', 'get', 'set', 'new', 'catch', 'finally', 'typeof', 'yield', 'async', 'await', 'from', 'as']);\nvar reserved_word_pattern = new RegExp('^(?:' + reserved_words.join('|') + ')$');\n\n// var template_pattern = /(?:(?:<\\?php|<\\?=)[\\s\\S]*?\\?>)|(?:<%[\\s\\S]*?%>)/g;\n\nvar in_html_comment;\n\nvar Tokenizer$1 = function(input_string, options) {\n BaseTokenizer.call(this, input_string, options);\n\n this._patterns.whitespace = this._patterns.whitespace.matching(\n /\\u00A0\\u1680\\u180e\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff/.source,\n /\\u2028\\u2029/.source);\n\n var pattern_reader = new Pattern$3(this._input);\n var templatable = new TemplatablePattern$1(this._input)\n .read_options(this._options);\n\n this.__patterns = {\n template: templatable,\n identifier: templatable.starting_with(acorn.identifier).matching(acorn.identifierMatch),\n number: pattern_reader.matching(number_pattern),\n punct: pattern_reader.matching(punct_pattern),\n // comment ends just before nearest linefeed or end of file\n comment: pattern_reader.starting_with(/\\/\\//).until(/[\\n\\r\\u2028\\u2029]/),\n // /* ... */ comment ends with nearest */ or end of file\n block_comment: pattern_reader.starting_with(/\\/\\*/).until_after(/\\*\\//),\n html_comment_start: pattern_reader.matching(//),\n include: pattern_reader.starting_with(/#include/).until_after(acorn.lineBreak),\n shebang: pattern_reader.starting_with(/#!/).until_after(acorn.lineBreak),\n xml: pattern_reader.matching(/[\\s\\S]*?<(\\/?)([-a-zA-Z:0-9_.]+|{[^}]+?}|!\\[CDATA\\[[^\\]]*?\\]\\]|)(\\s*{[^}]+?}|\\s+[-a-zA-Z:0-9_.]+|\\s+[-a-zA-Z:0-9_.]+\\s*=\\s*('[^']*'|\"[^\"]*\"|{([^{}]|{[^}]+?})+?}))*\\s*(\\/?)\\s*>/),\n single_quote: templatable.until(/['\\\\\\n\\r\\u2028\\u2029]/),\n double_quote: templatable.until(/[\"\\\\\\n\\r\\u2028\\u2029]/),\n template_text: templatable.until(/[`\\\\$]/),\n template_expression: templatable.until(/[`}\\\\]/)\n };\n\n};\nTokenizer$1.prototype = new BaseTokenizer();\n\nTokenizer$1.prototype._is_comment = function(current_token) {\n return current_token.type === TOKEN$1.COMMENT || current_token.type === TOKEN$1.BLOCK_COMMENT || current_token.type === TOKEN$1.UNKNOWN;\n};\n\nTokenizer$1.prototype._is_opening = function(current_token) {\n return current_token.type === TOKEN$1.START_BLOCK || current_token.type === TOKEN$1.START_EXPR;\n};\n\nTokenizer$1.prototype._is_closing = function(current_token, open_token) {\n return (current_token.type === TOKEN$1.END_BLOCK || current_token.type === TOKEN$1.END_EXPR) &&\n (open_token && (\n (current_token.text === ']' && open_token.text === '[') ||\n (current_token.text === ')' && open_token.text === '(') ||\n (current_token.text === '}' && open_token.text === '{')));\n};\n\nTokenizer$1.prototype._reset = function() {\n in_html_comment = false;\n};\n\nTokenizer$1.prototype._get_next_token = function(previous_token, open_token) { // jshint unused:false\n var token = null;\n this._readWhitespace();\n var c = this._input.peek();\n\n if (c === null) {\n return this._create_token(TOKEN$1.EOF, '');\n }\n\n token = token || this._read_non_javascript(c);\n token = token || this._read_string(c);\n token = token || this._read_word(previous_token);\n token = token || this._read_singles(c);\n token = token || this._read_comment(c);\n token = token || this._read_regexp(c, previous_token);\n token = token || this._read_xml(c, previous_token);\n token = token || this._read_punctuation();\n token = token || this._create_token(TOKEN$1.UNKNOWN, this._input.next());\n\n return token;\n};\n\nTokenizer$1.prototype._read_word = function(previous_token) {\n var resulting_string;\n resulting_string = this.__patterns.identifier.read();\n if (resulting_string !== '') {\n resulting_string = resulting_string.replace(acorn.allLineBreaks, '\\n');\n if (!(previous_token.type === TOKEN$1.DOT ||\n (previous_token.type === TOKEN$1.RESERVED && (previous_token.text === 'set' || previous_token.text === 'get'))) &&\n reserved_word_pattern.test(resulting_string)) {\n if (resulting_string === 'in' || resulting_string === 'of') { // hack for 'in' and 'of' operators\n return this._create_token(TOKEN$1.OPERATOR, resulting_string);\n }\n return this._create_token(TOKEN$1.RESERVED, resulting_string);\n }\n return this._create_token(TOKEN$1.WORD, resulting_string);\n }\n\n resulting_string = this.__patterns.number.read();\n if (resulting_string !== '') {\n return this._create_token(TOKEN$1.WORD, resulting_string);\n }\n};\n\nTokenizer$1.prototype._read_singles = function(c) {\n var token = null;\n if (c === '(' || c === '[') {\n token = this._create_token(TOKEN$1.START_EXPR, c);\n } else if (c === ')' || c === ']') {\n token = this._create_token(TOKEN$1.END_EXPR, c);\n } else if (c === '{') {\n token = this._create_token(TOKEN$1.START_BLOCK, c);\n } else if (c === '}') {\n token = this._create_token(TOKEN$1.END_BLOCK, c);\n } else if (c === ';') {\n token = this._create_token(TOKEN$1.SEMICOLON, c);\n } else if (c === '.' && dot_pattern.test(this._input.peek(1))) {\n token = this._create_token(TOKEN$1.DOT, c);\n } else if (c === ',') {\n token = this._create_token(TOKEN$1.COMMA, c);\n }\n\n if (token) {\n this._input.next();\n }\n return token;\n};\n\nTokenizer$1.prototype._read_punctuation = function() {\n var resulting_string = this.__patterns.punct.read();\n\n if (resulting_string !== '') {\n if (resulting_string === '=') {\n return this._create_token(TOKEN$1.EQUALS, resulting_string);\n } else if (resulting_string === '?.') {\n return this._create_token(TOKEN$1.DOT, resulting_string);\n } else {\n return this._create_token(TOKEN$1.OPERATOR, resulting_string);\n }\n }\n};\n\nTokenizer$1.prototype._read_non_javascript = function(c) {\n var resulting_string = '';\n\n if (c === '#') {\n if (this._is_first_token()) {\n resulting_string = this.__patterns.shebang.read();\n\n if (resulting_string) {\n return this._create_token(TOKEN$1.UNKNOWN, resulting_string.trim() + '\\n');\n }\n }\n\n // handles extendscript #includes\n resulting_string = this.__patterns.include.read();\n\n if (resulting_string) {\n return this._create_token(TOKEN$1.UNKNOWN, resulting_string.trim() + '\\n');\n }\n\n c = this._input.next();\n\n // Spidermonkey-specific sharp variables for circular references. Considered obsolete.\n var sharp = '#';\n if (this._input.hasNext() && this._input.testChar(digit)) {\n do {\n c = this._input.next();\n sharp += c;\n } while (this._input.hasNext() && c !== '#' && c !== '=');\n if (c === '#') ; else if (this._input.peek() === '[' && this._input.peek(1) === ']') {\n sharp += '[]';\n this._input.next();\n this._input.next();\n } else if (this._input.peek() === '{' && this._input.peek(1) === '}') {\n sharp += '{}';\n this._input.next();\n this._input.next();\n }\n return this._create_token(TOKEN$1.WORD, sharp);\n }\n\n this._input.back();\n\n } else if (c === '<' && this._is_first_token()) {\n resulting_string = this.__patterns.html_comment_start.read();\n if (resulting_string) {\n while (this._input.hasNext() && !this._input.testChar(acorn.newline)) {\n resulting_string += this._input.next();\n }\n in_html_comment = true;\n return this._create_token(TOKEN$1.COMMENT, resulting_string);\n }\n } else if (in_html_comment && c === '-') {\n resulting_string = this.__patterns.html_comment_end.read();\n if (resulting_string) {\n in_html_comment = false;\n return this._create_token(TOKEN$1.COMMENT, resulting_string);\n }\n }\n\n return null;\n};\n\nTokenizer$1.prototype._read_comment = function(c) {\n var token = null;\n if (c === '/') {\n var comment = '';\n if (this._input.peek(1) === '*') {\n // peek for comment /* ... */\n comment = this.__patterns.block_comment.read();\n var directives = directives_core.get_directives(comment);\n if (directives && directives.ignore === 'start') {\n comment += directives_core.readIgnored(this._input);\n }\n comment = comment.replace(acorn.allLineBreaks, '\\n');\n token = this._create_token(TOKEN$1.BLOCK_COMMENT, comment);\n token.directives = directives;\n } else if (this._input.peek(1) === '/') {\n // peek for comment // ...\n comment = this.__patterns.comment.read();\n token = this._create_token(TOKEN$1.COMMENT, comment);\n }\n }\n return token;\n};\n\nTokenizer$1.prototype._read_string = function(c) {\n if (c === '`' || c === \"'\" || c === '\"') {\n var resulting_string = this._input.next();\n this.has_char_escapes = false;\n\n if (c === '`') {\n resulting_string += this._read_string_recursive('`', true, '${');\n } else {\n resulting_string += this._read_string_recursive(c);\n }\n\n if (this.has_char_escapes && this._options.unescape_strings) {\n resulting_string = unescape_string(resulting_string);\n }\n\n if (this._input.peek() === c) {\n resulting_string += this._input.next();\n }\n\n resulting_string = resulting_string.replace(acorn.allLineBreaks, '\\n');\n\n return this._create_token(TOKEN$1.STRING, resulting_string);\n }\n\n return null;\n};\n\nTokenizer$1.prototype._allow_regexp_or_xml = function(previous_token) {\n // regex and xml can only appear in specific locations during parsing\n return (previous_token.type === TOKEN$1.RESERVED && in_array(previous_token.text, ['return', 'case', 'throw', 'else', 'do', 'typeof', 'yield'])) ||\n (previous_token.type === TOKEN$1.END_EXPR && previous_token.text === ')' &&\n previous_token.opened.previous.type === TOKEN$1.RESERVED && in_array(previous_token.opened.previous.text, ['if', 'while', 'for'])) ||\n (in_array(previous_token.type, [TOKEN$1.COMMENT, TOKEN$1.START_EXPR, TOKEN$1.START_BLOCK, TOKEN$1.START,\n TOKEN$1.END_BLOCK, TOKEN$1.OPERATOR, TOKEN$1.EQUALS, TOKEN$1.EOF, TOKEN$1.SEMICOLON, TOKEN$1.COMMA\n ]));\n};\n\nTokenizer$1.prototype._read_regexp = function(c, previous_token) {\n\n if (c === '/' && this._allow_regexp_or_xml(previous_token)) {\n // handle regexp\n //\n var resulting_string = this._input.next();\n var esc = false;\n\n var in_char_class = false;\n while (this._input.hasNext() &&\n ((esc || in_char_class || this._input.peek() !== c) &&\n !this._input.testChar(acorn.newline))) {\n resulting_string += this._input.peek();\n if (!esc) {\n esc = this._input.peek() === '\\\\';\n if (this._input.peek() === '[') {\n in_char_class = true;\n } else if (this._input.peek() === ']') {\n in_char_class = false;\n }\n } else {\n esc = false;\n }\n this._input.next();\n }\n\n if (this._input.peek() === c) {\n resulting_string += this._input.next();\n\n // regexps may have modifiers /regexp/MOD , so fetch those, too\n // Only [gim] are valid, but if the user puts in garbage, do what we can to take it.\n resulting_string += this._input.read(acorn.identifier);\n }\n return this._create_token(TOKEN$1.STRING, resulting_string);\n }\n return null;\n};\n\nTokenizer$1.prototype._read_xml = function(c, previous_token) {\n\n if (this._options.e4x && c === \"<\" && this._allow_regexp_or_xml(previous_token)) {\n var xmlStr = '';\n var match = this.__patterns.xml.read_match();\n // handle e4x xml literals\n //\n if (match) {\n // Trim root tag to attempt to\n var rootTag = match[2].replace(/^{\\s+/, '{').replace(/\\s+}$/, '}');\n var isCurlyRoot = rootTag.indexOf('{') === 0;\n var depth = 0;\n while (match) {\n var isEndTag = !!match[1];\n var tagName = match[2];\n var isSingletonTag = (!!match[match.length - 1]) || (tagName.slice(0, 8) === \"![CDATA[\");\n if (!isSingletonTag &&\n (tagName === rootTag || (isCurlyRoot && tagName.replace(/^{\\s+/, '{').replace(/\\s+}$/, '}')))) {\n if (isEndTag) {\n --depth;\n } else {\n ++depth;\n }\n }\n xmlStr += match[0];\n if (depth <= 0) {\n break;\n }\n match = this.__patterns.xml.read_match();\n }\n // if we didn't close correctly, keep unformatted.\n if (!match) {\n xmlStr += this._input.match(/[\\s\\S]*/g)[0];\n }\n xmlStr = xmlStr.replace(acorn.allLineBreaks, '\\n');\n return this._create_token(TOKEN$1.STRING, xmlStr);\n }\n }\n\n return null;\n};\n\nfunction unescape_string(s) {\n // You think that a regex would work for this\n // return s.replace(/\\\\x([0-9a-f]{2})/gi, function(match, val) {\n // return String.fromCharCode(parseInt(val, 16));\n // })\n // However, dealing with '\\xff', '\\\\xff', '\\\\\\xff' makes this more fun.\n var out = '',\n escaped = 0;\n\n var input_scan = new InputScanner$2(s);\n var matched = null;\n\n while (input_scan.hasNext()) {\n // Keep any whitespace, non-slash characters\n // also keep slash pairs.\n matched = input_scan.match(/([\\s]|[^\\\\]|\\\\\\\\)+/g);\n\n if (matched) {\n out += matched[0];\n }\n\n if (input_scan.peek() === '\\\\') {\n input_scan.next();\n if (input_scan.peek() === 'x') {\n matched = input_scan.match(/x([0-9A-Fa-f]{2})/g);\n } else if (input_scan.peek() === 'u') {\n matched = input_scan.match(/u([0-9A-Fa-f]{4})/g);\n } else {\n out += '\\\\';\n if (input_scan.hasNext()) {\n out += input_scan.next();\n }\n continue;\n }\n\n // If there's some error decoding, return the original string\n if (!matched) {\n return s;\n }\n\n escaped = parseInt(matched[1], 16);\n\n if (escaped > 0x7e && escaped <= 0xff && matched[0].indexOf('x') === 0) {\n // we bail out on \\x7f..\\xff,\n // leaving whole string escaped,\n // as it's probably completely binary\n return s;\n } else if (escaped >= 0x00 && escaped < 0x20) {\n // leave 0x00...0x1f escaped\n out += '\\\\' + matched[0];\n continue;\n } else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) {\n // single-quote, apostrophe, backslash - escape these\n out += '\\\\' + String.fromCharCode(escaped);\n } else {\n out += String.fromCharCode(escaped);\n }\n }\n }\n\n return out;\n}\n\n// handle string\n//\nTokenizer$1.prototype._read_string_recursive = function(delimiter, allow_unescaped_newlines, start_sub) {\n var current_char;\n var pattern;\n if (delimiter === '\\'') {\n pattern = this.__patterns.single_quote;\n } else if (delimiter === '\"') {\n pattern = this.__patterns.double_quote;\n } else if (delimiter === '`') {\n pattern = this.__patterns.template_text;\n } else if (delimiter === '}') {\n pattern = this.__patterns.template_expression;\n }\n\n var resulting_string = pattern.read();\n var next = '';\n while (this._input.hasNext()) {\n next = this._input.next();\n if (next === delimiter ||\n (!allow_unescaped_newlines && acorn.newline.test(next))) {\n this._input.back();\n break;\n } else if (next === '\\\\' && this._input.hasNext()) {\n current_char = this._input.peek();\n\n if (current_char === 'x' || current_char === 'u') {\n this.has_char_escapes = true;\n } else if (current_char === '\\r' && this._input.peek(1) === '\\n') {\n this._input.next();\n }\n next += this._input.next();\n } else if (start_sub) {\n if (start_sub === '${' && next === '$' && this._input.peek() === '{') {\n next += this._input.next();\n }\n\n if (start_sub === next) {\n if (delimiter === '`') {\n next += this._read_string_recursive('}', allow_unescaped_newlines, '`');\n } else {\n next += this._read_string_recursive('`', allow_unescaped_newlines, '${');\n }\n if (this._input.hasNext()) {\n next += this._input.next();\n }\n }\n }\n next += pattern.read();\n resulting_string += next;\n }\n\n return resulting_string;\n};\n\nvar Tokenizer_1$1 = Tokenizer$1;\nvar TOKEN_1$1 = TOKEN$1;\nvar positionable_operators_1 = positionable_operators.slice();\nvar line_starters_1 = line_starters.slice();\n\nvar tokenizer$1 = {\n\tTokenizer: Tokenizer_1$1,\n\tTOKEN: TOKEN_1$1,\n\tpositionable_operators: positionable_operators_1,\n\tline_starters: line_starters_1\n};\n\nvar Output$1 = output.Output;\nvar Token$2 = token.Token;\n\nvar Options$2 = options$1.Options;\nvar Tokenizer$2 = tokenizer$1.Tokenizer;\nvar line_starters$1 = tokenizer$1.line_starters;\nvar positionable_operators$1 = tokenizer$1.positionable_operators;\nvar TOKEN$2 = tokenizer$1.TOKEN;\n\n\nfunction in_array$1(what, arr) {\n return arr.indexOf(what) !== -1;\n}\n\nfunction ltrim(s) {\n return s.replace(/^\\s+/g, '');\n}\n\nfunction generateMapFromStrings(list) {\n var result = {};\n for (var x = 0; x < list.length; x++) {\n // make the mapped names underscored instead of dash\n result[list[x].replace(/-/g, '_')] = list[x];\n }\n return result;\n}\n\nfunction reserved_word(token, word) {\n return token && token.type === TOKEN$2.RESERVED && token.text === word;\n}\n\nfunction reserved_array(token, words) {\n return token && token.type === TOKEN$2.RESERVED && in_array$1(token.text, words);\n}\n// Unsure of what they mean, but they work. Worth cleaning up in future.\nvar special_words = ['case', 'return', 'do', 'if', 'throw', 'else', 'await', 'break', 'continue', 'async'];\n\nvar validPositionValues$1 = ['before-newline', 'after-newline', 'preserve-newline'];\n\n// Generate map from array\nvar OPERATOR_POSITION = generateMapFromStrings(validPositionValues$1);\n\nvar OPERATOR_POSITION_BEFORE_OR_PRESERVE = [OPERATOR_POSITION.before_newline, OPERATOR_POSITION.preserve_newline];\n\nvar MODE = {\n BlockStatement: 'BlockStatement', // 'BLOCK'\n Statement: 'Statement', // 'STATEMENT'\n ObjectLiteral: 'ObjectLiteral', // 'OBJECT',\n ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]',\n ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)',\n Conditional: 'Conditional', //'(COND-EXPRESSION)',\n Expression: 'Expression' //'(EXPRESSION)'\n};\n\nfunction remove_redundant_indentation(output, frame) {\n // This implementation is effective but has some issues:\n // - can cause line wrap to happen too soon due to indent removal\n // after wrap points are calculated\n // These issues are minor compared to ugly indentation.\n\n if (frame.multiline_frame ||\n frame.mode === MODE.ForInitializer ||\n frame.mode === MODE.Conditional) {\n return;\n }\n\n // remove one indent from each line inside this section\n output.remove_indent(frame.start_line_index);\n}\n\n// we could use just string.split, but\n// IE doesn't like returning empty strings\nfunction split_linebreaks(s) {\n //return s.split(/\\x0d\\x0a|\\x0a/);\n\n s = s.replace(acorn.allLineBreaks, '\\n');\n var out = [],\n idx = s.indexOf(\"\\n\");\n while (idx !== -1) {\n out.push(s.substring(0, idx));\n s = s.substring(idx + 1);\n idx = s.indexOf(\"\\n\");\n }\n if (s.length) {\n out.push(s);\n }\n return out;\n}\n\nfunction is_array(mode) {\n return mode === MODE.ArrayLiteral;\n}\n\nfunction is_expression(mode) {\n return in_array$1(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]);\n}\n\nfunction all_lines_start_with(lines, c) {\n for (var i = 0; i < lines.length; i++) {\n var line = lines[i].trim();\n if (line.charAt(0) !== c) {\n return false;\n }\n }\n return true;\n}\n\nfunction each_line_matches_indent(lines, indent) {\n var i = 0,\n len = lines.length,\n line;\n for (; i < len; i++) {\n line = lines[i];\n // allow empty lines to pass through\n if (line && line.indexOf(indent) !== 0) {\n return false;\n }\n }\n return true;\n}\n\n\nfunction Beautifier(source_text, options) {\n options = options || {};\n this._source_text = source_text || '';\n\n this._output = null;\n this._tokens = null;\n this._last_last_text = null;\n this._flags = null;\n this._previous_flags = null;\n\n this._flag_store = null;\n this._options = new Options$2(options);\n}\n\nBeautifier.prototype.create_flags = function(flags_base, mode) {\n var next_indent_level = 0;\n if (flags_base) {\n next_indent_level = flags_base.indentation_level;\n if (!this._output.just_added_newline() &&\n flags_base.line_indent_level > next_indent_level) {\n next_indent_level = flags_base.line_indent_level;\n }\n }\n\n var next_flags = {\n mode: mode,\n parent: flags_base,\n last_token: flags_base ? flags_base.last_token : new Token$2(TOKEN$2.START_BLOCK, ''), // last token text\n last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed\n declaration_statement: false,\n declaration_assignment: false,\n multiline_frame: false,\n inline_frame: false,\n if_block: false,\n else_block: false,\n do_block: false,\n do_while: false,\n import_block: false,\n in_case_statement: false, // switch(..){ INSIDE HERE }\n in_case: false, // we're on the exact line with \"case 0:\"\n case_body: false, // the indented case-action block\n case_block: false, // the indented case-action block is wrapped with {}\n indentation_level: next_indent_level,\n alignment: 0,\n line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level,\n start_line_index: this._output.get_line_number(),\n ternary_depth: 0\n };\n return next_flags;\n};\n\nBeautifier.prototype._reset = function(source_text) {\n var baseIndentString = source_text.match(/^[\\t ]*/)[0];\n\n this._last_last_text = ''; // pre-last token text\n this._output = new Output$1(this._options, baseIndentString);\n\n // If testing the ignore directive, start with output disable set to true\n this._output.raw = this._options.test_output_raw;\n\n\n // Stack of parsing/formatting states, including MODE.\n // We tokenize, parse, and output in an almost purely a forward-only stream of token input\n // and formatted output. This makes the beautifier less accurate than full parsers\n // but also far more tolerant of syntax errors.\n //\n // For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type\n // MODE.BlockStatement on the the stack, even though it could be object literal. If we later\n // encounter a \":\", we'll switch to to MODE.ObjectLiteral. If we then see a \";\",\n // most full parsers would die, but the beautifier gracefully falls back to\n // MODE.BlockStatement and continues on.\n this._flag_store = [];\n this.set_mode(MODE.BlockStatement);\n var tokenizer = new Tokenizer$2(source_text, this._options);\n this._tokens = tokenizer.tokenize();\n return source_text;\n};\n\nBeautifier.prototype.beautify = function() {\n // if disabled, return the input unchanged.\n if (this._options.disabled) {\n return this._source_text;\n }\n\n var sweet_code;\n var source_text = this._reset(this._source_text);\n\n var eol = this._options.eol;\n if (this._options.eol === 'auto') {\n eol = '\\n';\n if (source_text && acorn.lineBreak.test(source_text || '')) {\n eol = source_text.match(acorn.lineBreak)[0];\n }\n }\n\n var current_token = this._tokens.next();\n while (current_token) {\n this.handle_token(current_token);\n\n this._last_last_text = this._flags.last_token.text;\n this._flags.last_token = current_token;\n\n current_token = this._tokens.next();\n }\n\n sweet_code = this._output.get_code(eol);\n\n return sweet_code;\n};\n\nBeautifier.prototype.handle_token = function(current_token, preserve_statement_flags) {\n if (current_token.type === TOKEN$2.START_EXPR) {\n this.handle_start_expr(current_token);\n } else if (current_token.type === TOKEN$2.END_EXPR) {\n this.handle_end_expr(current_token);\n } else if (current_token.type === TOKEN$2.START_BLOCK) {\n this.handle_start_block(current_token);\n } else if (current_token.type === TOKEN$2.END_BLOCK) {\n this.handle_end_block(current_token);\n } else if (current_token.type === TOKEN$2.WORD) {\n this.handle_word(current_token);\n } else if (current_token.type === TOKEN$2.RESERVED) {\n this.handle_word(current_token);\n } else if (current_token.type === TOKEN$2.SEMICOLON) {\n this.handle_semicolon(current_token);\n } else if (current_token.type === TOKEN$2.STRING) {\n this.handle_string(current_token);\n } else if (current_token.type === TOKEN$2.EQUALS) {\n this.handle_equals(current_token);\n } else if (current_token.type === TOKEN$2.OPERATOR) {\n this.handle_operator(current_token);\n } else if (current_token.type === TOKEN$2.COMMA) {\n this.handle_comma(current_token);\n } else if (current_token.type === TOKEN$2.BLOCK_COMMENT) {\n this.handle_block_comment(current_token, preserve_statement_flags);\n } else if (current_token.type === TOKEN$2.COMMENT) {\n this.handle_comment(current_token, preserve_statement_flags);\n } else if (current_token.type === TOKEN$2.DOT) {\n this.handle_dot(current_token);\n } else if (current_token.type === TOKEN$2.EOF) {\n this.handle_eof(current_token);\n } else if (current_token.type === TOKEN$2.UNKNOWN) {\n this.handle_unknown(current_token, preserve_statement_flags);\n } else {\n this.handle_unknown(current_token, preserve_statement_flags);\n }\n};\n\nBeautifier.prototype.handle_whitespace_and_comments = function(current_token, preserve_statement_flags) {\n var newlines = current_token.newlines;\n var keep_whitespace = this._options.keep_array_indentation && is_array(this._flags.mode);\n\n if (current_token.comments_before) {\n var comment_token = current_token.comments_before.next();\n while (comment_token) {\n // The cleanest handling of inline comments is to treat them as though they aren't there.\n // Just continue formatting and the behavior should be logical.\n // Also ignore unknown tokens. Again, this should result in better behavior.\n this.handle_whitespace_and_comments(comment_token, preserve_statement_flags);\n this.handle_token(comment_token, preserve_statement_flags);\n comment_token = current_token.comments_before.next();\n }\n }\n\n if (keep_whitespace) {\n for (var i = 0; i < newlines; i += 1) {\n this.print_newline(i > 0, preserve_statement_flags);\n }\n } else {\n if (this._options.max_preserve_newlines && newlines > this._options.max_preserve_newlines) {\n newlines = this._options.max_preserve_newlines;\n }\n\n if (this._options.preserve_newlines) {\n if (newlines > 1) {\n this.print_newline(false, preserve_statement_flags);\n for (var j = 1; j < newlines; j += 1) {\n this.print_newline(true, preserve_statement_flags);\n }\n }\n }\n }\n\n};\n\nvar newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield'];\n\nBeautifier.prototype.allow_wrap_or_preserved_newline = function(current_token, force_linewrap) {\n force_linewrap = (force_linewrap === undefined) ? false : force_linewrap;\n\n // Never wrap the first token on a line\n if (this._output.just_added_newline()) {\n return;\n }\n\n var shouldPreserveOrForce = (this._options.preserve_newlines && current_token.newlines) || force_linewrap;\n var operatorLogicApplies = in_array$1(this._flags.last_token.text, positionable_operators$1) ||\n in_array$1(current_token.text, positionable_operators$1);\n\n if (operatorLogicApplies) {\n var shouldPrintOperatorNewline = (\n in_array$1(this._flags.last_token.text, positionable_operators$1) &&\n in_array$1(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)\n ) ||\n in_array$1(current_token.text, positionable_operators$1);\n shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline;\n }\n\n if (shouldPreserveOrForce) {\n this.print_newline(false, true);\n } else if (this._options.wrap_line_length) {\n if (reserved_array(this._flags.last_token, newline_restricted_tokens)) {\n // These tokens should never have a newline inserted\n // between them and the following expression.\n return;\n }\n this._output.set_wrap_point();\n }\n};\n\nBeautifier.prototype.print_newline = function(force_newline, preserve_statement_flags) {\n if (!preserve_statement_flags) {\n if (this._flags.last_token.text !== ';' && this._flags.last_token.text !== ',' && this._flags.last_token.text !== '=' && (this._flags.last_token.type !== TOKEN$2.OPERATOR || this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) {\n var next_token = this._tokens.peek();\n while (this._flags.mode === MODE.Statement &&\n !(this._flags.if_block && reserved_word(next_token, 'else')) &&\n !this._flags.do_block) {\n this.restore_mode();\n }\n }\n }\n\n if (this._output.add_new_line(force_newline)) {\n this._flags.multiline_frame = true;\n }\n};\n\nBeautifier.prototype.print_token_line_indentation = function(current_token) {\n if (this._output.just_added_newline()) {\n if (this._options.keep_array_indentation &&\n current_token.newlines &&\n (current_token.text === '[' || is_array(this._flags.mode))) {\n this._output.current_line.set_indent(-1);\n this._output.current_line.push(current_token.whitespace_before);\n this._output.space_before_token = false;\n } else if (this._output.set_indent(this._flags.indentation_level, this._flags.alignment)) {\n this._flags.line_indent_level = this._flags.indentation_level;\n }\n }\n};\n\nBeautifier.prototype.print_token = function(current_token) {\n if (this._output.raw) {\n this._output.add_raw_token(current_token);\n return;\n }\n\n if (this._options.comma_first && current_token.previous && current_token.previous.type === TOKEN$2.COMMA &&\n this._output.just_added_newline()) {\n if (this._output.previous_line.last() === ',') {\n var popped = this._output.previous_line.pop();\n // if the comma was already at the start of the line,\n // pull back onto that line and reprint the indentation\n if (this._output.previous_line.is_empty()) {\n this._output.previous_line.push(popped);\n this._output.trim(true);\n this._output.current_line.pop();\n this._output.trim();\n }\n\n // add the comma in front of the next token\n this.print_token_line_indentation(current_token);\n this._output.add_token(',');\n this._output.space_before_token = true;\n }\n }\n\n this.print_token_line_indentation(current_token);\n this._output.non_breaking_space = true;\n this._output.add_token(current_token.text);\n if (this._output.previous_token_wrapped) {\n this._flags.multiline_frame = true;\n }\n};\n\nBeautifier.prototype.indent = function() {\n this._flags.indentation_level += 1;\n this._output.set_indent(this._flags.indentation_level, this._flags.alignment);\n};\n\nBeautifier.prototype.deindent = function() {\n if (this._flags.indentation_level > 0 &&\n ((!this._flags.parent) || this._flags.indentation_level > this._flags.parent.indentation_level)) {\n this._flags.indentation_level -= 1;\n this._output.set_indent(this._flags.indentation_level, this._flags.alignment);\n }\n};\n\nBeautifier.prototype.set_mode = function(mode) {\n if (this._flags) {\n this._flag_store.push(this._flags);\n this._previous_flags = this._flags;\n } else {\n this._previous_flags = this.create_flags(null, mode);\n }\n\n this._flags = this.create_flags(this._previous_flags, mode);\n this._output.set_indent(this._flags.indentation_level, this._flags.alignment);\n};\n\n\nBeautifier.prototype.restore_mode = function() {\n if (this._flag_store.length > 0) {\n this._previous_flags = this._flags;\n this._flags = this._flag_store.pop();\n if (this._previous_flags.mode === MODE.Statement) {\n remove_redundant_indentation(this._output, this._previous_flags);\n }\n this._output.set_indent(this._flags.indentation_level, this._flags.alignment);\n }\n};\n\nBeautifier.prototype.start_of_object_property = function() {\n return this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement && (\n (this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || (reserved_array(this._flags.last_token, ['get', 'set'])));\n};\n\nBeautifier.prototype.start_of_statement = function(current_token) {\n var start = false;\n start = start || reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN$2.WORD;\n start = start || reserved_word(this._flags.last_token, 'do');\n start = start || (!(this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement)) && reserved_array(this._flags.last_token, newline_restricted_tokens) && !current_token.newlines;\n start = start || reserved_word(this._flags.last_token, 'else') &&\n !(reserved_word(current_token, 'if') && !current_token.comments_before);\n start = start || (this._flags.last_token.type === TOKEN$2.END_EXPR && (this._previous_flags.mode === MODE.ForInitializer || this._previous_flags.mode === MODE.Conditional));\n start = start || (this._flags.last_token.type === TOKEN$2.WORD && this._flags.mode === MODE.BlockStatement &&\n !this._flags.in_case &&\n !(current_token.text === '--' || current_token.text === '++') &&\n this._last_last_text !== 'function' &&\n current_token.type !== TOKEN$2.WORD && current_token.type !== TOKEN$2.RESERVED);\n start = start || (this._flags.mode === MODE.ObjectLiteral && (\n (this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || reserved_array(this._flags.last_token, ['get', 'set'])));\n\n if (start) {\n this.set_mode(MODE.Statement);\n this.indent();\n\n this.handle_whitespace_and_comments(current_token, true);\n\n // Issue #276:\n // If starting a new statement with [if, for, while, do], push to a new line.\n // if (a) if (b) if(c) d(); else e(); else f();\n if (!this.start_of_object_property()) {\n this.allow_wrap_or_preserved_newline(current_token,\n reserved_array(current_token, ['do', 'for', 'if', 'while']));\n }\n return true;\n }\n return false;\n};\n\nBeautifier.prototype.handle_start_expr = function(current_token) {\n // The conditional starts the statement if appropriate.\n if (!this.start_of_statement(current_token)) {\n this.handle_whitespace_and_comments(current_token);\n }\n\n var next_mode = MODE.Expression;\n if (current_token.text === '[') {\n\n if (this._flags.last_token.type === TOKEN$2.WORD || this._flags.last_token.text === ')') {\n // this is array index specifier, break immediately\n // a[x], fn()[x]\n if (reserved_array(this._flags.last_token, line_starters$1)) {\n this._output.space_before_token = true;\n }\n this.print_token(current_token);\n this.set_mode(next_mode);\n this.indent();\n if (this._options.space_in_paren) {\n this._output.space_before_token = true;\n }\n return;\n }\n\n next_mode = MODE.ArrayLiteral;\n if (is_array(this._flags.mode)) {\n if (this._flags.last_token.text === '[' ||\n (this._flags.last_token.text === ',' && (this._last_last_text === ']' || this._last_last_text === '}'))) {\n // ], [ goes to new line\n // }, [ goes to new line\n if (!this._options.keep_array_indentation) {\n this.print_newline();\n }\n }\n }\n\n if (!in_array$1(this._flags.last_token.type, [TOKEN$2.START_EXPR, TOKEN$2.END_EXPR, TOKEN$2.WORD, TOKEN$2.OPERATOR, TOKEN$2.DOT])) {\n this._output.space_before_token = true;\n }\n } else {\n if (this._flags.last_token.type === TOKEN$2.RESERVED) {\n if (this._flags.last_token.text === 'for') {\n this._output.space_before_token = this._options.space_before_conditional;\n next_mode = MODE.ForInitializer;\n } else if (in_array$1(this._flags.last_token.text, ['if', 'while', 'switch'])) {\n this._output.space_before_token = this._options.space_before_conditional;\n next_mode = MODE.Conditional;\n } else if (in_array$1(this._flags.last_word, ['await', 'async'])) {\n // Should be a space between await and an IIFE, or async and an arrow function\n this._output.space_before_token = true;\n } else if (this._flags.last_token.text === 'import' && current_token.whitespace_before === '') {\n this._output.space_before_token = false;\n } else if (in_array$1(this._flags.last_token.text, line_starters$1) || this._flags.last_token.text === 'catch') {\n this._output.space_before_token = true;\n }\n } else if (this._flags.last_token.type === TOKEN$2.EQUALS || this._flags.last_token.type === TOKEN$2.OPERATOR) {\n // Support of this kind of newline preservation.\n // a = (b &&\n // (c || d));\n if (!this.start_of_object_property()) {\n this.allow_wrap_or_preserved_newline(current_token);\n }\n } else if (this._flags.last_token.type === TOKEN$2.WORD) {\n this._output.space_before_token = false;\n\n // function name() vs function name ()\n // function* name() vs function* name ()\n // async name() vs async name ()\n // In ES6, you can also define the method properties of an object\n // var obj = {a: function() {}}\n // It can be abbreviated\n // var obj = {a() {}}\n // var obj = { a() {}} vs var obj = { a () {}}\n // var obj = { * a() {}} vs var obj = { * a () {}}\n var peek_back_two = this._tokens.peek(-3);\n if (this._options.space_after_named_function && peek_back_two) {\n // peek starts at next character so -1 is current token\n var peek_back_three = this._tokens.peek(-4);\n if (reserved_array(peek_back_two, ['async', 'function']) ||\n (peek_back_two.text === '*' && reserved_array(peek_back_three, ['async', 'function']))) {\n this._output.space_before_token = true;\n } else if (this._flags.mode === MODE.ObjectLiteral) {\n if ((peek_back_two.text === '{' || peek_back_two.text === ',') ||\n (peek_back_two.text === '*' && (peek_back_three.text === '{' || peek_back_three.text === ','))) {\n this._output.space_before_token = true;\n }\n }\n }\n } else {\n // Support preserving wrapped arrow function expressions\n // a.b('c',\n // () => d.e\n // )\n this.allow_wrap_or_preserved_newline(current_token);\n }\n\n // function() vs function ()\n // yield*() vs yield* ()\n // function*() vs function* ()\n if ((this._flags.last_token.type === TOKEN$2.RESERVED && (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) ||\n (this._flags.last_token.text === '*' &&\n (in_array$1(this._last_last_text, ['function', 'yield']) ||\n (this._flags.mode === MODE.ObjectLiteral && in_array$1(this._last_last_text, ['{', ',']))))) {\n this._output.space_before_token = this._options.space_after_anon_function;\n }\n }\n\n if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN$2.START_BLOCK) {\n this.print_newline();\n } else if (this._flags.last_token.type === TOKEN$2.END_EXPR || this._flags.last_token.type === TOKEN$2.START_EXPR || this._flags.last_token.type === TOKEN$2.END_BLOCK || this._flags.last_token.text === '.' || this._flags.last_token.type === TOKEN$2.COMMA) {\n // do nothing on (( and )( and ][ and ]( and .(\n // TODO: Consider whether forcing this is required. Review failing tests when removed.\n this.allow_wrap_or_preserved_newline(current_token, current_token.newlines);\n }\n\n this.print_token(current_token);\n this.set_mode(next_mode);\n if (this._options.space_in_paren) {\n this._output.space_before_token = true;\n }\n\n // In all cases, if we newline while inside an expression it should be indented.\n this.indent();\n};\n\nBeautifier.prototype.handle_end_expr = function(current_token) {\n // statements inside expressions are not valid syntax, but...\n // statements must all be closed when their container closes\n while (this._flags.mode === MODE.Statement) {\n this.restore_mode();\n }\n\n this.handle_whitespace_and_comments(current_token);\n\n if (this._flags.multiline_frame) {\n this.allow_wrap_or_preserved_newline(current_token,\n current_token.text === ']' && is_array(this._flags.mode) && !this._options.keep_array_indentation);\n }\n\n if (this._options.space_in_paren) {\n if (this._flags.last_token.type === TOKEN$2.START_EXPR && !this._options.space_in_empty_paren) {\n // () [] no inner space in empty parens like these, ever, ref #320\n this._output.trim();\n this._output.space_before_token = false;\n } else {\n this._output.space_before_token = true;\n }\n }\n this.deindent();\n this.print_token(current_token);\n this.restore_mode();\n\n remove_redundant_indentation(this._output, this._previous_flags);\n\n // do {} while () // no statement required after\n if (this._flags.do_while && this._previous_flags.mode === MODE.Conditional) {\n this._previous_flags.mode = MODE.Expression;\n this._flags.do_block = false;\n this._flags.do_while = false;\n\n }\n};\n\nBeautifier.prototype.handle_start_block = function(current_token) {\n this.handle_whitespace_and_comments(current_token);\n\n // Check if this is should be treated as a ObjectLiteral\n var next_token = this._tokens.peek();\n var second_token = this._tokens.peek(1);\n if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN$2.END_EXPR) {\n this.set_mode(MODE.BlockStatement);\n this._flags.in_case_statement = true;\n } else if (this._flags.case_body) {\n this.set_mode(MODE.BlockStatement);\n } else if (second_token && (\n (in_array$1(second_token.text, [':', ',']) && in_array$1(next_token.type, [TOKEN$2.STRING, TOKEN$2.WORD, TOKEN$2.RESERVED])) ||\n (in_array$1(next_token.text, ['get', 'set', '...']) && in_array$1(second_token.type, [TOKEN$2.WORD, TOKEN$2.RESERVED]))\n )) {\n // We don't support TypeScript,but we didn't break it for a very long time.\n // We'll try to keep not breaking it.\n if (in_array$1(this._last_last_text, ['class', 'interface']) && !in_array$1(second_token.text, [':', ','])) {\n this.set_mode(MODE.BlockStatement);\n } else {\n this.set_mode(MODE.ObjectLiteral);\n }\n } else if (this._flags.last_token.type === TOKEN$2.OPERATOR && this._flags.last_token.text === '=>') {\n // arrow function: (param1, paramN) => { statements }\n this.set_mode(MODE.BlockStatement);\n } else if (in_array$1(this._flags.last_token.type, [TOKEN$2.EQUALS, TOKEN$2.START_EXPR, TOKEN$2.COMMA, TOKEN$2.OPERATOR]) ||\n reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default'])\n ) {\n // Detecting shorthand function syntax is difficult by scanning forward,\n // so check the surrounding context.\n // If the block is being returned, imported, export default, passed as arg,\n // assigned with = or assigned in a nested object, treat as an ObjectLiteral.\n this.set_mode(MODE.ObjectLiteral);\n } else {\n this.set_mode(MODE.BlockStatement);\n }\n\n var empty_braces = !next_token.comments_before && next_token.text === '}';\n var empty_anonymous_function = empty_braces && this._flags.last_word === 'function' &&\n this._flags.last_token.type === TOKEN$2.END_EXPR;\n\n if (this._options.brace_preserve_inline) // check for inline, set inline_frame if so\n {\n // search forward for a newline wanted inside this block\n var index = 0;\n var check_token = null;\n this._flags.inline_frame = true;\n do {\n index += 1;\n check_token = this._tokens.peek(index - 1);\n if (check_token.newlines) {\n this._flags.inline_frame = false;\n break;\n }\n } while (check_token.type !== TOKEN$2.EOF &&\n !(check_token.type === TOKEN$2.END_BLOCK && check_token.opened === current_token));\n }\n\n if ((this._options.brace_style === \"expand\" ||\n (this._options.brace_style === \"none\" && current_token.newlines)) &&\n !this._flags.inline_frame) {\n if (this._flags.last_token.type !== TOKEN$2.OPERATOR &&\n (empty_anonymous_function ||\n this._flags.last_token.type === TOKEN$2.EQUALS ||\n (reserved_array(this._flags.last_token, special_words) && this._flags.last_token.text !== 'else'))) {\n this._output.space_before_token = true;\n } else {\n this.print_newline(false, true);\n }\n } else { // collapse || inline_frame\n if (is_array(this._previous_flags.mode) && (this._flags.last_token.type === TOKEN$2.START_EXPR || this._flags.last_token.type === TOKEN$2.COMMA)) {\n if (this._flags.last_token.type === TOKEN$2.COMMA || this._options.space_in_paren) {\n this._output.space_before_token = true;\n }\n\n if (this._flags.last_token.type === TOKEN$2.COMMA || (this._flags.last_token.type === TOKEN$2.START_EXPR && this._flags.inline_frame)) {\n this.allow_wrap_or_preserved_newline(current_token);\n this._previous_flags.multiline_frame = this._previous_flags.multiline_frame || this._flags.multiline_frame;\n this._flags.multiline_frame = false;\n }\n }\n if (this._flags.last_token.type !== TOKEN$2.OPERATOR && this._flags.last_token.type !== TOKEN$2.START_EXPR) {\n if (this._flags.last_token.type === TOKEN$2.START_BLOCK && !this._flags.inline_frame) {\n this.print_newline();\n } else {\n this._output.space_before_token = true;\n }\n }\n }\n this.print_token(current_token);\n this.indent();\n\n // Except for specific cases, open braces are followed by a new line.\n if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) {\n this.print_newline();\n }\n};\n\nBeautifier.prototype.handle_end_block = function(current_token) {\n // statements must all be closed when their container closes\n this.handle_whitespace_and_comments(current_token);\n\n while (this._flags.mode === MODE.Statement) {\n this.restore_mode();\n }\n\n var empty_braces = this._flags.last_token.type === TOKEN$2.START_BLOCK;\n\n if (this._flags.inline_frame && !empty_braces) { // try inline_frame (only set if this._options.braces-preserve-inline) first\n this._output.space_before_token = true;\n } else if (this._options.brace_style === \"expand\") {\n if (!empty_braces) {\n this.print_newline();\n }\n } else {\n // skip {}\n if (!empty_braces) {\n if (is_array(this._flags.mode) && this._options.keep_array_indentation) {\n // we REALLY need a newline here, but newliner would skip that\n this._options.keep_array_indentation = false;\n this.print_newline();\n this._options.keep_array_indentation = true;\n\n } else {\n this.print_newline();\n }\n }\n }\n this.restore_mode();\n this.print_token(current_token);\n};\n\nBeautifier.prototype.handle_word = function(current_token) {\n if (current_token.type === TOKEN$2.RESERVED) {\n if (in_array$1(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) {\n current_token.type = TOKEN$2.WORD;\n } else if (current_token.text === 'import' && in_array$1(this._tokens.peek().text, ['(', '.'])) {\n current_token.type = TOKEN$2.WORD;\n } else if (in_array$1(current_token.text, ['as', 'from']) && !this._flags.import_block) {\n current_token.type = TOKEN$2.WORD;\n } else if (this._flags.mode === MODE.ObjectLiteral) {\n var next_token = this._tokens.peek();\n if (next_token.text === ':') {\n current_token.type = TOKEN$2.WORD;\n }\n }\n }\n\n if (this.start_of_statement(current_token)) {\n // The conditional starts the statement if appropriate.\n if (reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN$2.WORD) {\n this._flags.declaration_statement = true;\n }\n } else if (current_token.newlines && !is_expression(this._flags.mode) &&\n (this._flags.last_token.type !== TOKEN$2.OPERATOR || (this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) &&\n this._flags.last_token.type !== TOKEN$2.EQUALS &&\n (this._options.preserve_newlines || !reserved_array(this._flags.last_token, ['var', 'let', 'const', 'set', 'get']))) {\n this.handle_whitespace_and_comments(current_token);\n this.print_newline();\n } else {\n this.handle_whitespace_and_comments(current_token);\n }\n\n if (this._flags.do_block && !this._flags.do_while) {\n if (reserved_word(current_token, 'while')) {\n // do {} ## while ()\n this._output.space_before_token = true;\n this.print_token(current_token);\n this._output.space_before_token = true;\n this._flags.do_while = true;\n return;\n } else {\n // do {} should always have while as the next word.\n // if we don't see the expected while, recover\n this.print_newline();\n this._flags.do_block = false;\n }\n }\n\n // if may be followed by else, or not\n // Bare/inline ifs are tricky\n // Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e();\n if (this._flags.if_block) {\n if (!this._flags.else_block && reserved_word(current_token, 'else')) {\n this._flags.else_block = true;\n } else {\n while (this._flags.mode === MODE.Statement) {\n this.restore_mode();\n }\n this._flags.if_block = false;\n this._flags.else_block = false;\n }\n }\n\n if (this._flags.in_case_statement && reserved_array(current_token, ['case', 'default'])) {\n this.print_newline();\n if (!this._flags.case_block && (this._flags.case_body || this._options.jslint_happy)) {\n // switch cases following one another\n this.deindent();\n }\n this._flags.case_body = false;\n\n this.print_token(current_token);\n this._flags.in_case = true;\n return;\n }\n\n if (this._flags.last_token.type === TOKEN$2.COMMA || this._flags.last_token.type === TOKEN$2.START_EXPR || this._flags.last_token.type === TOKEN$2.EQUALS || this._flags.last_token.type === TOKEN$2.OPERATOR) {\n if (!this.start_of_object_property()) {\n this.allow_wrap_or_preserved_newline(current_token);\n }\n }\n\n if (reserved_word(current_token, 'function')) {\n if (in_array$1(this._flags.last_token.text, ['}', ';']) ||\n (this._output.just_added_newline() && !(in_array$1(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || this._flags.last_token.type === TOKEN$2.OPERATOR))) {\n // make sure there is a nice clean space of at least one blank line\n // before a new function definition\n if (!this._output.just_added_blankline() && !current_token.comments_before) {\n this.print_newline();\n this.print_newline(true);\n }\n }\n if (this._flags.last_token.type === TOKEN$2.RESERVED || this._flags.last_token.type === TOKEN$2.WORD) {\n if (reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) ||\n reserved_array(this._flags.last_token, newline_restricted_tokens)) {\n this._output.space_before_token = true;\n } else if (reserved_word(this._flags.last_token, 'default') && this._last_last_text === 'export') {\n this._output.space_before_token = true;\n } else if (this._flags.last_token.text === 'declare') {\n // accomodates Typescript declare function formatting\n this._output.space_before_token = true;\n } else {\n this.print_newline();\n }\n } else if (this._flags.last_token.type === TOKEN$2.OPERATOR || this._flags.last_token.text === '=') {\n // foo = function\n this._output.space_before_token = true;\n } else if (!this._flags.multiline_frame && (is_expression(this._flags.mode) || is_array(this._flags.mode))) ; else {\n this.print_newline();\n }\n\n this.print_token(current_token);\n this._flags.last_word = current_token.text;\n return;\n }\n\n var prefix = 'NONE';\n\n if (this._flags.last_token.type === TOKEN$2.END_BLOCK) {\n\n if (this._previous_flags.inline_frame) {\n prefix = 'SPACE';\n } else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) {\n prefix = 'NEWLINE';\n } else {\n if (this._options.brace_style === \"expand\" ||\n this._options.brace_style === \"end-expand\" ||\n (this._options.brace_style === \"none\" && current_token.newlines)) {\n prefix = 'NEWLINE';\n } else {\n prefix = 'SPACE';\n this._output.space_before_token = true;\n }\n }\n } else if (this._flags.last_token.type === TOKEN$2.SEMICOLON && this._flags.mode === MODE.BlockStatement) {\n // TODO: Should this be for STATEMENT as well?\n prefix = 'NEWLINE';\n } else if (this._flags.last_token.type === TOKEN$2.SEMICOLON && is_expression(this._flags.mode)) {\n prefix = 'SPACE';\n } else if (this._flags.last_token.type === TOKEN$2.STRING) {\n prefix = 'NEWLINE';\n } else if (this._flags.last_token.type === TOKEN$2.RESERVED || this._flags.last_token.type === TOKEN$2.WORD ||\n (this._flags.last_token.text === '*' &&\n (in_array$1(this._last_last_text, ['function', 'yield']) ||\n (this._flags.mode === MODE.ObjectLiteral && in_array$1(this._last_last_text, ['{', ',']))))) {\n prefix = 'SPACE';\n } else if (this._flags.last_token.type === TOKEN$2.START_BLOCK) {\n if (this._flags.inline_frame) {\n prefix = 'SPACE';\n } else {\n prefix = 'NEWLINE';\n }\n } else if (this._flags.last_token.type === TOKEN$2.END_EXPR) {\n this._output.space_before_token = true;\n prefix = 'NEWLINE';\n }\n\n if (reserved_array(current_token, line_starters$1) && this._flags.last_token.text !== ')') {\n if (this._flags.inline_frame || this._flags.last_token.text === 'else' || this._flags.last_token.text === 'export') {\n prefix = 'SPACE';\n } else {\n prefix = 'NEWLINE';\n }\n\n }\n\n if (reserved_array(current_token, ['else', 'catch', 'finally'])) {\n if ((!(this._flags.last_token.type === TOKEN$2.END_BLOCK && this._previous_flags.mode === MODE.BlockStatement) ||\n this._options.brace_style === \"expand\" ||\n this._options.brace_style === \"end-expand\" ||\n (this._options.brace_style === \"none\" && current_token.newlines)) &&\n !this._flags.inline_frame) {\n this.print_newline();\n } else {\n this._output.trim(true);\n var line = this._output.current_line;\n // If we trimmed and there's something other than a close block before us\n // put a newline back in. Handles '} // comment' scenario.\n if (line.last() !== '}') {\n this.print_newline();\n }\n this._output.space_before_token = true;\n }\n } else if (prefix === 'NEWLINE') {\n if (reserved_array(this._flags.last_token, special_words)) {\n // no newline between 'return nnn'\n this._output.space_before_token = true;\n } else if (this._flags.last_token.text === 'declare' && reserved_array(current_token, ['var', 'let', 'const'])) {\n // accomodates Typescript declare formatting\n this._output.space_before_token = true;\n } else if (this._flags.last_token.type !== TOKEN$2.END_EXPR) {\n if ((this._flags.last_token.type !== TOKEN$2.START_EXPR || !reserved_array(current_token, ['var', 'let', 'const'])) && this._flags.last_token.text !== ':') {\n // no need to force newline on 'var': for (var x = 0...)\n if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) {\n // no newline for } else if {\n this._output.space_before_token = true;\n } else {\n this.print_newline();\n }\n }\n } else if (reserved_array(current_token, line_starters$1) && this._flags.last_token.text !== ')') {\n this.print_newline();\n }\n } else if (this._flags.multiline_frame && is_array(this._flags.mode) && this._flags.last_token.text === ',' && this._last_last_text === '}') {\n this.print_newline(); // }, in lists get a newline treatment\n } else if (prefix === 'SPACE') {\n this._output.space_before_token = true;\n }\n if (current_token.previous && (current_token.previous.type === TOKEN$2.WORD || current_token.previous.type === TOKEN$2.RESERVED)) {\n this._output.space_before_token = true;\n }\n this.print_token(current_token);\n this._flags.last_word = current_token.text;\n\n if (current_token.type === TOKEN$2.RESERVED) {\n if (current_token.text === 'do') {\n this._flags.do_block = true;\n } else if (current_token.text === 'if') {\n this._flags.if_block = true;\n } else if (current_token.text === 'import') {\n this._flags.import_block = true;\n } else if (this._flags.import_block && reserved_word(current_token, 'from')) {\n this._flags.import_block = false;\n }\n }\n};\n\nBeautifier.prototype.handle_semicolon = function(current_token) {\n if (this.start_of_statement(current_token)) {\n // The conditional starts the statement if appropriate.\n // Semicolon can be the start (and end) of a statement\n this._output.space_before_token = false;\n } else {\n this.handle_whitespace_and_comments(current_token);\n }\n\n var next_token = this._tokens.peek();\n while (this._flags.mode === MODE.Statement &&\n !(this._flags.if_block && reserved_word(next_token, 'else')) &&\n !this._flags.do_block) {\n this.restore_mode();\n }\n\n // hacky but effective for the moment\n if (this._flags.import_block) {\n this._flags.import_block = false;\n }\n this.print_token(current_token);\n};\n\nBeautifier.prototype.handle_string = function(current_token) {\n if (current_token.text.startsWith(\"`\") && current_token.newlines === 0 && current_token.whitespace_before === '' && (current_token.previous.text === ')' || this._flags.last_token.type === TOKEN$2.WORD)) ; else if (this.start_of_statement(current_token)) {\n // The conditional starts the statement if appropriate.\n // One difference - strings want at least a space before\n this._output.space_before_token = true;\n } else {\n this.handle_whitespace_and_comments(current_token);\n if (this._flags.last_token.type === TOKEN$2.RESERVED || this._flags.last_token.type === TOKEN$2.WORD || this._flags.inline_frame) {\n this._output.space_before_token = true;\n } else if (this._flags.last_token.type === TOKEN$2.COMMA || this._flags.last_token.type === TOKEN$2.START_EXPR || this._flags.last_token.type === TOKEN$2.EQUALS || this._flags.last_token.type === TOKEN$2.OPERATOR) {\n if (!this.start_of_object_property()) {\n this.allow_wrap_or_preserved_newline(current_token);\n }\n } else if ((current_token.text.startsWith(\"`\") && this._flags.last_token.type === TOKEN$2.END_EXPR && (current_token.previous.text === ']' || current_token.previous.text === ')') && current_token.newlines === 0)) {\n this._output.space_before_token = true;\n } else {\n this.print_newline();\n }\n }\n this.print_token(current_token);\n};\n\nBeautifier.prototype.handle_equals = function(current_token) {\n if (this.start_of_statement(current_token)) ; else {\n this.handle_whitespace_and_comments(current_token);\n }\n\n if (this._flags.declaration_statement) {\n // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done\n this._flags.declaration_assignment = true;\n }\n this._output.space_before_token = true;\n this.print_token(current_token);\n this._output.space_before_token = true;\n};\n\nBeautifier.prototype.handle_comma = function(current_token) {\n this.handle_whitespace_and_comments(current_token, true);\n\n this.print_token(current_token);\n this._output.space_before_token = true;\n if (this._flags.declaration_statement) {\n if (is_expression(this._flags.parent.mode)) {\n // do not break on comma, for(var a = 1, b = 2)\n this._flags.declaration_assignment = false;\n }\n\n if (this._flags.declaration_assignment) {\n this._flags.declaration_assignment = false;\n this.print_newline(false, true);\n } else if (this._options.comma_first) {\n // for comma-first, we want to allow a newline before the comma\n // to turn into a newline after the comma, which we will fixup later\n this.allow_wrap_or_preserved_newline(current_token);\n }\n } else if (this._flags.mode === MODE.ObjectLiteral ||\n (this._flags.mode === MODE.Statement && this._flags.parent.mode === MODE.ObjectLiteral)) {\n if (this._flags.mode === MODE.Statement) {\n this.restore_mode();\n }\n\n if (!this._flags.inline_frame) {\n this.print_newline();\n }\n } else if (this._options.comma_first) {\n // EXPR or DO_BLOCK\n // for comma-first, we want to allow a newline before the comma\n // to turn into a newline after the comma, which we will fixup later\n this.allow_wrap_or_preserved_newline(current_token);\n }\n};\n\nBeautifier.prototype.handle_operator = function(current_token) {\n var isGeneratorAsterisk = current_token.text === '*' &&\n (reserved_array(this._flags.last_token, ['function', 'yield']) ||\n (in_array$1(this._flags.last_token.type, [TOKEN$2.START_BLOCK, TOKEN$2.COMMA, TOKEN$2.END_BLOCK, TOKEN$2.SEMICOLON]))\n );\n var isUnary = in_array$1(current_token.text, ['-', '+']) && (\n in_array$1(this._flags.last_token.type, [TOKEN$2.START_BLOCK, TOKEN$2.START_EXPR, TOKEN$2.EQUALS, TOKEN$2.OPERATOR]) ||\n in_array$1(this._flags.last_token.text, line_starters$1) ||\n this._flags.last_token.text === ','\n );\n\n if (this.start_of_statement(current_token)) ; else {\n var preserve_statement_flags = !isGeneratorAsterisk;\n this.handle_whitespace_and_comments(current_token, preserve_statement_flags);\n }\n\n if (reserved_array(this._flags.last_token, special_words)) {\n // \"return\" had a special handling in TK_WORD. Now we need to return the favor\n this._output.space_before_token = true;\n this.print_token(current_token);\n return;\n }\n\n // hack for actionscript's import .*;\n if (current_token.text === '*' && this._flags.last_token.type === TOKEN$2.DOT) {\n this.print_token(current_token);\n return;\n }\n\n if (current_token.text === '::') {\n // no spaces around exotic namespacing syntax operator\n this.print_token(current_token);\n return;\n }\n\n // Allow line wrapping between operators when operator_position is\n // set to before or preserve\n if (this._flags.last_token.type === TOKEN$2.OPERATOR && in_array$1(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) {\n this.allow_wrap_or_preserved_newline(current_token);\n }\n\n if (current_token.text === ':' && this._flags.in_case) {\n this.print_token(current_token);\n\n this._flags.in_case = false;\n this._flags.case_body = true;\n if (this._tokens.peek().type !== TOKEN$2.START_BLOCK) {\n this.indent();\n this.print_newline();\n this._flags.case_block = false;\n } else {\n this._flags.case_block = true;\n this._output.space_before_token = true;\n }\n return;\n }\n\n var space_before = true;\n var space_after = true;\n var in_ternary = false;\n if (current_token.text === ':') {\n if (this._flags.ternary_depth === 0) {\n // Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant.\n space_before = false;\n } else {\n this._flags.ternary_depth -= 1;\n in_ternary = true;\n }\n } else if (current_token.text === '?') {\n this._flags.ternary_depth += 1;\n }\n\n // let's handle the operator_position option prior to any conflicting logic\n if (!isUnary && !isGeneratorAsterisk && this._options.preserve_newlines && in_array$1(current_token.text, positionable_operators$1)) {\n var isColon = current_token.text === ':';\n var isTernaryColon = (isColon && in_ternary);\n var isOtherColon = (isColon && !in_ternary);\n\n switch (this._options.operator_position) {\n case OPERATOR_POSITION.before_newline:\n // if the current token is : and it's not a ternary statement then we set space_before to false\n this._output.space_before_token = !isOtherColon;\n\n this.print_token(current_token);\n\n if (!isColon || isTernaryColon) {\n this.allow_wrap_or_preserved_newline(current_token);\n }\n\n this._output.space_before_token = true;\n return;\n\n case OPERATOR_POSITION.after_newline:\n // if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement,\n // then print a newline.\n\n this._output.space_before_token = true;\n\n if (!isColon || isTernaryColon) {\n if (this._tokens.peek().newlines) {\n this.print_newline(false, true);\n } else {\n this.allow_wrap_or_preserved_newline(current_token);\n }\n } else {\n this._output.space_before_token = false;\n }\n\n this.print_token(current_token);\n\n this._output.space_before_token = true;\n return;\n\n case OPERATOR_POSITION.preserve_newline:\n if (!isOtherColon) {\n this.allow_wrap_or_preserved_newline(current_token);\n }\n\n // if we just added a newline, or the current token is : and it's not a ternary statement,\n // then we set space_before to false\n space_before = !(this._output.just_added_newline() || isOtherColon);\n\n this._output.space_before_token = space_before;\n this.print_token(current_token);\n this._output.space_before_token = true;\n return;\n }\n }\n\n if (isGeneratorAsterisk) {\n this.allow_wrap_or_preserved_newline(current_token);\n space_before = false;\n var next_token = this._tokens.peek();\n space_after = next_token && in_array$1(next_token.type, [TOKEN$2.WORD, TOKEN$2.RESERVED]);\n } else if (current_token.text === '...') {\n this.allow_wrap_or_preserved_newline(current_token);\n space_before = this._flags.last_token.type === TOKEN$2.START_BLOCK;\n space_after = false;\n } else if (in_array$1(current_token.text, ['--', '++', '!', '~']) || isUnary) {\n // unary operators (and binary +/- pretending to be unary) special cases\n if (this._flags.last_token.type === TOKEN$2.COMMA || this._flags.last_token.type === TOKEN$2.START_EXPR) {\n this.allow_wrap_or_preserved_newline(current_token);\n }\n\n space_before = false;\n space_after = false;\n\n // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1\n // if there is a newline between -- or ++ and anything else we should preserve it.\n if (current_token.newlines && (current_token.text === '--' || current_token.text === '++' || current_token.text === '~')) {\n this.print_newline(false, true);\n }\n\n if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) {\n // for (;; ++i)\n // ^^^\n space_before = true;\n }\n\n if (this._flags.last_token.type === TOKEN$2.RESERVED) {\n space_before = true;\n } else if (this._flags.last_token.type === TOKEN$2.END_EXPR) {\n space_before = !(this._flags.last_token.text === ']' && (current_token.text === '--' || current_token.text === '++'));\n } else if (this._flags.last_token.type === TOKEN$2.OPERATOR) {\n // a++ + ++b;\n // a - -b\n space_before = in_array$1(current_token.text, ['--', '-', '++', '+']) && in_array$1(this._flags.last_token.text, ['--', '-', '++', '+']);\n // + and - are not unary when preceeded by -- or ++ operator\n // a-- + b\n // a * +b\n // a - -b\n if (in_array$1(current_token.text, ['+', '-']) && in_array$1(this._flags.last_token.text, ['--', '++'])) {\n space_after = true;\n }\n }\n\n\n if (((this._flags.mode === MODE.BlockStatement && !this._flags.inline_frame) || this._flags.mode === MODE.Statement) &&\n (this._flags.last_token.text === '{' || this._flags.last_token.text === ';')) {\n // { foo; --i }\n // foo(); --bar;\n this.print_newline();\n }\n }\n\n this._output.space_before_token = this._output.space_before_token || space_before;\n this.print_token(current_token);\n this._output.space_before_token = space_after;\n};\n\nBeautifier.prototype.handle_block_comment = function(current_token, preserve_statement_flags) {\n if (this._output.raw) {\n this._output.add_raw_token(current_token);\n if (current_token.directives && current_token.directives.preserve === 'end') {\n // If we're testing the raw output behavior, do not allow a directive to turn it off.\n this._output.raw = this._options.test_output_raw;\n }\n return;\n }\n\n if (current_token.directives) {\n this.print_newline(false, preserve_statement_flags);\n this.print_token(current_token);\n if (current_token.directives.preserve === 'start') {\n this._output.raw = true;\n }\n this.print_newline(false, true);\n return;\n }\n\n // inline block\n if (!acorn.newline.test(current_token.text) && !current_token.newlines) {\n this._output.space_before_token = true;\n this.print_token(current_token);\n this._output.space_before_token = true;\n return;\n } else {\n this.print_block_commment(current_token, preserve_statement_flags);\n }\n};\n\nBeautifier.prototype.print_block_commment = function(current_token, preserve_statement_flags) {\n var lines = split_linebreaks(current_token.text);\n var j; // iterator for this case\n var javadoc = false;\n var starless = false;\n var lastIndent = current_token.whitespace_before;\n var lastIndentLength = lastIndent.length;\n\n // block comment starts with a new line\n this.print_newline(false, preserve_statement_flags);\n\n // first line always indented\n this.print_token_line_indentation(current_token);\n this._output.add_token(lines[0]);\n this.print_newline(false, preserve_statement_flags);\n\n\n if (lines.length > 1) {\n lines = lines.slice(1);\n javadoc = all_lines_start_with(lines, '*');\n starless = each_line_matches_indent(lines, lastIndent);\n\n if (javadoc) {\n this._flags.alignment = 1;\n }\n\n for (j = 0; j < lines.length; j++) {\n if (javadoc) {\n // javadoc: reformat and re-indent\n this.print_token_line_indentation(current_token);\n this._output.add_token(ltrim(lines[j]));\n } else if (starless && lines[j]) {\n // starless: re-indent non-empty content, avoiding trim\n this.print_token_line_indentation(current_token);\n this._output.add_token(lines[j].substring(lastIndentLength));\n } else {\n // normal comments output raw\n this._output.current_line.set_indent(-1);\n this._output.add_token(lines[j]);\n }\n\n // for comments on their own line or more than one line, make sure there's a new line after\n this.print_newline(false, preserve_statement_flags);\n }\n\n this._flags.alignment = 0;\n }\n};\n\n\nBeautifier.prototype.handle_comment = function(current_token, preserve_statement_flags) {\n if (current_token.newlines) {\n this.print_newline(false, preserve_statement_flags);\n } else {\n this._output.trim(true);\n }\n\n this._output.space_before_token = true;\n this.print_token(current_token);\n this.print_newline(false, preserve_statement_flags);\n};\n\nBeautifier.prototype.handle_dot = function(current_token) {\n if (this.start_of_statement(current_token)) ; else {\n this.handle_whitespace_and_comments(current_token, true);\n }\n\n if (reserved_array(this._flags.last_token, special_words)) {\n this._output.space_before_token = false;\n } else {\n // allow preserved newlines before dots in general\n // force newlines on dots after close paren when break_chained - for bar().baz()\n this.allow_wrap_or_preserved_newline(current_token,\n this._flags.last_token.text === ')' && this._options.break_chained_methods);\n }\n\n // Only unindent chained method dot if this dot starts a new line.\n // Otherwise the automatic extra indentation removal will handle the over indent\n if (this._options.unindent_chained_methods && this._output.just_added_newline()) {\n this.deindent();\n }\n\n this.print_token(current_token);\n};\n\nBeautifier.prototype.handle_unknown = function(current_token, preserve_statement_flags) {\n this.print_token(current_token);\n\n if (current_token.text[current_token.text.length - 1] === '\\n') {\n this.print_newline(false, preserve_statement_flags);\n }\n};\n\nBeautifier.prototype.handle_eof = function(current_token) {\n // Unwind any open statements\n while (this._flags.mode === MODE.Statement) {\n this.restore_mode();\n }\n this.handle_whitespace_and_comments(current_token);\n};\n\nvar Beautifier_1 = Beautifier;\n\nvar beautifier = {\n\tBeautifier: Beautifier_1\n};\n\nvar Beautifier$1 = beautifier.Beautifier,\n Options$3 = options$1.Options;\n\nfunction js_beautify(js_source_text, options) {\n var beautifier = new Beautifier$1(js_source_text, options);\n return beautifier.beautify();\n}\n\nvar javascript = js_beautify;\nvar defaultOptions = function() {\n return new Options$3();\n};\njavascript.defaultOptions = defaultOptions;\n\nvar BaseOptions$1 = options.Options;\n\nfunction Options$4(options) {\n BaseOptions$1.call(this, options, 'css');\n\n this.selector_separator_newline = this._get_boolean('selector_separator_newline', true);\n this.newline_between_rules = this._get_boolean('newline_between_rules', true);\n var space_around_selector_separator = this._get_boolean('space_around_selector_separator');\n this.space_around_combinator = this._get_boolean('space_around_combinator') || space_around_selector_separator;\n\n var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']);\n this.brace_style = 'collapse';\n for (var bs = 0; bs < brace_style_split.length; bs++) {\n if (brace_style_split[bs] !== 'expand') {\n // default to collapse, as only collapse|expand is implemented for now\n this.brace_style = 'collapse';\n } else {\n this.brace_style = brace_style_split[bs];\n }\n }\n}\nOptions$4.prototype = new BaseOptions$1();\n\n\n\nvar Options_1$2 = Options$4;\n\nvar options$2 = {\n\tOptions: Options_1$2\n};\n\nvar Options$5 = options$2.Options;\nvar Output$2 = output.Output;\nvar InputScanner$3 = inputscanner.InputScanner;\nvar Directives$2 = directives.Directives;\n\nvar directives_core$1 = new Directives$2(/\\/\\*/, /\\*\\//);\n\nvar lineBreak = /\\r\\n|[\\r\\n]/;\nvar allLineBreaks = /\\r\\n|[\\r\\n]/g;\n\n// tokenizer\nvar whitespaceChar = /\\s/;\nvar whitespacePattern = /(?:\\s|\\n)+/g;\nvar block_comment_pattern = /\\/\\*(?:[\\s\\S]*?)((?:\\*\\/)|$)/g;\nvar comment_pattern = /\\/\\/(?:[^\\n\\r\\u2028\\u2029]*)/g;\n\nfunction Beautifier$2(source_text, options) {\n this._source_text = source_text || '';\n // Allow the setting of language/file-type specific options\n // with inheritance of overall settings\n this._options = new Options$5(options);\n this._ch = null;\n this._input = null;\n\n // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule\n this.NESTED_AT_RULE = {\n \"@page\": true,\n \"@font-face\": true,\n \"@keyframes\": true,\n // also in CONDITIONAL_GROUP_RULE below\n \"@media\": true,\n \"@supports\": true,\n \"@document\": true\n };\n this.CONDITIONAL_GROUP_RULE = {\n \"@media\": true,\n \"@supports\": true,\n \"@document\": true\n };\n this.NON_SEMICOLON_NEWLINE_PROPERTY = [\n \"grid-template\"\n ];\n\n}\n\nBeautifier$2.prototype.eatString = function(endChars) {\n var result = '';\n this._ch = this._input.next();\n while (this._ch) {\n result += this._ch;\n if (this._ch === \"\\\\\") {\n result += this._input.next();\n } else if (endChars.indexOf(this._ch) !== -1 || this._ch === \"\\n\") {\n break;\n }\n this._ch = this._input.next();\n }\n return result;\n};\n\n// Skips any white space in the source text from the current position.\n// When allowAtLeastOneNewLine is true, will output new lines for each\n// newline character found; if the user has preserve_newlines off, only\n// the first newline will be output\nBeautifier$2.prototype.eatWhitespace = function(allowAtLeastOneNewLine) {\n var result = whitespaceChar.test(this._input.peek());\n var newline_count = 0;\n while (whitespaceChar.test(this._input.peek())) {\n this._ch = this._input.next();\n if (allowAtLeastOneNewLine && this._ch === '\\n') {\n if (newline_count === 0 || newline_count < this._options.max_preserve_newlines) {\n newline_count++;\n this._output.add_new_line(true);\n }\n }\n }\n return result;\n};\n\n// Nested pseudo-class if we are insideRule\n// and the next special character found opens\n// a new block\nBeautifier$2.prototype.foundNestedPseudoClass = function() {\n var openParen = 0;\n var i = 1;\n var ch = this._input.peek(i);\n while (ch) {\n if (ch === \"{\") {\n return true;\n } else if (ch === '(') {\n // pseudoclasses can contain ()\n openParen += 1;\n } else if (ch === ')') {\n if (openParen === 0) {\n return false;\n }\n openParen -= 1;\n } else if (ch === \";\" || ch === \"}\") {\n return false;\n }\n i++;\n ch = this._input.peek(i);\n }\n return false;\n};\n\nBeautifier$2.prototype.print_string = function(output_string) {\n this._output.set_indent(this._indentLevel);\n this._output.non_breaking_space = true;\n this._output.add_token(output_string);\n};\n\nBeautifier$2.prototype.preserveSingleSpace = function(isAfterSpace) {\n if (isAfterSpace) {\n this._output.space_before_token = true;\n }\n};\n\nBeautifier$2.prototype.indent = function() {\n this._indentLevel++;\n};\n\nBeautifier$2.prototype.outdent = function() {\n if (this._indentLevel > 0) {\n this._indentLevel--;\n }\n};\n\n/*_____________________--------------------_____________________*/\n\nBeautifier$2.prototype.beautify = function() {\n if (this._options.disabled) {\n return this._source_text;\n }\n\n var source_text = this._source_text;\n var eol = this._options.eol;\n if (eol === 'auto') {\n eol = '\\n';\n if (source_text && lineBreak.test(source_text || '')) {\n eol = source_text.match(lineBreak)[0];\n }\n }\n\n\n // HACK: newline parsing inconsistent. This brute force normalizes the this._input.\n source_text = source_text.replace(allLineBreaks, '\\n');\n\n // reset\n var baseIndentString = source_text.match(/^[\\t ]*/)[0];\n\n this._output = new Output$2(this._options, baseIndentString);\n this._input = new InputScanner$3(source_text);\n this._indentLevel = 0;\n this._nestedLevel = 0;\n\n this._ch = null;\n var parenLevel = 0;\n\n var insideRule = false;\n // This is the value side of a property value pair (blue in the following ex)\n // label { content: blue }\n var insidePropertyValue = false;\n var enteringConditionalGroup = false;\n var insideAtExtend = false;\n var insideAtImport = false;\n var insideScssMap = false;\n var topCharacter = this._ch;\n var insideNonSemiColonValues = false;\n var whitespace;\n var isAfterSpace;\n var previous_ch;\n\n while (true) {\n whitespace = this._input.read(whitespacePattern);\n isAfterSpace = whitespace !== '';\n previous_ch = topCharacter;\n this._ch = this._input.next();\n if (this._ch === '\\\\' && this._input.hasNext()) {\n this._ch += this._input.next();\n }\n topCharacter = this._ch;\n\n if (!this._ch) {\n break;\n } else if (this._ch === '/' && this._input.peek() === '*') {\n // /* css comment */\n // Always start block comments on a new line.\n // This handles scenarios where a block comment immediately\n // follows a property definition on the same line or where\n // minified code is being beautified.\n this._output.add_new_line();\n this._input.back();\n\n var comment = this._input.read(block_comment_pattern);\n\n // Handle ignore directive\n var directives = directives_core$1.get_directives(comment);\n if (directives && directives.ignore === 'start') {\n comment += directives_core$1.readIgnored(this._input);\n }\n\n this.print_string(comment);\n\n // Ensures any new lines following the comment are preserved\n this.eatWhitespace(true);\n\n // Block comments are followed by a new line so they don't\n // share a line with other properties\n this._output.add_new_line();\n } else if (this._ch === '/' && this._input.peek() === '/') {\n // // single line comment\n // Preserves the space before a comment\n // on the same line as a rule\n this._output.space_before_token = true;\n this._input.back();\n this.print_string(this._input.read(comment_pattern));\n\n // Ensures any new lines following the comment are preserved\n this.eatWhitespace(true);\n } else if (this._ch === '@' || this._ch === '$') {\n this.preserveSingleSpace(isAfterSpace);\n\n // deal with less propery mixins @{...}\n if (this._input.peek() === '{') {\n this.print_string(this._ch + this.eatString('}'));\n } else {\n this.print_string(this._ch);\n\n // strip trailing space, if present, for hash property checks\n var variableOrRule = this._input.peekUntilAfter(/[: ,;{}()[\\]\\/='\"]/g);\n\n if (variableOrRule.match(/[ :]$/)) {\n // we have a variable or pseudo-class, add it and insert one space before continuing\n variableOrRule = this.eatString(\": \").replace(/\\s$/, '');\n this.print_string(variableOrRule);\n this._output.space_before_token = true;\n }\n\n variableOrRule = variableOrRule.replace(/\\s$/, '');\n\n if (variableOrRule === 'extend') {\n insideAtExtend = true;\n } else if (variableOrRule === 'import') {\n insideAtImport = true;\n }\n\n // might be a nesting at-rule\n if (variableOrRule in this.NESTED_AT_RULE) {\n this._nestedLevel += 1;\n if (variableOrRule in this.CONDITIONAL_GROUP_RULE) {\n enteringConditionalGroup = true;\n }\n // might be less variable\n } else if (!insideRule && parenLevel === 0 && variableOrRule.indexOf(':') !== -1) {\n insidePropertyValue = true;\n this.indent();\n }\n }\n } else if (this._ch === '#' && this._input.peek() === '{') {\n this.preserveSingleSpace(isAfterSpace);\n this.print_string(this._ch + this.eatString('}'));\n } else if (this._ch === '{') {\n if (insidePropertyValue) {\n insidePropertyValue = false;\n this.outdent();\n }\n\n // when entering conditional groups, only rulesets are allowed\n if (enteringConditionalGroup) {\n enteringConditionalGroup = false;\n insideRule = (this._indentLevel >= this._nestedLevel);\n } else {\n // otherwise, declarations are also allowed\n insideRule = (this._indentLevel >= this._nestedLevel - 1);\n }\n if (this._options.newline_between_rules && insideRule) {\n if (this._output.previous_line && this._output.previous_line.item(-1) !== '{') {\n this._output.ensure_empty_line_above('/', ',');\n }\n }\n\n this._output.space_before_token = true;\n\n // The difference in print_string and indent order is necessary to indent the '{' correctly\n if (this._options.brace_style === 'expand') {\n this._output.add_new_line();\n this.print_string(this._ch);\n this.indent();\n this._output.set_indent(this._indentLevel);\n } else {\n // inside mixin and first param is object\n if (previous_ch === '(') {\n this._output.space_before_token = false;\n } else if (previous_ch !== ',') {\n this.indent();\n }\n this.print_string(this._ch);\n }\n\n this.eatWhitespace(true);\n this._output.add_new_line();\n } else if (this._ch === '}') {\n this.outdent();\n this._output.add_new_line();\n if (previous_ch === '{') {\n this._output.trim(true);\n }\n insideAtImport = false;\n insideAtExtend = false;\n if (insidePropertyValue) {\n this.outdent();\n insidePropertyValue = false;\n }\n this.print_string(this._ch);\n insideRule = false;\n if (this._nestedLevel) {\n this._nestedLevel--;\n }\n\n this.eatWhitespace(true);\n this._output.add_new_line();\n\n if (this._options.newline_between_rules && !this._output.just_added_blankline()) {\n if (this._input.peek() !== '}') {\n this._output.add_new_line(true);\n }\n }\n if (this._input.peek() === ')') {\n this._output.trim(true);\n if (this._options.brace_style === \"expand\") {\n this._output.add_new_line(true);\n }\n }\n } else if (this._ch === \":\") {\n\n for (var i = 0; i < this.NON_SEMICOLON_NEWLINE_PROPERTY.length; i++) {\n if (this._input.lookBack(this.NON_SEMICOLON_NEWLINE_PROPERTY[i])) {\n insideNonSemiColonValues = true;\n break;\n }\n }\n\n if ((insideRule || enteringConditionalGroup) && !(this._input.lookBack(\"&\") || this.foundNestedPseudoClass()) && !this._input.lookBack(\"(\") && !insideAtExtend && parenLevel === 0) {\n // 'property: value' delimiter\n // which could be in a conditional group query\n this.print_string(':');\n if (!insidePropertyValue) {\n insidePropertyValue = true;\n this._output.space_before_token = true;\n this.eatWhitespace(true);\n this.indent();\n }\n } else {\n // sass/less parent reference don't use a space\n // sass nested pseudo-class don't use a space\n\n // preserve space before pseudoclasses/pseudoelements, as it means \"in any child\"\n if (this._input.lookBack(\" \")) {\n this._output.space_before_token = true;\n }\n if (this._input.peek() === \":\") {\n // pseudo-element\n this._ch = this._input.next();\n this.print_string(\"::\");\n } else {\n // pseudo-class\n this.print_string(':');\n }\n }\n } else if (this._ch === '\"' || this._ch === '\\'') {\n this.preserveSingleSpace(isAfterSpace);\n this.print_string(this._ch + this.eatString(this._ch));\n this.eatWhitespace(true);\n } else if (this._ch === ';') {\n insideNonSemiColonValues = false;\n if (parenLevel === 0) {\n if (insidePropertyValue) {\n this.outdent();\n insidePropertyValue = false;\n }\n insideAtExtend = false;\n insideAtImport = false;\n this.print_string(this._ch);\n this.eatWhitespace(true);\n\n // This maintains single line comments on the same\n // line. Block comments are also affected, but\n // a new line is always output before one inside\n // that section\n if (this._input.peek() !== '/') {\n this._output.add_new_line();\n }\n } else {\n this.print_string(this._ch);\n this.eatWhitespace(true);\n this._output.space_before_token = true;\n }\n } else if (this._ch === '(') { // may be a url\n if (this._input.lookBack(\"url\")) {\n this.print_string(this._ch);\n this.eatWhitespace();\n parenLevel++;\n this.indent();\n this._ch = this._input.next();\n if (this._ch === ')' || this._ch === '\"' || this._ch === '\\'') {\n this._input.back();\n } else if (this._ch) {\n this.print_string(this._ch + this.eatString(')'));\n if (parenLevel) {\n parenLevel--;\n this.outdent();\n }\n }\n } else {\n this.preserveSingleSpace(isAfterSpace);\n this.print_string(this._ch);\n\n // handle scss/sass map\n if (insidePropertyValue && previous_ch === \"$\" && this._options.selector_separator_newline) {\n this._output.add_new_line();\n insideScssMap = true;\n } else {\n this.eatWhitespace();\n parenLevel++;\n this.indent();\n }\n }\n } else if (this._ch === ')') {\n if (parenLevel) {\n parenLevel--;\n this.outdent();\n }\n if (insideScssMap && this._input.peek() === \";\" && this._options.selector_separator_newline) {\n insideScssMap = false;\n this.outdent();\n this._output.add_new_line();\n }\n this.print_string(this._ch);\n } else if (this._ch === ',') {\n this.print_string(this._ch);\n this.eatWhitespace(true);\n if (this._options.selector_separator_newline && (!insidePropertyValue || insideScssMap) && parenLevel === 0 && !insideAtImport && !insideAtExtend) {\n this._output.add_new_line();\n } else {\n this._output.space_before_token = true;\n }\n } else if ((this._ch === '>' || this._ch === '+' || this._ch === '~') && !insidePropertyValue && parenLevel === 0) {\n //handle combinator spacing\n if (this._options.space_around_combinator) {\n this._output.space_before_token = true;\n this.print_string(this._ch);\n this._output.space_before_token = true;\n } else {\n this.print_string(this._ch);\n this.eatWhitespace();\n // squash extra whitespace\n if (this._ch && whitespaceChar.test(this._ch)) {\n this._ch = '';\n }\n }\n } else if (this._ch === ']') {\n this.print_string(this._ch);\n } else if (this._ch === '[') {\n this.preserveSingleSpace(isAfterSpace);\n this.print_string(this._ch);\n } else if (this._ch === '=') { // no whitespace before or after\n this.eatWhitespace();\n this.print_string('=');\n if (whitespaceChar.test(this._ch)) {\n this._ch = '';\n }\n } else if (this._ch === '!' && !this._input.lookBack(\"\\\\\")) { // !important\n this.print_string(' ');\n this.print_string(this._ch);\n } else {\n var preserveAfterSpace = previous_ch === '\"' || previous_ch === '\\'';\n this.preserveSingleSpace(preserveAfterSpace || isAfterSpace);\n this.print_string(this._ch);\n\n if (!this._output.just_added_newline() && this._input.peek() === '\\n' && insideNonSemiColonValues) {\n this._output.add_new_line();\n }\n }\n }\n\n var sweetCode = this._output.get_code(eol);\n\n return sweetCode;\n};\n\nvar Beautifier_1$1 = Beautifier$2;\n\nvar beautifier$1 = {\n\tBeautifier: Beautifier_1$1\n};\n\nvar Beautifier$3 = beautifier$1.Beautifier,\n Options$6 = options$2.Options;\n\nfunction css_beautify(source_text, options) {\n var beautifier = new Beautifier$3(source_text, options);\n return beautifier.beautify();\n}\n\nvar css = css_beautify;\nvar defaultOptions$1 = function() {\n return new Options$6();\n};\ncss.defaultOptions = defaultOptions$1;\n\nvar BaseOptions$2 = options.Options;\n\nfunction Options$7(options) {\n BaseOptions$2.call(this, options, 'html');\n if (this.templating.length === 1 && this.templating[0] === 'auto') {\n this.templating = ['django', 'erb', 'handlebars', 'php'];\n }\n\n this.indent_inner_html = this._get_boolean('indent_inner_html');\n this.indent_body_inner_html = this._get_boolean('indent_body_inner_html', true);\n this.indent_head_inner_html = this._get_boolean('indent_head_inner_html', true);\n\n this.indent_handlebars = this._get_boolean('indent_handlebars', true);\n this.wrap_attributes = this._get_selection('wrap_attributes',\n ['auto', 'force', 'force-aligned', 'force-expand-multiline', 'aligned-multiple', 'preserve', 'preserve-aligned']);\n this.wrap_attributes_indent_size = this._get_number('wrap_attributes_indent_size', this.indent_size);\n this.extra_liners = this._get_array('extra_liners', ['head', 'body', '/html']);\n\n // Block vs inline elements\n // https://developer.mozilla.org/en-US/docs/Web/HTML/Block-level_elements\n // https://developer.mozilla.org/en-US/docs/Web/HTML/Inline_elements\n // https://www.w3.org/TR/html5/dom.html#phrasing-content\n this.inline = this._get_array('inline', [\n 'a', 'abbr', 'area', 'audio', 'b', 'bdi', 'bdo', 'br', 'button', 'canvas', 'cite',\n 'code', 'data', 'datalist', 'del', 'dfn', 'em', 'embed', 'i', 'iframe', 'img',\n 'input', 'ins', 'kbd', 'keygen', 'label', 'map', 'mark', 'math', 'meter', 'noscript',\n 'object', 'output', 'progress', 'q', 'ruby', 's', 'samp', /* 'script', */ 'select', 'small',\n 'span', 'strong', 'sub', 'sup', 'svg', 'template', 'textarea', 'time', 'u', 'var',\n 'video', 'wbr', 'text',\n // obsolete inline tags\n 'acronym', 'big', 'strike', 'tt'\n ]);\n this.void_elements = this._get_array('void_elements', [\n // HTLM void elements - aka self-closing tags - aka singletons\n // https://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements\n 'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',\n 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr',\n // NOTE: Optional tags are too complex for a simple list\n // they are hard coded in _do_optional_end_element\n\n // Doctype and xml elements\n '!doctype', '?xml',\n\n // obsolete tags\n // basefont: https://www.computerhope.com/jargon/h/html-basefont-tag.htm\n // isndex: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/isindex\n 'basefont', 'isindex'\n ]);\n this.unformatted = this._get_array('unformatted', []);\n this.content_unformatted = this._get_array('content_unformatted', [\n 'pre', 'textarea'\n ]);\n this.unformatted_content_delimiter = this._get_characters('unformatted_content_delimiter');\n this.indent_scripts = this._get_selection('indent_scripts', ['normal', 'keep', 'separate']);\n\n}\nOptions$7.prototype = new BaseOptions$2();\n\n\n\nvar Options_1$3 = Options$7;\n\nvar options$3 = {\n\tOptions: Options_1$3\n};\n\nvar BaseTokenizer$1 = tokenizer.Tokenizer;\nvar BASETOKEN$1 = tokenizer.TOKEN;\nvar Directives$3 = directives.Directives;\nvar TemplatablePattern$2 = templatablepattern.TemplatablePattern;\nvar Pattern$4 = pattern.Pattern;\n\nvar TOKEN$3 = {\n TAG_OPEN: 'TK_TAG_OPEN',\n TAG_CLOSE: 'TK_TAG_CLOSE',\n ATTRIBUTE: 'TK_ATTRIBUTE',\n EQUALS: 'TK_EQUALS',\n VALUE: 'TK_VALUE',\n COMMENT: 'TK_COMMENT',\n TEXT: 'TK_TEXT',\n UNKNOWN: 'TK_UNKNOWN',\n START: BASETOKEN$1.START,\n RAW: BASETOKEN$1.RAW,\n EOF: BASETOKEN$1.EOF\n};\n\nvar directives_core$2 = new Directives$3(/<\\!--/, /-->/);\n\nvar Tokenizer$3 = function(input_string, options) {\n BaseTokenizer$1.call(this, input_string, options);\n this._current_tag_name = '';\n\n // Words end at whitespace or when a tag starts\n // if we are indenting handlebars, they are considered tags\n var templatable_reader = new TemplatablePattern$2(this._input).read_options(this._options);\n var pattern_reader = new Pattern$4(this._input);\n\n this.__patterns = {\n word: templatable_reader.until(/[\\n\\r\\t <]/),\n single_quote: templatable_reader.until_after(/'/),\n double_quote: templatable_reader.until_after(/\"/),\n attribute: templatable_reader.until(/[\\n\\r\\t =>]|\\/>/),\n element_name: templatable_reader.until(/[\\n\\r\\t >\\/]/),\n\n handlebars_comment: pattern_reader.starting_with(/{{!--/).until_after(/--}}/),\n handlebars: pattern_reader.starting_with(/{{/).until_after(/}}/),\n handlebars_open: pattern_reader.until(/[\\n\\r\\t }]/),\n handlebars_raw_close: pattern_reader.until(/}}/),\n comment: pattern_reader.starting_with(//),\n cdata: pattern_reader.starting_with(//),\n // https://en.wikipedia.org/wiki/Conditional_comment\n conditional_comment: pattern_reader.starting_with(//),\n processing: pattern_reader.starting_with(/<\\?/).until_after(/\\?>/)\n };\n\n if (this._options.indent_handlebars) {\n this.__patterns.word = this.__patterns.word.exclude('handlebars');\n }\n\n this._unformatted_content_delimiter = null;\n\n if (this._options.unformatted_content_delimiter) {\n var literal_regexp = this._input.get_literal_regexp(this._options.unformatted_content_delimiter);\n this.__patterns.unformatted_content_delimiter =\n pattern_reader.matching(literal_regexp)\n .until_after(literal_regexp);\n }\n};\nTokenizer$3.prototype = new BaseTokenizer$1();\n\nTokenizer$3.prototype._is_comment = function(current_token) { // jshint unused:false\n return false; //current_token.type === TOKEN.COMMENT || current_token.type === TOKEN.UNKNOWN;\n};\n\nTokenizer$3.prototype._is_opening = function(current_token) {\n return current_token.type === TOKEN$3.TAG_OPEN;\n};\n\nTokenizer$3.prototype._is_closing = function(current_token, open_token) {\n return current_token.type === TOKEN$3.TAG_CLOSE &&\n (open_token && (\n ((current_token.text === '>' || current_token.text === '/>') && open_token.text[0] === '<') ||\n (current_token.text === '}}' && open_token.text[0] === '{' && open_token.text[1] === '{')));\n};\n\nTokenizer$3.prototype._reset = function() {\n this._current_tag_name = '';\n};\n\nTokenizer$3.prototype._get_next_token = function(previous_token, open_token) { // jshint unused:false\n var token = null;\n this._readWhitespace();\n var c = this._input.peek();\n\n if (c === null) {\n return this._create_token(TOKEN$3.EOF, '');\n }\n\n token = token || this._read_open_handlebars(c, open_token);\n token = token || this._read_attribute(c, previous_token, open_token);\n token = token || this._read_close(c, open_token);\n token = token || this._read_raw_content(c, previous_token, open_token);\n token = token || this._read_content_word(c);\n token = token || this._read_comment_or_cdata(c);\n token = token || this._read_processing(c);\n token = token || this._read_open(c, open_token);\n token = token || this._create_token(TOKEN$3.UNKNOWN, this._input.next());\n\n return token;\n};\n\nTokenizer$3.prototype._read_comment_or_cdata = function(c) { // jshint unused:false\n var token = null;\n var resulting_string = null;\n var directives = null;\n\n if (c === '<') {\n var peek1 = this._input.peek(1);\n // We treat all comments as literals, even more than preformatted tags\n // we only look for the appropriate closing marker\n if (peek1 === '!') {\n resulting_string = this.__patterns.comment.read();\n\n // only process directive on html comments\n if (resulting_string) {\n directives = directives_core$2.get_directives(resulting_string);\n if (directives && directives.ignore === 'start') {\n resulting_string += directives_core$2.readIgnored(this._input);\n }\n } else {\n resulting_string = this.__patterns.cdata.read();\n }\n }\n\n if (resulting_string) {\n token = this._create_token(TOKEN$3.COMMENT, resulting_string);\n token.directives = directives;\n }\n }\n\n return token;\n};\n\nTokenizer$3.prototype._read_processing = function(c) { // jshint unused:false\n var token = null;\n var resulting_string = null;\n var directives = null;\n\n if (c === '<') {\n var peek1 = this._input.peek(1);\n if (peek1 === '!' || peek1 === '?') {\n resulting_string = this.__patterns.conditional_comment.read();\n resulting_string = resulting_string || this.__patterns.processing.read();\n }\n\n if (resulting_string) {\n token = this._create_token(TOKEN$3.COMMENT, resulting_string);\n token.directives = directives;\n }\n }\n\n return token;\n};\n\nTokenizer$3.prototype._read_open = function(c, open_token) {\n var resulting_string = null;\n var token = null;\n if (!open_token) {\n if (c === '<') {\n\n resulting_string = this._input.next();\n if (this._input.peek() === '/') {\n resulting_string += this._input.next();\n }\n resulting_string += this.__patterns.element_name.read();\n token = this._create_token(TOKEN$3.TAG_OPEN, resulting_string);\n }\n }\n return token;\n};\n\nTokenizer$3.prototype._read_open_handlebars = function(c, open_token) {\n var resulting_string = null;\n var token = null;\n if (!open_token) {\n if (this._options.indent_handlebars && c === '{' && this._input.peek(1) === '{') {\n if (this._input.peek(2) === '!') {\n resulting_string = this.__patterns.handlebars_comment.read();\n resulting_string = resulting_string || this.__patterns.handlebars.read();\n token = this._create_token(TOKEN$3.COMMENT, resulting_string);\n } else {\n resulting_string = this.__patterns.handlebars_open.read();\n token = this._create_token(TOKEN$3.TAG_OPEN, resulting_string);\n }\n }\n }\n return token;\n};\n\n\nTokenizer$3.prototype._read_close = function(c, open_token) {\n var resulting_string = null;\n var token = null;\n if (open_token) {\n if (open_token.text[0] === '<' && (c === '>' || (c === '/' && this._input.peek(1) === '>'))) {\n resulting_string = this._input.next();\n if (c === '/') { // for close tag \"/>\"\n resulting_string += this._input.next();\n }\n token = this._create_token(TOKEN$3.TAG_CLOSE, resulting_string);\n } else if (open_token.text[0] === '{' && c === '}' && this._input.peek(1) === '}') {\n this._input.next();\n this._input.next();\n token = this._create_token(TOKEN$3.TAG_CLOSE, '}}');\n }\n }\n\n return token;\n};\n\nTokenizer$3.prototype._read_attribute = function(c, previous_token, open_token) {\n var token = null;\n var resulting_string = '';\n if (open_token && open_token.text[0] === '<') {\n\n if (c === '=') {\n token = this._create_token(TOKEN$3.EQUALS, this._input.next());\n } else if (c === '\"' || c === \"'\") {\n var content = this._input.next();\n if (c === '\"') {\n content += this.__patterns.double_quote.read();\n } else {\n content += this.__patterns.single_quote.read();\n }\n token = this._create_token(TOKEN$3.VALUE, content);\n } else {\n resulting_string = this.__patterns.attribute.read();\n\n if (resulting_string) {\n if (previous_token.type === TOKEN$3.EQUALS) {\n token = this._create_token(TOKEN$3.VALUE, resulting_string);\n } else {\n token = this._create_token(TOKEN$3.ATTRIBUTE, resulting_string);\n }\n }\n }\n }\n return token;\n};\n\nTokenizer$3.prototype._is_content_unformatted = function(tag_name) {\n // void_elements have no content and so cannot have unformatted content\n // script and style tags should always be read as unformatted content\n // finally content_unformatted and unformatted element contents are unformatted\n return this._options.void_elements.indexOf(tag_name) === -1 &&\n (this._options.content_unformatted.indexOf(tag_name) !== -1 ||\n this._options.unformatted.indexOf(tag_name) !== -1);\n};\n\n\nTokenizer$3.prototype._read_raw_content = function(c, previous_token, open_token) { // jshint unused:false\n var resulting_string = '';\n if (open_token && open_token.text[0] === '{') {\n resulting_string = this.__patterns.handlebars_raw_close.read();\n } else if (previous_token.type === TOKEN$3.TAG_CLOSE &&\n previous_token.opened.text[0] === '<' && previous_token.text[0] !== '/') {\n // ^^ empty tag has no content \n var tag_name = previous_token.opened.text.substr(1).toLowerCase();\n if (tag_name === 'script' || tag_name === 'style') {\n // Script and style tags are allowed to have comments wrapping their content\n // or just have regular content.\n var token = this._read_comment_or_cdata(c);\n if (token) {\n token.type = TOKEN$3.TEXT;\n return token;\n }\n resulting_string = this._input.readUntil(new RegExp('', 'ig'));\n } else if (this._is_content_unformatted(tag_name)) {\n\n resulting_string = this._input.readUntil(new RegExp('', 'ig'));\n }\n }\n\n if (resulting_string) {\n return this._create_token(TOKEN$3.TEXT, resulting_string);\n }\n\n return null;\n};\n\nTokenizer$3.prototype._read_content_word = function(c) {\n var resulting_string = '';\n if (this._options.unformatted_content_delimiter) {\n if (c === this._options.unformatted_content_delimiter[0]) {\n resulting_string = this.__patterns.unformatted_content_delimiter.read();\n }\n }\n\n if (!resulting_string) {\n resulting_string = this.__patterns.word.read();\n }\n if (resulting_string) {\n return this._create_token(TOKEN$3.TEXT, resulting_string);\n }\n};\n\nvar Tokenizer_1$2 = Tokenizer$3;\nvar TOKEN_1$2 = TOKEN$3;\n\nvar tokenizer$2 = {\n\tTokenizer: Tokenizer_1$2,\n\tTOKEN: TOKEN_1$2\n};\n\nvar Options$8 = options$3.Options;\nvar Output$3 = output.Output;\nvar Tokenizer$4 = tokenizer$2.Tokenizer;\nvar TOKEN$4 = tokenizer$2.TOKEN;\n\nvar lineBreak$1 = /\\r\\n|[\\r\\n]/;\nvar allLineBreaks$1 = /\\r\\n|[\\r\\n]/g;\n\nvar Printer = function(options, base_indent_string) { //handles input/output and some other printing functions\n\n this.indent_level = 0;\n this.alignment_size = 0;\n this.max_preserve_newlines = options.max_preserve_newlines;\n this.preserve_newlines = options.preserve_newlines;\n\n this._output = new Output$3(options, base_indent_string);\n\n};\n\nPrinter.prototype.current_line_has_match = function(pattern) {\n return this._output.current_line.has_match(pattern);\n};\n\nPrinter.prototype.set_space_before_token = function(value, non_breaking) {\n this._output.space_before_token = value;\n this._output.non_breaking_space = non_breaking;\n};\n\nPrinter.prototype.set_wrap_point = function() {\n this._output.set_indent(this.indent_level, this.alignment_size);\n this._output.set_wrap_point();\n};\n\n\nPrinter.prototype.add_raw_token = function(token) {\n this._output.add_raw_token(token);\n};\n\nPrinter.prototype.print_preserved_newlines = function(raw_token) {\n var newlines = 0;\n if (raw_token.type !== TOKEN$4.TEXT && raw_token.previous.type !== TOKEN$4.TEXT) {\n newlines = raw_token.newlines ? 1 : 0;\n }\n\n if (this.preserve_newlines) {\n newlines = raw_token.newlines < this.max_preserve_newlines + 1 ? raw_token.newlines : this.max_preserve_newlines + 1;\n }\n for (var n = 0; n < newlines; n++) {\n this.print_newline(n > 0);\n }\n\n return newlines !== 0;\n};\n\nPrinter.prototype.traverse_whitespace = function(raw_token) {\n if (raw_token.whitespace_before || raw_token.newlines) {\n if (!this.print_preserved_newlines(raw_token)) {\n this._output.space_before_token = true;\n }\n return true;\n }\n return false;\n};\n\nPrinter.prototype.previous_token_wrapped = function() {\n return this._output.previous_token_wrapped;\n};\n\nPrinter.prototype.print_newline = function(force) {\n this._output.add_new_line(force);\n};\n\nPrinter.prototype.print_token = function(token) {\n if (token.text) {\n this._output.set_indent(this.indent_level, this.alignment_size);\n this._output.add_token(token.text);\n }\n};\n\nPrinter.prototype.indent = function() {\n this.indent_level++;\n};\n\nPrinter.prototype.get_full_indent = function(level) {\n level = this.indent_level + (level || 0);\n if (level < 1) {\n return '';\n }\n\n return this._output.get_indent_string(level);\n};\n\nvar get_type_attribute = function(start_token) {\n var result = null;\n var raw_token = start_token.next;\n\n // Search attributes for a type attribute\n while (raw_token.type !== TOKEN$4.EOF && start_token.closed !== raw_token) {\n if (raw_token.type === TOKEN$4.ATTRIBUTE && raw_token.text === 'type') {\n if (raw_token.next && raw_token.next.type === TOKEN$4.EQUALS &&\n raw_token.next.next && raw_token.next.next.type === TOKEN$4.VALUE) {\n result = raw_token.next.next.text;\n }\n break;\n }\n raw_token = raw_token.next;\n }\n\n return result;\n};\n\nvar get_custom_beautifier_name = function(tag_check, raw_token) {\n var typeAttribute = null;\n var result = null;\n\n if (!raw_token.closed) {\n return null;\n }\n\n if (tag_check === 'script') {\n typeAttribute = 'text/javascript';\n } else if (tag_check === 'style') {\n typeAttribute = 'text/css';\n }\n\n typeAttribute = get_type_attribute(raw_token) || typeAttribute;\n\n // For script and style tags that have a type attribute, only enable custom beautifiers for matching values\n // For those without a type attribute use default;\n if (typeAttribute.search('text/css') > -1) {\n result = 'css';\n } else if (typeAttribute.search(/module|((text|application|dojo)\\/(x-)?(javascript|ecmascript|jscript|livescript|(ld\\+)?json|method|aspect))/) > -1) {\n result = 'javascript';\n } else if (typeAttribute.search(/(text|application|dojo)\\/(x-)?(html)/) > -1) {\n result = 'html';\n } else if (typeAttribute.search(/test\\/null/) > -1) {\n // Test only mime-type for testing the beautifier when null is passed as beautifing function\n result = 'null';\n }\n\n return result;\n};\n\nfunction in_array$2(what, arr) {\n return arr.indexOf(what) !== -1;\n}\n\nfunction TagFrame(parent, parser_token, indent_level) {\n this.parent = parent || null;\n this.tag = parser_token ? parser_token.tag_name : '';\n this.indent_level = indent_level || 0;\n this.parser_token = parser_token || null;\n}\n\nfunction TagStack(printer) {\n this._printer = printer;\n this._current_frame = null;\n}\n\nTagStack.prototype.get_parser_token = function() {\n return this._current_frame ? this._current_frame.parser_token : null;\n};\n\nTagStack.prototype.record_tag = function(parser_token) { //function to record a tag and its parent in this.tags Object\n var new_frame = new TagFrame(this._current_frame, parser_token, this._printer.indent_level);\n this._current_frame = new_frame;\n};\n\nTagStack.prototype._try_pop_frame = function(frame) { //function to retrieve the opening tag to the corresponding closer\n var parser_token = null;\n\n if (frame) {\n parser_token = frame.parser_token;\n this._printer.indent_level = frame.indent_level;\n this._current_frame = frame.parent;\n }\n\n return parser_token;\n};\n\nTagStack.prototype._get_frame = function(tag_list, stop_list) { //function to retrieve the opening tag to the corresponding closer\n var frame = this._current_frame;\n\n while (frame) { //till we reach '' (the initial value);\n if (tag_list.indexOf(frame.tag) !== -1) { //if this is it use it\n break;\n } else if (stop_list && stop_list.indexOf(frame.tag) !== -1) {\n frame = null;\n break;\n }\n frame = frame.parent;\n }\n\n return frame;\n};\n\nTagStack.prototype.try_pop = function(tag, stop_list) { //function to retrieve the opening tag to the corresponding closer\n var frame = this._get_frame([tag], stop_list);\n return this._try_pop_frame(frame);\n};\n\nTagStack.prototype.indent_to_tag = function(tag_list) {\n var frame = this._get_frame(tag_list);\n if (frame) {\n this._printer.indent_level = frame.indent_level;\n }\n};\n\nfunction Beautifier$4(source_text, options, js_beautify, css_beautify) {\n //Wrapper function to invoke all the necessary constructors and deal with the output.\n this._source_text = source_text || '';\n options = options || {};\n this._js_beautify = js_beautify;\n this._css_beautify = css_beautify;\n this._tag_stack = null;\n\n // Allow the setting of language/file-type specific options\n // with inheritance of overall settings\n var optionHtml = new Options$8(options, 'html');\n\n this._options = optionHtml;\n\n this._is_wrap_attributes_force = this._options.wrap_attributes.substr(0, 'force'.length) === 'force';\n this._is_wrap_attributes_force_expand_multiline = (this._options.wrap_attributes === 'force-expand-multiline');\n this._is_wrap_attributes_force_aligned = (this._options.wrap_attributes === 'force-aligned');\n this._is_wrap_attributes_aligned_multiple = (this._options.wrap_attributes === 'aligned-multiple');\n this._is_wrap_attributes_preserve = this._options.wrap_attributes.substr(0, 'preserve'.length) === 'preserve';\n this._is_wrap_attributes_preserve_aligned = (this._options.wrap_attributes === 'preserve-aligned');\n}\n\nBeautifier$4.prototype.beautify = function() {\n\n // if disabled, return the input unchanged.\n if (this._options.disabled) {\n return this._source_text;\n }\n\n var source_text = this._source_text;\n var eol = this._options.eol;\n if (this._options.eol === 'auto') {\n eol = '\\n';\n if (source_text && lineBreak$1.test(source_text)) {\n eol = source_text.match(lineBreak$1)[0];\n }\n }\n\n // HACK: newline parsing inconsistent. This brute force normalizes the input.\n source_text = source_text.replace(allLineBreaks$1, '\\n');\n\n var baseIndentString = source_text.match(/^[\\t ]*/)[0];\n\n var last_token = {\n text: '',\n type: ''\n };\n\n var last_tag_token = new TagOpenParserToken();\n\n var printer = new Printer(this._options, baseIndentString);\n var tokens = new Tokenizer$4(source_text, this._options).tokenize();\n\n this._tag_stack = new TagStack(printer);\n\n var parser_token = null;\n var raw_token = tokens.next();\n while (raw_token.type !== TOKEN$4.EOF) {\n\n if (raw_token.type === TOKEN$4.TAG_OPEN || raw_token.type === TOKEN$4.COMMENT) {\n parser_token = this._handle_tag_open(printer, raw_token, last_tag_token, last_token);\n last_tag_token = parser_token;\n } else if ((raw_token.type === TOKEN$4.ATTRIBUTE || raw_token.type === TOKEN$4.EQUALS || raw_token.type === TOKEN$4.VALUE) ||\n (raw_token.type === TOKEN$4.TEXT && !last_tag_token.tag_complete)) {\n parser_token = this._handle_inside_tag(printer, raw_token, last_tag_token, tokens);\n } else if (raw_token.type === TOKEN$4.TAG_CLOSE) {\n parser_token = this._handle_tag_close(printer, raw_token, last_tag_token);\n } else if (raw_token.type === TOKEN$4.TEXT) {\n parser_token = this._handle_text(printer, raw_token, last_tag_token);\n } else {\n // This should never happen, but if it does. Print the raw token\n printer.add_raw_token(raw_token);\n }\n\n last_token = parser_token;\n\n raw_token = tokens.next();\n }\n var sweet_code = printer._output.get_code(eol);\n\n return sweet_code;\n};\n\nBeautifier$4.prototype._handle_tag_close = function(printer, raw_token, last_tag_token) {\n var parser_token = {\n text: raw_token.text,\n type: raw_token.type\n };\n printer.alignment_size = 0;\n last_tag_token.tag_complete = true;\n\n printer.set_space_before_token(raw_token.newlines || raw_token.whitespace_before !== '', true);\n if (last_tag_token.is_unformatted) {\n printer.add_raw_token(raw_token);\n } else {\n if (last_tag_token.tag_start_char === '<') {\n printer.set_space_before_token(raw_token.text[0] === '/', true); // space before />, no space before >\n if (this._is_wrap_attributes_force_expand_multiline && last_tag_token.has_wrapped_attrs) {\n printer.print_newline(false);\n }\n }\n printer.print_token(raw_token);\n\n }\n\n if (last_tag_token.indent_content &&\n !(last_tag_token.is_unformatted || last_tag_token.is_content_unformatted)) {\n printer.indent();\n\n // only indent once per opened tag\n last_tag_token.indent_content = false;\n }\n\n if (!last_tag_token.is_inline_element &&\n !(last_tag_token.is_unformatted || last_tag_token.is_content_unformatted)) {\n printer.set_wrap_point();\n }\n\n return parser_token;\n};\n\nBeautifier$4.prototype._handle_inside_tag = function(printer, raw_token, last_tag_token, tokens) {\n var wrapped = last_tag_token.has_wrapped_attrs;\n var parser_token = {\n text: raw_token.text,\n type: raw_token.type\n };\n\n printer.set_space_before_token(raw_token.newlines || raw_token.whitespace_before !== '', true);\n if (last_tag_token.is_unformatted) {\n printer.add_raw_token(raw_token);\n } else if (last_tag_token.tag_start_char === '{' && raw_token.type === TOKEN$4.TEXT) {\n // For the insides of handlebars allow newlines or a single space between open and contents\n if (printer.print_preserved_newlines(raw_token)) {\n raw_token.newlines = 0;\n printer.add_raw_token(raw_token);\n } else {\n printer.print_token(raw_token);\n }\n } else {\n if (raw_token.type === TOKEN$4.ATTRIBUTE) {\n printer.set_space_before_token(true);\n last_tag_token.attr_count += 1;\n } else if (raw_token.type === TOKEN$4.EQUALS) { //no space before =\n printer.set_space_before_token(false);\n } else if (raw_token.type === TOKEN$4.VALUE && raw_token.previous.type === TOKEN$4.EQUALS) { //no space before value\n printer.set_space_before_token(false);\n }\n\n if (raw_token.type === TOKEN$4.ATTRIBUTE && last_tag_token.tag_start_char === '<') {\n if (this._is_wrap_attributes_preserve || this._is_wrap_attributes_preserve_aligned) {\n printer.traverse_whitespace(raw_token);\n wrapped = wrapped || raw_token.newlines !== 0;\n }\n\n\n if (this._is_wrap_attributes_force) {\n var force_attr_wrap = last_tag_token.attr_count > 1;\n if (this._is_wrap_attributes_force_expand_multiline && last_tag_token.attr_count === 1) {\n var is_only_attribute = true;\n var peek_index = 0;\n var peek_token;\n do {\n peek_token = tokens.peek(peek_index);\n if (peek_token.type === TOKEN$4.ATTRIBUTE) {\n is_only_attribute = false;\n break;\n }\n peek_index += 1;\n } while (peek_index < 4 && peek_token.type !== TOKEN$4.EOF && peek_token.type !== TOKEN$4.TAG_CLOSE);\n\n force_attr_wrap = !is_only_attribute;\n }\n\n if (force_attr_wrap) {\n printer.print_newline(false);\n wrapped = true;\n }\n }\n }\n printer.print_token(raw_token);\n wrapped = wrapped || printer.previous_token_wrapped();\n last_tag_token.has_wrapped_attrs = wrapped;\n }\n return parser_token;\n};\n\nBeautifier$4.prototype._handle_text = function(printer, raw_token, last_tag_token) {\n var parser_token = {\n text: raw_token.text,\n type: 'TK_CONTENT'\n };\n if (last_tag_token.custom_beautifier_name) { //check if we need to format javascript\n this._print_custom_beatifier_text(printer, raw_token, last_tag_token);\n } else if (last_tag_token.is_unformatted || last_tag_token.is_content_unformatted) {\n printer.add_raw_token(raw_token);\n } else {\n printer.traverse_whitespace(raw_token);\n printer.print_token(raw_token);\n }\n return parser_token;\n};\n\nBeautifier$4.prototype._print_custom_beatifier_text = function(printer, raw_token, last_tag_token) {\n var local = this;\n if (raw_token.text !== '') {\n\n var text = raw_token.text,\n _beautifier,\n script_indent_level = 1,\n pre = '',\n post = '';\n if (last_tag_token.custom_beautifier_name === 'javascript' && typeof this._js_beautify === 'function') {\n _beautifier = this._js_beautify;\n } else if (last_tag_token.custom_beautifier_name === 'css' && typeof this._css_beautify === 'function') {\n _beautifier = this._css_beautify;\n } else if (last_tag_token.custom_beautifier_name === 'html') {\n _beautifier = function(html_source, options) {\n var beautifier = new Beautifier$4(html_source, options, local._js_beautify, local._css_beautify);\n return beautifier.beautify();\n };\n }\n\n if (this._options.indent_scripts === \"keep\") {\n script_indent_level = 0;\n } else if (this._options.indent_scripts === \"separate\") {\n script_indent_level = -printer.indent_level;\n }\n\n var indentation = printer.get_full_indent(script_indent_level);\n\n // if there is at least one empty line at the end of this text, strip it\n // we'll be adding one back after the text but before the containing tag.\n text = text.replace(/\\n[ \\t]*$/, '');\n\n // Handle the case where content is wrapped in a comment or cdata.\n if (last_tag_token.custom_beautifier_name !== 'html' &&\n text[0] === '<' && text.match(/^(|]]>)$/.exec(text);\n\n // if we start to wrap but don't finish, print raw\n if (!matched) {\n printer.add_raw_token(raw_token);\n return;\n }\n\n pre = indentation + matched[1] + '\\n';\n text = matched[4];\n if (matched[5]) {\n post = indentation + matched[5];\n }\n\n // if there is at least one empty line at the end of this text, strip it\n // we'll be adding one back after the text but before the containing tag.\n text = text.replace(/\\n[ \\t]*$/, '');\n\n if (matched[2] || matched[3].indexOf('\\n') !== -1) {\n // if the first line of the non-comment text has spaces\n // use that as the basis for indenting in null case.\n matched = matched[3].match(/[ \\t]+$/);\n if (matched) {\n raw_token.whitespace_before = matched[0];\n }\n }\n }\n\n if (text) {\n if (_beautifier) {\n\n // call the Beautifier if avaliable\n var Child_options = function() {\n this.eol = '\\n';\n };\n Child_options.prototype = this._options.raw_options;\n var child_options = new Child_options();\n text = _beautifier(indentation + text, child_options);\n } else {\n // simply indent the string otherwise\n var white = raw_token.whitespace_before;\n if (white) {\n text = text.replace(new RegExp('\\n(' + white + ')?', 'g'), '\\n');\n }\n\n text = indentation + text.replace(/\\n/g, '\\n' + indentation);\n }\n }\n\n if (pre) {\n if (!text) {\n text = pre + post;\n } else {\n text = pre + text + '\\n' + post;\n }\n }\n\n printer.print_newline(false);\n if (text) {\n raw_token.text = text;\n raw_token.whitespace_before = '';\n raw_token.newlines = 0;\n printer.add_raw_token(raw_token);\n printer.print_newline(true);\n }\n }\n};\n\nBeautifier$4.prototype._handle_tag_open = function(printer, raw_token, last_tag_token, last_token) {\n var parser_token = this._get_tag_open_token(raw_token);\n\n if ((last_tag_token.is_unformatted || last_tag_token.is_content_unformatted) &&\n !last_tag_token.is_empty_element &&\n raw_token.type === TOKEN$4.TAG_OPEN && raw_token.text.indexOf(']*)/);\n this.tag_check = tag_check_match ? tag_check_match[1] : '';\n } else {\n tag_check_match = raw_token.text.match(/^{{(?:[\\^]|#\\*?)?([^\\s}]+)/);\n this.tag_check = tag_check_match ? tag_check_match[1] : '';\n\n // handle \"{{#> myPartial}}\n if (raw_token.text === '{{#>' && this.tag_check === '>' && raw_token.next !== null) {\n this.tag_check = raw_token.next.text.split(' ')[0];\n }\n }\n this.tag_check = this.tag_check.toLowerCase();\n\n if (raw_token.type === TOKEN$4.COMMENT) {\n this.tag_complete = true;\n }\n\n this.is_start_tag = this.tag_check.charAt(0) !== '/';\n this.tag_name = !this.is_start_tag ? this.tag_check.substr(1) : this.tag_check;\n this.is_end_tag = !this.is_start_tag ||\n (raw_token.closed && raw_token.closed.text === '/>');\n\n // handlebars tags that don't start with # or ^ are single_tags, and so also start and end.\n this.is_end_tag = this.is_end_tag ||\n (this.tag_start_char === '{' && (this.text.length < 3 || (/[^#\\^]/.test(this.text.charAt(2)))));\n }\n};\n\nBeautifier$4.prototype._get_tag_open_token = function(raw_token) { //function to get a full tag and parse its type\n var parser_token = new TagOpenParserToken(this._tag_stack.get_parser_token(), raw_token);\n\n parser_token.alignment_size = this._options.wrap_attributes_indent_size;\n\n parser_token.is_end_tag = parser_token.is_end_tag ||\n in_array$2(parser_token.tag_check, this._options.void_elements);\n\n parser_token.is_empty_element = parser_token.tag_complete ||\n (parser_token.is_start_tag && parser_token.is_end_tag);\n\n parser_token.is_unformatted = !parser_token.tag_complete && in_array$2(parser_token.tag_check, this._options.unformatted);\n parser_token.is_content_unformatted = !parser_token.is_empty_element && in_array$2(parser_token.tag_check, this._options.content_unformatted);\n parser_token.is_inline_element = in_array$2(parser_token.tag_name, this._options.inline) || parser_token.tag_start_char === '{';\n\n return parser_token;\n};\n\nBeautifier$4.prototype._set_tag_position = function(printer, raw_token, parser_token, last_tag_token, last_token) {\n\n if (!parser_token.is_empty_element) {\n if (parser_token.is_end_tag) { //this tag is a double tag so check for tag-ending\n parser_token.start_tag_token = this._tag_stack.try_pop(parser_token.tag_name); //remove it and all ancestors\n } else { // it's a start-tag\n // check if this tag is starting an element that has optional end element\n // and do an ending needed\n if (this._do_optional_end_element(parser_token)) {\n if (!parser_token.is_inline_element) {\n printer.print_newline(false);\n }\n }\n\n this._tag_stack.record_tag(parser_token); //push it on the tag stack\n\n if ((parser_token.tag_name === 'script' || parser_token.tag_name === 'style') &&\n !(parser_token.is_unformatted || parser_token.is_content_unformatted)) {\n parser_token.custom_beautifier_name = get_custom_beautifier_name(parser_token.tag_check, raw_token);\n }\n }\n }\n\n if (in_array$2(parser_token.tag_check, this._options.extra_liners)) { //check if this double needs an extra line\n printer.print_newline(false);\n if (!printer._output.just_added_blankline()) {\n printer.print_newline(true);\n }\n }\n\n if (parser_token.is_empty_element) { //if this tag name is a single tag type (either in the list or has a closing /)\n\n // if you hit an else case, reset the indent level if you are inside an:\n // 'if', 'unless', or 'each' block.\n if (parser_token.tag_start_char === '{' && parser_token.tag_check === 'else') {\n this._tag_stack.indent_to_tag(['if', 'unless', 'each']);\n parser_token.indent_content = true;\n // Don't add a newline if opening {{#if}} tag is on the current line\n var foundIfOnCurrentLine = printer.current_line_has_match(/{{#if/);\n if (!foundIfOnCurrentLine) {\n printer.print_newline(false);\n }\n }\n\n // Don't add a newline before elements that should remain where they are.\n if (parser_token.tag_name === '!--' && last_token.type === TOKEN$4.TAG_CLOSE &&\n last_tag_token.is_end_tag && parser_token.text.indexOf('\\n') === -1) ; else {\n if (!(parser_token.is_inline_element || parser_token.is_unformatted)) {\n printer.print_newline(false);\n }\n this._calcluate_parent_multiline(printer, parser_token);\n }\n } else if (parser_token.is_end_tag) { //this tag is a double tag so check for tag-ending\n var do_end_expand = false;\n\n // deciding whether a block is multiline should not be this hard\n do_end_expand = parser_token.start_tag_token && parser_token.start_tag_token.multiline_content;\n do_end_expand = do_end_expand || (!parser_token.is_inline_element &&\n !(last_tag_token.is_inline_element || last_tag_token.is_unformatted) &&\n !(last_token.type === TOKEN$4.TAG_CLOSE && parser_token.start_tag_token === last_tag_token) &&\n last_token.type !== 'TK_CONTENT'\n );\n\n if (parser_token.is_content_unformatted || parser_token.is_unformatted) {\n do_end_expand = false;\n }\n\n if (do_end_expand) {\n printer.print_newline(false);\n }\n } else { // it's a start-tag\n parser_token.indent_content = !parser_token.custom_beautifier_name;\n\n if (parser_token.tag_start_char === '<') {\n if (parser_token.tag_name === 'html') {\n parser_token.indent_content = this._options.indent_inner_html;\n } else if (parser_token.tag_name === 'head') {\n parser_token.indent_content = this._options.indent_head_inner_html;\n } else if (parser_token.tag_name === 'body') {\n parser_token.indent_content = this._options.indent_body_inner_html;\n }\n }\n\n if (!(parser_token.is_inline_element || parser_token.is_unformatted) &&\n (last_token.type !== 'TK_CONTENT' || parser_token.is_content_unformatted)) {\n printer.print_newline(false);\n }\n\n this._calcluate_parent_multiline(printer, parser_token);\n }\n};\n\nBeautifier$4.prototype._calcluate_parent_multiline = function(printer, parser_token) {\n if (parser_token.parent && printer._output.just_added_newline() &&\n !((parser_token.is_inline_element || parser_token.is_unformatted) && parser_token.parent.is_inline_element)) {\n parser_token.parent.multiline_content = true;\n }\n};\n\n//To be used for

tag special case:\nvar p_closers = ['address', 'article', 'aside', 'blockquote', 'details', 'div', 'dl', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hr', 'main', 'nav', 'ol', 'p', 'pre', 'section', 'table', 'ul'];\nvar p_parent_excludes = ['a', 'audio', 'del', 'ins', 'map', 'noscript', 'video'];\n\nBeautifier$4.prototype._do_optional_end_element = function(parser_token) {\n var result = null;\n // NOTE: cases of \"if there is no more content in the parent element\"\n // are handled automatically by the beautifier.\n // It assumes parent or ancestor close tag closes all children.\n // https://www.w3.org/TR/html5/syntax.html#optional-tags\n if (parser_token.is_empty_element || !parser_token.is_start_tag || !parser_token.parent) {\n return;\n\n }\n\n if (parser_token.tag_name === 'body') {\n // A head element\u2019s end tag may be omitted if the head element is not immediately followed by a space character or a comment.\n result = result || this._tag_stack.try_pop('head');\n\n //} else if (parser_token.tag_name === 'body') {\n // DONE: A body element\u2019s end tag may be omitted if the body element is not immediately followed by a comment.\n\n } else if (parser_token.tag_name === 'li') {\n // An li element\u2019s end tag may be omitted if the li element is immediately followed by another li element or if there is no more content in the parent element.\n result = result || this._tag_stack.try_pop('li', ['ol', 'ul']);\n\n } else if (parser_token.tag_name === 'dd' || parser_token.tag_name === 'dt') {\n // A dd element\u2019s end tag may be omitted if the dd element is immediately followed by another dd element or a dt element, or if there is no more content in the parent element.\n // A dt element\u2019s end tag may be omitted if the dt element is immediately followed by another dt element or a dd element.\n result = result || this._tag_stack.try_pop('dt', ['dl']);\n result = result || this._tag_stack.try_pop('dd', ['dl']);\n\n\n } else if (parser_token.parent.tag_name === 'p' && p_closers.indexOf(parser_token.tag_name) !== -1) {\n // IMPORTANT: this else-if works because p_closers has no overlap with any other element we look for in this method\n // check for the parent element is an HTML element that is not an ,