@peter.naydenov/url-pattern 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Options for customizing the pattern syntax
+ */
+export interface UrlPatternOptions {
+  /** Character used for escaping special characters (default: '\\') */
+  escapeChar?: string;
+  /** Character that starts a named segment (default: ':') */
+  segmentNameStartChar?: string;
+  /** Characters allowed in segment names (default: 'a-zA-Z0-9') */
+  segmentNameCharset?: string;
+  /** Characters allowed in segment values (default: 'a-zA-Z0-9-_~ %') */
+  segmentValueCharset?: string;
+  /** Character that starts an optional segment (default: '(') */
+  optionalSegmentStartChar?: string;
+  /** Character that ends an optional segment (default: ')') */
+  optionalSegmentEndChar?: string;
+  /** Character that denotes a wildcard (default: '*') */
+  wildcardChar?: string;
+}
+
+/**
+ * Result of matching a pattern against a string
+ */
+export interface MatchResult {
+  [key: string]: string | string[] | null;
+}
+
+/**
+ * Compiled pattern object
+ */
+export interface CompiledPattern {
+  regex: string;
+  regexObj: RegExp;
+  segments: ParsedSegment[];
+  segmentNames: SegmentName[];
+  options: UrlPatternOptions;
+  isRegex: boolean;
+  pattern?: string;
+  keys?: string[];
+}
+
+/**
+ * Parsed segment
+ */
+export interface ParsedSegment {
+  name: string;
+  type: 'named' | 'wildcard' | 'literal';
+  optional?: boolean;
+  regex: string;
+}
+
+/**
+ * Segment name mapping
+ */
+export interface SegmentName {
+  name: string;
+  index: number;
+  type: 'named' | 'wildcard';
+}
+
+/**
+ * UrlPattern class for matching and generating URLs
+ */
+export class UrlPattern {
+  /**
+   * @param pattern - Pattern string or RegExp
+   * @param options - Options object or keys array (for regex patterns)
+   */
+  constructor(pattern: string | RegExp, options?: UrlPatternOptions | string[]);
+
+  /**
+   * Match a string against the pattern
+   * @param str - String to match
+   * @returns Extracted values or null if no match
+   */
+  match(str: string): MatchResult | null;
+
+  /**
+   * Generate a string from the pattern
+   * @param values - Values to stringify
+   * @returns Generated string
+   */
+  stringify(values?: Record<string, any>): string;
+}
+
+/**
+ * Creates a new UrlPattern instance (functional API)
+ * @param pattern - Pattern string or RegExp
+ * @param options - Options object or keys array (for regex patterns)
+ * @returns UrlPattern instance
+ */
+export function urlPattern(pattern: string | RegExp, options?: UrlPatternOptions | string[]): UrlPattern;
+
+/**
+ * Creates a compiled pattern from a string
+ * @param pattern - Pattern string
+ * @param options - Options
+ * @returns Compiled pattern
+ */
+export function makePattern(pattern: string, options?: UrlPatternOptions): CompiledPattern;
+
+/**
+ * Creates a compiled pattern from a regex
+ * @param regex - Regex pattern
+ * @param keys - Array of key names for captured groups
+ * @returns Compiled pattern
+ */
+export function makePatternFromRegex(regex: RegExp, keys?: string[]): CompiledPattern;
+
+/**
+ * Matches a string against a compiled pattern
+ * @param compiled - Compiled pattern
+ * @param str - String to match
+ * @returns Extracted values or null
+ */
+export function match(compiled: CompiledPattern, str: string): MatchResult | null;
+
+/**
+ * Stringifies a pattern with given values
+ * @param compiled - Compiled pattern
+ * @param values - Values to stringify
+ * @returns Generated string
+ */
+export function stringify(compiled: CompiledPattern, values?: Record<string, any>): string;
+
+/**
+ * Default options
+ */
+export const DEFAULT_OPTIONS: UrlPatternOptions;
+
+export default UrlPattern;

package/dist/index.js

@@ -0,0 +1,493 @@
+/**
+ * @fileoverview URL pattern matching library
+ * @module url-pattern
+ */
+
+/**
+ * @typedef {Object} UrlPatternOptions
+ * @property {string} [escapeChar='\\'] - Character used for escaping special characters
+ * @property {string} [segmentNameStartChar=':'] - Character that starts a named segment
+ * @property {string} [segmentNameCharset='a-zA-Z0-9'] - Characters allowed in segment names
+ * @property {string} [segmentValueCharset='a-zA-Z0-9-_~ %'] - Characters allowed in segment values
+ * @property {string} [optionalSegmentStartChar='('] - Character that starts an optional segment
+ * @property {string} [optionalSegmentEndChar=')'] - Character that ends an optional segment
+ * @property {string} [wildcardChar='*'] - Character that denotes a wildcard
+ */
+
+/**
+ * @typedef {Object} ParsedSegment
+ * @property {string} name - Segment name
+ * @property {string} type - Segment type ('named' | 'wildcard' | 'literal')
+ * @property {boolean} [optional=false] - Whether the segment is optional
+ * @property {string} regex - Compiled regex string
+ */
+
+/**
+ * @typedef {Object} SegmentName
+ * @property {string} name - Segment name
+ * @property {number} index - Capture group index
+ * @property {string} type - Segment type ('named' | 'wildcard')
+ */
+
+/**
+ * @typedef {Object} CompiledPattern
+ * @property {string} regex - Compiled regex string
+ * @property {RegExp} regexObj - Compiled regex object
+ * @property {Array<ParsedSegment>} segments - Parsed segments
+ * @property {Array<SegmentName>} segmentNames - Segment name mappings
+ * @property {UrlPatternOptions} options - Options used
+ * @property {boolean} isRegex - Whether pattern was created from regex
+ * @property {string} [pattern] - Original pattern string
+ * @property {Array<string>} [keys] - Keys for regex patterns
+ */
+
+/**
+ * Default options for URL pattern matching
+ * @type {UrlPatternOptions}
+ */
+const DEFAULT_OPTIONS = {
+  escapeChar: '\\',
+  segmentNameStartChar: ':',
+  segmentNameCharset: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
+  segmentValueCharset: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_~ %',
+  optionalSegmentStartChar: '(',
+  optionalSegmentEndChar: ')',
+  wildcardChar: '*'
+};
+
+/**
+ * Escapes special regex characters in a string
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * Merges default options with user provided options
+ * @param {UrlPatternOptions} [userOptions={}] - User provided options
+ * @returns {UrlPatternOptions} Merged options
+ */
+const mergeOptions = (userOptions = {}) => ({
+  ...DEFAULT_OPTIONS,
+  ...userOptions
+});
+
+/**
+ * Finds the position of the next special character in the pattern
+ * @param {string} pattern - Pattern string
+ * @param {number} start - Starting position
+ * @param {UrlPatternOptions} options - Parsing options
+ * @returns {number} Position of next special character
+ */
+const findNextSpecialChar = (pattern, start, options) => {
+  const chars = [
+    options.escapeChar, 
+    options.optionalSegmentStartChar, 
+    options.optionalSegmentEndChar, 
+    options.wildcardChar, 
+    options.segmentNameStartChar
+  ];
+  
+  let minPos = pattern.length;
+  
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i];
+    if (!char) continue;
+    const pos = pattern.indexOf(char, start);
+    if (pos !== -1 && pos < minPos) {
+      minPos = pos;
+    }
+  }
+  
+  return minPos;
+};
+
+/**
+ * Parses a pattern string into segments
+ * @param {string} pattern - Pattern string to parse
+ * @param {UrlPatternOptions} options - Parsing options
+ * @returns {Array<ParsedSegment>} Parsed segments
+ */
+const parsePattern = (pattern, options) => {
+  const segments = [];
+  let i = 0;
+  let inOptional = false;
+
+  while (i < pattern.length) {
+    const char = pattern[i];
+
+    if (char === options.escapeChar && i + 1 < pattern.length) {
+      segments.push({
+        type: 'literal',
+        name: pattern[i + 1],
+        regex: escapeRegex(pattern[i + 1]),
+        optional: inOptional
+      });
+      i += 2;
+      continue;
+    }
+
+    if (char === options.optionalSegmentStartChar) {
+      inOptional = true;
+      i++;
+      continue;
+    }
+
+    if (char === options.optionalSegmentEndChar) {
+      inOptional = false;
+      i++;
+      continue;
+    }
+
+    if (char === options.wildcardChar) {
+      segments.push({
+        type: 'wildcard',
+        name: '_',
+        regex: '.*',
+        optional: inOptional
+      });
+      i++;
+      continue;
+    }
+
+    if (char === options.segmentNameStartChar && i + 1 < pattern.length) {
+      const remaining = pattern.slice(i + 1);
+      let nameEnd = 0;
+      const charset = options.segmentNameCharset || '';
+      
+      for (let j = 0; j < remaining.length; j++) {
+        if (!charset.includes(remaining[j])) {
+          break;
+        }
+        nameEnd = j + 1;
+      }
+      
+      const name = remaining.slice(0, nameEnd);
+      
+      if (name.length > 0) {
+        let valueCharset = options.segmentValueCharset || '';
+        if (valueCharset.includes('-') && valueCharset.indexOf('-') > 0 && valueCharset.indexOf('-') < valueCharset.length - 1) {
+          valueCharset = valueCharset.replace(/-/g, '');
+          valueCharset += '-';
+        }
+        const escapedValueCharset = valueCharset.replace(/\]/g, '\\]');
+        const valueRegex = `([${escapedValueCharset}]+)`;
+        
+        segments.push({
+          type: 'named',
+          name,
+          regex: valueRegex,
+          optional: inOptional
+        });
+        i += 1 + nameEnd;
+        continue;
+      }
+    }
+
+    const literalEnd = findNextSpecialChar(pattern, i, options);
+    
+    if (literalEnd > i) {
+      const literal = pattern.slice(i, literalEnd);
+      segments.push({
+        type: 'literal',
+        name: literal,
+        regex: escapeRegex(literal),
+        optional: inOptional
+      });
+      i = literalEnd;
+      continue;
+    }
+
+    i++;
+  }
+
+  return segments;
+};
+
+/**
+ * Compiles segments into a regex pattern
+ * @param {Array<ParsedSegment>} segments - Parsed segments
+ * @param {UrlPatternOptions} options - Options
+ * @returns {{regex: string, segmentNames: Array<SegmentName>}} Compiled regex and segment names
+ */
+const compileRegex = (segments, options) => {
+  let regex = '^';
+  let groupIndex = 0;
+  /** @type {Array<SegmentName>} */
+  const segmentNames = [];
+  let i = 0;
+
+  while (i < segments.length) {
+    const segment = segments[i];
+    
+    if (segment.optional) {
+      let optionalPart = '';
+      let j = i;
+      
+      while (j < segments.length && segments[j].optional) {
+        const seg = segments[j];
+        
+        if (seg.type === 'wildcard') {
+          optionalPart += '(.*)';
+          segmentNames.push({ name: '_', index: groupIndex, type: 'wildcard' });
+          groupIndex++;
+        } else if (seg.type === 'named') {
+          optionalPart += seg.regex;
+          segmentNames.push({ name: seg.name, index: groupIndex, type: 'named' });
+          groupIndex++;
+        } else {
+          optionalPart += seg.regex;
+        }
+        
+        j++;
+      }
+      
+      regex += `(?:${optionalPart})?`;
+      i = j;
+      continue;
+    }
+
+    if (segment.type === 'wildcard') {
+      regex += '(.*)';
+      segmentNames.push({ name: '_', index: groupIndex, type: 'wildcard' });
+      groupIndex++;
+    } else if (segment.type === 'named') {
+      regex += segment.regex;
+      segmentNames.push({ name: segment.name, index: groupIndex, type: 'named' });
+      groupIndex++;
+    } else {
+      regex += segment.regex;
+    }
+    
+    i++;
+  }
+
+  regex += '$';
+  
+  return { regex, segmentNames };
+};
+
+/**
+ * Creates a compiled pattern from a string
+ * @param {string} pattern - Pattern string
+ * @param {UrlPatternOptions} [options={}] - Options
+ * @returns {CompiledPattern} Compiled pattern
+ */
+const makePattern = (pattern, options = {}) => {
+  const mergedOptions = mergeOptions(options);
+  const segments = parsePattern(pattern, mergedOptions);
+  const { regex, segmentNames } = compileRegex(segments, mergedOptions);
+
+  return {
+    regex,
+    regexObj: new RegExp(regex),
+    segments,
+    segmentNames,
+    options: mergedOptions,
+    isRegex: false,
+    pattern
+  };
+};
+
+/**
+ * Creates a compiled pattern from a regex
+ * @param {RegExp} regex - Regex pattern
+ * @param {Array<string>} [keys=[]] - Array of key names for captured groups
+ * @returns {CompiledPattern} Compiled pattern
+ */
+const makePatternFromRegex = (regex, keys = []) => {
+  return {
+    regex: regex.source,
+    regexObj: regex,
+    segments: [],
+    segmentNames: keys.map((name, index) => ({ name, index, type: 'named' })),
+    options: DEFAULT_OPTIONS,
+    isRegex: true,
+    keys
+  };
+};
+
+/**
+ * Matches a string against a compiled pattern
+ * @param {CompiledPattern} compiled - Compiled pattern
+ * @param {string} str - String to match
+ * @returns {Object|null} Extracted values or null if no match
+ */
+const match = (compiled, str) => {
+  const matchResult = compiled.regexObj.exec(str);
+  
+  if (!matchResult) {
+    return null;
+  }
+
+  if (compiled.isRegex) {
+    if (compiled.keys && compiled.keys.length > 0) {
+      const result = {};
+      compiled.keys.forEach((key, index) => {
+        const val = matchResult[index + 1];
+        result[key] = val !== undefined ? val : null;
+      });
+      return result;
+    }
+    return matchResult.slice(1);
+  }
+
+  const result = {};
+  const usedNames = new Set();
+
+  for (let i = 0; i < compiled.segmentNames.length; i++) {
+    const segInfo = compiled.segmentNames[i];
+    const value = matchResult[segInfo.index + 1] || '';
+    
+    if (usedNames.has(segInfo.name)) {
+      if (!Array.isArray(result[segInfo.name])) {
+        result[segInfo.name] = [result[segInfo.name]];
+      }
+      result[segInfo.name].push(value);
+    } else {
+      usedNames.add(segInfo.name);
+      result[segInfo.name] = value;
+    }
+  }
+
+  for (const key in result) {
+    if (result[key] === '') {
+      delete result[key];
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Stringifies a pattern with given values
+ * @param {CompiledPattern} compiled - Compiled pattern
+ * @param {Object} [values={}] - Values to stringify
+ * @returns {string} Generated string
+ * @throws {Error} If required values are missing
+ */
+const stringify = (compiled, values = {}) => {
+  if (compiled.isRegex) {
+    throw new Error('Cannot stringify a pattern created from regex');
+  }
+
+  let result = '';
+  let i = 0;
+  
+  while (i < compiled.segments.length) {
+    const segment = compiled.segments[i];
+    
+    if (segment.optional) {
+      let optionalPart = '';
+      let j = i;
+      
+      while (j < compiled.segments.length && compiled.segments[j].optional) {
+        const seg = compiled.segments[j];
+        
+        if (seg.type === 'literal') {
+          optionalPart += seg.name;
+        } else if (seg.type === 'named') {
+          const val = values[seg.name];
+          if (val !== undefined && val !== null && val !== '') {
+            optionalPart += Array.isArray(val) ? val.join('/') : val;
+          } else {
+            optionalPart = '';
+            break;
+          }
+        } else if (seg.type === 'wildcard') {
+          const val = values._;
+          if (val !== undefined && val !== null && val !== '') {
+            optionalPart += Array.isArray(val) ? val.join('/') : val;
+          } else {
+            optionalPart = '';
+            break;
+          }
+        }
+        
+        j++;
+      }
+      
+      if (optionalPart !== '') {
+        result += optionalPart;
+      }
+      
+      if (i === j) {
+        i++;
+      } else {
+        i = j;
+      }
+      continue;
+    }
+
+    if (segment.type === 'literal') {
+      result += segment.name;
+    } else if (segment.type === 'named') {
+      const value = values[segment.name];
+      if (value === undefined || value === null || value === '') {
+        throw new Error(`Missing required value for segment: ${segment.name}`);
+      }
+      result += Array.isArray(value) ? value.join('/') : value;
+    } else if (segment.type === 'wildcard') {
+      const value = values._;
+      if (value === undefined || value === null || value === '') {
+        throw new Error('Missing required wildcard value');
+      }
+      result += Array.isArray(value) ? value.join('/') : value;
+    }
+    
+    i++;
+  }
+
+  return result;
+};
+
+/**
+ * UrlPattern class for matching and generating URLs
+ */
+class UrlPattern {
+  /**
+   * @param {string|RegExp} pattern - Pattern string or regex
+   * @param {UrlPatternOptions|Array<string>} [options={}] - Options or keys (for regex)
+   */
+  constructor(pattern, options = {}) {
+    if (pattern instanceof RegExp) {
+      const keys = Array.isArray(options) ? options : [];
+      /** @type {CompiledPattern} */
+      this.compiled = makePatternFromRegex(pattern, keys);
+    } else {
+      /** @type {CompiledPattern} */
+      this.compiled = makePattern(pattern, /** @type {UrlPatternOptions} */ (options));
+    }
+  }
+
+  /**
+   * Match a string against the pattern
+   * @param {string} str - String to match
+   * @returns {Object|null} Extracted values or null if no match
+   */
+  match(str) {
+    return match(this.compiled, str);
+  }
+
+  /**
+   * Generate a string from the pattern
+   * @param {Object} [values={}] - Values to stringify
+   * @returns {string} Generated string
+   */
+  stringify(values) {
+    return stringify(this.compiled, values);
+  }
+}
+
+/**
+ * Creates a new UrlPattern instance (functional API)
+ * @param {string|RegExp} pattern - Pattern string or regex
+ * @param {UrlPatternOptions|Array<string>} [options={}] - Options or keys
+ * @returns {UrlPattern} UrlPattern instance
+ */
+const urlPattern = (pattern, options = {}) => {
+  return new UrlPattern(pattern, options);
+};
+
+export { UrlPattern, urlPattern, makePattern, makePatternFromRegex, match, stringify, DEFAULT_OPTIONS };
+export default UrlPattern;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@peter.naydenov/url-pattern",
+  "version": "1.0.0",
+  "description": "Matching patterns for urls and other strings. Turn strings into data or data into strings.",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "cp src/index.js dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "cover": "vitest run --coverage",
+    "lint": "eslint src --ext .js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "url",
+    "pattern",
+    "match",
+    "routing",
+    "regex"
+  ],
+  "author": "Peter Naydenov",
+  "license": "MIT",
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.5",
+    "eslint": "^10.3.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  }
+}

package/readme.md

@@ -0,0 +1,136 @@
+# URL Pattern (@peter.naydenov/url-pattern)
+
+[![version](https://img.shields.io/npm/v/@peter.naydenov/url-pattern.svg)](https://www.npmjs.com/package/@peter.naydenov/url-pattern)
+[![license](https://img.shields.io/github/license/PeterNaydenov/git-url-pattern.svg)](https://github.com/PeterNaydenov/git-url-pattern/blob/main/LICENSE)
+[![GitHub issues](https://img.shields.io/github/issues-raw/PeterNaydenov/git-url-pattern.svg)](https://github.com/PeterNaydenov/git-url-pattern/issues)
+[![GitHub top language](https://img.shields.io/github/languages/top/PeterNaydenov/git-url-pattern.svg)](https://github.com/PeterNaydenov/git-url-pattern)
+[![npm bundle size](https://img.shields.io/bundlejs/size/@peter.naydenov/url-pattern.svg)](https://www.npmjs.com/package/@peter.naydenov/url-pattern)
+
+Easier than regex string matching patterns for urls and other strings. Turn strings into data or data into strings.
+
+## Install
+
+```
+npm install @peter.naydenov/url-pattern
+```
+
+Once it has been installed, it can be used by writing this line of JavaScript:
+
+```js
+// if you are using ES6:
+import urlPattern from '@peter.naydenov/url-pattern'
+
+// if you are using commonJS:
+const urlPattern = require ( '@peter.naydenov/url-pattern' )
+```
+
+## How to use it
+
+### Parse a pattern and match a string
+
+```js
+import urlPattern from '@peter.naydenov/url-pattern'
+
+const pattern = urlPattern ( '/user/:username/post/:postId' )
+const result = pattern.match ( '/user/john/post/123' )
+
+console.log ( result )
+// Output: { username: 'john', postId: '123' }
+```
+
+### Match a URL with optional segments
+
+```js
+import urlPattern from '@peter.naydenov/url-pattern'
+
+const pattern = urlPattern ( '/api/(v1)/users/:id' )
+const result = pattern.match ( '/api/v1/users/456' )
+
+console.log ( result )
+// Output: { id: '456' }
+```
+
+### Use wildcard
+
+```js
+import urlPattern from '@peter.naydenov/url-pattern'
+
+const pattern = urlPattern ( '/files/*' )
+const result = pattern.match ( '/files/images/photo.jpg' )
+
+console.log ( result )
+// Output: { '*': 'images/photo.jpg' }
+```
+
+### Generate URL from data
+
+```js
+import urlPattern from '@peter.naydenov/url-pattern'
+
+const pattern = urlPattern ( '/user/:username/post/:postId' )
+const url = pattern.stringify ( { username: 'john', postId: '123' } )
+
+console.log ( url )
+// Output: '/user/john/post/123'
+```
+
+### Configure pattern options
+
+```js
+import urlPattern from '@peter.naydenov/url-pattern'
+
+const pattern = urlPattern ( '/user/{username}/post/{postId}', {
+    segmentNameStartChar: '{',
+    segmentNameEndChar: '}'
+})
+
+const result = pattern.match ( '/user/john/post/123' )
+
+console.log ( result )
+// Output: { username: 'john', postId: '123' }
+```
+
+## API Reference
+
+### `urlPattern(pattern, [options])`
+
+Creates a new pattern instance.
+
+- **pattern** `{string}` - URL pattern string with named segments (`:name`), optional segments (`(segment)`), or wildcards (`*`)
+- **options** `{object}` - Optional configuration object
+
+#### Options
+
+- **escapeChar** `{string}` - Character used for escaping special characters (default: `'\\'`)
+- **segmentNameStartChar** `{string}` - Character that starts a named segment (default: `':'`)
+- **segmentNameEndChar** `{string}` - Character that ends a named segment (default: `undefined`)
+- **segmentNameCharset** `{string}` - Characters allowed in segment names (default: `'a-zA-Z0-9'`)
+- **segmentValueCharset** `{string}` - Characters allowed in segment values (default: `'a-zA-Z0-9-_~ %'`)
+- **optionalSegmentStartChar** `{string}` - Character that starts an optional segment (default: `'('`)
+- **optionalSegmentEndChar** `{string}` - Character that ends an optional segment (default: `')'`)
+- **wildcardChar** `{string}` - Character that denotes a wildcard (default: `'*'`)
+
+### Pattern Methods
+
+#### `pattern.match(string)`
+
+Matches a string against the pattern and returns an object with captured values, or `null` if no match.
+
+#### `pattern.stringify(data)`
+
+Generates a URL string from provided data object.
+
+#### `pattern.compile()`
+
+Returns an object with `regex` (compiled RegExp), `segments` (parsed segments array), and `segmentNames` (segment name mappings).
+
+## Links
+
+- [History of changes](CHANGELOG.md)
+- [TypeScript definitions](types/index.d.ts)
+
+## Credits
+
+'@peter.naydenov/url-pattern' was created and supported by [Peter Naydenov](https://github.com/PeterNaydenov).
+
+'@peter.naydenov/url-pattern' is released under the [MIT License](https://github.com/PeterNaydenov/git-url-pattern/blob/main/LICENSE).