@viren070/parse-torrent-title 0.1.3 → 0.3.0

package/README.md

@@ -1,3 +1,348 @@
 # parse-torrent-title
 
-A TypeScript library for parsing torrent titles. This is mostly a port of [go-ptt](https://github.com/MunifTanjim/go-ptt).
+A TypeScript library for parsing torrent titles. This is mostly a port of [go-ptt](https://github.com/MunifTanjim/go-ptt), which in turn is inspired by [TheBeastLT/parse-torrent-title](https://github.com/TheBeastLT/parse-torrent-title) and [dreulavelle/PTT](https://github.com/dreulavelle/PTT).
+
+## Installation
+
+**npm:**
+```bash
+npm install @viren070/parse-torrent-title
+```
+
+**pnpm:**
+```bash
+pnpm add @viren070/parse-torrent-title
+```
+
+**yarn:**
+```bash
+yarn add @viren070/parse-torrent-title
+```
+
+## Demo
+
+Try out the parser in your browser with our [demo](https://viren070.github.io/parse-torrent-title/)! Enter any torrent filename and see the parsed results in real-time.
+
+## Quick Start
+
+```typescript
+import { parseTorrentTitle } from '@viren070/parse-torrent-title';
+
+const result = parseTorrentTitle('The.Matrix.1999.1080p.BluRay.x264.DTS-HD.MA.5.1');
+
+console.log(result);
+// {
+//   "resolution": "1080p",
+//   "year": "1999",
+//   "quality": "BluRay",
+//   "codec": "x264",
+//   "channels": [
+//     "5.1"
+//   ],
+//   "audio": [
+//     "DTS Lossless"
+//   ],
+//   "title": "The Matrix"
+// }
+```
+
+## Output Types
+
+The parser returns a `ParsedResult` object with the following optional fields:
+
+```typescript
+interface ParsedResult {
+  // Basic Information
+  title?: string;           // Movie or series title
+  year?: string;            // Release year
+  date?: string;            // Release date
+  
+  // Video Quality
+  resolution?: string;      // e.g., '1080p', '720p', '4K', '2160p'
+  quality?: string;         // e.g., 'BluRay', 'WEB-DL', 'HDTV', 'DVDRip'
+  codec?: string;           // e.g., 'x264', 'x265', 'hevc', 'xvid'
+  bitDepth?: string;        // e.g., '10bit', '8bit'
+  hdr?: string[];           // e.g., ['HDR10', 'HDR', 'Dolby Vision']
+  threeD?: string;          // e.g., '3D SBS', '3D HOU'
+  
+  // Audio
+  audio?: string[];         // e.g., ['DTS', 'AC3', 'AAC', 'MP3']
+  channels?: string[];      // e.g., ['5.1', '7.1', '2.0']
+  
+  // Episode/Season Information
+  seasons?: number[];       // Season numbers, e.g., [1, 2, 3]
+  episodes?: number[];      // Episode numbers, e.g., [1, 2, 3]
+  episodeCode?: string;     // e.g., '5E46AC39'
+  complete?: boolean;       // Complete season/series indicator
+  volumes?: number[];       // Volume numbers
+  
+  // Languages and Subtitles
+  languages?: string[];     // e.g., ['en', 'jp', 'multi subs', 'multi audio', 'dual audio', 'es-419']
+  dubbed?: boolean;         // Whether content is dubbed
+  subbed?: boolean;         // Whether subtitles are included
+  hardcoded?: boolean;      // Hardcoded subtitles
+  
+  // Release Information
+  group?: string;           // Release group name
+  site?: string;            // Source site
+  network?: string;         // Broadcasting network (e.g., 'Netflix', 'HBO', 'Amazon')
+  edition?: string;         // e.g., 'Extended', 'Theatrical', "Director's Cut"
+  releaseTypes?: string[];  // Release type tags
+  
+  // Release Flags
+  repack?: boolean;         // Repack indicator
+  proper?: boolean;         // Proper release indicator
+  retail?: boolean;         // Retail release
+  remastered?: boolean;     // Remastered release
+  unrated?: boolean;        // Unrated version
+  uncensored?: boolean;     // Uncensored version
+  extended?: boolean;       // Extended version
+  convert?: boolean;        // Converted release
+  documentary?: boolean;    // Documentary flag
+  commentary?: boolean;     // Commentary track included
+  upscaled?: boolean;       // Upscaled content indicator
+  
+  // Technical Details
+  container?: string;       // File container, e.g., 'mkv', 'mp4', 'avi'
+  extension?: string;       // File extension
+  region?: string;          // Regional encoding
+  size?: string;            // File size
+}
+```
+
+## Advanced Usage
+
+### Using the Parser Class
+
+For more control, you can use the `Parser` class:
+
+```typescript
+import { Parser } from '@viren070/parse-torrent-title';
+
+// Create a parser with only specific fields
+const parser = new Parser()
+  .addDefaultHandlers('title', 'year', 'resolution', 'quality');
+
+const result = parser.parse('The.Matrix.1999.1080p.BluRay.x264');
+// Only extracts: title, year, resolution, quality
+```
+
+## Writing Custom Handlers
+
+You can extend the parser's capabilities by writing your own handlers. A handler is an object that defines how to find and process a piece of metadata in the torrent title.
+
+### Handler Interface
+
+Here is the structure of a `Handler` object:
+
+```typescript
+interface Handler {
+  field: string;
+  pattern?: RegExp;
+  validateMatch?: (input: string, idxs: number[]) => boolean;
+  transform?: (title: string, m: ParseMeta, result: Map<string, ParseMeta>) => void;
+  process?: (title: string, m: ParseMeta, result: Map<string, ParseMeta>) => ParseMeta;
+  remove?: boolean;
+  keepMatching?: boolean;
+  skipIfFirst?: boolean;
+  skipIfBefore?: string[];
+  skipFromTitle?: boolean;
+  matchGroup?: number;
+  valueGroup?: number;
+}
+```
+
+### Handler Properties
+
+| Property | Type | Description |
+| :--- | :--- | :--- |
+| `field` | `string` | **Required.** The key this handler will populate in the result object (e.g., `'resolution'`, `'quality'`). |
+| `pattern` | `RegExp` | A regular expression used to find a value in the title. |
+| `transform` | `function` | A function to process the matched value. See the [Transformers](#transformers) section for available utilities. |
+| `validateMatch` | `function` | A function that returns `true` or `false` to determine if a match is valid. Use this to prevent a handler from running on a bad match. See [Validators](#validators) for available utilities to aid in writing validation logic. |
+| `process` | `function` | For complex logic that can't be handled by `pattern` and `transform`. It can create or modify the entire metadata object for a field. |
+| `remove` | `boolean` | If `true`, the matched text is removed from the title string. Defaults to `false`. |
+| `keepMatching` | `boolean` | If `true`, the parser will keep searching for this field even if a value has already been found. Useful for fields that can have multiple values (e.g., `languages`). Defaults to `false`. |
+| `skipFromTitle` | `boolean` | If `true`, this match will not be used to determine the end of the main `title` property. Useful for metadata at the end of the string (e.g., release group). Defaults to `false`. |
+| `skipIfFirst` | `boolean` | If `true`, the handler will be skipped if its match is the very first piece of metadata found in the title. |
+| `skipIfBefore` | `string[]` | An array of field names. The handler will be skipped if its match appears before any of those fields have been matched. |
+| `matchGroup` | `number` | The regex capture group to use as the "full match" text. This is the part that gets removed from the title if `remove` is `true`. |
+| `valueGroup` | `number` | The regex capture group to use as the "value" for the field. If not set, it defaults to capture group 1 if it exists. |
+
+### Custom Handler Example
+
+Here is an example of a custom handler that finds a fictional "Source" tag (e.g., `[SRC-XYZ]`) and adds it to a custom field:
+
+```javascript
+import { Parser, toTrimmed } from '@viren070/parse-torrent-title';
+
+const parser = new Parser();
+
+// Add a custom handler
+parser.addHandler({
+  field: 'sourceId',
+  pattern: /\[SRC-([\w]+)\]/i,
+  transform: toTrimmed(), // Trim whitespace from the matched value
+  remove: true, // Remove "[SRC-XYZ]" from the title
+  valueGroup: 1, // Use the first capture group "XYZ" as the value
+});
+
+parser.addDefaultHandlers();
+
+const result = parser.parse('My.Movie.2023.1080p.[SRC-WIKIPEDIA].mkv');
+
+console.log(result.sourceId); // "WIKIPEDIA"
+console.log(result.title); // "My Movie"
+```
+
+### Type-Safe Custom Fields
+
+You can use TypeScript generics to get full type safety for your custom fields:
+
+```typescript
+import { Parser, Handler, transforms } from '@viren070/parse-torrent-title';
+
+const customHandler: Handler = {
+  field: 'customId',
+  pattern: /custom-(\d+)/i,
+  transform: transforms.toIntArray()
+};
+
+const parser = new Parser()
+  .addDefaultHandlers() // Add all default handlers
+  .addHandler(customHandler); // Add your custom handler
+
+type CustomFields = { customId: number[] };
+const typedResult = parser.parse<CustomFields>('Movie.2024.custom-123.1080p');
+console.log(typedResult.customId); // [123] - fully type-safe!
+```
+
+### Transformers
+
+Transformers modify the captured value before it's stored in the result. All transformers are functions that return a `HandlerTransformer`.
+
+**Value Transformers:**
+- `toValue(value: string)` - Set a fixed value instead of the captured text
+- `toBoolean()` - Set the value to `true` (useful for flags)
+- `toIntArray()` - Convert captured text to an array with a single integer
+- `toIntRange()` - Convert range like "1-8" to `[1,2,3,4,5,6,7,8]`
+
+**String Transformers:**
+- `toLowercase()` - Convert to lowercase
+- `toUppercase()` - Convert to uppercase
+- `toTrimmed()` - Trim whitespace from the value
+- `toWithSuffix(suffix: string)` - Append a suffix to the value
+
+**Date/Time Transformers:**
+- `toDate(format: string)` - Parse and format date strings (supports formats like "2006 01 02", "20060102")
+- `toYear()` - Extract and format year (handles year ranges like "2020-2024")
+- `toCleanDate()` - Remove ordinal suffixes (1st → 1, 2nd → 2, etc.)
+- `toCleanMonth()` - Normalize month names to 3-letter abbreviations
+
+**Advanced Transformers:**
+- `toValueSet(value: any)` - Add value to a ValueSet (for multi-value fields)
+- `toValueSetWithTransform(fn: (v: string) => any)` - Transform and add to ValueSet
+- `toValueSetMultiWithTransform(fn: (v: string) => any[])` - Transform to multiple values and add to ValueSet
+
+**Processor:**
+- `removeFromValue(regex: RegExp)` - Remove matching patterns from the captured value
+
+### Validators
+
+Validators determine whether a match should be accepted. They're used with the `validateMatch` property.
+
+- `validateMatch(regex: RegExp)` - Accept only if the captured text matches the regex
+- `validateNotMatch(regex: RegExp)` - Reject if the captured text matches the regex
+- `validateNotAtStart()` - Reject matches at the start of the title
+- `validateNotAtEnd()` - Reject matches at the end of the title
+- `validateMatchedGroupsAreSame(...indices: number[])` - Accept only if specified capture groups have the same value
+- `validateAnd(...validators: HandlerMatchValidator[])` - Combine multiple validators (all must pass)
+
+Example with validators:
+
+```typescript
+import { Parser, Handler, validators, transforms } from '@viren070/parse-torrent-title';
+
+const handler: Handler = {
+  field: 'episodes',
+  pattern: /episode[.\s]*(\d+)/i,
+  validateMatch: validators.validateNotMatch(/season/i), // Don't match if "season" is present
+  transform: transforms.toIntArray()
+};
+```
+
+## Examples
+
+### TV Series
+
+```typescript
+parseTorrentTitle('[Erai-raws] Attack on Titan - S04E01 [1080p][Multiple Subtitle].mkv');
+// {
+//   "resolution": "1080p",
+//   "container": "mkv",
+//   "seasons": [4],
+//   "episodes": [1],
+//   "languages": ["multi subs"],
+//   "subbed": true,
+//   "group": "Erai-raws",
+//   "extension": "mkv",
+//   "title": "Attack on Titan"
+// }
+```
+
+### Season Packs
+
+```typescript
+parseTorrentTitle('Breaking.Bad.Season.1-5.Complete.1080p.BluRay.x265.HEVC.10bit');
+// {
+//   "resolution": "1080p",
+//   "quality": "BluRay",
+//   "bitDepth": "10bit",
+//   "codec": "hevc",
+//   "complete": true,
+//   "seasons": [1, 2, 3, 4, 5],
+//   "title": "Breaking Bad"
+// }
+```
+
+### Movies with HDR
+
+```typescript
+parseTorrentTitle('Dune.2021.2160p.UHD.BluRay.HDR10.DV.x265.DTS-HD.MA.5.1');
+// {
+//   "resolution": "4k",
+//   "year": "2021",
+//   "quality": "BluRay",
+//   "bitDepth": "10bit",
+//   "hdr": [
+//     "DV",
+//     "HDR"
+//   ],
+//   "codec": "x265",
+//   "channels": [
+//     "5.1"
+//   ],
+//   "audio": [
+//     "DTS Lossless"
+//   ],
+//   "title": "Dune"
+// }
+```
+
+## TypeScript Support
+
+This library is written in TypeScript and includes full type definitions. All types are exported for your use:
+
+```typescript
+import { ParsedResult, Handler } from '@viren070/parse-torrent-title';
+```
+
+## License
+
+MIT
+
+## Credits
+
+- [MunifTanjim/go-ptt](https://github.com/MunifTanjim/go-ptt)
+- [TheBeastLT/parse-torrent-title](https://github.com/TheBeastLT/parse-torrent-title)
+- [dreulavelle/PTT](https://github.com/dreulavelle/PTT)

package/dist/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../src/handlers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAY,MAAM,YAAY,CAAC;AA2B/C;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,OAAO,EAuxF7B,CAAC"}
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../src/handlers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAY,MAAM,YAAY,CAAC;AAgC/C;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,OAAO,EA+7F7B,CAAC"}

package/dist/handlers.js

@@ -6,7 +6,9 @@
  */
 import { ValueSet } from './types.js';
 import { nonAlphasRegex } from './utils.js';
-import { validateAnd, validateNotAtStart, validateNotAtEnd, validateNotMatch, validateMatch, validateMatchedGroupsAreSame, toValue, toLowercase, toUppercase, toTrimmed, toCleanDate, toCleanMonth, toDate, toYear, toIntRange, toWithSuffix, toBoolean, toValueSet, toValueSetWithTransform, toValueSetMultiWithTransform, toIntArray, removeFromValue } from './transforms.js';
+import { toValue, toLowercase, toUppercase, toTrimmed, toCleanDate, toCleanMonth, toDate, toYear, toIntRange, toWithSuffix, toBoolean, toValueSet, toValueSetWithTransform, toValueSetMultiWithTransform, toIntArray } from './transforms.js';
+import { validateAnd, validateNotAtStart, validateNotAtEnd, validateNotMatch, validateMatch, validateMatchedGroupsAreSame, validateLookbehind, validateOr, validateLookahead } from './validators.js';
+import { removeFromValue } from './processors.js';
 /**
  * All handlers in the exact order as handlers.go
  *
@@ -27,13 +29,15 @@ export const handlers = [
     // PPV handlers (lines 294-300 in handlers.go)
     {
         field: 'ppv',
-        pattern: /\bPPV\b/i,
+        pattern: /\bPPV(?:HD)?\b/i,
+        transform: toBoolean(),
         remove: true,
         skipFromTitle: true
     },
     {
         field: 'ppv',
         pattern: /\b\W?Fight.?Nights?\W?\b/i,
+        transform: toBoolean(),
         skipFromTitle: true
     },
     // Site handlers (lines 302-317 in handlers.go)
@@ -213,7 +217,9 @@ export const handlers = [
         pattern: /[ .]?([(\[*]?((?:19\d|20[012])\d[ .]?-[ .]?(?:19\d|20[012])\d)[*)\]]?)[ .]?/,
         transform: (title, m, result) => {
             toYear()(title, m, result);
-            if (!result.has('complete') && typeof m.value === 'string' && m.value.includes('-')) {
+            if (!result.has('complete') &&
+                typeof m.value === 'string' &&
+                m.value.includes('-')) {
                 result.set('complete', {
                     mIndex: m.mIndex,
                     mValue: m.mValue,
@@ -232,7 +238,9 @@ export const handlers = [
         pattern: /[(\[*][ .]?((?:19\d|20[012])\d[ .]?-[ .]?\d{2})(?:\s?[*)\]])?/,
         transform: (title, m, result) => {
             toYear()(title, m, result);
-            if (!result.has('complete') && typeof m.value === 'string' && m.value.includes('-')) {
+            if (!result.has('complete') &&
+                typeof m.value === 'string' &&
+                m.value.includes('-')) {
                 result.set('complete', {
                     mIndex: m.mIndex,
                     mValue: m.mValue,
@@ -296,7 +304,7 @@ export const handlers = [
         field: 'edition',
         pattern: /\b\d{2,3}(?:th)?[\.\s\-\+_\/(),]Anniversary[\.\s\-\+_\/(),](?:Edition|Ed)?\b/i,
         transform: toValue('Anniversary Edition'),
-        remove: true,
+        remove: true
     },
     {
         field: 'edition',
@@ -672,6 +680,12 @@ export const handlers = [
         transform: toValue('WEBRip'),
         remove: true
     },
+    {
+        field: 'quality',
+        pattern: /\bWEB[ .-]?Cap\b/i,
+        transform: toValue('WEBCap'),
+        remove: true
+    },
     {
         field: 'quality',
         pattern: /\bWEB[ .-]?DL[ .-]?Rip\b/i,
@@ -691,7 +705,9 @@ export const handlers = [
     },
     {
         field: 'quality',
-        pattern: /\b(DivX|XviD)\b/
+        pattern: /\b(W(?:ORK)P(?:RINT))\b/,
+        transform: toValue('WORKPRINT'),
+        remove: true
     },
     {
         field: 'quality',
@@ -709,10 +725,16 @@ export const handlers = [
     },
     {
         field: 'quality',
-        pattern: /\bHD(?:.?TV)?\b/i,
+        pattern: /\bHD(?:.?TV)?\b(?!-ELITE\.NET)/i,
         transform: toValue('HDTV'),
         remove: true
     },
+    {
+        field: 'quality',
+        pattern: /\bSD(?:.?TV)?\b/i,
+        transform: toValue('SDTV'),
+        remove: true
+    },
     // Bit Depth handlers (lines 1056-1077 in handlers.go)
     {
         field: 'bitDepth',
@@ -1568,8 +1590,11 @@ export const handlers = [
             let mStr = '';
             if (match && match.index !== undefined) {
                 mStr = match[0];
-                if (match.index === 0 || btReNegBefore.test(mStr) || btReNegAfter.test(mStr) ||
-                    commonResolutionNeg.test(mStr) || commonFPSNeg.test(mStr)) {
+                if (match.index === 0 ||
+                    btReNegBefore.test(mStr) ||
+                    btReNegAfter.test(mStr) ||
+                    commonResolutionNeg.test(mStr) ||
+                    commonFPSNeg.test(mStr)) {
                     match = null;
                     mStr = '';
                 }
@@ -1583,7 +1608,8 @@ export const handlers = [
                     // Check from the start of capture group 1 (the number) to the end
                     const captureGroupIndex = match[0].indexOf(match[1]);
                     const fromCaptureGroup = middleTitle.substring(match.index + captureGroupIndex);
-                    if (mtReNegAfter.test(fromCaptureGroup) || commonResolutionNeg.test(mStr)) {
+                    if (mtReNegAfter.test(fromCaptureGroup) ||
+                        commonResolutionNeg.test(mStr)) {
                         match = null;
                         mStr = '';
                     }
@@ -1761,22 +1787,24 @@ export const handlers = [
     // French language handlers
     {
         field: 'languages',
-        pattern: /\bFR(?:a|e|anc[eê]s|VF[FQIB2]?)?\b/i,
+        pattern: /\bFR(?:a|e|anc[eê]s|VF[FQIB2]?)\b/i,
         transform: toValueSet('fr'),
         keepMatching: true,
         skipFromTitle: true
     },
     {
         field: 'languages',
-        pattern: /\b(?:TRUE|SUB).?FRENCH\b|\bFRENCH\b/,
+        pattern: /\b(?:TRUE|SUB).?FRENCH\b|\bFRENCH\b|\bFre?\b/,
         transform: toValueSet('fr'),
-        keepMatching: true
+        keepMatching: true,
+        remove: true
     },
     {
         field: 'languages',
         pattern: /\b\[?(?:VF[FQRIB2]?\]?\b|(?:VOST)?FR2?)\b/,
         transform: toValueSet('fr'),
-        keepMatching: true
+        keepMatching: true,
+        remove: true
     },
     {
         field: 'languages',
@@ -1801,24 +1829,9 @@ export const handlers = [
     },
     {
         field: 'languages',
-        pattern: /\b(?:audio.)?(?:ESP|spa|(?:en[ .]+)?espa[nñ]ola?|castellano)\b/i,
+        pattern: /\b(?:audio.)?(?:ESP?|spa|(?:en[ .]+)?espa[nñ]ola?|castellano)\b/i,
         transform: toValueSet('es'),
-        keepMatching: true,
-        remove: true
-    },
-    {
-        field: 'languages',
-        pattern: /\b(?:[ .,/-]+(?:[A-Z]{2}[ .,/-]+){2,})es\b/i,
-        transform: toValueSet('es'),
-        keepMatching: true,
-        skipFromTitle: true
-    },
-    {
-        field: 'languages',
-        pattern: /\b(?:[ .,/-]*[A-Z]{2}[ .,/-]+)es(?:[ .,/-]+[A-Z]{2}[ .,/-]+)\b/i,
-        transform: toValueSet('es'),
-        keepMatching: true,
-        skipFromTitle: true
+        keepMatching: true
     },
     {
         field: 'languages',
@@ -1840,6 +1853,13 @@ export const handlers = [
         keepMatching: true,
         skipIfFirst: true
     },
+    {
+        field: 'languages',
+        pattern: /\b[\.\s\[]?Sp[\.\s\]]?\b/i,
+        transform: toValueSet('es'),
+        keepMatching: true,
+        remove: true
+    },
     // Portuguese language handlers
     {
         field: 'languages',
@@ -1886,6 +1906,13 @@ export const handlers = [
         keepMatching: true,
         skipFromTitle: true
     },
+    {
+        field: 'languages',
+        pattern: /\bpt\b/i,
+        transform: toValueSet('pt'),
+        keepMatching: true,
+        remove: true
+    },
     {
         field: 'languages',
         pattern: /\bpor\b/i,
@@ -1902,15 +1929,16 @@ export const handlers = [
     },
     {
         field: 'languages',
-        pattern: /\b(?:w{3}\.\w+\.)?IT(?:[ .,/-]+(?:[a-zA-Z]{2}[ .,/-]+){2,})\b/,
-        validateMatch: validateNotMatch(/(?:w{3}\.\w+\.)IT/),
+        pattern: /\bIT\b/i,
+        validateMatch: validateAnd(validateLookbehind('(?:w{3}\\.\\w+\\.)', 'i', false), validateOr(validateLookahead('(?:[ .,/-]+(?:[A-Z]{2}[ .,/-]+){2,})', 'i', true), validateLookbehind('(?:(?:[ .,/-]*[A-Z]{2}){2,}[ .,/-]+)', 'i', true))),
         transform: toValueSet('it'),
         keepMatching: true,
         skipFromTitle: true
     },
     {
         field: 'languages',
-        pattern: /\bit(?:\.(?:ass|ssa|srt|sub|idx)$)/i,
+        pattern: /\bit/i,
+        validateMatch: validateLookahead('(?:\\.(?:ass|ssa|srt|sub|idx)$)', 'i', true),
         transform: toValueSet('it'),
         keepMatching: true,
         skipFromTitle: true
@@ -1940,15 +1968,25 @@ export const handlers = [
     },
     {
         field: 'languages',
-        pattern: /\bde(?:[ .,/-]+(?:[A-Z]{2}[ .,/-]+){2,})\b/i,
+        pattern: /\bde\b/i,
+        validateMatch: validateLookahead('(?:[ .,/-]+(?:[A-Z]{2}[ .,/-]+){2,})', 'i', true),
         transform: toValueSet('de'),
         keepMatching: true,
         skipFromTitle: true
     },
     {
         field: 'languages',
-        pattern: /\b(?:[ .,/-]+(?:[A-Z]{2}[ .,/-]+){2,})de\b/i,
+        pattern: /\bde\b/i,
         transform: toValueSet('de'),
+        validateMatch: validateLookbehind('(?:[ .,/-]+(?:[A-Z]{2}[ .,/-]+){2,})', 'i', true),
+        keepMatching: true,
+        skipFromTitle: true
+    },
+    {
+        field: 'languages',
+        pattern: /\bde\b/i,
+        transform: toValueSet('de'),
+        validateMatch: validateAnd(validateLookbehind('(?:[ .,/-]+[A-Z]{2}[ .,/-]+)', 'i', true), validateLookahead('(?:[ .,/-]+[A-Z]{2}[ .,/-]+)', 'i', true)),
         keepMatching: true,
         skipFromTitle: true
     },
@@ -2534,6 +2572,12 @@ export const handlers = [
         remove: true,
         skipFromTitle: true
     },
+    {
+        field: 'dubbed',
+        pattern: /\bMULTi\b/i,
+        transform: toBoolean(),
+        remove: true
+    },
     {
         field: 'dubbed',
         pattern: /\b(?:Fan.*)?(?:DUBBED|dublado|dubbing|DUBS?)\b/i,
@@ -2560,7 +2604,9 @@ export const handlers = [
                 return m;
             }
             const s = lm.value;
-            if (s && s.exists && (s.exists('multi audio') || s.exists('dual audio'))) {
+            if (s &&
+                s.exists &&
+                (s.exists('multi audio') || s.exists('dual audio'))) {
                 m.value = true;
             }
             return m;
@@ -2575,7 +2621,21 @@ export const handlers = [
     // Site handlers
     {
         field: 'site',
-        pattern: /\[([^\[\].]+\.[^\].]+)\](?:\.\w{2,4}$|\s)/i,
+        pattern: /\[eztv\]/i,
+        transform: toValue('eztv.re'),
+        remove: true,
+        skipFromTitle: true
+    },
+    {
+        field: 'site',
+        pattern: /\beztv\b/i,
+        transform: toValue('eztv.re'),
+        remove: true,
+        skipFromTitle: true
+    },
+    {
+        field: 'site',
+        pattern: /^\[([^\[\]]+\.[^\[\]]+)\]/i,
         transform: toTrimmed(),
         remove: true,
         skipFromTitle: true,
@@ -2583,9 +2643,27 @@ export const handlers = [
     },
     {
         field: 'site',
-        pattern: /[\[{(](www.\w*.\w+)[)}\]]/i,
+        pattern: /-(www\.[\w-]+\.[\w-]+(?:\.[\w-]+)*)\.(\w{2,4})$/i,
+        transform: toTrimmed(),
         remove: true,
-        skipFromTitle: true
+        skipFromTitle: true,
+        matchGroup: 1
+    },
+    {
+        field: 'site',
+        pattern: /\[([^\[\].]+\.[^\].]+)\](?:\.\w{2,4})?(?:$|\s)/i,
+        transform: toTrimmed(),
+        remove: true,
+        skipFromTitle: true,
+        matchGroup: 1
+    },
+    {
+        field: 'site',
+        pattern: /[\[{(](www\.[\w-]+\.[\w-]+(?:\.[\w-]+)*)[)}\]]/i,
+        transform: toTrimmed(),
+        remove: true,
+        skipFromTitle: true,
+        matchGroup: 1
     },
     {
         field: 'site',