PHP's xdiff_string_patch in TypeScript

How to use

Install via yarn add locutus and import: import { xdiff_string_patch } from 'locutus/php/xdiff/xdiff_string_patch'.

Or with CommonJS: const { xdiff_string_patch } = require('locutus/php/xdiff/xdiff_string_patch')

Use a bundler that supports tree-shaking so you only ship the functions you actually use. Vite, webpack, Rollup, and Parcel all handle this. For server-side use this is less of a concern.

Examples

These examples are extracted from test cases that automatically verify our functions against their native counterparts.

#	code	expected result
1	xdiff_string_patch('', '@@ -0,0 +1,1 @@\n+Hello world!')	'Hello world!'

Notes

• The XDIFF_PATCH_IGNORESPACE flag and the error argument are not currently supported.

• This has not been tested exhaustively yet.

• The errorObj parameter (optional) if used must be passed in as a object. The errors will then be written by reference into it’s value property

Dependencies

This function uses the following Locutus functions:

• _phpRuntimeState (php/_helpers)

Here's what our current TypeScript equivalent to PHP's xdiff_string_patch looks like.

TSTypeScript JSJavaScript TSStandalone TS JSStandalone JS

Copy code

import { getPhpObjectEntry, setPhpObjectEntry } from '../_helpers/_phpRuntimeState.ts'
import type { PhpInput } from '../_helpers/_phpTypes.ts'

type XRegExpMeta = {
  source: string
  captureNames?: string[] | null
}

type PatchErrorObject = { value?: string }

export function xdiff_string_patch(
  originalStr: string,
  patch: string,
  flags?: number | string | string[],
  errorObj?: PatchErrorObject,
): string | false {
  //      discuss at: https://locutus.io/php/xdiff_string_patch/
  // parity verified: PHP 8.3
  //     original by: Brett Zamir (https://brett-zamir.me)
  //     improved by: Steven Levithan (stevenlevithan.com)
  //          note 1: The XDIFF_PATCH_IGNORESPACE flag and the error argument are not
  //          note 1: currently supported.
  //          note 2: This has not been tested exhaustively yet.
  //          note 3: The errorObj parameter (optional) if used must be passed in as a
  //          note 3: object. The errors will then be written by reference into it's `value` property
  //       example 1: xdiff_string_patch('', '@@ -0,0 +1,1 @@\n+Hello world!')
  //       returns 1: 'Hello world!'

  // First two functions were adapted from Steven Levithan, also under an MIT license
  // Adapted from XRegExp 1.5.0
  // (c) 2007-2010 Steven Levithan
  // MIT License
  // <https://xregexp.com>

  const isRecord = (value: PhpInput): value is { [key: string]: PhpInput } =>
    typeof value === 'object' && value !== null && !Array.isArray(value)

  const _getNativeFlags = function (regex: RegExp): string {
    const extended = getPhpObjectEntry(regex, 'extended') === true
    const sticky = getPhpObjectEntry(regex, 'sticky') === true
    // Proposed for ES4; included in AS3
    return [
      regex.global ? 'g' : '',
      regex.ignoreCase ? 'i' : '',
      regex.multiline ? 'm' : '',
      extended ? 'x' : '',
      sticky ? 'y' : '',
    ].join('')
  }

  const getXRegExpMeta = (regex: RegExp): XRegExpMeta | undefined => {
    const xregexpValue = getPhpObjectEntry(regex, '_xregexp')
    if (!isRecord(xregexpValue)) {
      return undefined
    }

    const sourceValue = getPhpObjectEntry(xregexpValue, 'source')
    if (typeof sourceValue !== 'string') {
      return undefined
    }

    const captureNamesValue = getPhpObjectEntry(xregexpValue, 'captureNames')
    let captureNames: string[] | null | undefined
    if (captureNamesValue === null) {
      captureNames = null
    } else if (
      Array.isArray(captureNamesValue) &&
      captureNamesValue.every((captureName) => typeof captureName === 'string')
    ) {
      captureNames = captureNamesValue
    }

    if (captureNames === undefined) {
      return { source: sourceValue }
    }

    return {
      source: sourceValue,
      captureNames,
    }
  }

  const _cbSplit = function (input: string, sep: RegExp | string): string[] {
    // If separator `s` is not a regex, use the native `split`
    if (!(sep instanceof RegExp)) {
      return input.split(sep)
    }
    const str = String(input)
    const output: string[] = []
    let lastLastIndex = 0
    let match: RegExpExecArray | null = null
    let lastLength = 0
    const limit = Infinity
    const x = getXRegExpMeta(sep)
    // This is required if not `s.global`, and it avoids needing to set `s.lastIndex` to zero
    // and restore it to its original value when we're done using the regex
    // Brett paring down
    const s = new RegExp(sep.source, _getNativeFlags(sep) + 'g')
    if (x) {
      setPhpObjectEntry(s, '_xregexp', {
        source: x.source,
        captureNames: x.captureNames ? x.captureNames.slice(0) : null,
      })
    }

    while ((match = s.exec(str))) {
      // Run the altered `exec` (required for `lastIndex` fix, etc.)
      if (s.lastIndex > lastLastIndex) {
        output.push(str.slice(lastLastIndex, match.index))

        if (match.length > 1 && match.index < str.length) {
          const captures = match.slice(1).filter((capture): capture is string => capture !== undefined)
          Array.prototype.push.apply(output, captures)
        }

        lastLength = match[0].length
        lastLastIndex = s.lastIndex

        if (output.length >= limit) {
          break
        }
      }

      if (s.lastIndex === match.index) {
        s.lastIndex++
      }
    }

    if (lastLastIndex === str.length) {
      if (!s.test('') || lastLength) {
        output.push('')
      }
    } else {
      output.push(str.slice(lastLastIndex))
    }

    return output.length > limit ? output.slice(0, limit) : output
  }

  // Input defaulting & sanitation
  if (!patch) {
    return false
  }

  let i = 0
  let ll = 0
  let ranges: RegExpMatchArray | null = null
  let lastLinePos = 0
  let firstChar = ''
  const rangeExp = /^@@\s+-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@$/
  const lineBreaks = /\r?\n/
  const lines = _cbSplit(patch.replace(/(\r?\n)+$/, ''), lineBreaks)
  const origLines = _cbSplit(originalStr, lineBreaks)
  const newStrArr: string[] = []
  let linePos = 0
  const errors = ''
  let optTemp = 0 // Both string & integer (constant) input is allowed
  const OPTS = {
    // Unsure of actual PHP values, so better to rely on string
    XDIFF_PATCH_NORMAL: 1,
    XDIFF_PATCH_REVERSE: 2,
    XDIFF_PATCH_IGNORESPACE: 4,
  }

  if (!flags) {
    flags = 'XDIFF_PATCH_NORMAL'
  }

  if (typeof flags !== 'number') {
    // Allow for a single string or an array of string flags
    const flagList = Array.isArray(flags) ? flags : [flags]
    const isPatchOption = (value: string): value is keyof typeof OPTS => value in OPTS
    for (i = 0; i < flagList.length; i++) {
      const currentFlag = flagList[i]
      if (!currentFlag) {
        continue
      }
      // Resolve string input to bitwise e.g. 'XDIFF_PATCH_NORMAL' becomes 1
      if (isPatchOption(currentFlag)) {
        optTemp = optTemp | OPTS[currentFlag]
      }
    }
    flags = optTemp
  }

  if (flags & OPTS.XDIFF_PATCH_NORMAL) {
    for (i = 0, ll = lines.length; i < ll; i++) {
      const line = lines[i] ?? ''
      ranges = line.match(rangeExp)
      if (ranges?.[1]) {
        lastLinePos = linePos
        linePos = Number(ranges[1]) - 1
        while (lastLinePos < linePos) {
          newStrArr.push(origLines[lastLinePos++] ?? '')
        }
        while (lines[++i] !== undefined && rangeExp.exec(lines[i] ?? '') === null) {
          const patchedLine = lines[i] ?? ''
          firstChar = patchedLine.charAt(0)
          switch (firstChar) {
            case '-':
              // Skip including that line
              ++linePos
              break
            case '+':
              newStrArr.push(patchedLine.slice(1))
              break
            case ' ':
              newStrArr.push(origLines[linePos++] ?? '')
              break
            default:
              // Reconcile with returning errrors arg?
              throw new Error('Unrecognized initial character in unidiff line')
          }
        }
        if (lines[i]) {
          i--
        }
      }
    }
    while (linePos > 0 && linePos < origLines.length) {
      newStrArr.push(origLines[linePos++] ?? '')
    }
  } else if (flags & OPTS.XDIFF_PATCH_REVERSE) {
    // Only differs from above by a few lines
    for (i = 0, ll = lines.length; i < ll; i++) {
      const line = lines[i] ?? ''
      ranges = line.match(rangeExp)
      if (ranges?.[3]) {
        lastLinePos = linePos
        linePos = Number(ranges[3]) - 1
        while (lastLinePos < linePos) {
          newStrArr.push(origLines[lastLinePos++] ?? '')
        }
        while (lines[++i] !== undefined && rangeExp.exec(lines[i] ?? '') === null) {
          const patchedLine = lines[i] ?? ''
          firstChar = patchedLine.charAt(0)
          switch (firstChar) {
            case '-':
              newStrArr.push(patchedLine.slice(1))
              break
            case '+':
              // Skip including that line
              ++linePos
              break
            case ' ':
              newStrArr.push(origLines[linePos++] ?? '')
              break
            default:
              // Reconcile with returning errrors arg?
              throw new Error('Unrecognized initial character in unidiff line')
          }
        }
        if (lines[i]) {
          i--
        }
      }
    }
    while (linePos > 0 && linePos < origLines.length) {
      newStrArr.push(origLines[linePos++] ?? '')
    }
  }

  if (errorObj) {
    errorObj.value = errors
  }

  return newStrArr.join('\n')
}

import { getPhpObjectEntry, setPhpObjectEntry } from '../_helpers/_phpRuntimeState.ts'

export function xdiff_string_patch(originalStr, patch, flags, errorObj) {
  //      discuss at: https://locutus.io/php/xdiff_string_patch/
  // parity verified: PHP 8.3
  //     original by: Brett Zamir (https://brett-zamir.me)
  //     improved by: Steven Levithan (stevenlevithan.com)
  //          note 1: The XDIFF_PATCH_IGNORESPACE flag and the error argument are not
  //          note 1: currently supported.
  //          note 2: This has not been tested exhaustively yet.
  //          note 3: The errorObj parameter (optional) if used must be passed in as a
  //          note 3: object. The errors will then be written by reference into it's `value` property
  //       example 1: xdiff_string_patch('', '@@ -0,0 +1,1 @@\n+Hello world!')
  //       returns 1: 'Hello world!'

  // First two functions were adapted from Steven Levithan, also under an MIT license
  // Adapted from XRegExp 1.5.0
  // (c) 2007-2010 Steven Levithan
  // MIT License
  // <https://xregexp.com>

  const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value)

  const _getNativeFlags = function (regex) {
    const extended = getPhpObjectEntry(regex, 'extended') === true
    const sticky = getPhpObjectEntry(regex, 'sticky') === true
    // Proposed for ES4; included in AS3
    return [
      regex.global ? 'g' : '',
      regex.ignoreCase ? 'i' : '',
      regex.multiline ? 'm' : '',
      extended ? 'x' : '',
      sticky ? 'y' : '',
    ].join('')
  }

  const getXRegExpMeta = (regex) => {
    const xregexpValue = getPhpObjectEntry(regex, '_xregexp')
    if (!isRecord(xregexpValue)) {
      return undefined
    }

    const sourceValue = getPhpObjectEntry(xregexpValue, 'source')
    if (typeof sourceValue !== 'string') {
      return undefined
    }

    const captureNamesValue = getPhpObjectEntry(xregexpValue, 'captureNames')
    let captureNames
    if (captureNamesValue === null) {
      captureNames = null
    } else if (
      Array.isArray(captureNamesValue) &&
      captureNamesValue.every((captureName) => typeof captureName === 'string')
    ) {
      captureNames = captureNamesValue
    }

    if (captureNames === undefined) {
      return { source: sourceValue }
    }

    return {
      source: sourceValue,
      captureNames,
    }
  }

  const _cbSplit = function (input, sep) {
    // If separator `s` is not a regex, use the native `split`
    if (!(sep instanceof RegExp)) {
      return input.split(sep)
    }
    const str = String(input)
    const output = []
    let lastLastIndex = 0
    let match = null
    let lastLength = 0
    const limit = Infinity
    const x = getXRegExpMeta(sep)
    // This is required if not `s.global`, and it avoids needing to set `s.lastIndex` to zero
    // and restore it to its original value when we're done using the regex
    // Brett paring down
    const s = new RegExp(sep.source, _getNativeFlags(sep) + 'g')
    if (x) {
      setPhpObjectEntry(s, '_xregexp', {
        source: x.source,
        captureNames: x.captureNames ? x.captureNames.slice(0) : null,
      })
    }

    while ((match = s.exec(str))) {
      // Run the altered `exec` (required for `lastIndex` fix, etc.)
      if (s.lastIndex > lastLastIndex) {
        output.push(str.slice(lastLastIndex, match.index))

        if (match.length > 1 && match.index < str.length) {
          const captures = match.slice(1).filter((capture) => capture !== undefined)
          Array.prototype.push.apply(output, captures)
        }

        lastLength = match[0].length
        lastLastIndex = s.lastIndex

        if (output.length >= limit) {
          break
        }
      }

      if (s.lastIndex === match.index) {
        s.lastIndex++
      }
    }

    if (lastLastIndex === str.length) {
      if (!s.test('') || lastLength) {
        output.push('')
      }
    } else {
      output.push(str.slice(lastLastIndex))
    }

    return output.length > limit ? output.slice(0, limit) : output
  }

  // Input defaulting & sanitation
  if (!patch) {
    return false
  }

  let i = 0
  let ll = 0
  let ranges = null
  let lastLinePos = 0
  let firstChar = ''
  const rangeExp = /^@@\s+-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@$/
  const lineBreaks = /\r?\n/
  const lines = _cbSplit(patch.replace(/(\r?\n)+$/, ''), lineBreaks)
  const origLines = _cbSplit(originalStr, lineBreaks)
  const newStrArr = []
  let linePos = 0
  const errors = ''
  let optTemp = 0 // Both string & integer (constant) input is allowed
  const OPTS = {
    // Unsure of actual PHP values, so better to rely on string
    XDIFF_PATCH_NORMAL: 1,
    XDIFF_PATCH_REVERSE: 2,
    XDIFF_PATCH_IGNORESPACE: 4,
  }

  if (!flags) {
    flags = 'XDIFF_PATCH_NORMAL'
  }

  if (typeof flags !== 'number') {
    // Allow for a single string or an array of string flags
    const flagList = Array.isArray(flags) ? flags : [flags]
    const isPatchOption = (value) => value in OPTS
    for (i = 0; i < flagList.length; i++) {
      const currentFlag = flagList[i]
      if (!currentFlag) {
        continue
      }
      // Resolve string input to bitwise e.g. 'XDIFF_PATCH_NORMAL' becomes 1
      if (isPatchOption(currentFlag)) {
        optTemp = optTemp | OPTS[currentFlag]
      }
    }
    flags = optTemp
  }

  if (flags & OPTS.XDIFF_PATCH_NORMAL) {
    for (i = 0, ll = lines.length; i < ll; i++) {
      const line = lines[i] ?? ''
      ranges = line.match(rangeExp)
      if (ranges?.[1]) {
        lastLinePos = linePos
        linePos = Number(ranges[1]) - 1
        while (lastLinePos < linePos) {
          newStrArr.push(origLines[lastLinePos++] ?? '')
        }
        while (lines[++i] !== undefined && rangeExp.exec(lines[i] ?? '') === null) {
          const patchedLine = lines[i] ?? ''
          firstChar = patchedLine.charAt(0)
          switch (firstChar) {
            case '-':
              // Skip including that line
              ++linePos
              break
            case '+':
              newStrArr.push(patchedLine.slice(1))
              break
            case ' ':
              newStrArr.push(origLines[linePos++] ?? '')
              break
            default:
              // Reconcile with returning errrors arg?
              throw new Error('Unrecognized initial character in unidiff line')
          }
        }
        if (lines[i]) {
          i--
        }
      }
    }
    while (linePos > 0 && linePos < origLines.length) {
      newStrArr.push(origLines[linePos++] ?? '')
    }
  } else if (flags & OPTS.XDIFF_PATCH_REVERSE) {
    // Only differs from above by a few lines
    for (i = 0, ll = lines.length; i < ll; i++) {
      const line = lines[i] ?? ''
      ranges = line.match(rangeExp)
      if (ranges?.[3]) {
        lastLinePos = linePos
        linePos = Number(ranges[3]) - 1
        while (lastLinePos < linePos) {
          newStrArr.push(origLines[lastLinePos++] ?? '')
        }
        while (lines[++i] !== undefined && rangeExp.exec(lines[i] ?? '') === null) {
          const patchedLine = lines[i] ?? ''
          firstChar = patchedLine.charAt(0)
          switch (firstChar) {
            case '-':
              newStrArr.push(patchedLine.slice(1))
              break
            case '+':
              // Skip including that line
              ++linePos
              break
            case ' ':
              newStrArr.push(origLines[linePos++] ?? '')
              break
            default:
              // Reconcile with returning errrors arg?
              throw new Error('Unrecognized initial character in unidiff line')
          }
        }
        if (lines[i]) {
          i--
        }
      }
    }
    while (linePos > 0 && linePos < origLines.length) {
      newStrArr.push(origLines[linePos++] ?? '')
    }
  }

  if (errorObj) {
    errorObj.value = errors
  }

  return newStrArr.join('\n')
}

// php/_helpers/_phpTypes (Locutus helper dependency)
type PhpNullish = null | undefined

type PhpInput = {} | PhpNullish

type PhpCallableArgs = PhpInput[]

type PhpCallable<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = PhpInput> = (
  ...args: TArgs
) => TResult

// php/_helpers/_phpRuntimeState (Locutus helper dependency)
type PhpObjectEntryContainer = object | PhpCallable

function getPhpObjectEntry(value: PhpInput, key: string): PhpInput | undefined {
  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
    return undefined
  }

  let current: object | null = value
  while (current) {
    const descriptor = Object.getOwnPropertyDescriptor(current, key)
    if (descriptor) {
      if (typeof descriptor.get === 'function') {
        const getterValue = descriptor.get.call(value)
        return typeof getterValue === 'undefined' ? undefined : getterValue
      }
      const directValue = descriptor.value
      return typeof directValue === 'undefined' ? undefined : directValue
    }
    current = Object.getPrototypeOf(current)
  }

  return undefined
}

function setPhpObjectEntry(value: PhpInput, key: string, entry: PhpInput): boolean {
  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
    return false
  }

  const container: PhpObjectEntryContainer = value
  let current: object | null = container
  while (current) {
    const descriptor = Object.getOwnPropertyDescriptor(current, key)
    if (descriptor) {
      if (typeof descriptor.set === 'function') {
        descriptor.set.call(container, entry)
        return true
      }
      if (descriptor.writable) {
        Object.defineProperty(container, key, {
          configurable: descriptor.configurable ?? true,
          enumerable: descriptor.enumerable ?? true,
          value: entry,
          writable: true,
        })
        return true
      }
      return false
    }
    current = Object.getPrototypeOf(current)
  }

  Object.defineProperty(container, key, {
    configurable: true,
    enumerable: true,
    value: entry,
    writable: true,
  })
  return true
}

// php/xdiff/xdiff_string_patch (target function module)
type XRegExpMeta = {
  source: string
  captureNames?: string[] | null
}

type PatchErrorObject = { value?: string }

function xdiff_string_patch(
  originalStr: string,
  patch: string,
  flags?: number | string | string[],
  errorObj?: PatchErrorObject,
): string | false {
  //      discuss at: https://locutus.io/php/xdiff_string_patch/
  // parity verified: PHP 8.3
  //     original by: Brett Zamir (https://brett-zamir.me)
  //     improved by: Steven Levithan (stevenlevithan.com)
  //          note 1: The XDIFF_PATCH_IGNORESPACE flag and the error argument are not
  //          note 1: currently supported.
  //          note 2: This has not been tested exhaustively yet.
  //          note 3: The errorObj parameter (optional) if used must be passed in as a
  //          note 3: object. The errors will then be written by reference into it's `value` property
  //       example 1: xdiff_string_patch('', '@@ -0,0 +1,1 @@\n+Hello world!')
  //       returns 1: 'Hello world!'

  // First two functions were adapted from Steven Levithan, also under an MIT license
  // Adapted from XRegExp 1.5.0
  // (c) 2007-2010 Steven Levithan
  // MIT License
  // <https://xregexp.com>

  const isRecord = (value: PhpInput): value is { [key: string]: PhpInput } =>
    typeof value === 'object' && value !== null && !Array.isArray(value)

  const _getNativeFlags = function (regex: RegExp): string {
    const extended = getPhpObjectEntry(regex, 'extended') === true
    const sticky = getPhpObjectEntry(regex, 'sticky') === true
    // Proposed for ES4; included in AS3
    return [
      regex.global ? 'g' : '',
      regex.ignoreCase ? 'i' : '',
      regex.multiline ? 'm' : '',
      extended ? 'x' : '',
      sticky ? 'y' : '',
    ].join('')
  }

  const getXRegExpMeta = (regex: RegExp): XRegExpMeta | undefined => {
    const xregexpValue = getPhpObjectEntry(regex, '_xregexp')
    if (!isRecord(xregexpValue)) {
      return undefined
    }

    const sourceValue = getPhpObjectEntry(xregexpValue, 'source')
    if (typeof sourceValue !== 'string') {
      return undefined
    }

    const captureNamesValue = getPhpObjectEntry(xregexpValue, 'captureNames')
    let captureNames: string[] | null | undefined
    if (captureNamesValue === null) {
      captureNames = null
    } else if (
      Array.isArray(captureNamesValue) &&
      captureNamesValue.every((captureName) => typeof captureName === 'string')
    ) {
      captureNames = captureNamesValue
    }

    if (captureNames === undefined) {
      return { source: sourceValue }
    }

    return {
      source: sourceValue,
      captureNames,
    }
  }

  const _cbSplit = function (input: string, sep: RegExp | string): string[] {
    // If separator `s` is not a regex, use the native `split`
    if (!(sep instanceof RegExp)) {
      return input.split(sep)
    }
    const str = String(input)
    const output: string[] = []
    let lastLastIndex = 0
    let match: RegExpExecArray | null = null
    let lastLength = 0
    const limit = Infinity
    const x = getXRegExpMeta(sep)
    // This is required if not `s.global`, and it avoids needing to set `s.lastIndex` to zero
    // and restore it to its original value when we're done using the regex
    // Brett paring down
    const s = new RegExp(sep.source, _getNativeFlags(sep) + 'g')
    if (x) {
      setPhpObjectEntry(s, '_xregexp', {
        source: x.source,
        captureNames: x.captureNames ? x.captureNames.slice(0) : null,
      })
    }

    while ((match = s.exec(str))) {
      // Run the altered `exec` (required for `lastIndex` fix, etc.)
      if (s.lastIndex > lastLastIndex) {
        output.push(str.slice(lastLastIndex, match.index))

        if (match.length > 1 && match.index < str.length) {
          const captures = match.slice(1).filter((capture): capture is string => capture !== undefined)
          Array.prototype.push.apply(output, captures)
        }

        lastLength = match[0].length
        lastLastIndex = s.lastIndex

        if (output.length >= limit) {
          break
        }
      }

      if (s.lastIndex === match.index) {
        s.lastIndex++
      }
    }

    if (lastLastIndex === str.length) {
      if (!s.test('') || lastLength) {
        output.push('')
      }
    } else {
      output.push(str.slice(lastLastIndex))
    }

    return output.length > limit ? output.slice(0, limit) : output
  }

  // Input defaulting & sanitation
  if (!patch) {
    return false
  }

  let i = 0
  let ll = 0
  let ranges: RegExpMatchArray | null = null
  let lastLinePos = 0
  let firstChar = ''
  const rangeExp = /^@@\s+-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@$/
  const lineBreaks = /\r?\n/
  const lines = _cbSplit(patch.replace(/(\r?\n)+$/, ''), lineBreaks)
  const origLines = _cbSplit(originalStr, lineBreaks)
  const newStrArr: string[] = []
  let linePos = 0
  const errors = ''
  let optTemp = 0 // Both string & integer (constant) input is allowed
  const OPTS = {
    // Unsure of actual PHP values, so better to rely on string
    XDIFF_PATCH_NORMAL: 1,
    XDIFF_PATCH_REVERSE: 2,
    XDIFF_PATCH_IGNORESPACE: 4,
  }

  if (!flags) {
    flags = 'XDIFF_PATCH_NORMAL'
  }

  if (typeof flags !== 'number') {
    // Allow for a single string or an array of string flags
    const flagList = Array.isArray(flags) ? flags : [flags]
    const isPatchOption = (value: string): value is keyof typeof OPTS => value in OPTS
    for (i = 0; i < flagList.length; i++) {
      const currentFlag = flagList[i]
      if (!currentFlag) {
        continue
      }
      // Resolve string input to bitwise e.g. 'XDIFF_PATCH_NORMAL' becomes 1
      if (isPatchOption(currentFlag)) {
        optTemp = optTemp | OPTS[currentFlag]
      }
    }
    flags = optTemp
  }

  if (flags & OPTS.XDIFF_PATCH_NORMAL) {
    for (i = 0, ll = lines.length; i < ll; i++) {
      const line = lines[i] ?? ''
      ranges = line.match(rangeExp)
      if (ranges?.[1]) {
        lastLinePos = linePos
        linePos = Number(ranges[1]) - 1
        while (lastLinePos < linePos) {
          newStrArr.push(origLines[lastLinePos++] ?? '')
        }
        while (lines[++i] !== undefined && rangeExp.exec(lines[i] ?? '') === null) {
          const patchedLine = lines[i] ?? ''
          firstChar = patchedLine.charAt(0)
          switch (firstChar) {
            case '-':
              // Skip including that line
              ++linePos
              break
            case '+':
              newStrArr.push(patchedLine.slice(1))
              break
            case ' ':
              newStrArr.push(origLines[linePos++] ?? '')
              break
            default:
              // Reconcile with returning errrors arg?
              throw new Error('Unrecognized initial character in unidiff line')
          }
        }
        if (lines[i]) {
          i--
        }
      }
    }
    while (linePos > 0 && linePos < origLines.length) {
      newStrArr.push(origLines[linePos++] ?? '')
    }
  } else if (flags & OPTS.XDIFF_PATCH_REVERSE) {
    // Only differs from above by a few lines
    for (i = 0, ll = lines.length; i < ll; i++) {
      const line = lines[i] ?? ''
      ranges = line.match(rangeExp)
      if (ranges?.[3]) {
        lastLinePos = linePos
        linePos = Number(ranges[3]) - 1
        while (lastLinePos < linePos) {
          newStrArr.push(origLines[lastLinePos++] ?? '')
        }
        while (lines[++i] !== undefined && rangeExp.exec(lines[i] ?? '') === null) {
          const patchedLine = lines[i] ?? ''
          firstChar = patchedLine.charAt(0)
          switch (firstChar) {
            case '-':
              newStrArr.push(patchedLine.slice(1))
              break
            case '+':
              // Skip including that line
              ++linePos
              break
            case ' ':
              newStrArr.push(origLines[linePos++] ?? '')
              break
            default:
              // Reconcile with returning errrors arg?
              throw new Error('Unrecognized initial character in unidiff line')
          }
        }
        if (lines[i]) {
          i--
        }
      }
    }
    while (linePos > 0 && linePos < origLines.length) {
      newStrArr.push(origLines[linePos++] ?? '')
    }
  }

  if (errorObj) {
    errorObj.value = errors
  }

  return newStrArr.join('\n')
}

// php/_helpers/_phpRuntimeState (Locutus helper dependency)
function getPhpObjectEntry(value, key) {
  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
    return undefined
  }

  let current = value
  while (current) {
    const descriptor = Object.getOwnPropertyDescriptor(current, key)
    if (descriptor) {
      if (typeof descriptor.get === 'function') {
        const getterValue = descriptor.get.call(value)
        return typeof getterValue === 'undefined' ? undefined : getterValue
      }
      const directValue = descriptor.value
      return typeof directValue === 'undefined' ? undefined : directValue
    }
    current = Object.getPrototypeOf(current)
  }

  return undefined
}

function setPhpObjectEntry(value, key, entry) {
  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
    return false
  }

  const container = value
  let current = container
  while (current) {
    const descriptor = Object.getOwnPropertyDescriptor(current, key)
    if (descriptor) {
      if (typeof descriptor.set === 'function') {
        descriptor.set.call(container, entry)
        return true
      }
      if (descriptor.writable) {
        Object.defineProperty(container, key, {
          configurable: descriptor.configurable ?? true,
          enumerable: descriptor.enumerable ?? true,
          value: entry,
          writable: true,
        })
        return true
      }
      return false
    }
    current = Object.getPrototypeOf(current)
  }

  Object.defineProperty(container, key, {
    configurable: true,
    enumerable: true,
    value: entry,
    writable: true,
  })
  return true
}

// php/xdiff/xdiff_string_patch (target function module)
function xdiff_string_patch(originalStr, patch, flags, errorObj) {
  //      discuss at: https://locutus.io/php/xdiff_string_patch/
  // parity verified: PHP 8.3
  //     original by: Brett Zamir (https://brett-zamir.me)
  //     improved by: Steven Levithan (stevenlevithan.com)
  //          note 1: The XDIFF_PATCH_IGNORESPACE flag and the error argument are not
  //          note 1: currently supported.
  //          note 2: This has not been tested exhaustively yet.
  //          note 3: The errorObj parameter (optional) if used must be passed in as a
  //          note 3: object. The errors will then be written by reference into it's `value` property
  //       example 1: xdiff_string_patch('', '@@ -0,0 +1,1 @@\n+Hello world!')
  //       returns 1: 'Hello world!'

  // First two functions were adapted from Steven Levithan, also under an MIT license
  // Adapted from XRegExp 1.5.0
  // (c) 2007-2010 Steven Levithan
  // MIT License
  // <https://xregexp.com>

  const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value)

  const _getNativeFlags = function (regex) {
    const extended = getPhpObjectEntry(regex, 'extended') === true
    const sticky = getPhpObjectEntry(regex, 'sticky') === true
    // Proposed for ES4; included in AS3
    return [
      regex.global ? 'g' : '',
      regex.ignoreCase ? 'i' : '',
      regex.multiline ? 'm' : '',
      extended ? 'x' : '',
      sticky ? 'y' : '',
    ].join('')
  }

  const getXRegExpMeta = (regex) => {
    const xregexpValue = getPhpObjectEntry(regex, '_xregexp')
    if (!isRecord(xregexpValue)) {
      return undefined
    }

    const sourceValue = getPhpObjectEntry(xregexpValue, 'source')
    if (typeof sourceValue !== 'string') {
      return undefined
    }

    const captureNamesValue = getPhpObjectEntry(xregexpValue, 'captureNames')
    let captureNames
    if (captureNamesValue === null) {
      captureNames = null
    } else if (
      Array.isArray(captureNamesValue) &&
      captureNamesValue.every((captureName) => typeof captureName === 'string')
    ) {
      captureNames = captureNamesValue
    }

    if (captureNames === undefined) {
      return { source: sourceValue }
    }

    return {
      source: sourceValue,
      captureNames,
    }
  }

  const _cbSplit = function (input, sep) {
    // If separator `s` is not a regex, use the native `split`
    if (!(sep instanceof RegExp)) {
      return input.split(sep)
    }
    const str = String(input)
    const output = []
    let lastLastIndex = 0
    let match = null
    let lastLength = 0
    const limit = Infinity
    const x = getXRegExpMeta(sep)
    // This is required if not `s.global`, and it avoids needing to set `s.lastIndex` to zero
    // and restore it to its original value when we're done using the regex
    // Brett paring down
    const s = new RegExp(sep.source, _getNativeFlags(sep) + 'g')
    if (x) {
      setPhpObjectEntry(s, '_xregexp', {
        source: x.source,
        captureNames: x.captureNames ? x.captureNames.slice(0) : null,
      })
    }

    while ((match = s.exec(str))) {
      // Run the altered `exec` (required for `lastIndex` fix, etc.)
      if (s.lastIndex > lastLastIndex) {
        output.push(str.slice(lastLastIndex, match.index))

        if (match.length > 1 && match.index < str.length) {
          const captures = match.slice(1).filter((capture) => capture !== undefined)
          Array.prototype.push.apply(output, captures)
        }

        lastLength = match[0].length
        lastLastIndex = s.lastIndex

        if (output.length >= limit) {
          break
        }
      }

      if (s.lastIndex === match.index) {
        s.lastIndex++
      }
    }

    if (lastLastIndex === str.length) {
      if (!s.test('') || lastLength) {
        output.push('')
      }
    } else {
      output.push(str.slice(lastLastIndex))
    }

    return output.length > limit ? output.slice(0, limit) : output
  }

  // Input defaulting & sanitation
  if (!patch) {
    return false
  }

  let i = 0
  let ll = 0
  let ranges = null
  let lastLinePos = 0
  let firstChar = ''
  const rangeExp = /^@@\s+-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@$/
  const lineBreaks = /\r?\n/
  const lines = _cbSplit(patch.replace(/(\r?\n)+$/, ''), lineBreaks)
  const origLines = _cbSplit(originalStr, lineBreaks)
  const newStrArr = []
  let linePos = 0
  const errors = ''
  let optTemp = 0 // Both string & integer (constant) input is allowed
  const OPTS = {
    // Unsure of actual PHP values, so better to rely on string
    XDIFF_PATCH_NORMAL: 1,
    XDIFF_PATCH_REVERSE: 2,
    XDIFF_PATCH_IGNORESPACE: 4,
  }

  if (!flags) {
    flags = 'XDIFF_PATCH_NORMAL'
  }

  if (typeof flags !== 'number') {
    // Allow for a single string or an array of string flags
    const flagList = Array.isArray(flags) ? flags : [flags]
    const isPatchOption = (value) => value in OPTS
    for (i = 0; i < flagList.length; i++) {
      const currentFlag = flagList[i]
      if (!currentFlag) {
        continue
      }
      // Resolve string input to bitwise e.g. 'XDIFF_PATCH_NORMAL' becomes 1
      if (isPatchOption(currentFlag)) {
        optTemp = optTemp | OPTS[currentFlag]
      }
    }
    flags = optTemp
  }

  if (flags & OPTS.XDIFF_PATCH_NORMAL) {
    for (i = 0, ll = lines.length; i < ll; i++) {
      const line = lines[i] ?? ''
      ranges = line.match(rangeExp)
      if (ranges?.[1]) {
        lastLinePos = linePos
        linePos = Number(ranges[1]) - 1
        while (lastLinePos < linePos) {
          newStrArr.push(origLines[lastLinePos++] ?? '')
        }
        while (lines[++i] !== undefined && rangeExp.exec(lines[i] ?? '') === null) {
          const patchedLine = lines[i] ?? ''
          firstChar = patchedLine.charAt(0)
          switch (firstChar) {
            case '-':
              // Skip including that line
              ++linePos
              break
            case '+':
              newStrArr.push(patchedLine.slice(1))
              break
            case ' ':
              newStrArr.push(origLines[linePos++] ?? '')
              break
            default:
              // Reconcile with returning errrors arg?
              throw new Error('Unrecognized initial character in unidiff line')
          }
        }
        if (lines[i]) {
          i--
        }
      }
    }
    while (linePos > 0 && linePos < origLines.length) {
      newStrArr.push(origLines[linePos++] ?? '')
    }
  } else if (flags & OPTS.XDIFF_PATCH_REVERSE) {
    // Only differs from above by a few lines
    for (i = 0, ll = lines.length; i < ll; i++) {
      const line = lines[i] ?? ''
      ranges = line.match(rangeExp)
      if (ranges?.[3]) {
        lastLinePos = linePos
        linePos = Number(ranges[3]) - 1
        while (lastLinePos < linePos) {
          newStrArr.push(origLines[lastLinePos++] ?? '')
        }
        while (lines[++i] !== undefined && rangeExp.exec(lines[i] ?? '') === null) {
          const patchedLine = lines[i] ?? ''
          firstChar = patchedLine.charAt(0)
          switch (firstChar) {
            case '-':
              newStrArr.push(patchedLine.slice(1))
              break
            case '+':
              // Skip including that line
              ++linePos
              break
            case ' ':
              newStrArr.push(origLines[linePos++] ?? '')
              break
            default:
              // Reconcile with returning errrors arg?
              throw new Error('Unrecognized initial character in unidiff line')
          }
        }
        if (lines[i]) {
          i--
        }
      }
    }
    while (linePos > 0 && linePos < origLines.length) {
      newStrArr.push(origLines[linePos++] ?? '')
    }
  }

  if (errorObj) {
    errorObj.value = errors
  }

  return newStrArr.join('\n')
}

Improve this function

Locutus is a community effort following The McDonald's Theory: we ship first iterations, hoping others will improve them. If you see something that could be better, we'd love your contribution.

View on GitHub · Edit on GitHub · View Raw

---

« More PHP xdiff functions

Star