PHP Sequence Matcher

https://github.com/jfcherng/php-sequence-matcher
Admin
A longest sequence matcher for PHP that implements difflib-like functionality to find the longest...
Tokens:7,639
Snippets:51
Trust Score:9.6
License:BSD-3-Clause
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install php-sequence-matcher using Composer

Source: https://github.com/jfcherng/php-sequence-matcher/blob/master/README.md

Use this command to install the package via Composer. Ensure you have Composer installed and configured for your project.

```bash
composer require jfcherng/php-sequence-matcher
```

--------------------------------

### Run Static Analysis and Linting

Source: https://github.com/jfcherng/php-sequence-matcher/blob/master/CLAUDE.md

Perform static analysis using Phan and linting with phpcs. This command helps maintain code quality and adherence to style guides.

```bash
composer analyze
```

--------------------------------

### Run PHPUnit Tests

Source: https://github.com/jfcherng/php-sequence-matcher/blob/master/CLAUDE.md

Execute all PHPUnit tests in the project. Ensure Composer is installed and dependencies are managed.

```bash
composer test
```

--------------------------------

### Get Edit Operations with getOpcodes()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

The getOpcodes() method returns a detailed list of operations (equal, delete, insert, replace) required to transform one sequence into another. Each operation specifies the affected ranges in both sequences.

```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher(
    ['Who', 'has', 'been', 'read', 'the', 'book'],
    ['Who', 'read', 'the', 'book', 'today'],
);

foreach ($matcher->getOpcodes() as [$op, $i1, $i2, $j1, $j2]) {
    $opStr = SequenceMatcher::opIntToStr($op);
    echo sprintf("%s  a[%d:%d]  b[%d:%d]\n", $opStr, $i1, $i2, $j1, $j2);
}
// eq   a[0:1]  b[0:1]   →  'Who' is equal
// del  a[1:3]  b[1:1]   →  delete 'has','been' from $a
// eq   a[3:6]  b[1:4]   →  'read','the','book' are equal
// ins  a[6:6]  b[4:5]   →  insert 'today' from $b
```

--------------------------------

### Find Longest Matching Block

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Find the longest contiguous matching subsequence within specified ranges of the two sequences. Returns the start indices and length of the match.

```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher(
    ['a', 'b', 'c', 'd', 'e'],
    ['x', 'b', 'c', 'd', 'y'],
);

// Search over the full range of both sequences
[$i, $j, $size] = $matcher->findLongestMatch(
    alo: 0, ahi: 5,
    blo: 0, bhi: 5,
);

// i=1, j=1, size=3  →  'b','c','d' matched at index 1 in both sequences
echo "Match at a[$i], b[$j], length $size\n";
// Match at a[1], b[1], length 3
```

--------------------------------

### Initialize SequenceMatcher

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Create a new SequenceMatcher instance with two sequences (arrays of strings) and optional junk callback and options.

```php
use Jfcherng\Diff\SequenceMatcher;
use Jfcherng\Diff\SequenceMatcherOptions;

$old = ['apple', 'banana', 'cherry'];
$new = ['apple', 'cherry', 'date'];

$matcher = new SequenceMatcher(
    a: $old,
    b: $new,
    junkCallback: null,
    options: new SequenceMatcherOptions(),
);
```

--------------------------------

### SequenceMatcher::__construct()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Initializes the SequenceMatcher with two sequences of strings (old and new). Optionally accepts a junk callback and SequenceMatcherOptions.

```APIDOC
## SequenceMatcher::__construct()

### Description
Initializes the matcher with the old sequence $a and new sequence $b. Both must be `string[]` arrays (typically one element per line). An optional junk callback and options object can be supplied.

### Method
```php
new SequenceMatcher(array $a = [], array $b = [], ?callable $junkCallback = null, ?SequenceMatcherOptions $options = null)
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```php
use Jfcherng\Diff\SequenceMatcher;
use Jfcherng\Diff\SequenceMatcherOptions;

$old = ['apple', 'banana', 'cherry'];
$new = ['apple', 'cherry', 'date'];

$matcher = new SequenceMatcher(
    a: $old,
    b: $new,
    junkCallback: null,
    options: new SequenceMatcherOptions(),
);
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Configure SequenceMatcherOptions

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Configure comparison behavior like case sensitivity, line ending normalization, and whitespace handling. Options can be set directly or from an array.

```php
use Jfcherng\Diff\SequenceMatcherOptions;

// Construct directly
$options = new SequenceMatcherOptions(
    ignoreCase: true,         // treat "Foo" and "foo" as equal
    ignoreLineEnding: true,   // treat "\r\n" and "\n" as equal
    ignoreWhitespace: false,  // whitespace differences still matter
    lengthLimit: 2000,        // lines appearing >1 % of the time are treated as junk
);

// Or build from an array (unknown keys are silently ignored)
$options = SequenceMatcherOptions::fromArray([
    'ignoreCase'       => true,
    'ignoreLineEnding' => true,
]);

// Inspect / serialise
var_dump($options->toArray());
// [
//   'ignoreCase'       => true,
//   'ignoreLineEnding' => true,
//   'ignoreWhitespace' => false,
//   'lengthLimit'      => 2000,
// ]
```

--------------------------------

### setOptions() / getOptions()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Updates or retrieves the `SequenceMatcherOptions` used for comparison. Changing options may trigger an automatic rebuild of the internal index.

```APIDOC
## setOptions() / getOptions()

### Description
Options can be swapped after construction. If the new options differ from the current ones the internal index is rebuilt automatically.

### Method
```php
setOptions(SequenceMatcherOptions $options): void
getOptions(): SequenceMatcherOptions
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```php
use Jfcherng\Diff\SequenceMatcher;
use Jfcherng\Diff\SequenceMatcherOptions;

$matcher = new SequenceMatcher(
    explode("\n", "Hello\nWorld"),
    explode("\n", "hello\nworld"),
);

// First pass — case-sensitive (default)
$opcodes = $matcher->getOpcodes();
// [OP_REP, 0, 2, 0, 2] — both lines replaced

// Switch to case-insensitive
$matcher->setOptions(new SequenceMatcherOptions(ignoreCase: true));
$opcodes = $matcher->getOpcodes();
// [] — sequences are now considered equal

$current = $matcher->getOptions();
var_dump($current->ignoreCase); // true
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Auto-Format Code

Source: https://github.com/jfcherng/php-sequence-matcher/blob/master/CLAUDE.md

Automatically format the codebase according to the defined ruleset using php-cs-fixer. Run this command before committing changes.

```bash
composer fix
```

--------------------------------

### opIntToStr() / opStrToInt()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Static helper methods for converting between integer representations of opcodes (e.g., `OP_EQ`) and their string equivalents (e.g., 'eq').

```APIDOC
## opIntToStr() / opStrToInt()

### Description
Convert opcode representations.

Static helpers for round-tripping between integer and string opcode representations. Both throw `\InvalidArgumentException` on unknown values.

### Methods
```php
public static function opIntToStr(int $op): string
public static function opStrToInt(string $op): int
```

### Example
```php
use Jfcherng\Diff\SequenceMatcher;

echo SequenceMatcher::opIntToStr(SequenceMatcher::OP_DEL); // "del"
echo SequenceMatcher::opIntToStr(SequenceMatcher::OP_INS); // "ins"
echo SequenceMatcher::opIntToStr(SequenceMatcher::OP_REP); // "rep"
echo SequenceMatcher::opIntToStr(SequenceMatcher::OP_EQ);  // "eq"

echo SequenceMatcher::opStrToInt('del'); // 2
echo SequenceMatcher::opStrToInt('ins'); // 4

try {
    SequenceMatcher::opIntToStr(999);
} catch (\InvalidArgumentException $e) {
    echo $e->getMessage(); // "Invalid OP: 999"
}
```
```

--------------------------------

### Update Comparison Options at Runtime

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Change comparison options after SequenceMatcher construction. The internal index is automatically rebuilt if the options differ.

```php
use Jfcherng\Diff\SequenceMatcher;
use Jfcherng\Diff\SequenceMatcherOptions;

$matcher = new SequenceMatcher(
    explode("\n", "Hello\nWorld"),
    explode("\n", "hello\nworld"),
);

// First pass — case-sensitive (default)
$opcodes = $matcher->getOpcodes();
// [OP_REP, 0, 2, 0, 2] — both lines replaced

// Switch to case-insensitive
$matcher->setOptions(new SequenceMatcherOptions(ignoreCase: true));
$opcodes = $matcher->getOpcodes();
// [] — sequences are now considered equal

$current = $matcher->getOptions();
var_dump($current->ignoreCase); // true
```

--------------------------------

### SequenceMatcherOptions

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

A value object to configure comparison behavior like case sensitivity, line ending normalization, whitespace handling, and junk detection.

```APIDOC
## SequenceMatcherOptions

### Description
A readonly value object controlling how lines are normalised before comparison. All properties default to their "strict" values. Can also be built from an associative array via `SequenceMatcherOptions::fromArray()`.

### Method
```php
new SequenceMatcherOptions(bool $ignoreCase = false, bool $ignoreLineEnding = false, bool $ignoreWhitespace = false, ?int $lengthLimit = null)
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```php
use Jfcherng\Diff\SequenceMatcherOptions;

// Construct directly
$options = new SequenceMatcherOptions(
    ignoreCase: true,         // treat "Foo" and "foo" as equal
    ignoreLineEnding: true,   // treat "\r\n" and "\n" as equal
    ignoreWhitespace: false,  // whitespace differences still matter
    lengthLimit: 2000,        // lines appearing >1 % of the time are treated as junk
);

// Or build from an array (unknown keys are silently ignored)
$options = SequenceMatcherOptions::fromArray([
    'ignoreCase'       => true,
    'ignoreLineEnding' => true,
]);

// Inspect / serialise
var_dump($options->toArray());
// [
//   'ignoreCase'       => true,
//   'ignoreLineEnding' => true,
//   'ignoreWhitespace' => false,
//   'lengthLimit'      => 2000,
// ]
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Retrieve Matching Blocks with getMatchingBlocks()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Use getMatchingBlocks() to obtain a sorted list of non-overlapping matching blocks between two sequences. The output includes a sentinel value for the end of the sequences.

```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher(
    ['I', 'Am', 'the', 'best'],
    ['I', 'am', 'almost', 'the', 'best', 'one'],
);

$blocks = $matcher->getMatchingBlocks();
// [
//   [0, 0, 1],   →  'I' matches at a[0] / b[0], length 1
//   [2, 3, 2],   →  'the','best' match at a[2] / b[3], length 2
//   [4, 6, 0],   →  sentinel
// ]
foreach ($blocks as [$i, $j, $k]) {
    if ($k === 0) continue; // skip sentinel
    echo "a[$i.." . ($i + $k - 1) . "] matches b[$j.." . ($j + $k - 1) . "]\n";
}
```

--------------------------------

### getOpcodes()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Generates a detailed list of edit operations required to transform one sequence into another. Each operation is represented by a tuple `[op, i1, i2, j1, j2]`.

```APIDOC
## getOpcodes()

### Description
Get the full list of edit operations.

Returns an array of `[op, i1, i2, j1, j2]` instructions describing exactly how to transform `$a` into `$b`. `op` is one of the integer constants `OP_EQ`, `OP_DEL`, `OP_INS`, `OP_REP`.

### Method
```php
public function getOpcodes(): array
```

### Example
```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher(
    ['Who', 'has', 'been', 'read', 'the', 'book'],
    ['Who', 'read', 'the', 'book', 'today'],
);

foreach ($matcher->getOpcodes() as [$op, $i1, $i2, $j1, $j2]) {
    $opStr = SequenceMatcher::opIntToStr($op);
    echo sprintf("%s  a[%d:%d]  b[%d:%d]\n", $opStr, $i1, $i2, $j1, $j2);
}
// eq   a[0:1]  b[0:1]   →  'Who' is equal
// del  a[1:3]  b[1:1]   →  delete 'has','been' from $a
// eq   a[3:6]  b[1:4]   →  'read','the','book' are equal
// ins  a[6:6]  b[4:5]   →  insert 'today' from $b
```
```

--------------------------------

### Exclude Noise with Junk Callback

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

A junk callback function can be provided to the SequenceMatcher constructor to identify and exclude 'junk' elements, such as blank lines, from the matching process, leading to cleaner diffs.

```php
use Jfcherng\Diff\SequenceMatcher;

$old = ['', 'function foo()', '{', '    return 1;', '}', ''];
$new = ['', 'function foo()', '{', '    return 2;', '}', ''];

// Treat blank lines as junk
$matcher = new SequenceMatcher(
    $old,
    $new,
    junkCallback: static fn(string $line): bool => trim($line) === '',
);

foreach ($matcher->getOpcodes() as [$op, $i1, $i2, $j1, $j2]) {
    if ($op !== SequenceMatcher::OP_EQ) {
        echo SequenceMatcher::opIntToStr($op)
            . "  a[$i1:$i2] → b[$j1:$j2]\n";
    }
}
// rep  a[3:4] → b[3:4]   →  only the return-value line differs
```

--------------------------------

### Run Single PHPUnit Test

Source: https://github.com/jfcherng/php-sequence-matcher/blob/master/CLAUDE.md

Execute a specific PHPUnit test case by its name. This is useful for targeted testing during development.

```bash
vendor/bin/phpunit --filter TestName
```

--------------------------------

### setSequences() / setSeq1() / setSeq2()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Replaces one or both sequences in the matcher. `setSequences()` is preferred for replacing both for efficiency.

```APIDOC
## setSequences() / setSeq1() / setSeq2()

### Description
Efficiently updates one or both sequences and invalidates internal caches. Prefer `setSequences()` when changing both at once; it avoids running the internal `chainB()` routine twice.

### Method
```php
setSequences(array $a, array $b): void
setSeq1(array $a): void
setSeq2(array $b): void
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher([], []);

// Replace both at once (most efficient)
$matcher->setSequences(
    explode("\n", "line1\nline2\nline3"),
    explode("\n", "line1\nlineX\nline3"),
);

// Or set individually (useful when only one side changes)
$matcher->setSeq1(['Who', 'has', 'been', 'read', 'the', 'book']);
$matcher->setSeq2(['Who', 'read', 'the', 'book', 'today']);
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Convert Opcode Representations with opIntToStr() / opStrToInt()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Static helper methods opIntToStr() and opStrToInt() allow conversion between integer opcode constants and their string representations. Both methods will throw an InvalidArgumentException for unknown values.

```php
use Jfcherng\Diff\SequenceMatcher;

echo SequenceMatcher::opIntToStr(SequenceMatcher::OP_DEL); // "del"
echo SequenceMatcher::opIntToStr(SequenceMatcher::OP_INS); // "ins"
echo SequenceMatcher::opIntToStr(SequenceMatcher::OP_REP); // "rep"
echo SequenceMatcher::opIntToStr(SequenceMatcher::OP_EQ);  // "eq"

echo SequenceMatcher::opStrToInt('del'); // 2
echo SequenceMatcher::opStrToInt('ins'); // 4

try {
    SequenceMatcher::opIntToStr(999);
} catch (\InvalidArgumentException $e) {
    echo $e->getMessage(); // "Invalid OP: 999"
}
```

--------------------------------

### Group Opcodes with Context using getGroupedOpcodes()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Use getGroupedOpcodes() to group edit operations into hunks, optionally including surrounding context lines. A context value of 0 returns only the changed blocks.

```php
use Jfcherng\Diff\SequenceMatcher;

$old = explode("\n", "apples\noranges\nkiwis\ncarrots");
$new = explode("\n", "apples\nkiwis\ncarrots\ngrapefruits");

$matcher = new SequenceMatcher($old, $new);

// Default context = 3 lines
$groups = $matcher->getGroupedOpcodes(3);
// [
//   [
//     [OP_EQ,  0, 1, 0, 1],   →  'apples' (context)
//     [OP_DEL, 1, 2, 1, 1],   →  delete 'oranges'
//     [OP_EQ,  2, 4, 1, 3],   →  'kiwis','carrots' (context)
//     [OP_INS, 4, 4, 3, 4],   →  insert 'grapefruits'
//   ]
// ]

// Zero context — only the raw diffs
$groups = $matcher->getGroupedOpcodes(0);
// [
//   [[OP_DEL, 1, 2, 1, 1]],
//   [[OP_INS, 4, 4, 3, 4]],
// ]
```

--------------------------------

### Junk callback

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Allows specifying a callback function to identify and exclude 'junk' elements from the sequence matching process, leading to cleaner diffs by ignoring noise like blank lines.

```APIDOC
## Junk callback

### Description
Exclude noise elements from matching.

Passing a `\Closure` as `$junkCallback` marks matching elements as "junk" so they do not anchor the longest-match algorithm, producing cleaner diffs when noise lines (blank lines, comment lines, etc.) are present.

### Method Signature
```php
public function __construct(
    array $a, array $b, ?callable $junkCallback = null, ...
)
```

### Example
```php
use Jfcherng\Diff\SequenceMatcher;

$old = ['', 'function foo()', '{', '    return 1;', '}', ''];
$new = ['', 'function foo()', '{', '    return 2;', '}', ''];

// Treat blank lines as junk
$matcher = new SequenceMatcher(
    $old,
    $new,
    junkCallback: static fn(string $line): bool => trim($line) === '',
);

foreach ($matcher->getOpcodes() as [$op, $i1, $i2, $j1, $j2]) {
    if ($op !== SequenceMatcher::OP_EQ) {
        echo SequenceMatcher::opIntToStr($op)
            . "  a[".$i1.":"..$i2."] → b[".$j1.":"..$j2."]\n";
    }
}
// rep  a[3:4] → b[3:4]   →  only the return-value line differs
```
```

--------------------------------

### getMatchingBlocks()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Retrieves all non-overlapping matching blocks between two sequences. It returns a sorted list of triples `[i, j, k]` representing matching segments, along with a terminal sentinel.

```APIDOC
## getMatchingBlocks()

### Description
Retrieve all non-overlapping matching blocks.

Returns a sorted list of `[i, j, k]` triples for every maximal contiguous match, plus a terminal sentinel `[len($a), len($b), 0]`.

### Method
```php
public function getMatchingBlocks(): array
```

### Example
```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher(
    ['I', 'Am', 'the', 'best'],
    ['I', 'am', 'almost', 'the', 'best', 'one'],
);

$blocks = $matcher->getMatchingBlocks();
// [
//   [0, 0, 1],   →  'I' matches at a[0] / b[0], length 1
//   [2, 3, 2],   →  'the','best' match at a[2] / b[3], length 2
//   [4, 6, 0],   →  sentinel
// ]
foreach ($blocks as [$i, $j, $k]) {
    if ($k === 0) continue; // skip sentinel
    echo "a[".($i + $k - 1)."]." matches b[".($j + $k - 1)."]\n";
}
```
```

--------------------------------

### Replace Sequences in Matcher

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Efficiently update one or both sequences in an existing SequenceMatcher instance. Use setSequences() to update both at once for better performance.

```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher([], []);

// Replace both at once (most efficient)
$matcher->setSequences(
    explode("\n", "line1\nline2\nline3"),
    explode("\n", "line1\nlineX\nline3"),
);

// Or set individually (useful when only one side changes)
$matcher->setSeq1(['Who', 'has', 'been', 'read', 'the', 'book']);
$matcher->setSeq2(['Who', 'read', 'the', 'book', 'today']);
```

--------------------------------

### getGroupedOpcodes()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Retrieves opcodes grouped into hunks, with optional context lines. This method is useful for displaying diffs in a more readable, chunked format.

```APIDOC
## getGroupedOpcodes()

### Description
Get opcodes grouped with surrounding context.

Groups opcodes into "hunks" separated by large equal blocks, optionally trimming leading/trailing equal lines to `$context` lines each side (default 3). Passing `0` returns only the changed blocks with no surrounding context.

### Method
```php
public function getGroupedOpcodes(int $context = 3): array
```

### Parameters
#### Path Parameters
- **context** (int) - Optional - The number of context lines to include around each hunk. Defaults to 3.

### Example
```php
use Jfcherng\Diff\SequenceMatcher;

$old = explode("\n", "apples\noranges\nkiwis\ncarrots");
$new = explode("\n", "apples\nkiwis\ncarrots\ngrapefruits");

$matcher = new SequenceMatcher($old, $new);

// Default context = 3 lines
$groups = $matcher->getGroupedOpcodes(3);
// [
//   [
//     [OP_EQ,  0, 1, 0, 1],   →  'apples' (context)
//     [OP_DEL, 1, 2, 1, 1],   →  delete 'oranges'
//     [OP_EQ,  2, 4, 1, 3],   →  'kiwis','carrots' (context)
//     [OP_INS, 4, 4, 3, 4],   →  insert 'grapefruits'
//   ]
// ]

// Zero context — only the raw diffs
$groups = $matcher->getGroupedOpcodes(0);
// [
//   [[OP_DEL, 1, 2, 1, 1]],
//   [[OP_INS, 4, 4, 3, 4]],
// ]
```
```

--------------------------------

### Manually Invalidate Cache with resetCachedResults()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

The resetCachedResults() method can be used to manually clear the internal cache for opcodes and matching blocks. This forces a recomputation on the next call to getOpcodes() or getMatchingBlocks(), useful for advanced scenarios where sequences might be modified externally.

```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher(['a', 'b'], ['a', 'c']);
$opcodes = $matcher->getOpcodes(); // computed & cached

// Mutate sequences from outside (hypothetical) and force a recalc
$matcher->resetCachedResults();
$opcodes = $matcher->getOpcodes(); // freshly recomputed
```

--------------------------------

### resetCachedResults()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Manually invalidates the cached results of matching blocks and opcodes. This forces a recomputation on the next call to `getOpcodes()` or `getMatchingBlocks()`, useful for advanced scenarios where sequences might be modified externally.

```APIDOC
## resetCachedResults()

### Description
Manually invalidate cached opcodes.

Forces recomputation of matching blocks and opcodes on the next call to `getOpcodes()` or `getMatchingBlocks()`. Normally called automatically, but exposed for advanced use cases.

### Method
```php
public function resetCachedResults(): void
```

### Example
```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher(['a', 'b'], ['a', 'c']);
$opcodes = $matcher->getOpcodes(); // computed & cached

// Mutate sequences from outside (hypothetical) and force a recalc
$matcher->resetCachedResults();
$opcodes = $matcher->getOpcodes(); // freshly recomputed
```
```

--------------------------------

### findLongestMatch()

Source: https://context7.com/jfcherng/php-sequence-matcher/llms.txt

Finds the longest contiguous matching block within specified ranges of the two sequences.

```APIDOC
## findLongestMatch()

### Description
Returns `[i, j, size]`: the starting index in `$a`, the starting index in `$b`, and the length of the match. Useful for low-level block searching within sub-ranges.

### Method
```php
findLongestMatch(int $alo, int $ahi, int $blo, int $bhi): array
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```php
use Jfcherng\Diff\SequenceMatcher;

$matcher = new SequenceMatcher(
    ['a', 'b', 'c', 'd', 'e'],
    ['x', 'b', 'c', 'd', 'y'],
);

// Search over the full range of both sequences
[$i, $j, $size] = $matcher->findLongestMatch(
    alo: 0, ahi: 5,
    blo: 0, bhi: 5,
);

// i=1, j=1, size=3  →  'b','c','d' matched at index 1 in both sequences
echo "Match at a[$i], b[$j], length $size\n";
// Match at a[1], b[1], length 3
```

### Response
#### Success Response (200)
- **array** - An array containing `[i, j, size]` where `i` is the start index in sequence `a`, `j` is the start index in sequence `b`, and `size` is the length of the match.

#### Response Example
```php
// Example output for the above request:
// [1, 1, 3]
```
```
Tokens:
Raw