function UrlMatcher(pattern) {

  // Find all placeholders and create a compiled pattern, using either classic or curly syntax:
  //   '*' name
  //   ':' name
  //   '{' name '}'
  //   '{' name ':' regexp '}'
  // The regular expression is somewhat complicated due to the need to allow curly braces
  // inside the regular expression. The placeholder regexp breaks down as follows:
  //    ([:*])(\w+)               classic placeholder ($1 / $2)
  //    \{(\w+)(?:\:( ... ))?\}   curly brace placeholder ($3) with optional regexp ... ($4)
  //    (?: ... | ... | ... )+    the regexp consists of any number of atoms, an atom being either
  //    [^{}\\]+                  - anything other than curly braces or backslash
  //    \\.                       - a backslash escape
  //    \{(?:[^{}\\]+|\\.)*\}     - a matched set of curly braces containing other atoms
  var placeholder = /([:*])(\w+)|\{(\w+)(?:\:((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g,
      names = {}, compiled = '^', last = 0, m,
      segments = this.segments = [],
      params = this.params = [];

  function addParameter(id) {
    if (!/^\w+(-+\w+)*$/.test(id)) throw new Error("Invalid parameter name '" + id + "' in pattern '" + pattern + "'");
    if (names[id]) throw new Error("Duplicate parameter name '" + id + "' in pattern '" + pattern + "'");
    names[id] = true;
    params.push(id);
  }

  function quoteRegExp(string) {
    return string.replace(/[\\\[\]\^$*+?.()|{}]/g, "\\$&");
  }

  this.source = pattern;

  // Split into static segments separated by path parameter placeholders.
  // The number of segments is always 1 more than the number of parameters.
  var id, regexp, segment;
  while ((m = placeholder.exec(pattern))) {
    id = m[2] || m[3]; // IE[78] returns '' for unmatched groups instead of null
    regexp = m[4] || (m[1] == '*' ? '.*' : '[^/]*');
    segment = pattern.substring(last, m.index);
    if (segment.indexOf('?') >= 0) break; // we're into the search part
    compiled += quoteRegExp(segment) + '(' + regexp + ')';
    addParameter(id);
    segments.push(segment);
    last = placeholder.lastIndex;
  }
  segment = pattern.substring(last);

  // Find any search parameter names and remove them from the last segment
  var i = segment.indexOf('?');
  if (i >= 0) {
    var search = this.sourceSearch = segment.substring(i);
    segment = segment.substring(0, i);
    this.sourcePath = pattern.substring(0, last+i);

    // Allow parameters to be separated by '?' as well as '&' to make concat() easier
    forEach(search.substring(1).split(/[&?]/), addParameter);
  } else {
    this.sourcePath = pattern;
    this.sourceSearch = '';
  }

  compiled += quoteRegExp(segment) + '$';
  segments.push(segment);
  this.regexp = new RegExp(compiled);
  this.prefix = segments[0];
}
/**
 * Matches URLs against patterns and extracts named parameters from the path or the search
 * part of the URL. A URL pattern consists of a path pattern, optionally followed by '?' and a list
 * of search parameters. Multiple search parameter names are separated by '&'. Search parameters
 * do not influence whether or not a URL is matched, but their values are passed through into
 * the matched parameters returned by {@link UrlMatcher#exec exec}.
 * 
 * Path parameter placeholders can be specified using simple colon/catch-all syntax or curly brace
 * syntax, which optionally allows a regular expression for the parameter to be specified:
 *
 * * ':' name - colon placeholder
 * * '*' name - catch-all placeholder
 * * '{' name '}' - curly placeholder
 * * '{' name ':' regexp '}' - curly placeholder with regexp. Should the regexp itself contain
 *   curly braces, they must be in matched pairs or escaped with a backslash.
 *
 * Parameter names may contain only word characters (latin letters, digits, and underscore) and
 * must be unique within the pattern (across both path and search parameters). For colon 
 * placeholders or curly placeholders without an explicit regexp, a path parameter matches any
 * number of characters other than '/'. For catch-all placeholders the path parameter matches
 * any number of characters.
 * 
 * ### Examples
 * 
 * * '/hello/' - Matches only if the path is exactly '/hello/'. There is no special treatment for
 *   trailing slashes, and patterns have to match the entire path, not just a prefix.
 * * '/user/:id' - Matches '/user/bob' or '/user/1234!!!' or even '/user/' but not '/user' or
 *   '/user/bob/details'. The second path segment will be captured as the parameter 'id'.
 * * '/user/{id}' - Same as the previous example, but using curly brace syntax.
 * * '/user/{id:[^/]*}' - Same as the previous example.
 * * '/user/{id:[0-9a-fA-F]{1,8}}' - Similar to the previous example, but only matches if the id
 *   parameter consists of 1 to 8 hex digits.
 * * '/files/{path:.*}' - Matches any URL starting with '/files/' and captures the rest of the
 *   path into the parameter 'path'.
 * * '/files/*path' - ditto.
 *
 * @constructor
 * @param {string} pattern  the pattern to compile into a matcher.
 *
 * @property {string} prefix  A static prefix of this pattern. The matcher guarantees that any
 *   URL matching this matcher (i.e. any string for which {@link UrlMatcher#exec exec()} returns
 *   non-null) will start with this prefix.
 */
Matches URLs against patterns and extracts named parameters from the path or the search
part of the URL. A URL pattern consists of a path pattern, optionally followed by '?' and a list
of search parameters. Multiple search parameter names are separated by '&'. Search parameters
do not influence whether or not a URL is matched, but their values are passed through into
the matched parameters returned by  UrlMatcher#exec exec.

Path parameter placeholders can be specified using simple colon/catch-all syntax or curly brace
syntax, which optionally allows a regular expression for the parameter to be specified.



Parameter names may contain only word characters (latin letters, digits, and underscore) and
must be unique within the pattern (across both path and search parameters). For colon
placeholders or curly placeholders without an explicit regexp, a path parameter matches any
number of characters other than '/'. For catch-all placeholders the path parameter matches
any number of characters.

Examples

'/hello/' - Matches only if the path is exactly '/hello/'. There is no special treatment for
trailing slashes, and patterns have to match the entire path, not just a prefix.

@constructor
@param {string} pattern  the pattern to compile into a matcher.

@property {string} prefix  A static prefix of this pattern. The matcher guarantees that any
URL matching this matcher } returns
non-null) will start with this prefix.
Matches URLs against patterns and extracts named parameters from the path or the search part of the URL . A URL pattern consists of a path pattern optionally followed by ' ? ' and a list of search parameters . Multiple search parameter names are separated by ' & ' . Search parameters do not influence whether or not a URL is matched but their values are passed through into the matched parameters returned by UrlMatcher#exec exec . Path parameter placeholders can be specified using simple colon / catch - all syntax or curly brace syntax which optionally allows a regular expression for the parameter to be specified . Parameter names may contain only word characters ( latin letters digits and underscore ) and must be unique within the pattern ( across both path and search parameters ) . For colon placeholders or curly placeholders without an explicit regexp a path parameter matches any number of characters other than ' / ' . For catch - all placeholders the path parameter matches any number of characters . Examples ' / hello / ' - Matches only if the path is exactly ' / hello / ' . There is no special treatment for trailing slashes and patterns have to match the entire path not just a prefix . @constructor @param { string } pattern the pattern to compile into a matcher . @property { string } prefix A static prefix of this pattern . The matcher guarantees that any URL matching this matcher } returns non - null ) will start with this prefix .
function UrlMatcher(pattern) {
  var placeholder = /([:*])(\w+)|\{(\w+)(?:\:((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g,
      names = {}, compiled = '^', last = 0, m,
      segments = this.segments = [],
      params = this.params = [];
  function addParameter(id) {
    if (!/^\w+(-+\w+)*$/.test(id)) throw new Error("Invalid parameter name '" + id + "' in pattern '" + pattern + "'");
    if (names[id]) throw new Error("Duplicate parameter name '" + id + "' in pattern '" + pattern + "'");
    names[id] = true;
    params.push(id);
  }
  function quoteRegExp(string) {
    return string.replace(/[\\\[\]\^$*+?.()|{}]/g, "\\$&");
  }
  this.source = pattern;
  var id, regexp, segment;
  while ((m = placeholder.exec(pattern))) {
    id = m[2] || m[3]; 
    regexp = m[4] || (m[1] == '*' ? '.*' : '[^/]*');
    segment = pattern.substring(last, m.index);
    if (segment.indexOf('?') >= 0) break; 
    compiled += quoteRegExp(segment) + '(' + regexp + ')';
    addParameter(id);
    segments.push(segment);
    last = placeholder.lastIndex;
  }
  segment = pattern.substring(last);
  var i = segment.indexOf('?');
  if (i >= 0) {
    var search = this.sourceSearch = segment.substring(i);
    segment = segment.substring(0, i);
    this.sourcePath = pattern.substring(0, last+i);
    forEach(search.substring(1).split(/[&?]/), addParameter);
  } else {
    this.sourcePath = pattern;
    this.sourceSearch = '';
  }
  compiled += quoteRegExp(segment) + '$';
  segments.push(segment);
  this.regexp = new RegExp(compiled);
  this.prefix = segments[0];
}
function UrlMatcher ( pattern ) { var placeholder = / ([:*])(\w+)|\{(\w+)(?:\:((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\} / g , names = { } , compiled = '^' , last = 0 , m , segments = this . segments = [ ] , params = this . params = [ ] ; function addParameter ( id ) { if ( ! / ^\w+(-+\w+)*$ / . test ( id ) ) throw new Error ( "Invalid parameter name '" + id + "' in pattern '" + pattern + "'" ) ; if ( names [ id ] ) throw new Error ( "Duplicate parameter name '" + id + "' in pattern '" + pattern + "'" ) ; names [ id ] = true ; params . push ( id ) ; } function quoteRegExp ( string ) { return string . replace ( / [\\\[\]\^$*+?.()|{}] / g , "\\$&" ) ; } this . source = pattern ; var id , regexp , segment ; while ( ( m = placeholder . exec ( pattern ) ) ) { id = m [ 2 ] || m [ 3 ] ; regexp = m [ 4 ] || ( m [ 1 ] == '*' ? '.*' : '[^/]*' ) ; segment = pattern . substring ( last , m . index ) ; if ( segment . indexOf ( '?' ) >= 0 ) break ; compiled += quoteRegExp ( segment ) + '(' + regexp + ')' ; addParameter ( id ) ; segments . push ( segment ) ; last = placeholder . lastIndex ; } segment = pattern . substring ( last ) ; var i = segment . indexOf ( '?' ) ; if ( i >= 0 ) { var search = this . sourceSearch = segment . substring ( i ) ; segment = segment . substring ( 0 , i ) ; this . sourcePath = pattern . substring ( 0 , last + i ) ; forEach ( search . substring ( 1 ) . split ( / [&?] / ) , addParameter ) ; } else { this . sourcePath = pattern ; this . sourceSearch = '' ; } compiled += quoteRegExp ( segment ) + '$' ; segments . push ( segment ) ; this . regexp = new RegExp ( compiled ) ; this . prefix = segments [ 0 ] ; }
Matches URLs against patterns and extracts named parameters from the path or the search
 part of the URL.
Matches URLs against patterns and extracts named parameters from the path or the search part of the URL .
// Find all placeholders and create a compiled pattern, using either classic or curly syntax: //   '*' name //   ':' name //   '{' name '}' //   '{' name ':' regexp '}' // The regular expression is somewhat complicated due to the need to allow curly braces // inside the regular expression. The placeholder regexp breaks down as follows: //    ([:*])(\w+)               classic placeholder ($1 / $2) //    \{(\w+)(?:\:( ... ))?\}   curly brace placeholder ($3) with optional regexp ... ($4) //    (?: ... | ... | ... )+    the regexp consists of any number of atoms, an atom being either //    [^{}\\]+                  - anything other than curly braces or backslash //    \\.                       - a backslash escape //    \{(?:[^{}\\]+|\\.)*\}     - a matched set of curly braces containing other atoms // Split into static segments separated by path parameter placeholders. // The number of segments is always 1 more than the number of parameters. // IE[78] returns '' for unmatched groups instead of null // we're into the search part // Find any search parameter names and remove them from the last segment // Allow parameters to be separated by '?' as well as '&' to make concat() easier