@peter.naydenov/url-pattern 1.0.1 → 1.0.3

package/dist/url-pattern.umd.js

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

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@peter.naydenov/url-pattern",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Matching patterns for urls and other strings. Turn strings into data or data into strings.",
   "type": "module",
   "main": "./src/main.js",
   "module": "./dist/url-pattern.es.js",
-  "types": "./types/index.d.ts",
+  "types": "./types/main.d.ts",
   "files": [
     "dist",
     "types",
@@ -28,7 +28,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "cover": "vitest run --coverage",
-    "lint": "eslint src --ext .js",
+    "lint": "oxlint src",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -45,11 +45,14 @@
     "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"
+    "@rollup/plugin-terser": "^1.0.0",
+    "@vitest/coverage-v8": "^4.1.10",
+    "oxlint": "^1.73.0",
+    "rollup": "^4.62.2",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "allowScripts": {
+    "fsevents@2.3.3": true
   }
 }

package/readme.md

@@ -59,7 +59,7 @@ const pattern = urlPattern ( '/files/*' )
 const result = pattern.match ( '/files/images/photo.jpg' )
 
 console.log ( result )
-// Output: { '*': 'images/photo.jpg' }
+// Output: { _: 'images/photo.jpg' }
 ```
 
 ### Generate URL from data
@@ -89,6 +89,11 @@ const result = pattern.match ( '/user/john/post/123' )
 console.log ( result )
 // Output: { username: 'john', postId: '123' }
 ```
+## URL Patterns
+
+See [supported URL pattern types with examples](./PATTERNS.md).
+
+
 
 ## API Reference
 
@@ -103,9 +108,9 @@ Creates a new pattern instance.
 
 - **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-_~ %'`)
+- **segmentNameEndChar** `{string}` - Character that ends a named segment (default: `undefined`). When set, the segment name stops at the first occurrence of this character instead of at the first character outside `segmentNameCharset`.
+- **segmentNameCharset** `{string}` - Characters allowed in segment names (default: `'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'`). Treated as a list of explicit characters; range notation is not interpreted.
+- **segmentValueCharset** `{string}` - Characters allowed in segment values (default: `'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_~ %'`). Treated as a list of explicit characters; range notation is not interpreted.
 - **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: `'*'`)
@@ -120,17 +125,25 @@ Matches a string against the pattern and returns an object with captured values,
 
 Generates a URL string from provided data object.
 
-#### `pattern.compile()`
+#### `pattern.compiled`
+
+Read-only object exposing the internal compiled state: `regex` (regex source), `regexObj` (compiled `RegExp`), `segments` (parsed segments array), `segmentNames` (segment name → capture-group mappings), `options` (merged options), `isRegex` (whether the pattern was created from a regex), and `pattern` (the original pattern string). Useful for introspection; do not mutate.
 
-Returns an object with `regex` (compiled RegExp), `segments` (parsed segments array), and `segmentNames` (segment name mappings).
 
-## Links
 
+## Links
+- [Supported URL patterns with examples](./PATTERNS.md).
 - [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).
 
+
+
+## License
+
 '@peter.naydenov/url-pattern' is released under the [MIT License](https://github.com/PeterNaydenov/git-url-pattern/blob/main/LICENSE).