🆙 Add cms i using 🆙

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2018 Mike Grip, Evilebot Tnawi, Christian Zosel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/README.md

@@ -0,0 +1,313 @@
+<div align="center">
+<img alt="Prettier"
+  src="https://raw.githubusercontent.com/prettier/prettier-logo/master/images/prettier-icon-light.png">
+<img alt="PHP" height="180" hspace="25" vspace="15"
+  src="https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/PHP-logo.svg/500px-PHP-logo.svg.png">
+</div>
+
+<h2 align="center">Prettier PHP Plugin</h2>
+
+<p align="center">
+  <a href="https://github.com/prettier/plugin-php/actions">
+    <img alt="GitHub Workflow Status" src="https://img.shields.io/github/workflow/status/prettier/plugin-php/Node CI?style=flat-square">
+  </a>
+  <a href="https://www.npmjs.com/package/@prettier/plugin-php">
+    <img alt="npm version" src="https://img.shields.io/npm/v/@prettier/plugin-php.svg?style=flat-square">
+  </a>
+  <a href="https://codecov.io/gh/prettier/plugin-php">
+    <img alt="Codecov Coverage Status" src="https://img.shields.io/codecov/c/github/prettier/plugin-php.svg?style=flat-square">
+  </a>
+  <!-- <a href="https://www.npmjs.com/package/@prettier/plugin-php">
+    <img alt="monthly downloads" src="https://img.shields.io/npm/dm/@prettier/plugin-php.svg?style=flat-square">
+  </a> -->
+  <a href="#badge">
+    <img alt="code style: prettier" src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square">
+  </a>
+  <a href="https://gitter.im/jlongster/prettier">
+    <img alt="Gitter" src="https://img.shields.io/gitter/room/jlongster/prettier.svg?style=flat-square">
+  </a>
+  <a href="https://twitter.com/PrettierCode">
+    <img alt="Follow+Prettier+on+Twitter" src="https://img.shields.io/twitter/follow/prettiercode.svg?label=follow+prettier&style=flat-square">
+  </a>
+</p>
+
+## Intro
+
+Prettier is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary.
+
+This plugin adds support for the PHP language to Prettier.
+
+### Can this be used in production?
+
+We're considering the plugin to be stable when pure PHP files are formatted. Formatting of files that contain mixed PHP and HTML is still considered unstable - please see [open issues with the tag "inline"](https://github.com/prettier/plugin-php/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Ainline) for details.
+
+If you want to use the plugin in production, we recommend limiting its scope to pure PHP files.
+
+### Input
+
+```php
+<?php
+array_map(function($arg1,$arg2) use ( $var1, $var2 ) {
+    return $arg1+$arg2/($var+$var2);
+}, array("complex"=>"code","with"=>
+    function() {return "inconsistent";}
+,"formatting"=>"is", "hard" => "to", "maintain"=>true));
+```
+
+### Output
+
+```php
+<?php
+
+array_map(
+    function ($arg1, $arg2) use ($var1, $var2) {
+        return $arg1 + $arg2 / ($var + $var2);
+    },
+    [
+        "complex" => "code",
+        "with" => function () {
+            return "inconsistent";
+        },
+        "formatting" => "is",
+        "hard" => "to",
+        "maintain" => true,
+    ]
+);
+```
+
+## Playground
+
+You can give the plugin a try in our [playground](https://loilo.github.io/prettier-php-playground/)!
+
+## Install
+
+yarn:
+
+```bash
+yarn add --dev prettier @prettier/plugin-php
+# or globally
+yarn global add prettier @prettier/plugin-php
+```
+
+npm:
+
+```bash
+npm install --save-dev prettier @prettier/plugin-php
+# or globally
+npm install --global prettier @prettier/plugin-php
+```
+
+## Use
+
+### With Node.js
+
+If you installed prettier as a local dependency, you can add prettier as a script in your `package.json`,
+
+```json
+{
+  "scripts": {
+    "prettier": "prettier"
+  }
+}
+```
+
+and then run it via
+
+```bash
+yarn run prettier path/to/file.php --write
+# or
+npm run prettier -- path/to/file.php --write
+```
+
+If you installed globally, run
+
+```bash
+prettier path/to/file.php --write
+```
+
+### In the Browser
+
+This package exposes a `standalone.js` that can be used alongside Prettier's own `standalone.js` to make the PHP plugin work in browsers without a compile step.
+
+First, grab both standalone scripts from an npm CDN like [unpkg](https://unpkg.com/):
+
+```html
+<script src="https://unpkg.com/prettier/standalone.js"></script>
+<script src="https://unpkg.com/@prettier/plugin-php/standalone.js"></script>
+```
+
+Then use Prettier with PHP, just like this:
+
+```js
+prettier.format(YOUR_CODE, {
+  plugins: prettierPlugins,
+  parser: "php"
+});
+```
+
+See this code in action [in this basic demo](https://jsbin.com/butoruw/edit?html,output).
+
+### With Bundlers
+
+Bundlers like webpack, Rollup or browserify automatically recognize how to handle the PHP plugin. Remember that even when using a bundler, you still have to use the standalone builds:
+
+```js
+import prettier from "prettier/standalone";
+import phpPlugin from "@prettier/plugin-php/standalone";
+
+prettier.format(YOUR_CODE, {
+  plugins: [phpPlugin],
+  parser: "php"
+});
+```
+
+## Configuration
+
+Prettier for PHP supports the following options. We recommend that all users set the `phpVersion` option.
+
+| Name               | Default    | Description                                                                                                                                                                                                                                                                          |
+| ------------------ |------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `phpVersion`       | `"7.0"`    | Allows specifying the PHP version you're using. If you're using PHP 7.1 or later, setting this option will make use of modern language features in the printed output. If you're using PHP lower than 7.0, you'll have to set this option or Prettier will generate incompatible code. |
+| `printWidth`       | `80`       | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#print-width))                                                                                                                                                                                      |
+| `tabWidth`         | `4`        | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)), The default is `4` based on the `PSR-2` coding standard.                                                                                                                              |
+| `useTabs`          | `false`    | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tabs))                                                                                                                                                                                             |
+| `singleQuote`      | `false`    | If set to `"true"`, strings that use double quotes but do not rely on the features they add, will be reformatted. Example: `"foo" -> 'foo'`, `"foo $bar" -> "foo $bar"`.                                                                                                             |
+| `trailingCommaPHP` | `true`     | If set to `true`, trailing commas will be added wherever possible. <br> If set to `false`, no trailing commas are printed.                                                                                                                                                           |
+| `braceStyle`       | `"per-cs"` | If set to `"per-cs"`, prettier will move open brace for code blocks (classes, functions and methods) onto new line. <br> If set to `"1tbs"`, prettier will move open brace for code blocks (classes, functions and methods) onto same line.                                           |
+| `requirePragma`    | `false`    | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#require-pragma))                                                                                                                                                                                   |
+| `insertPragma`     | `false`    | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#insert-pragma))                                                                                                                                                                                    |
+
+## Ignoring code
+
+A comment `// prettier-ignore` will exclude the next node in the abstract syntax tree from formatting.
+
+For example:
+
+```php
+matrix(
+  1, 0, 0,
+  0, 1, 0,
+  0, 0, 1
+);
+
+// prettier-ignore
+matrix(
+  1, 0, 0,
+  0, 1, 0,
+  0, 0, 1
+);
+```
+
+will be transformed to
+
+```php
+matrix(1, 0, 0, 0, 1, 0, 0, 0, 1);
+
+// prettier-ignore
+matrix(
+  1, 0, 0,
+  0, 1, 0,
+  0, 0, 1
+)
+```
+
+## Editor integration
+
+### Atom
+
+The official [prettier plugin for atom](https://github.com/prettier/prettier-atom) supports plugins.
+
+### VScode
+
+The official [prettier plugin for vscode](https://github.com/prettier/prettier-vscode) supports plugins since Version 1.10.0. To enable it, install the extension and make sure the plugin is installed _locally_ (in your project folder). After restarting VScode the plugin should work as expected.
+
+### PhpStorm / IntelliJ / Jetbrains IDE
+
+- Install prettier and plugin locally `yarn add -D prettier @prettier/plugin-php`
+- Open Settings (File, Settings)
+- Go to Plugins Section, Select Marketplace, Search for Prettier, Install Plugin, Restart IDE
+- Open Settings, Search for Prettier, select Prettier in left settings navigation
+- Check prettier package has auto-detected, should be something like `myproject/node_modules/prettier`
+- Update Run for Files to include .php, eg: `{**/*,*}.{js,ts,jsx,tsx,php,json,scss,vue,md}`
+- Tick the On Save button, if you want your files formatting updated on file save
+- Clock OK to save settings
+
+_Note: Just pressing save does not reformat your current file unless the file has been modified in some way, 
+alternatively you can use the Prettier shortcut Ctrl+Alt+Shift+P_
+
+### Sublime Text
+
+Sublime Text support is available through Package Control and the [JsPrettier](https://packagecontrol.io/packages/JsPrettier) plugin.
+
+### Vim
+
+Regarding plugin support in the official plugin vim-prettier see [this issue](https://github.com/prettier/vim-prettier/issues/119).
+
+#### ALE
+
+The linting plugin ALE has built-in support for prettier and its plugins. Just add prettier to your [list of fixers](https://github.com/w0rp/ale#2ii-fixing). For example:
+
+```vim
+let g:ale_fixers={
+  \'javascript': ['prettier'],
+  \'json': ['prettier'],
+  \'php': ['prettier'],
+\}
+```
+
+#### Custom
+
+Alternatively, adding the following to `.vimrc` will define a custom command `:PrettierPhp` that runs the plugin while preserving the cursor position and run it on save.
+
+```vim
+" Prettier for PHP
+function PrettierPhpCursor()
+  let save_pos = getpos(".")
+  %! prettier --stdin --parser=php
+  call setpos('.', save_pos)
+endfunction
+" define custom command
+command PrettierPhp call PrettierPhpCursor()
+" format on save
+autocmd BufwritePre *.php PrettierPhp
+```
+
+## Integration for other tools
+
+### PHP-CS-Fixer
+
+See `docs/recipes/php-cs-fixer` for integration help, code can also be found in https://gist.github.com/Billz95/9d5fad3af728b88540fa831b73261733
+
+## Contributing
+
+If you're interested in contributing to the development of Prettier for PHP, you can follow the [CONTRIBUTING guide from Prettier](https://github.com/prettier/prettier/blob/master/CONTRIBUTING.md), as it all applies to this repository too.
+
+To test it out on a PHP file:
+
+- Clone this repository.
+- Run `yarn`.
+- Create a file called `test.php`.
+- Run `yarn prettier test.php` to check the output.
+
+## Maintainers
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center">
+        <a href="https://github.com/czosel">
+          <img width="150" height="150" src="https://github.com/czosel.png?v=3&s=150">
+          </br>
+          Christian Zosel
+        </a>
+      </td>
+      <td align="center">
+        <a href="https://github.com/evilebottnawi">
+          <img width="150" height="150" src="https://github.com/evilebottnawi.png?v=3&s=150">
+          </br>
+          Evilebot Tnawi
+        </a>
+      </td>
+    </tr>
+  <tbody>
+</table>

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@prettier/plugin-php",
+  "version": "0.19.5",
+  "description": "Prettier PHP Plugin",
+  "repository": "prettier/prettier-php",
+  "author": "Lucas Azzola <@azz>",
+  "license": "MIT",
+  "main": "src",
+  "files": [
+    "src",
+    "standalone.js"
+  ],
+  "dependencies": {
+    "linguist-languages": "^7.21.0",
+    "mem": "^8.0.0",
+    "php-parser": "^3.1.3"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.19.4",
+    "codecov": "3.8.3",
+    "cross-env": "^7.0.2",
+    "eslint": "8.36.0",
+    "eslint-config-prettier": "8.7.0",
+    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-jest": "27.2.1",
+    "eslint-plugin-prettier": "4.2.1",
+    "eslint-plugin-prettier-doc": "^1.1.0",
+    "jest": "29.5.0",
+    "jest-environment-jsdom": "29.5.0",
+    "jest-runner-eslint": "2.0.0",
+    "jest-snapshot-serializer-raw": "^1.1.0",
+    "prettier": "^2.8.4",
+    "rollup": "^2.75.7",
+    "rollup-plugin-alias": "^2.0.0",
+    "rollup-plugin-babel": "^4.3.2",
+    "rollup-plugin-commonjs": "^10.0.2",
+    "rollup-plugin-inject": "^3.0.1",
+    "rollup-plugin-json": "^4.0.0",
+    "rollup-plugin-node-resolve": "^5.2.0",
+    "rollup-plugin-replace": "^2.1.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "strip-ansi": "^6.0.0",
+    "yarpm": "^1.1.1"
+  },
+  "peerDependencies": {
+    "prettier": "^1.15.0 || ^2.0.0"
+  },
+  "scripts": {
+    "test": "jest",
+    "prepublishOnly": "yarpm run build-standalone && cross-env RUN_STANDALONE_TESTS=true yarpm test",
+    "prettier": "prettier --plugin=. --parser=php",
+    "build-standalone": "rollup -c build/rollup.config.js",
+    "debug": "node --inspect-brk node_modules/.bin/jest --runInBand"
+  }
+}

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/src/clean.js

@@ -0,0 +1,113 @@
+"use strict";
+
+const util = require("./util");
+
+const ignoredProperties = new Set([
+  "loc",
+  "range",
+  "raw",
+  "comments",
+  "leadingComments",
+  "trailingComments",
+  "parenthesizedExpression",
+  "parent",
+  "prev",
+  "start",
+  "end",
+  "tokens",
+  "errors",
+  "extra",
+]);
+
+/**
+ * This function takes the existing ast node and a copy, by reference
+ * We use it for testing, so that we can compare pre-post versions of the AST,
+ * excluding things we don't care about (like node location, case that will be
+ * changed by the printer, etc.)
+ */
+function clean(node, newObj) {
+  if (node.kind === "string") {
+    // TODO if options are available in this method, replace with
+    // newObj.isDoubleQuote = !util.useSingleQuote(node, options);
+    delete newObj.isDoubleQuote;
+  }
+
+  if (["array", "list"].includes(node.kind)) {
+    // TODO if options are available in this method, assign instead of delete
+    delete newObj.shortForm;
+  }
+
+  if (node.kind === "inline") {
+    if (node.value.includes("___PSEUDO_INLINE_PLACEHOLDER___")) {
+      return null;
+    }
+
+    newObj.value = newObj.value.replace(/\n/g, "");
+  }
+
+  // continue ((2)); -> continue 2;
+  // continue 1; -> continue;
+  if ((node.kind === "continue" || node.kind === "break") && node.level) {
+    const { level } = newObj;
+
+    if (level.kind === "number") {
+      newObj.level = level.value === "1" ? null : level;
+    }
+  }
+
+  // if () {{ }} -> if () {}
+  if (node.kind === "block") {
+    if (node.children.length === 1 && node.children[0].kind === "block") {
+      while (newObj.children[0].kind === "block") {
+        newObj.children = newObj.children[0].children;
+      }
+    }
+  }
+
+  // Normalize numbers
+  if (node.kind === "number") {
+    newObj.value = util.printNumber(node.value);
+  }
+
+  const statements = ["foreach", "for", "if", "while", "do"];
+
+  if (statements.includes(node.kind)) {
+    if (node.body && node.body.kind !== "block") {
+      newObj.body = {
+        kind: "block",
+        children: [newObj.body],
+      };
+    } else {
+      newObj.body = newObj.body ? newObj.body : null;
+    }
+
+    if (node.alternate && node.alternate.kind !== "block") {
+      newObj.alternate = {
+        kind: "block",
+        children: [newObj.alternate],
+      };
+    } else {
+      newObj.alternate = newObj.alternate ? newObj.alternate : null;
+    }
+  }
+
+  if (node.kind === "usegroup" && typeof node.name === "string") {
+    newObj.name = newObj.name.replace(/^\\/, "");
+  }
+
+  if (node.kind === "useitem") {
+    newObj.name = newObj.name.replace(/^\\/, "");
+  }
+
+  if (node.kind === "method" && node.name.kind === "identifier") {
+    newObj.name.name = util.normalizeMagicMethodName(newObj.name.name);
+  }
+
+  if (node.kind === "noop") {
+    return null;
+  }
+}
+
+clean.ignoredProperties = ignoredProperties;
+
+module.exports = clean;

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/src/index.js

@@ -0,0 +1,154 @@
+"use strict";
+
+const parse = require("./parser");
+const print = require("./printer");
+const clean = require("./clean");
+const options = require("./options");
+const comments = require("./comments");
+const { join, hardline } = require("prettier").doc.builders;
+const { hasPragma, insertPragma } = require("./pragma");
+
+function createLanguage(linguistData, { extend, override }) {
+  const language = {};
+
+  for (const key in linguistData) {
+    const newKey = key === "languageId" ? "linguistLanguageId" : key;
+    language[newKey] = linguistData[key];
+  }
+
+  if (extend) {
+    for (const key in extend) {
+      language[key] = (language[key] || []).concat(extend[key]);
+    }
+  }
+
+  for (const key in override) {
+    language[key] = override[key];
+  }
+
+  return language;
+}
+
+const languages = [
+  createLanguage(require("linguist-languages/data/PHP"), {
+    override: {
+      parsers: ["php"],
+      vscodeLanguageIds: ["php"],
+    },
+  }),
+  createLanguage(require("linguist-languages/data/HTML+PHP"), {
+    override: {
+      parsers: ["php"],
+      vscodeLanguageIds: ["php"],
+    },
+  }),
+];
+
+const loc = (prop) => (node) => {
+  return node.loc && node.loc[prop] && node.loc[prop].offset;
+};
+
+const parsers = {
+  php: {
+    parse,
+    astFormat: "php",
+    locStart: loc("start"),
+    locEnd: loc("end"),
+    hasPragma,
+  },
+};
+
+const printers = {
+  php: {
+    print,
+    insertPragma,
+    massageAstNode: clean,
+    getCommentChildNodes: comments.getCommentChildNodes,
+    canAttachComment: comments.canAttachComment,
+    isBlockComment: comments.isBlockComment,
+    handleComments: {
+      ownLine: comments.handleOwnLineComment,
+      endOfLine: comments.handleEndOfLineComment,
+      remaining: comments.handleRemainingComment,
+    },
+    willPrintOwnComments(path) {
+      const node = path.getValue();
+
+      return node && node.kind === "noop";
+    },
+    printComment(commentPath) {
+      const comment = commentPath.getValue();
+
+      switch (comment.kind) {
+        case "commentblock": {
+          // for now, don't touch single line block comments
+          if (!comment.value.includes("\n")) {
+            return comment.value;
+          }
+
+          const lines = comment.value.split("\n");
+          // if this is a block comment, handle indentation
+          if (
+            lines
+              .slice(1, lines.length - 1)
+              .every((line) => line.trim()[0] === "*")
+          ) {
+            return join(
+              hardline,
+              lines.map(
+                (line, index) =>
+                  (index > 0 ? " " : "") +
+                  (index < lines.length - 1 ? line.trim() : line.trimLeft())
+              )
+            );
+          }
+
+          // otherwise we can't be sure about indentation, so just print as is
+          return comment.value;
+        }
+        case "commentline": {
+          return comment.value.trimRight();
+        }
+        /* istanbul ignore next */
+        default:
+          throw new Error(`Not a comment: ${JSON.stringify(comment)}`);
+      }
+    },
+    hasPrettierIgnore(path) {
+      const isSimpleIgnore = (comment) =>
+        comment.value.includes("prettier-ignore") &&
+        !comment.value.includes("prettier-ignore-start") &&
+        !comment.value.includes("prettier-ignore-end");
+
+      const parentNode = path.getParentNode();
+      const node = path.getNode();
+
+      return (
+        (node &&
+          node.kind !== "classconstant" &&
+          node.comments &&
+          node.comments.length > 0 &&
+          node.comments.some(isSimpleIgnore)) ||
+        // For proper formatting, the classconstant ignore formatting should
+        // run on the "constant" child
+        (node &&
+          node.kind === "constant" &&
+          parentNode &&
+          parentNode.kind === "classconstant" &&
+          parentNode.comments &&
+          parentNode.comments.length > 0 &&
+          parentNode.comments.some(isSimpleIgnore))
+      );
+    },
+  },
+};
+
+module.exports = {
+  languages,
+  printers,
+  parsers,
+  options,
+  defaultOptions: {
+    tabWidth: 4,
+  },
+};

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/src/module.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./index");

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/src/needs-parens.js

@@ -0,0 +1,258 @@
+"use strict";
+
+const assert = require("assert");
+
+const { getPrecedence, shouldFlatten, isBitwiseOperator } = require("./util");
+
+function needsParens(path) {
+  const parent = path.getParentNode();
+
+  if (!parent) {
+    return false;
+  }
+
+  const name = path.getName();
+  const node = path.getNode();
+
+  if (
+    [
+      //  No need parens for top level children of this nodes
+      "program",
+      "expressionstatement",
+      "namespace",
+      "declare",
+      "block",
+
+      // No need parens
+      "include",
+      "print",
+      "return",
+      "echo",
+    ].includes(parent.kind)
+  ) {
+    return false;
+  }
+
+  switch (node.kind) {
+    case "pre":
+    case "post":
+      if (parent.kind === "unary") {
+        return (
+          node.kind === "pre" &&
+          ((node.type === "+" && parent.type === "+") ||
+            (node.type === "-" && parent.type === "-"))
+        );
+      }
+    // else fallthrough
+    case "unary":
+      switch (parent.kind) {
+        case "unary":
+          return (
+            node.type === parent.type &&
+            (node.type === "+" || node.type === "-")
+          );
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          return name === "what" && parent.what === node;
+        case "bin":
+          return parent.type === "**" && name === "left";
+        default:
+          return false;
+      }
+    case "bin": {
+      switch (parent.kind) {
+        case "assign":
+        case "retif":
+          return ["and", "xor", "or"].includes(node.type);
+        case "silent":
+        case "cast":
+          // TODO: bug https://github.com/glayzzle/php-parser/issues/172
+          return node.parenthesizedExpression;
+        case "pre":
+        case "post":
+        case "unary":
+          return true;
+        case "call":
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+          return name === "what" && parent.what === node;
+        case "bin": {
+          const po = parent.type;
+          const pp = getPrecedence(po);
+          const no = node.type;
+          const np = getPrecedence(no);
+
+          if (pp > np) {
+            return true;
+          }
+
+          if (po === "||" && no === "&&") {
+            return true;
+          }
+
+          if (pp === np && name === "right") {
+            assert.strictEqual(parent.right, node);
+
+            return true;
+          }
+
+          if (pp === np && !shouldFlatten(po, no)) {
+            return true;
+          }
+
+          if (pp < np && no === "%") {
+            return po === "+" || po === "-";
+          }
+
+          // Add parenthesis when working with bitwise operators
+          // It's not stricly needed but helps with code understanding
+          if (isBitwiseOperator(po)) {
+            return true;
+          }
+
+          return false;
+        }
+
+        default:
+          return false;
+      }
+    }
+    case "propertylookup":
+    case "nullsafepropertylookup":
+    case "staticlookup": {
+      switch (parent.kind) {
+        case "call":
+          return (
+            name === "what" &&
+            parent.what === node &&
+            node.parenthesizedExpression
+          );
+
+        default:
+          return false;
+      }
+    }
+    case "clone":
+    case "new": {
+      switch (parent.kind) {
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          return name === "what" && parent.what === node;
+        default:
+          return false;
+      }
+    }
+    case "yield": {
+      switch (parent.kind) {
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          return name === "what" && parent.what === node;
+
+        case "retif":
+          return parent.test === node;
+
+        default:
+          return !!(node.key || node.value);
+      }
+    }
+    case "assign": {
+      if (
+        parent.kind === "for" &&
+        (parent.init.includes(node) || parent.increment.includes(node))
+      ) {
+        return false;
+      } else if (parent.kind === "assign") {
+        return false;
+      } else if (parent.kind === "static") {
+        return false;
+      } else if (
+        ["if", "do", "while", "foreach", "switch"].includes(parent.kind)
+      ) {
+        return false;
+      } else if (parent.kind === "silent") {
+        return false;
+      } else if (parent.kind === "call") {
+        return false;
+      }
+
+      return true;
+    }
+    case "retif":
+      switch (parent.kind) {
+        case "cast":
+          return true;
+        case "unary":
+        case "bin":
+        case "retif":
+          if (name === "test" && !parent.trueExpr) {
+            return false;
+          }
+
+          return true;
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          return name === "what" && parent.what === node;
+
+        default:
+          return false;
+      }
+    case "closure":
+      switch (parent.kind) {
+        case "call":
+          return name === "what" && parent.what === node;
+
+        // https://github.com/prettier/plugin-php/issues/1675
+        case "propertylookup":
+        case "nullsafepropertylookup":
+          return true;
+
+        default:
+          return false;
+      }
+    case "silence":
+    case "cast":
+      // TODO: bug https://github.com/glayzzle/php-parser/issues/172
+      return node.parenthesizedExpression;
+    // else fallthrough
+    case "string":
+    case "array":
+      switch (parent.kind) {
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          if (
+            ["string", "array"].includes(node.kind) &&
+            parent.kind === "offsetlookup"
+          ) {
+            return false;
+          }
+
+          return name === "what" && parent.what === node;
+        default:
+          return false;
+      }
+    case "print":
+    case "include":
+      return parent.kind === "bin";
+  }
+
+  return false;
+}
+
+module.exports = needsParens;

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/src/options.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const CATEGORY_PHP = "PHP";
+
+module.exports = {
+  phpVersion: {
+    since: "0.13.0",
+    category: CATEGORY_PHP,
+    type: "choice",
+    default: "7.0",
+    description: "Minimum target PHP version.",
+    choices: [
+      { value: "5.0" },
+      { value: "5.1" },
+      { value: "5.2" },
+      { value: "5.3" },
+      { value: "5.4" },
+      { value: "5.5" },
+      { value: "5.6" },
+      { value: "7.0" },
+      { value: "7.1" },
+      { value: "7.2" },
+      { value: "7.3" },
+      { value: "7.4" },
+      { value: "8.0" },
+      { value: "8.1" },
+      { value: "8.2" },
+    ],
+  },
+  trailingCommaPHP: {
+    since: "0.0.0",
+    category: CATEGORY_PHP,
+    type: "boolean",
+    default: true,
+    description: "Print trailing commas wherever possible when multi-line.",
+  },
+  braceStyle: {
+    since: "0.10.0",
+    category: CATEGORY_PHP,
+    type: "choice",
+    default: "per-cs",
+    description:
+      "Print one space or newline for code blocks (classes and functions).",
+    choices: [
+      { value: "psr-2", description: "(deprecated) Use per-cs" },
+      { value: "per-cs", description: "Use the PER Coding Style brace style." },
+      { value: "1tbs", description: "Use 1tbs brace style." },
+    ],
+  },
+};

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/src/parser.js

@@ -0,0 +1,64 @@
+"use strict";
+const engine = require("php-parser");
+
+function parse(text, parsers, opts) {
+  const inMarkdown = opts && opts.parentParser === "markdown";
+
+  if (!text && inMarkdown) {
+    return "";
+  }
+
+  // Todo https://github.com/glayzzle/php-parser/issues/170
+  text = text.replace(/\?>\n<\?/g, "?>\n___PSEUDO_INLINE_PLACEHOLDER___<?");
+
+  // initialize a new parser instance
+  const parser = new engine({
+    parser: {
+      extractDoc: true,
+    },
+    ast: {
+      withPositions: true,
+      withSource: true,
+    },
+  });
+
+  const hasOpenPHPTag = text.indexOf("<?php") !== -1;
+  const parseAsEval = inMarkdown && !hasOpenPHPTag;
+
+  let ast;
+  try {
+    ast = parseAsEval ? parser.parseEval(text) : parser.parseCode(text);
+  } catch (err) {
+    if (err instanceof SyntaxError && "lineNumber" in err) {
+      err.loc = {
+        start: {
+          line: err.lineNumber,
+          column: err.columnNumber,
+        },
+      };
+
+      delete err.lineNumber;
+      delete err.columnNumber;
+    }
+
+    throw err;
+  }
+
+  ast.extra = {
+    parseAsEval,
+  };
+
+  // https://github.com/glayzzle/php-parser/issues/155
+  // currently inline comments include the line break at the end, we need to
+  // strip those out and update the end location for each comment manually
+  ast.comments.forEach((comment) => {
+    if (comment.value[comment.value.length - 1] === "\n") {
+      comment.value = comment.value.slice(0, -1);
+      comment.loc.end.offset = comment.loc.end.offset - 1;
+    }
+  });
+
+  return ast;
+}
+
+module.exports = parse;

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/src/pragma.js

@@ -0,0 +1,97 @@
+"use strict";
+
+const parse = require("./parser");
+const memoize = require("mem");
+
+const reHasPragma = /@prettier|@format/;
+
+const getPageLevelDocBlock = memoize((text) => {
+  const parsed = parse(text);
+
+  const [firstChild] = parsed.children;
+  const [firstDocBlock] = parsed.comments.filter(
+    (el) => el.kind === "commentblock"
+  );
+
+  if (
+    firstChild &&
+    firstDocBlock &&
+    firstDocBlock.loc.start.line < firstChild.loc.start.line
+  ) {
+    return firstDocBlock;
+  }
+});
+
+function hasPragma(text) {
+  // fast path optimization - check if the pragma shows up in the file at all
+  if (!reHasPragma.test(text)) {
+    return false;
+  }
+
+  const pageLevelDocBlock = getPageLevelDocBlock(text);
+
+  if (pageLevelDocBlock) {
+    const { value } = pageLevelDocBlock;
+
+    return reHasPragma.test(value);
+  }
+
+  return false;
+}
+
+function injectPragma(docblock) {
+  let lines = docblock.split("\n");
+
+  if (lines.length === 1) {
+    // normalize to multiline for simplicity
+    const [, line] = /\/*\*\*(.*)\*\//.exec(lines[0]);
+
+    lines = ["/**", ` * ${line.trim()}`, " */"];
+  }
+
+  // find the first @pragma
+  // if there happens to be one on the opening line, just put it on the next line.
+  const pragmaIndex = lines.findIndex((line) => /@\S/.test(line)) || 1;
+
+  // not found => index == -1, which conveniently will splice 1 from the end.
+  lines.splice(pragmaIndex, 0, " * @format");
+
+  return lines.join("\n");
+}
+
+function insertPragma(text) {
+  const pageLevelDocBlock = getPageLevelDocBlock(text);
+
+  if (pageLevelDocBlock) {
+    const {
+      start: { offset: startOffset },
+      end: { offset: endOffset },
+    } = pageLevelDocBlock.loc;
+    const before = text.substring(0, startOffset);
+    const after = text.substring(endOffset);
+
+    return `${before}${injectPragma(pageLevelDocBlock.value, text)}${after}`;
+  }
+
+  const openTag = "<?php";
+
+  if (!text.startsWith(openTag)) {
+    // bail out
+    return text;
+  }
+
+  const splitAt = openTag.length;
+  const phpTag = text.substring(0, splitAt);
+  const after = text.substring(splitAt);
+
+  return `${phpTag}
+/** 
+ * @format 
+ */
+${after}`;
+}
+
+module.exports = {
+  hasPragma,
+  insertPragma,
+};

Optimized Atomcms daily updated/node_modules/@prettier/plugin-php/src/util.js

@@ -0,0 +1,733 @@
+"use strict";
+
+const {
+  hasNewline,
+  skipEverythingButNewLine,
+  skipNewline,
+  isNextLineEmpty: _isNextLineEmpty,
+  isPreviousLineEmpty: _isPreviousLineEmpty,
+  getNextNonSpaceNonCommentCharacterIndex:
+    _getNextNonSpaceNonCommentCharacterIndex,
+} = require("prettier").util;
+
+const prettierVersion = require("prettier").version;
+
+function lookupIfPrettier2(options, prop) {
+  return parseInt(prettierVersion[0]) > 1 ? options[prop] : options;
+}
+
+function isPreviousLineEmpty(text, node, options) {
+  return _isPreviousLineEmpty(
+    text,
+    node,
+    lookupIfPrettier2(options, "locStart")
+  );
+}
+
+function isNextLineEmpty(text, node, options) {
+  return _isNextLineEmpty(text, node, lookupIfPrettier2(options, "locEnd"));
+}
+
+function getNextNonSpaceNonCommentCharacterIndex(text, node, options) {
+  return _getNextNonSpaceNonCommentCharacterIndex(
+    text,
+    node,
+    lookupIfPrettier2(options, "locEnd")
+  );
+}
+
+function printNumber(rawNumber) {
+  return (
+    rawNumber
+      .toLowerCase()
+      // Remove unnecessary plus and zeroes from scientific notation.
+      .replace(/^([+-]?[\d.]+e)(?:\+|(-))?0*(\d)/, "$1$2$3")
+      // Remove unnecessary scientific notation (1e0).
+      .replace(/^([+-]?[\d.]+)e[+-]?0+$/, "$1")
+      // Make sure numbers always start with a digit.
+      .replace(/^([+-])?\./, "$10.")
+      // Remove extraneous trailing decimal zeroes.
+      .replace(/(\.\d+?)0+(?=e|$)/, "$1")
+      // Remove unnecessary .e notation
+      .replace(/\.(?=e)/, "")
+  );
+}
+
+// http://php.net/manual/en/language.operators.precedence.php
+const PRECEDENCE = {};
+[
+  ["or"],
+  ["xor"],
+  ["and"],
+  [
+    "=",
+    "+=",
+    "-=",
+    "*=",
+    "**=",
+    "/=",
+    ".=",
+    "%=",
+    "&=",
+    "|=",
+    "^=",
+    "<<=",
+    ">>=",
+  ],
+  ["??"],
+  ["||"],
+  ["&&"],
+  ["|"],
+  ["^"],
+  ["&"],
+  ["==", "===", "!=", "!==", "<>", "<=>"],
+  ["<", ">", "<=", ">="],
+  [">>", "<<"],
+  ["+", "-", "."],
+  ["*", "/", "%"],
+  ["!"],
+  ["instanceof"],
+  ["++", "--", "~"],
+  ["**"],
+].forEach((tier, i) => {
+  tier.forEach((op) => {
+    PRECEDENCE[op] = i;
+  });
+});
+
+function getPrecedence(op) {
+  return PRECEDENCE[op];
+}
+
+const equalityOperators = ["==", "!=", "===", "!==", "<>", "<=>"];
+const multiplicativeOperators = ["*", "/", "%"];
+const bitshiftOperators = [">>", "<<"];
+
+function isBitwiseOperator(operator) {
+  return (
+    !!bitshiftOperators[operator] ||
+    operator === "|" ||
+    operator === "^" ||
+    operator === "&"
+  );
+}
+
+function shouldFlatten(parentOp, nodeOp) {
+  if (getPrecedence(nodeOp) !== getPrecedence(parentOp)) {
+    return false;
+  }
+
+  // ** is right-associative
+  // x ** y ** z --> x ** (y ** z)
+  if (parentOp === "**") {
+    return false;
+  }
+
+  // x == y == z --> (x == y) == z
+  if (
+    equalityOperators.includes(parentOp) &&
+    equalityOperators.includes(nodeOp)
+  ) {
+    return false;
+  }
+
+  // x * y % z --> (x * y) % z
+  if (
+    (nodeOp === "%" && multiplicativeOperators.includes(parentOp)) ||
+    (parentOp === "%" && multiplicativeOperators.includes(nodeOp))
+  ) {
+    return false;
+  }
+
+  // x * y / z --> (x * y) / z
+  // x / y * z --> (x / y) * z
+  if (
+    nodeOp !== parentOp &&
+    multiplicativeOperators.includes(nodeOp) &&
+    multiplicativeOperators.includes(parentOp)
+  ) {
+    return false;
+  }
+
+  // x << y << z --> (x << y) << z
+  if (
+    bitshiftOperators.includes(parentOp) &&
+    bitshiftOperators.includes(nodeOp)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function nodeHasStatement(node) {
+  return [
+    "block",
+    "program",
+    "namespace",
+    "class",
+    "enum",
+    "interface",
+    "trait",
+    "traituse",
+    "declare",
+  ].includes(node.kind);
+}
+
+function getBodyFirstChild({ body }) {
+  if (!body) {
+    return null;
+  }
+  if (body.kind === "block") {
+    body = body.children;
+  }
+  return body[0];
+}
+
+function getNodeListProperty(node) {
+  const body = node.children || node.body || node.adaptations;
+  return Array.isArray(body) ? body : null;
+}
+
+function getParentNodeListProperty(path) {
+  const parent = path.getParentNode();
+  if (!parent) {
+    return null;
+  }
+  return getNodeListProperty(parent);
+}
+
+function getLast(arr) {
+  if (arr.length > 0) {
+    return arr[arr.length - 1];
+  }
+  return null;
+}
+
+function getPenultimate(arr) {
+  if (arr.length > 1) {
+    return arr[arr.length - 2];
+  }
+  return null;
+}
+
+function isLastStatement(path) {
+  const body = getParentNodeListProperty(path);
+  if (!body) {
+    return true;
+  }
+  const node = path.getValue();
+  return body[body.length - 1] === node;
+}
+
+function isFirstChildrenInlineNode(path) {
+  const node = path.getValue();
+
+  if (node.kind === "program") {
+    const children = getNodeListProperty(node);
+
+    if (!children || children.length === 0) {
+      return false;
+    }
+
+    return children[0].kind === "inline";
+  }
+
+  if (node.kind === "switch") {
+    if (!node.body) {
+      return false;
+    }
+
+    const children = getNodeListProperty(node.body);
+
+    if (children.length === 0) {
+      return false;
+    }
+
+    const [firstCase] = children;
+
+    if (!firstCase.body) {
+      return false;
+    }
+
+    const firstCaseChildren = getNodeListProperty(firstCase.body);
+
+    if (firstCaseChildren.length === 0) {
+      return false;
+    }
+
+    return firstCaseChildren[0].kind === "inline";
+  }
+
+  const firstChild = getBodyFirstChild(node);
+
+  if (!firstChild) {
+    return false;
+  }
+
+  return firstChild.kind === "inline";
+}
+
+function isDocNode(node) {
+  return (
+    node.kind === "nowdoc" ||
+    (node.kind === "encapsed" && node.type === "heredoc")
+  );
+}
+
+/**
+ * Heredoc/Nowdoc nodes need a trailing linebreak if they
+ * appear as function arguments or array elements
+ */
+function docShouldHaveTrailingNewline(path, recurse = 0) {
+  const node = path.getNode(recurse);
+  const parent = path.getNode(recurse + 1);
+  const parentParent = path.getNode(recurse + 2);
+
+  if (!parent) {
+    return false;
+  }
+
+  if (
+    (parentParent &&
+      ["call", "new", "echo"].includes(parentParent.kind) &&
+      !["call", "array"].includes(parent.kind)) ||
+    parent.kind === "parameter"
+  ) {
+    const lastIndex = parentParent.arguments.length - 1;
+    const index = parentParent.arguments.indexOf(parent);
+
+    return index !== lastIndex;
+  }
+
+  if (parentParent && parentParent.kind === "for") {
+    const initIndex = parentParent.init.indexOf(parent);
+
+    if (initIndex !== -1) {
+      return initIndex !== parentParent.init.length - 1;
+    }
+
+    const testIndex = parentParent.test.indexOf(parent);
+
+    if (testIndex !== -1) {
+      return testIndex !== parentParent.test.length - 1;
+    }
+
+    const incrementIndex = parentParent.increment.indexOf(parent);
+
+    if (incrementIndex !== -1) {
+      return incrementIndex !== parentParent.increment.length - 1;
+    }
+  }
+
+  if (parent.kind === "bin") {
+    return (
+      parent.left === node || docShouldHaveTrailingNewline(path, recurse + 1)
+    );
+  }
+
+  if (parent.kind === "case" && parent.test === node) {
+    return true;
+  }
+
+  if (parent.kind === "staticvariable") {
+    const lastIndex = parentParent.variables.length - 1;
+    const index = parentParent.variables.indexOf(parent);
+
+    return index !== lastIndex;
+  }
+
+  if (parent.kind === "entry") {
+    if (parent.key === node) {
+      return true;
+    }
+
+    const lastIndex = parentParent.items.length - 1;
+    const index = parentParent.items.indexOf(parent);
+
+    return index !== lastIndex;
+  }
+
+  if (["call", "new"].includes(parent.kind)) {
+    const lastIndex = parent.arguments.length - 1;
+    const index = parent.arguments.indexOf(node);
+
+    return index !== lastIndex;
+  }
+
+  if (parent.kind === "echo") {
+    const lastIndex = parent.expressions.length - 1;
+    const index = parent.expressions.indexOf(node);
+
+    return index !== lastIndex;
+  }
+
+  if (parent.kind === "array") {
+    const lastIndex = parent.items.length - 1;
+    const index = parent.items.indexOf(node);
+
+    return index !== lastIndex;
+  }
+
+  if (parent.kind === "retif") {
+    return docShouldHaveTrailingNewline(path, recurse + 1);
+  }
+
+  return false;
+}
+
+function lineShouldEndWithSemicolon(path) {
+  const node = path.getValue();
+  const parentNode = path.getParentNode();
+  if (!parentNode) {
+    return false;
+  }
+  // for single line control structures written in a shortform (ie without a block),
+  // we need to make sure the single body node gets a semicolon
+  if (
+    ["for", "foreach", "while", "do", "if", "switch"].includes(
+      parentNode.kind
+    ) &&
+    node.kind !== "block" &&
+    node.kind !== "if" &&
+    (parentNode.body === node || parentNode.alternate === node)
+  ) {
+    return true;
+  }
+  if (!nodeHasStatement(parentNode)) {
+    return false;
+  }
+  if (node.kind === "echo" && node.shortForm) {
+    return false;
+  }
+  if (node.kind === "traituse") {
+    return !node.adaptations;
+  }
+  if (node.kind === "method" && node.isAbstract) {
+    return true;
+  }
+  if (node.kind === "method") {
+    const parent = path.getParentNode();
+    if (parent && parent.kind === "interface") {
+      return true;
+    }
+  }
+  return [
+    "expressionstatement",
+    "do",
+    "usegroup",
+    "classconstant",
+    "propertystatement",
+    "traitprecedence",
+    "traitalias",
+    "goto",
+    "constantstatement",
+    "enumcase",
+    "global",
+    "static",
+    "echo",
+    "unset",
+    "return",
+    "break",
+    "continue",
+    "throw",
+  ].includes(node.kind);
+}
+
+function fileShouldEndWithHardline(path) {
+  const node = path.getValue();
+  const isProgramNode = node.kind === "program";
+  const lastNode = node.children && getLast(node.children);
+
+  if (!isProgramNode) {
+    return false;
+  }
+
+  if (lastNode && ["halt", "inline"].includes(lastNode.kind)) {
+    return false;
+  }
+
+  if (
+    lastNode &&
+    (lastNode.kind === "declare" || lastNode.kind === "namespace")
+  ) {
+    const lastNestedNode =
+      lastNode.children.length > 0 && getLast(lastNode.children);
+
+    if (lastNestedNode && ["halt", "inline"].includes(lastNestedNode.kind)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function maybeStripLeadingSlashFromUse(name) {
+  const nameWithoutLeadingSlash = name.replace(/^\\/, "");
+  if (nameWithoutLeadingSlash.indexOf("\\") !== -1) {
+    return nameWithoutLeadingSlash;
+  }
+  return name;
+}
+
+function hasDanglingComments(node) {
+  return (
+    node.comments &&
+    node.comments.some((comment) => !comment.leading && !comment.trailing)
+  );
+}
+
+function hasLeadingComment(node) {
+  return node.comments && node.comments.some((comment) => comment.leading);
+}
+
+function hasTrailingComment(node) {
+  return node.comments && node.comments.some((comment) => comment.trailing);
+}
+
+function isLookupNode(node) {
+  return (
+    node.kind === "propertylookup" ||
+    node.kind === "nullsafepropertylookup" ||
+    node.kind === "staticlookup" ||
+    node.kind === "offsetlookup"
+  );
+}
+
+function shouldPrintHardLineAfterStartInControlStructure(path) {
+  const node = path.getValue();
+
+  if (["try", "catch"].includes(node.kind)) {
+    return false;
+  }
+
+  return isFirstChildrenInlineNode(path);
+}
+
+function shouldPrintHardLineBeforeEndInControlStructure(path) {
+  const node = path.getValue();
+
+  if (["try", "catch"].includes(node.kind)) {
+    return true;
+  }
+
+  if (node.kind === "switch") {
+    const children = getNodeListProperty(node.body);
+
+    if (children.length === 0) {
+      return true;
+    }
+
+    const lastCase = getLast(children);
+
+    if (!lastCase.body) {
+      return true;
+    }
+
+    const childrenInCase = getNodeListProperty(lastCase.body);
+
+    if (childrenInCase.length === 0) {
+      return true;
+    }
+
+    return childrenInCase[0].kind !== "inline";
+  }
+
+  return !isFirstChildrenInlineNode(path);
+}
+
+function getAlignment(text) {
+  const lines = text.split("\n");
+  const lastLine = lines.pop();
+
+  return lastLine.length - lastLine.trimLeft().length + 1;
+}
+
+function getNextNode(path, node) {
+  const parent = path.getParentNode();
+  const children = getNodeListProperty(parent);
+
+  if (!children) {
+    return null;
+  }
+
+  const index = children.indexOf(node);
+
+  if (index === -1) {
+    return null;
+  }
+
+  return parent.children[index + 1];
+}
+
+function isProgramLikeNode(node) {
+  return ["program", "declare", "namespace"].includes(node.kind);
+}
+
+function isReferenceLikeNode(node) {
+  return [
+    "name",
+    "parentreference",
+    "selfreference",
+    "staticreference",
+  ].includes(node.kind);
+}
+
+// Return `logical` value for `bin` node containing `||` or `&&` type otherwise return kind of node.
+// Require for grouping logical and binary nodes in right way.
+function getNodeKindIncludingLogical(node) {
+  if (node.kind === "bin" && ["||", "&&"].includes(node.type)) {
+    return "logical";
+  }
+
+  return node.kind;
+}
+
+/**
+ * Check if string can safely be converted from double to single quotes and vice-versa, i.e.
+ *
+ * - no embedded variables ("foo $bar")
+ * - no linebreaks
+ * - no special characters like \n, \t, ...
+ * - no octal/hex/unicode characters
+ *
+ * See https://php.net/manual/en/language.types.string.php#language.types.string.syntax.double
+ */
+function useDoubleQuote(node, options) {
+  if (node.isDoubleQuote === options.singleQuote) {
+    // We have a double quote and the user passed singleQuote:true, or the other way around.
+    const rawValue = node.raw.slice(node.raw[0] === "b" ? 2 : 1, -1);
+    const isComplex = rawValue.match(
+      /\\([$nrtfve]|[xX][0-9a-fA-F]{1,2}|[0-7]{1,3}|u{([0-9a-fA-F]+)})|\r?\n|'|"|\$/
+    );
+    return node.isDoubleQuote ? isComplex : !isComplex;
+  }
+  return node.isDoubleQuote;
+}
+
+function hasEmptyBody(path, name = "body") {
+  const node = path.getValue();
+
+  return (
+    node[name] &&
+    node[name].children &&
+    node[name].children.length === 0 &&
+    (!node[name].comments || node[name].comments.length === 0)
+  );
+}
+
+function isNextLineEmptyAfterNamespace(text, node, locStart) {
+  let idx = locStart(node);
+  idx = skipEverythingButNewLine(text, idx);
+  idx = skipNewline(text, idx);
+  return hasNewline(text, idx);
+}
+
+function shouldPrintHardlineBeforeTrailingComma(lastElem) {
+  if (
+    lastElem.kind === "nowdoc" ||
+    (lastElem.kind === "encapsed" && lastElem.type === "heredoc")
+  ) {
+    return true;
+  }
+
+  if (
+    lastElem.kind === "entry" &&
+    (lastElem.value.kind === "nowdoc" ||
+      (lastElem.value.kind === "encapsed" && lastElem.value.type === "heredoc"))
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function getAncestorCounter(path, typeOrTypes) {
+  const types = [].concat(typeOrTypes);
+  let counter = -1;
+  let ancestorNode;
+  while ((ancestorNode = path.getParentNode(++counter))) {
+    if (types.indexOf(ancestorNode.kind) !== -1) {
+      return counter;
+    }
+  }
+  return -1;
+}
+
+function getAncestorNode(path, typeOrTypes) {
+  const counter = getAncestorCounter(path, typeOrTypes);
+  return counter === -1 ? null : path.getParentNode(counter);
+}
+
+const magicMethods = [
+  "__construct",
+  "__destruct",
+  "__call",
+  "__callStatic",
+  "__get",
+  "__set",
+  "__isset",
+  "__unset",
+  "__sleep",
+  "__wakeup",
+  "__toString",
+  "__invoke",
+  "__set_state",
+  "__clone",
+  "__debugInfo",
+];
+const MagicMethodsMap = magicMethods.reduce((map, obj) => {
+  map[obj.toLowerCase()] = obj;
+
+  return map;
+}, {});
+
+function normalizeMagicMethodName(name) {
+  const loweredName = name.toLowerCase();
+
+  if (MagicMethodsMap[loweredName]) {
+    return MagicMethodsMap[loweredName];
+  }
+
+  return name;
+}
+
+module.exports = {
+  printNumber,
+  getPrecedence,
+  isBitwiseOperator,
+  shouldFlatten,
+  nodeHasStatement,
+  getNodeListProperty,
+  getParentNodeListProperty,
+  getLast,
+  getPenultimate,
+  isLastStatement,
+  getBodyFirstChild,
+  lineShouldEndWithSemicolon,
+  fileShouldEndWithHardline,
+  maybeStripLeadingSlashFromUse,
+  hasDanglingComments,
+  hasLeadingComment,
+  hasTrailingComment,
+  docShouldHaveTrailingNewline,
+  isLookupNode,
+  isFirstChildrenInlineNode,
+  shouldPrintHardLineAfterStartInControlStructure,
+  shouldPrintHardLineBeforeEndInControlStructure,
+  getAlignment,
+  isProgramLikeNode,
+  isReferenceLikeNode,
+  getNodeKindIncludingLogical,
+  useDoubleQuote,
+  hasEmptyBody,
+  isNextLineEmptyAfterNamespace,
+  shouldPrintHardlineBeforeTrailingComma,
+  isDocNode,
+  getAncestorNode,
+  getNextNode,
+  normalizeMagicMethodName,
+  isPreviousLineEmpty,
+  isNextLineEmpty,
+  getNextNonSpaceNonCommentCharacterIndex,
+};