@peter.naydenov/url-pattern 1.0.0 → 1.0.1

package/dist/url-pattern.umd.js

@@ -0,0 +1,509 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.urlPattern = {}));
+})(this, (function (exports) { 'use strict';
+
+  /**
+   * @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);
+
+    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);
+  };
+
+  exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+  exports.UrlPattern = UrlPattern;
+  exports.default = UrlPattern;
+  exports.makePattern = makePattern;
+  exports.makePatternFromRegex = makePatternFromRegex;
+  exports.match = match;
+  exports.stringify = stringify;
+  exports.urlPattern = urlPattern;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

package/dist/url-pattern.umd.min.js

@@ -0,0 +1 @@
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).urlPattern={})}(this,function(e){"use strict";const n={escapeChar:"\\",segmentNameStartChar:":",segmentNameCharset:"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",segmentValueCharset:"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_~ %",optionalSegmentStartChar:"(",optionalSegmentEndChar:")",wildcardChar:"*"},t=e=>e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),r=(e,n,t)=>{const r=[t.escapeChar,t.optionalSegmentStartChar,t.optionalSegmentEndChar,t.wildcardChar,t.segmentNameStartChar];let a=e.length;for(let t=0;t<r.length;t++){const s=r[t];if(!s)continue;const i=e.indexOf(s,n);-1!==i&&i<a&&(a=i)}return a},a=(e,a={})=>{const s=((e={})=>({...n,...e}))(a),i=((e,n)=>{const a=[];let s=0,i=!1;for(;s<e.length;){const o=e[s];if(o===n.escapeChar&&s+1<e.length){a.push({type:"literal",name:e[s+1],regex:t(e[s+1]),optional:i}),s+=2;continue}if(o===n.optionalSegmentStartChar){i=!0,s++;continue}if(o===n.optionalSegmentEndChar){i=!1,s++;continue}if(o===n.wildcardChar){a.push({type:"wildcard",name:"_",regex:".*",optional:i}),s++;continue}if(o===n.segmentNameStartChar&&s+1<e.length){const t=e.slice(s+1);let r=0;const o=n.segmentNameCharset||"";for(let e=0;e<t.length&&o.includes(t[e]);e++)r=e+1;const l=t.slice(0,r);if(l.length>0){let e=n.segmentValueCharset||"";e.includes("-")&&e.indexOf("-")>0&&e.indexOf("-")<e.length-1&&(e=e.replace(/-/g,""),e+="-");const t=`([${e.replace(/\]/g,"\\]")}]+)`;a.push({type:"named",name:l,regex:t,optional:i}),s+=1+r;continue}}const l=r(e,s,n);if(l>s){const n=e.slice(s,l);a.push({type:"literal",name:n,regex:t(n),optional:i}),s=l;continue}s++}return a})(e,s),{regex:o,segmentNames:l}=(e=>{let n="^",t=0;const r=[];let a=0;for(;a<e.length;){const s=e[a];if(s.optional){let s="",i=a;for(;i<e.length&&e[i].optional;){const n=e[i];"wildcard"===n.type?(s+="(.*)",r.push({name:"_",index:t,type:"wildcard"}),t++):"named"===n.type?(s+=n.regex,r.push({name:n.name,index:t,type:"named"}),t++):s+=n.regex,i++}n+=`(?:${s})?`,a=i;continue}"wildcard"===s.type?(n+="(.*)",r.push({name:"_",index:t,type:"wildcard"}),t++):"named"===s.type?(n+=s.regex,r.push({name:s.name,index:t,type:"named"}),t++):n+=s.regex,a++}return n+="$",{regex:n,segmentNames:r}})(i);return{regex:o,regexObj:new RegExp(o),segments:i,segmentNames:l,options:s,isRegex:!1,pattern:e}},s=(e,t=[])=>({regex:e.source,regexObj:e,segments:[],segmentNames:t.map((e,n)=>({name:e,index:n,type:"named"})),options:n,isRegex:!0,keys:t}),i=(e,n)=>{const t=e.regexObj.exec(n);if(!t)return null;if(e.isRegex){if(e.keys&&e.keys.length>0){const n={};return e.keys.forEach((e,r)=>{const a=t[r+1];n[e]=void 0!==a?a:null}),n}return t.slice(1)}const r={},a=new Set;for(let n=0;n<e.segmentNames.length;n++){const s=e.segmentNames[n],i=t[s.index+1]||"";a.has(s.name)?(Array.isArray(r[s.name])||(r[s.name]=[r[s.name]]),r[s.name].push(i)):(a.add(s.name),r[s.name]=i)}for(const e in r)""===r[e]&&delete r[e];return r},o=(e,n={})=>{if(e.isRegex)throw new Error("Cannot stringify a pattern created from regex");let t="",r=0;for(;r<e.segments.length;){const a=e.segments[r];if(a.optional){let a="",s=r;for(;s<e.segments.length&&e.segments[s].optional;){const t=e.segments[s];if("literal"===t.type)a+=t.name;else if("named"===t.type){const e=n[t.name];if(null==e||""===e){a="";break}a+=Array.isArray(e)?e.join("/"):e}else if("wildcard"===t.type){const e=n._;if(null==e||""===e){a="";break}a+=Array.isArray(e)?e.join("/"):e}s++}""!==a&&(t+=a),r===s?r++:r=s;continue}if("literal"===a.type)t+=a.name;else if("named"===a.type){const e=n[a.name];if(null==e||""===e)throw new Error(`Missing required value for segment: ${a.name}`);t+=Array.isArray(e)?e.join("/"):e}else if("wildcard"===a.type){const e=n._;if(null==e||""===e)throw new Error("Missing required wildcard value");t+=Array.isArray(e)?e.join("/"):e}r++}return t};class l{constructor(e,n={}){if(e instanceof RegExp){const t=Array.isArray(n)?n:[];this.compiled=s(e,t)}else this.compiled=a(e,n)}match(e){return i(this.compiled,e)}stringify(e){return o(this.compiled,e)}}e.DEFAULT_OPTIONS=n,e.UrlPattern=l,e.default=l,e.makePattern=a,e.makePatternFromRegex=s,e.match=i,e.stringify=o,e.urlPattern=(e,n={})=>new l(e,n),Object.defineProperty(e,"__esModule",{value:!0})});

package/package.json

@@ -1,15 +1,30 @@
 {
   "name": "@peter.naydenov/url-pattern",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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",
+  "type": "module",
+  "main": "./src/main.js",
+  "module": "./dist/url-pattern.es.js",
+  "types": "./types/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "types",
+    "src"
   ],
+  "exports": {
+    ".": {
+      "import": "./dist/url-pattern.es.js",
+      "require": "./dist/url-pattern.cjs.js",
+      "default": "./dist/url-pattern.es.js"
+    },
+    "./package.json": "./package.json",
+    "./src/*": "./src/*",
+    "./dist/*": "./dist/*",
+    "./types/*": "./types/*"
+  },
   "scripts": {
-    "build": "cp src/index.js dist/index.js",
+    "build": "rollup -c",
+    "postbuild": "tsc -p tsconfig.build.json",
     "test": "vitest run",
     "test:watch": "vitest",
     "cover": "vitest run --coverage",
@@ -25,9 +40,15 @@
   ],
   "author": "Peter Naydenov",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PeterNaydenov/url-pattern"
+  },
   "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
     "@vitest/coverage-v8": "^4.1.5",
     "eslint": "^10.3.0",
+    "rollup": "^4.9.6",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
   }

package/readme.md

@@ -1,9 +1,9 @@
 # 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)
+[![license](https://img.shields.io/github/license/PeterNaydenov/url-pattern.svg)](https://github.com/PeterNaydenov/url-pattern/blob/main/LICENSE)
+[![GitHub issues](https://img.shields.io/github/issues-raw/PeterNaydenov/url-pattern.svg)](https://github.com/PeterNaydenov/url-pattern/issues)
+[![GitHub top language](https://img.shields.io/github/languages/top/PeterNaydenov/url-pattern.svg)](https://github.com/PeterNaydenov/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.