"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;


"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,
  },
};


"use strict";
module.exports = require("./index");


"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;


"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" },
    ],
  },
  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." },
    ],
  },
};


"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;


"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,
};


"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,
};


The deposit reference (you can get it from the 

Get Deposit Details

Query Parameters

Response properties

Error Codes

Using this endpoint you'll have the ability to get the entire information of a specific deposit.

DashPay API Documentation

Welcome to the DashPay API Documentation. Here you'll find all details regarding to the integration process with DashPay.

Introduction

Learn how to use the development environment of DashPay API.

Development

Initiate new session for a payment. This endpoint will help you get the `paymentURL` that you can use to redirect the customer to in order to complete the payment.

Initiate Session

Initiate new session for a payment. This endpoint will help you get the SessionId that will be used to execute the payment later.

Executes a payment using the SessionId you have from the `initiateSession` endpoint. This endpoint will return a payment URL to redirect your customers to the payment page.

executePayment

Using this endpoint you'll have the ability to get the complete information about a specific invoice or payment using it's identifier (e.g: InvoiceId)

Payment Inquiry

Using this endpoint you'll have the ability to make a refund full/partial for a specific invoice or payment.

Make Refund

Using this endpoint you'll have the ability to get a list of deposits that sent or prepared to be sent to the vendor bank account.

Get Deposits

Using this endpoint you'll have the ability to get a list of transactions with some filtering & sorting capabilities.

Code	Description
1	Missing or invalid api key
2	`depositReference` is a required parameter.

Redirect Integration

Embedded Integration

General Endpoints

Get Deposit Details

Query Parameters

Response properties

Error Codes

Redirect Integration

Embedded Integration

General Endpoints

​Query Parameters

​Response properties

​Error Codes

Query Parameters

Response properties

Error Codes