{"version":3,"sources":["jsdelivr-header.js","/npm/javascript-to-php@0.1.7-c/index.js"],"names":[],"mappings":"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","file":"/npm/javascript-to-php@0.1.7-c/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/javascript-to-php@0.1.7-c/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","var core = require('./core'),\n    scope = require('./scope'),\n    utils = require('./utils'),\n    espree = require('espree');\n\nmodule.exports = function(code, options) {\n  options = options || {};\n  if (options.braced) {\n    // special option to handle code inside braced regions only\n    var nest = 0, quote = null, outside = '', inside = '';\n    var noptions = Object.assign({}, options, {\n      braced: false, watermark: false, noOpenTag: true, indent: 1,\n    });\n    if (options.watermark) { outside += `/* ${options.watermark} */\\n`; }\n    code.split(\n      //  /([{}]|\\/\\*(?:(?!\\*\\/).)*\\*\\/|\\/\\/[^\\n]*(?:\\n|$)|\"[^\"]*\"|'[^']'|\\[[^\\]]*\\])/mg\n      /([{}'\"\\[\\]]|\\/\\*|\\*\\/|\\/\\/|\\n)/g\n    ).forEach(function(chunk) {\n      var isStartQuote = (nest === 0) &&\n          (chunk==='\"' || chunk===\"'\" || chunk==='[' || chunk==='/*' || chunk==='//');\n      if (quote || isStartQuote) {\n        var trailingBackslash = outside.endsWith('\\\\');\n        outside += chunk;\n        if (chunk === quote && !trailingBackslash) { quote = null; }\n        else if (!quote) {\n          switch (chunk) {\n          case '/*' : quote = '*/'; break;\n          case '//': quote = '\\n'; break;\n          case '[': quote = ']'; break;\n          default: quote = chunk; break;\n          }\n        }\n        return;\n      }\n      if (chunk==='}') { nest--; }\n      if (nest <= 0) {\n        if (inside) {\n          outside += module.exports(inside, noptions);\n          inside = '';\n        }\n        outside += chunk;\n        nest = 0;\n      } else {\n        inside += chunk;\n      }\n      if (chunk==='{') { nest++; }\n    });\n    if (inside) { outside += module.exports(inside, noptions); }\n    return outside;\n  }\n  var useConciseArrays = (options.conciseArrays === false) ? false : true;\n  var ast = espree.parse(code, {\n    loc : true,\n    range : true,\n    tokens : true,\n    comment : true,\n    attachComment: true,\n    ecmaFeatures: {\n      arrowFunctions: true, // enable parsing of arrow functions\n      blockBindings: true, // enable parsing of let/const\n      destructuring: true, // enable parsing of destructured arrays and objects\n      regexYFlag: true, // enable parsing of regular expression y flag\n      regexUFlag: true, // enable parsing of regular expression u flag\n      templateStrings: true, // enable parsing of template strings\n      binaryLiterals: true, // enable parsing of binary literals\n      octalLiterals: true, // enable parsing of ES6 octal literals\n      unicodeCodePointEscapes: true, // enable parsing unicode code point escape sequences\n      defaultParams: true, // enable parsing of default parameters\n      restParams: true, // enable parsing of rest parameters\n      forOf: true, // enable parsing of for-of statement\n      objectLiteralComputedProperties: true, // enable parsing computed object literal properties\n      objectLiteralShorthandMethods: true, // enable parsing of shorthand object literal methods\n      objectLiteralShorthandProperties: true, // enable parsing of shorthand object literal properties\n      objectLiteralDuplicateProperties: true, // Allow duplicate object literal properties (except '__proto__')\n      generators: true, // enable parsing of generators/yield\n      spread: true, // enable parsing spread operator\n      superInFunctions: true, // enable super in functions\n      classes: true, // enable parsing classes\n      newTarget: false, // enable parsing of new.target\n      modules: true, // enable parsing of modules\n      jsx: true, // enable React JSX parsing\n      globalReturn: true, // enable return in global scope\n      experimentalObjectRestSpread: true // allow experimental object rest/spread\n    }\n  });\n  var tokenStartMap = Object.create(null), tokenEndMap = Object.create(null);\n  var locToKey = function(loc) {\n    return loc.line + '-' + loc.column;\n  };\n  (function() {\n    var lines = code.split(/\\n/g);\n    // slideFwd and slideBck skip over whitespace\n    var slideFwd = function(loc) {\n      loc = {line: loc.line, column: loc.column};\n      while (loc.line <= lines.length) {\n        var l = lines[loc.line - 1];\n        var c = l[loc.column];\n        if (!/[ \\t\\r\\n]/.test(c)) break;\n        loc.column++;\n        if (loc.column >= l.length) { loc.column = 0; loc.line++; }\n      }\n      return loc;\n    };\n    var slideBck = function(loc) {\n      loc = {line: loc.line, column: loc.column};\n      while (loc.line >= 1) {\n        var l = lines[loc.line - 1];\n        var c = l[loc.column - 1];\n        if (!/[ \\t\\r\\n]/.test(c)) break;\n        loc.column--;\n        if (loc.column < 0) {\n          loc.line--;\n          loc.column = lines[loc.line - 1].length - 1;\n        }\n      }\n      return loc;\n    };\n    ast.tokens.forEach(function(t) {\n      tokenStartMap[locToKey(slideBck(t.loc.start))] = t;\n      tokenEndMap[locToKey(slideFwd(t.loc.end))] = t;\n    });\n  })();\n\n  var rootScope = scope.create(ast, scope.KIND_ROOT);\n  function Emitter() {\n    this.buffer = '';\n    this.line = 1;\n    this.insertionPoints = [];\n    this.indentLevel = 0;\n  }\n  Emitter.prototype.toString = function() { return this.buffer; };\n  Emitter.prototype.emit = function(str) {\n    this.buffer += str;\n  };\n  Emitter.prototype.nl = function() {\n    this.buffer = this.buffer.replace(/[ \\t]+$/, '') + '\\n';\n    for (var i = 0; i < this.indentLevel; i++) {\n      this.buffer += '\\t';\n    }\n    this.line++;\n  }\n  Emitter.prototype.block = function(open, f, close) {\n    var firstline = this.line;\n    this.emit(open); this.emit(' ');\n    var checkpoint = this.buffer.length;\n    this.incrIndent();\n    f();\n    if (this.line > firstline) {\n      this.ensureNl();\n    } else if (this.buffer.length !== checkpoint) {\n      this.emit(' ');\n    } else {\n      // no content in block => no space\n      this.buffer = this.buffer.replace(/[\\t ]+$/, '');\n    }\n    this.decrIndent();\n    this.emit(close);\n  };\n  Emitter.prototype.incrIndent = function() {\n    this.indentLevel++;\n    if (/\\t$/.test(this.buffer)) { this.emit('\\t'); }\n  }\n  Emitter.prototype.decrIndent = function() {\n    this.indentLevel--;\n    if (/\\t$/.test(this.buffer)) {\n      this.buffer = this.buffer.slice(0, this.buffer.length - 1);\n    }\n  }\n  Emitter.prototype.locStart = function(node) {\n    if (node.leadingComments && node.leadingComments.length) {\n      node.leadingComments.forEach(function(c) {\n        this.emitComment(c);\n      }, this);\n    }\n    if (node.type === 'Program') { return; }\n    if (node && node.loc) {\n      while (node.loc.start.line > this.line) {\n        this.nl();\n      }\n      this.line = node.loc.start.line;\n    }\n    // Hack for preserving parentheses from the original\n    if (!(node && node.suppressParens)) {\n      var startT = node && node.loc && tokenEndMap[locToKey(node.loc.start)];\n      var endT = node && node.loc && tokenStartMap[locToKey(node.loc.end)];\n      if (\n        node.forceParens ||\n          (utils.isType(startT, 'Punctuator') && startT.value === '(' &&\n           utils.isType(endT, 'Punctuator') && endT.value === ')')\n      ) {\n        this.emit('( ');\n      }\n    }\n  };\n  Emitter.prototype.locEnd = function(node) {\n    // Hack for preserving parentheses from the original\n    if (!(node && node.suppressParens)) {\n      var startT = node && node.loc && tokenEndMap[locToKey(node.loc.start)];\n      var endT = node && node.loc && tokenStartMap[locToKey(node.loc.end)];\n      if (node.forceParens ||\n          (utils.isType(startT, 'Punctuator') && startT.value === '(' &&\n           utils.isType(endT, 'Punctuator') && endT.value === ')')\n         ) {\n        if (!this.endsInNl()) this.emit(' ');\n        this.emit(')');\n      }\n    }\n    if (node && node.loc) {\n      while (node.loc.end.line > this.line) {\n        this.nl();\n      }\n      this.line = node.loc.end.line;\n    }\n    if (node.trailingComments && node.trailingComments.length) {\n      node.trailingComments.forEach(function(c) {\n        this.emitComment(c);\n      }, this);\n    }\n  };\n  Emitter.prototype.emitComment = function(c) {\n    if (c.emitted) { return; }\n    this.locStart(c);\n    if (c.type==='Block') {\n      this.emit('/*');\n      c.value.split(/\\n/).forEach(function(l, idx) {\n        if (idx > 0) { this.nl(); }\n        this.emit(l.replace(/^\\t+/, ''));\n      }, this);\n      this.emit('*/');\n    } else {\n      this.emit('//' + c.value); this.nl();\n    }\n    c.emitted = true;\n  };\n  Emitter.prototype.endsInNl = function() {\n    return /\\n[ \\t]*$/.test(this.buffer);\n  };\n  Emitter.prototype.isSemiLast = function() {\n    return this.buffer.match(/;\\n?[ ]*$/);\n  }\n  Emitter.prototype.ensureSemi = function() {\n    if (!emitter.isSemiLast()) { this.emit('; '); }\n  };\n  Emitter.prototype.ensureNl = function() {\n    if (!this.endsInNl()) {\n      this.nl();\n    }\n  };\n  Emitter.prototype.replaceSemiWithComma = function() {\n    this.buffer = this.buffer.replace(/;([ \\t]*)$/, ', $1');\n  };\n  Emitter.prototype.pushInsertionPoint = function() {\n    this.insertionPoints.push(this.buffer.length);\n  }\n  Emitter.prototype.popInsertionPoint = function() {\n    this.insertionPoints.pop();\n  }\n  Emitter.prototype.insertAt = function(depth, str) {\n    var idx = this.insertionPoints.length - depth - 1;\n    var at = this.insertionPoints[idx];\n    this.buffer = this.buffer.slice(0, at) + str + this.buffer.slice(at);\n    while (++idx < this.insertionPoints.length) {\n      this.insertionPoints[idx] += str.length;\n    }\n  }\n  var emitter = new Emitter();\n  if (options.indent) { emitter.indentLevel = options.indent; }\n\n  function handleImport(parent, node) {\n    node.declarations.forEach(function(d) {\n      if (d.type !== 'VariableDeclarator') { return; }\n      scope.get(parent).register(d);\n      d.isImport = true;\n      // the RHS is require('..some string..') but we're going to ignore that\n      if (d.id.type === 'ObjectPattern') {\n        emitter.locStart(d);\n        d.id.properties.forEach(function(p, idx) {\n          scope.get(parent).register({\n            type: 'VariableDeclarator',\n            id: { type: 'Identifier', name: p.value.name },\n            isImport: true,\n          });\n          if (idx > 0) { emitter.nl(); }\n          var name = utils.classize(p.key.name);\n          if (options.namespace) { name = options.namespace + \"\\\\\" + name; }\n          emitter.emit(\"use \" + name);\n          if (p.key.name !== p.value.name || options.namespace) {\n            emitter.emit(\" as \" + utils.classize(p.value.name));\n          }\n          emitter.emit(\";\");\n        });\n        emitter.locEnd(d);\n      } else if (d.id.type === 'Identifier') {\n        var name = d.id.name;\n        emitter.locStart(d);\n        if (options.namespace) {\n          emitter.emit(`use ${options.namespace}\\\\${name} as ${name};`);\n        } else {\n          emitter.emit(`use ${name};`);\n        }\n        emitter.locEnd(d);\n      }\n    });\n  }\n\n  function visit(node, parent) {\n    var semicolon = false;\n\n    // set parent node\n    if (parent) { node.parent = parent; }\n    if (!node.suppressLoc) { emitter.locStart(node); }\n\n    if (utils.isType(node, /^(Program|BlockStatement|ClassBody)$/)) {\n      // Skip strictness declaration\n      if (utils.isType(node.body[0], 'ExpressionStatement') &&\n          utils.isType(node.body[0].expression, 'Literal') &&\n          node.body[0].expression.raw.match(/^[\"']use strict[\"']$/)) {\n        emitter.locStart(node.body[0]); // flush leading comment\n        node.body.shift();\n      }\n      if (node.type === 'Program') {\n        if (options.namespace && !options.noOpenTag) {\n          // Add optional namespace.\n          emitter.emit(`namespace ${options.namespace};`);\n          emitter.nl();\n        }\n\n        // skip core update require\n        while (utils.isType(node.body[0], 'ExpressionStatement') &&\n               utils.isType(node.body[0].expression, 'CallExpression') &&\n               utils.isId(node.body[0].expression.callee, 'require')) {\n          node.body.shift(); // discard this\n        }\n\n        // Look for require declarations\n        while (utils.isType(node.body[0], 'VariableDeclaration') &&\n               utils.isType(node.body[0].declarations[0], 'VariableDeclarator') &&\n               utils.isType(node.body[0].declarations[0].init, 'CallExpression') &&\n               utils.isId(node.body[0].declarations[0].init.callee, 'require')) {\n          handleImport(node, node.body.shift());\n        }\n      }\n\n      for (var i=0,length = node.body.length;i<length;i++) {\n        visit(node.body[i], node);\n      }\n\n    } else if (node.type == \"VariableDeclaration\") {\n      // declaration of one or multiple variables\n      for (var i=0,length=node.declarations.length;i<length;i++) {\n        visit(node.declarations[i], node);\n      }\n\n    } else if (node.type == \"VariableDeclarator\" && node.id.type === 'ObjectPattern') {\n      var tmpName = scope.get(node).getTmpName();\n      visit({\n        type: 'VariableDeclarator',\n        id: { type: 'Identifier', name: tmpName },\n        init: node.init,\n      }, node);\n      node.id.properties.forEach(function(p) {\n        visit({\n          type: 'VariableDeclarator',\n          id: p.value,\n          init: {\n            type: 'MemberExpression',\n            object: {\n              type: 'Identifier',\n              name: tmpName,\n            },\n            property: p.key,\n          },\n        }, node);\n      });\n    } else if (node.type == \"VariableDeclarator\") {\n      scope.get(node).register(node);\n      var isForStatement = node.parent &&\n          utils.isType(node.parent.parent, /^For(In|Of|)Statement$/);\n      if (isForStatement) { emitter.replaceSemiWithComma(); }\n\n      // declaration of one variable\n      emitter.emit('$' + node.id.name);\n\n      if (node.init) {\n        emitter.emit(' = ');\n        visit(node.init, node);\n        semicolon = true;\n      } else if (!isForStatement || node.parent.parent==='ForStatement') {\n        emitter.emit(' = null');\n        semicolon = true;\n      }\n\n    } else if (utils.isId(node, \"undefined\")) {\n      emitter.emit(\"null\");\n    } else if (node.type == \"Identifier\") {\n      var identifier = (node.name || node.value);\n\n      if (!node.static && !node.isCallee && !node.isMemberExpression) {\n        var targetDefinition = scope.get(node).getDefinition(node);\n        if (utils.isType(node.parent && node.parent.parent, \"NewExpression\") &&\n            node.parent.callee === node) {\n          emitter.emit(identifier);\n        } else if (targetDefinition && targetDefinition.isImport) {\n          emitter.emit(identifier + '::class');\n        } else {\n          emitter.emit('$' + identifier);\n        }\n      } else {\n        emitter.emit(identifier);\n      }\n\n    } else if (node.type == \"Punctuator\") {\n      emitter.emit(node.value);\n\n    } else if (node.type == \"Literal\") {\n      if (node.regex) {\n        emitter.emit(\"/* RegExp */ \" + utils.stringify(node.raw));\n      } else if (typeof node.value === 'string' && node.value !== 'undefined') {\n        emitter.emit(utils.stringify(node.value));\n      } else {\n        var value = (node.raw.match(/^[\"']undefined[\"']$/)) ? \"NULL\" : node.raw;\n        emitter.emit(value);\n      }\n    } else if (node.type == \"BinaryExpression\" || node.type == \"LogicalExpression\") {\n\n      if (node.operator == 'in') {\n        visit({\n          type: 'CallExpression',\n          callee: {\n            type: 'Identifier',\n            name: 'isset',\n          },\n          arguments: [{\n            type: 'MemberExpression',\n            computed: true,\n            object: node.right,\n            property: node.left\n          }]\n        }, node);\n\n      } else {\n\n        // test for two strings.\n        var leftDefinition = scope.get(node).getDefinition(node.left);\n        var rightDefinition = scope.get(node).getDefinition(node.right);\n\n        if (leftDefinition && rightDefinition) {\n          if (leftDefinition.type == \"VariableDeclarator\" && rightDefinition.type == \"VariableDeclarator\") {\n            if (leftDefinition.init && utils.isString(leftDefinition.init) &&\n                rightDefinition.init && utils.isString(rightDefinition.init)) {\n              if (/\\+/.test(node.operator)) {\n                node.operator = node.operator.replace('+', '.');\n                node.dataType = 'String';\n              }\n            }\n          }\n        }\n        visit(node.left, node);\n        emitter.emit(\" \");\n        emitter.pushInsertionPoint();\n        emitter.emit(\" \");\n        emitter.incrIndent();\n        visit(node.right, node);\n        emitter.decrIndent();\n        if (utils.isString(node.left) || utils.isString(node.right)) {\n          if (/\\+/.test(node.operator)) {\n            node.operator = node.operator.replace('+', '.');\n            node.dataType = 'String';\n          }\n        }\n        emitter.insertAt(0, node.operator);\n        emitter.popInsertionPoint();\n      }\n\n    } else if (node.type == \"AssignmentExpression\" && node.left.type == \"ObjectPattern\") {\n      var tmpName = scope.get(node).getTmpName();\n      var expressions = [\n          {\n            type: 'AssignmentExpression',\n            operator: '=',\n            left: {\n              type: 'Identifier',\n              name: tmpName,\n            },\n            right: node.right,\n          },\n      ];\n      node.left.properties.forEach(function(p) {\n        expressions.push({\n          type: 'AssignmentExpression',\n          operator: '=',\n          left: p.value,\n          right: {\n            type: 'MemberExpression',\n            object: {\n              type: 'Identifier',\n              name: tmpName,\n            },\n            property: p.key,\n          },\n        });\n      });\n      // Don't return an assignment expression when visiting the sequence\n      expressions.push({\n        type: \"Literal\",\n        value: null,\n        raw: \"null\",\n      });\n      visit({\n        type: 'SequenceExpression',\n        expressions\n      }, node);\n    } else if (node.type == \"AssignmentExpression\" || node.type == \"AssignmentPattern\") {\n      scope.get(node).register(node.left);\n\n      visit(node.left, node);\n      emitter.emit(\" \" + (node.operator || \"=\") + \" \");\n      visit(node.right, node);\n\n    } else if (node.type == \"ConditionalExpression\") {\n      emitter.block('(', function() {\n        node.test.suppressParens = true;\n        visit(node.test, node);\n      }, ')');\n      emitter.emit(' ? ');\n      visit(node.consequent, node);\n      emitter.emit(' : ');\n      visit(node.alternate, node);\n\n    } else if (node.type == \"UnaryExpression\") {\n\n      // override typeof unary expression\n      if (node.operator == 'typeof') {\n        visit({\n          type: 'CallExpression',\n          callee: {\n            type: 'Identifier',\n            name: 'gettype',\n          },\n          arguments: [node.argument]\n        }, node);\n\n        // override delete unary expression\n      } else if (node.operator == 'delete') {\n        visit({\n          type: 'CallExpression',\n          callee: {\n            type: 'Identifier',\n            name: 'unset',\n          },\n          arguments: [node.argument]\n        }, node);\n\n      } else {\n        emitter.emit(node.operator);\n        visit(node.argument, node);\n      }\n\n    } else if (node.type == \"ExpressionStatement\") {\n      if (node.expression.type === 'Literal' && node.expression.raw.match(/^[\"']use strict[\"']$/)) {\n        // Ignore strictness declarations.\n        return;\n      }\n      var iife = \"\";\n\n      var isIIFE = (\n        node.expression.type === \"CallExpression\" && (\n          node.expression.callee.type === \"FunctionExpression\" ||\n          node.expression.callee.type === \"ArrowFunctionExpression\"\n        )\n      );\n\n      // IIFE\n      if (isIIFE) {\n        node.expression.isIIFE = true;\n        node.expression.suppressParens = true;\n        iife = \"call_user_func( \";\n      }\n\n      emitter.emit(iife);\n      visit(node.expression, node);\n      semicolon = true;\n\n    } else if (node.type == \"CallExpression\") {\n\n      var calleeDefined = scope.get(node).getDefinition(node.callee);\n      node = core.evaluate(node);\n\n      node.callee.isCallee = (!calleeDefined || calleeDefined && (calleeDefined.type != \"Identifier\" &&\n        calleeDefined.type != \"VariableDeclarator\"));\n\n      if (node.parent && node.parent.arguments === false &&\n          utils.isType(node.parent.parent, 'ExpressionStatement') &&\n          utils.isId(node.callee, 'array_push') &&\n          node.arguments.length === 2) {\n        // Special case syntax\n        visit(node.arguments[0], node);\n        emitter.emit('[] = ');\n        visit(node.arguments[1], node);\n        emitter.locEnd(node);\n        return;\n      }\n\n      if (node.callee.type === 'Super') {\n        emitter.emit('parent::__construct');\n      } else {\n        visit(node.callee, node);\n      }\n\n      // inline anonymous call\n      if (\n        (node.callee.isCallee && node.callee.type == \"FunctionDeclaration\") ||\n        node.type == \"ArrowFunctionExpression\"\n      ) {\n        var identifier = null;\n        if (node.parent.type == \"VariableDeclarator\") {\n          identifier = node.parent.id.name;\n\n        } else if (node.parent.type == \"AssignmentExpression\") {\n          identifier = node.parent.left.name;\n        }\n        if (!node.callee.isSequence) {\n          emitter.emit(\";\");\n          emitter.nl();\n          emitter.emit(\"$\" + identifier + \" = \" + \"$\" + identifier);\n        }\n      }\n\n      if (node.arguments) {\n        var arguments = [];\n\n        emitter.block(\n          node.isIIFE ? (node.arguments.length ? ',' : '') : '(', function() {\n            for (var i=0, length = node.arguments.length; i < length; i++) {\n              if (node.arguments.length===1) {\n                node.arguments[i].suppressParens=true;\n              }\n              visit(node.arguments[i], node);\n              if ((i+1) < length) { emitter.emit(', '); }\n            }\n          }, ')'\n        );\n      }\n\n      // allow semicolon if parent node isn't MemberExpression or Property\n      if (node.parent && node.parent.type == \"ExpressionStatement\") {\n        semicolon = true;\n      }\n\n    } else if (node.type == \"MemberExpression\") {\n      var newNode = core.evaluate(node);\n\n      if (node != newNode) {\n        // fix parent node type\n        visit(newNode, node.parent);\n\n      } else {\n\n        var object, property;\n\n        if (node.object.type == \"MemberExpression\" && node.object.object && node.object.property) {\n          object = node.object.object,\n          property = node.object.property;\n        } else {\n          object = node.object;\n          property = node.property;\n        }\n\n        object.static = (object.name || object.value || \"\").match(/^[A-Z]/);\n        property.static = String(property.name || property.value || \"\").match(/^[A-Z]/);\n        var targetDefinition = scope.get(node).getDefinition(object);\n        if (\n          node.object.type === 'Identifier' &&\n          targetDefinition && targetDefinition.isImport\n        ) {\n          object.static = true;\n        }\n\n        var accessor;\n        if (node.property.static && object.static) {\n          accessor = \"\\\\\"; // namespace\n        } else if ((property.static || object.static) || object.type == \"Super\") {\n          accessor = \"::\"; // static\n        } else {\n          accessor = \"->\"; // instance\n        }\n\n        if (node.computed) {\n          visit(node.object, node);\n          emitter.block('[', function() {\n            visit(node.property, node);\n          }, ']');\n        } else {\n          node.property.isMemberExpression = true;\n          visit(node.object, node);\n          emitter.emit(accessor);\n          visit(node.property, node);\n        }\n      }\n\n    } else if (node.type == \"FunctionDeclaration\" ||\n      node.type == \"ArrowFunctionExpression\") {\n      var defaults = node.defaults || [];\n\n      emitter.emit(\"function \");\n      if (node.id) {\n        if (typeof node.id.name === 'string') {\n          emitter.emit(node.id.name);\n        } else if (utils.isType(node.id.name, 'Identifier')) {\n          // PHP doesn't support an identifier here, so suppress it.\n          emitter.emit(\"/* \" + node.id.name.name + \" */\");\n        }\n      }\n      emitter.block('(', function() {\n\n        // function declaration creates a new scope\n        scope.create(node);\n\n        // compute function params\n        for (var i=0; i < node.params.length; i++) {\n          if (defaults[i]) {\n            visit({\n              type: \"BinaryExpression\",\n              left: node.params[i],\n              operator: '=',\n              right: defaults[i]\n            }, node);\n          } else {\n            if (node.params.length===1) { node.params[i].suppressParens=true; }\n            visit(node.params[i], node)\n          }\n          if ((i+1) < node.params.length) {\n            emitter.emit(', ');\n          }\n\n          // register parameter identifiers\n          if (scope.get(node).parent) {\n            scope.get(node).register(node.params[i]);\n          }\n        }\n      }, ')');\n      emitter.emit(' ');\n      emitter.pushInsertionPoint();\n      emitter.emit('{');\n      emitter.pushInsertionPoint();\n      emitter.block('', function() {\n\n        visit(node.body, node); /* function contents */\n        var using = scope.get(node).using\n            // XXX I don't understand why I have to do this:\n            .filter(function(u) { return u!==undefined;});\n\n        // try to use parent's variables\n        // http://php.net/manual/pt_BR/functions.anonymous.php\n        if (using.length > 0 &&\n            !utils.isType(node.parent, /^(Program|MethodDefinition)$/)) {\n          emitter.insertAt(1, \"use ( \" + using.map(function(identifier) {\n            return \"&$\" + identifier;\n          }).join(', ') + \" ) \");\n        }\n\n        // workaround when scope doesn't allow to have the `use` keyword.\n        if (node.parent.type === \"Program\") {\n          emitter.insertAt(0, using.map(function(identifier) {\n            return `\\n\\tglobal $${identifier};`;\n          }).join(''));\n        }\n\n        if (node.expression) {\n          // x => x * 2\n          emitter.insertAt(0, 'return ');\n          emitter.emit(';');\n        }\n      }, '}');\n      emitter.popInsertionPoint();\n      emitter.popInsertionPoint();\n\n    } else if (node.type == \"ObjectExpression\") {\n      emitter.block(useConciseArrays ? '[' : 'array(', function() {\n        for (var i=0; i < node.properties.length; i++) {\n          visit(node.properties[i], node);\n          if ((i+1) < node.properties.length) { emitter.emit(', '); }\n        }\n      }, useConciseArrays ? ']' : ')');\n\n    } else if (node.type == \"ArrayExpression\") {\n      emitter.block(useConciseArrays ? '[' : 'array(', function() {\n        for (var i=0; i < node.elements.length; i++) {\n          visit(node.elements[i], node);\n          if ((i+1) < node.elements.length) { emitter.emit(', '); }\n        }\n      }, useConciseArrays ? ']' : ')');\n\n    } else if (node.type == \"Property\") {\n      var property = (node.key.type == 'Identifier') ? node.key.name : node.key.value;\n      if (typeof(property)==='string') { property = utils.stringify(property); }\n      emitter.emit(String(property) + ' => ');\n      visit(node.value, node);\n\n    } else if (node.type == \"ReturnStatement\") {\n      semicolon = true;\n      emitter.emit('return');\n\n      if (node.argument) {\n        emitter.emit(' ');\n        visit(node.argument, node);\n      }\n\n    } else if (node.type == \"ClassDeclaration\") {\n      emitter.emit(\"class \" + node.id.name + \" \");\n\n      if (node.superClass) {\n        emitter.emit(\"extends \" + node.superClass.name + \" \");\n      }\n\n      var s = scope.create(node);\n      emitter.emit('{'); emitter.incrIndent();\n      visit(node.body, node);\n\n      if (s.getters.length > 0) {\n        emitter.emit(\"function __get($_property) \");\n        emitter.block('{', function() {\n          for (var i=0;i<s.getters.length;i++) {\n            emitter.nl();\n            emitter.emit(\"if ($_property === '\"+s.getters[i].key.name+\"') \");\n            emitter.block('{', function() {\n              visit(s.getters[i].value.body, node);\n            }, '}');\n          }\n          emitter.nl();\n        }, '}');\n        emitter.nl();\n      }\n\n      if (s.setters.length > 0) {\n        emitter.emit(\"function __set($_property, $value) \");\n        emitter.block('{', function() {\n          for (var i=0;i<s.setters.length;i++) {\n            emitter.nl();\n            emitter.emit(\"if ($_property === '\"+s.setters[i].key.name+\"') \");\n            emitter.block('{', function() {\n              visit(s.setters[i].value.body, node);\n            }, '}');\n          }\n        }, '}');\n        emitter.nl();\n      }\n\n      emitter.decrIndent();\n      emitter.emit(\"}\");\n\n\n    } else if (node.type == \"MethodDefinition\") {\n      scope.get(node).register(node);\n\n      // define getters and setters on scope\n      if (node.kind == \"get\" || node.kind == \"set\") {\n        return;\n      }\n\n      var isConstructor = (node.key.name == \"constructor\");\n      if (isConstructor) { node.key.name = \"__construct\"; }\n\n      // Re-use FunctionDeclaration structure for method definitions\n      node.value.type = \"FunctionDeclaration\";\n      node.value.id = { name: node.key.name };\n\n      // every method is public.\n      emitter.emit(\"public \");\n      if (node.static) { emitter.emit(\"static \"); }\n      visit(node.value, node);\n\n      // try to define public properties there were defined on constructor\n      if (isConstructor) {\n        node.key.name = \"__construct\";\n        var definitions = scope.get(node.value).definitions;\n        for(var i in definitions) {\n          if (definitions[i] && definitions[i].type == \"MemberExpression\") {\n            definitions[i].property.isMemberExpression = false;\n            emitter.nl();\n            if (definitions[i].parent.type === 'AssignmentExpression' &&\n                definitions[i].parent.parent.type==='ExpressionStatement') {\n              var p = definitions[i].parent.parent;\n              (p.leadingComments || []).forEach(function(c) {\n                if (c.type === 'Block') { /* repeat property doc comments */\n                  c.emitted=false;\n                }\n              });\n              emitter.locStart(p);\n             }\n            emitter.emit('public ');\n            definitions[i].property.suppressLoc = true;\n            visit(definitions[i].property, null);\n            emitter.emit(\"; \");\n            //emitter.locEnd(definitions[i].property);\n          }\n        }\n      }\n\n    } else if (node.type == \"ThisExpression\") {\n      emitter.emit(\"$this\");\n\n    } else if (node.type == \"Super\") {\n      emitter.emit(\"parent\");\n\n    } else if (node.type == \"IfStatement\") {\n      emitter.emit(\"if \");\n      emitter.block('(', function() {\n        node.test.suppressParens = true;\n        visit(node.test, node);\n      }, ')');\n      emitter.emit(' ');\n      emitter.block('{', function() {\n        visit(node.consequent, node);\n      }, '}');\n\n      if (node.alternate) {\n        emitter.emit(\" else\");\n        if (utils.isType(node.alternate, \"IfStatement\") && !node.alternate.leadingComments) {\n          /* suppress the space to create `elseif` token */\n        } else {\n          emitter.emit(\" \");\n        }\n\n        if (utils.isType(node.alternate, \"BlockStatement\")) {\n          emitter.block('{', function() {\n            visit(node.alternate, node);\n          }, '}');\n\n        } else {\n          visit(node.alternate, node)\n        }\n      }\n\n    } else if (node.type == \"SequenceExpression\" && node.parent.type === 'ForStatement') {\n\n      // PHP doesn't really have a true SequenceExpression (aka comma operator)\n      // This version works iff the sequence expression is in a for loop:\n      for (var i=0;i<node.expressions.length;i++) {\n        visit(node.expressions[i], node);\n        if ((i+1) < node.expressions.length) {\n          emitter.emit(', ');\n        }\n      }\n\n    } else if (node.type == \"SequenceExpression\") {\n      // This is a completely general version\n      visit({\n        type: 'CallExpression',\n        loc: node.loc,\n        callee: {\n          isSequence: true,\n          forceParens: true,\n          type: 'FunctionExpression',\n          id: null,\n          params: [],\n          body: {\n            type: 'BlockStatement',\n            body: node.expressions.map(function(e, idx) {\n              if (idx < node.expressions.length - 1) {\n                return {\n                  type: 'ExpressionStatement',\n                  expression: e,\n                };\n              } else {\n                return {\n                  type: 'ReturnStatement',\n                  argument: e,\n                };\n              }\n            }),\n          },\n        },\n        arguments: [],\n      }, node);\n\n    } else if (node.type == \"WhileStatement\") {\n\n      emitter.emit(\"while \");\n      emitter.block('(', function() { node.test.suppressParens = true; visit(node.test, node); }, ')');\n      emitter.emit(' ');\n      emitter.block('{', function() { visit(node.body, node); }, '}');\n\n    } else if (node.type == \"DoWhileStatement\") {\n\n      emitter.emit(\"do \");\n      emitter.block('{', function() { visit(node.body, node); }, '}');\n      emitter.emit(' while ');\n      emitter.block('(', function() { node.test.suppressParens = true; visit(node.test, node); }, ')');\n      semicolon = true;\n\n    } else if (node.type == \"ForStatement\") {\n      emitter.emit(\"for \");\n      emitter.block('(', function() {\n        if (node.init) { visit(node.init, node); }\n        emitter.ensureSemi(); emitter.emit(' ');\n        if (node.test) { visit(node.test, node); } else { emitter.emit('true'); }\n        emitter.ensureSemi(); emitter.emit(' ');\n        if (node.update) { visit(node.update, node); }\n      }, ')');\n      emitter.emit(' ');\n      emitter.block('{', function() { visit(node.body, node); }, '}');\n\n    } else if (node.type == \"ForInStatement\" || node.type == \"ForOfStatement\") {\n      emitter.emit(\"foreach \");\n      emitter.block('(', function() {\n        visit(node.right, node);\n        emitter.emit(\" as \");\n        visit(node.left, node);\n        emitter.emit(\" => $___\");\n      }, ')');\n      emitter.emit(' ');\n      emitter.block('{', function() { visit(node.body, node); }, '}');\n\n    } else if (node.type == \"UpdateExpression\") {\n\n      if (node.prefix) {\n        emitter.emit(node.operator);\n      }\n\n      visit(node.argument, node);\n\n      if (!node.prefix) {\n        emitter.emit(node.operator);\n      }\n\n    } else if (node.type == \"SwitchStatement\") {\n      emitter.emit(\"switch \");\n      emitter.block('(', function() { node.discriminant.suppressParens = true; visit(node.discriminant, node); }, ')');\n      emitter.emit(' ');\n      emitter.block('{', function() {\n        for (var i=0; i < node.cases.length; i++) {\n          visit(node.cases[i], node); emitter.nl();\n        }\n      }, '}');\n\n    } else if (node.type == \"SwitchCase\") {\n\n      if (node.test) {\n        emitter.emit(\"case \");\n        visit(node.test, node);\n        emitter.emit(\":\");\n      } else {\n        emitter.emit(\"default:\");\n      }\n      emitter.nl();\n\n      for (var i=0; i < node.consequent.length; i++) {\n        visit(node.consequent[i], node);\n      }\n\n    } else if (node.type == \"BreakStatement\") {\n      emitter.emit(\"break; \");\n\n    } else if (node.type == \"ContinueStatement\") {\n      emitter.emit(\"continue; \");\n\n    } else if (node.type == \"NewExpression\") {\n      // re-use CallExpression for NewExpression's\n      var newNode = utils.clone(node);\n      newNode.type = \"CallExpression\";\n      newNode.suppressParens = true;\n\n      emitter.emit('new ');\n      visit(newNode, node);\n\n    } else if (node.type == \"FunctionExpression\") {\n\n      // Re-use FunctionDeclaration structure for method definitions\n      node.type = \"FunctionDeclaration\";\n      node.id = { name: node.id || \"\" };\n\n      visit(node, node.parent);\n\n\n      // Modules & Export (http://wiki.ecmascript.org/doku.php?id=harmony:modules_examples)\n    } else if (node.type == \"ModuleDeclaration\") {\n      emitter.emit(\"namespace \" + utils.classize(node.id.value) + \"; \");\n      visit(node.body, node);\n\n    } else if (node.type == \"ExportNamedDeclaration\") {\n      visit(node.declaration, node);\n\n    } else if (node.type == \"ImportDeclaration\") {\n      for (var i=0,length = node.specifiers.length;i<length;i++) {\n        visit(node.specifiers[i], node);\n      }\n\n    } else if (node.type == \"ImportSpecifier\") {\n      var namespace = utils.classize(node.parent.source.value);\n      emitter.emit(\"use \\\\\" + namespace + \"\\\\\" + node.imported.name);\n\n      // alias\n      if (node.local) { emitter.emit(\" as \" + node.local.name); }\n\n      emitter.emit(\";\\n\");\n\n    } else if (node.type == \"TemplateLiteral\") {\n      var expressions = node.expressions\n        , quasis = node.quasis\n        , nodes = quasis.concat(expressions).sort(function(a, b) {\n          return b.range[0] < a.range[0];\n        })\n        , cooked = \"\";\n\n      emitter.emit('\"');\n      for (var i=0; i<nodes.length; i++) {\n        if (nodes[i].type == \"TemplateElement\") {\n          emitter.emit(utils.stringify(nodes[i].value.cooked, true).slice(1,-1));\n        } else {\n          emitter.emit('{');\n          visit(nodes[i], node);\n          emitter.emit('}');\n        }\n      }\n      emitter.emit('\"');\n\n    } else if (node.type === \"TryStatement\") {\n      emitter.emit(\"try \");\n      emitter.block('{', function() { visit(node.block, node); }, '}');\n\n      if (node.handler) {\n        visit(node.handler, node);\n      }\n\n      if (node.finalizer) {\n        emitter.emit(\" finally \");\n        emitter.block('{', function() { visit(node.finalizer, node); }, '}');\n      }\n\n    } else if (node.type === \"CatchClause\") {\n      emitter.emit(' catch ( Exception ');\n      scope.create(node.param, node);\n      node.param.suppressParens = true;\n      visit(node.param, node);\n      emitter.emit(\" ) \");\n      emitter.block('{', function() { visit(node.body, node); }, '}');\n    } else if (node.type === \"ThrowStatement\") {\n      emitter.emit(\"throw \");\n      visit(node.argument, node);\n      semicolon = true;\n    } else if (node.type === \"RestElement\") {\n      emitter.emit('...');\n      visit(node.argument, node);\n    } else if (node.type === \"SpreadElement\") {\n      emitter.emit('...');\n      visit(node.argument, node);\n    } else if (node.type === \"YieldExpression\") {\n      // Parsoid-specific: ignore yield expression.\n      emitter.emit(\"/* await */ \");\n      visit(node.argument, node);\n    } else if (node.type === 'EmptyStatement') {\n      /* do nothing */\n    } else {\n      throw new Error(\"'\" + node.type + \"' not implemented: \" + JSON.stringify(node.loc));\n    }\n\n    // append semicolon when required\n    if (semicolon) {\n      emitter.ensureSemi();\n    }\n    if (!node.suppressLoc) { emitter.locEnd(node); }\n  }\n\n  if (!options.noOpenTag) {\n    emitter.emit(\"<?php\\n\");\n  }\n  if (options.watermark) {\n    emitter.emit(`/* ${options.watermark} */\\n`);\n  }\n  visit(ast);\n  if (!options.noOpenTag) {\n    emitter.ensureNl();\n  }\n  return emitter.toString().replace(/[ \\t]+\\n/g, '\\n'); // remove trailing space\n}\n"]}