orator 6.0.2 → 6.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/package.json +8 -8
  2. package/dist/indoctrinate_content_staging/Indoctrinate-Catalog-AppData.json +0 -2364
  3. package/dist/orator.compatible.js +0 -4889
  4. package/dist/orator.compatible.min.js +0 -17
  5. package/dist/orator.compatible.min.js.map +0 -1
  6. package/dist/orator.js +0 -4487
  7. package/dist/orator.min.js +0 -17
  8. package/dist/orator.min.js.map +0 -1
  9. /package/docs/{cover.md → _cover.md} +0 -0
package/dist/orator.min.js.map DELETED
@@ -1 +0,0 @@
1
- {"version":3,"sources":["orator.min.js","node_modules/browser-pack/_prelude.js","node_modules/assert/assert.js","node_modules/assert/node_modules/inherits/inherits_browser.js","node_modules/assert/node_modules/util/support/isBufferBrowser.js","node_modules/assert/node_modules/util/util.js","node_modules/fable-serviceproviderbase/source/Fable-ServiceProviderBase-Preinit.js","node_modules/fable-serviceproviderbase/source/Fable-ServiceProviderBase.js","node_modules/fast-decode-uri-component/index.js","node_modules/fast-deep-equal/index.js","node_modules/fast-querystring/lib/index.js","node_modules/fast-querystring/lib/internals/querystring.js","node_modules/fast-querystring/lib/parse.js","node_modules/fast-querystring/lib/stringify.js","node_modules/find-my-way/index.js","node_modules/find-my-way/lib/constrainer.js","node_modules/find-my-way/lib/handler-storage.js","node_modules/find-my-way/lib/http-methods.js","node_modules/find-my-way/lib/node.js","node_modules/find-my-way/lib/pretty-print.js","node_modules/find-my-way/lib/strategies/accept-host.js","node_modules/find-my-way/lib/strategies/accept-version.js","node_modules/find-my-way/lib/strategies/http-method.js","node_modules/find-my-way/lib/url-sanitizer.js","node_modules/object-assign/index.js","node_modules/process/browser.js","node_modules/safe-regex2/index.js","node_modules/safe-regex2/node_modules/ret/lib/index.js","node_modules/safe-regex2/node_modules/ret/lib/positions.js","node_modules/safe-regex2/node_modules/ret/lib/sets.js","node_modules/safe-regex2/node_modules/ret/lib/types.js","node_modules/safe-regex2/node_modules/ret/lib/util.js","source/Orator-Default-Configuration.js","source/Orator-Default-ServiceServer-Web.js","source/Orator-ServiceServer-Base.js","source/Orator-ServiceServer-IPC-SynthesizedResponse.js","source/Orator-ServiceServer-IPC.js","source/Orator.js"],"names":["_excluded","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_objectWithoutProperties","excluded","_objectWithoutPropertiesLoose","sourceSymbolKeys","indexOf","prototype","propertyIsEnumerable","call","sourceKeys","obj","value","_toPropertyKey","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","TypeError","Number","f","exports","module","define","amd","window","global","self","this","Orator","r","e","n","t","o","c","require","u","a","Error","code","p","objectAssign","compare","b","x","y","len","Math","min","isBuffer","Buffer","_isBuffer","util","hasOwn","hasOwnProperty","pSlice","Array","slice","functionsHaveNames","name","pToString","toString","isView","arrbuf","ArrayBuffer","DataView","buffer","assert","ok","regex","getName","func","isFunction","match","truncate","s","inspect","something","rawname","fail","actual","expected","message","operator","stackStartFunction","AssertionError","_deepEqual","strict","memos","isDate","getTime","isRegExp","multiline","lastIndex","ignoreCase","Float32Array","Float64Array","Uint8Array","actualIndex","actualVisitedObjects","isPrimitive","getPrototypeOf","aIsArgs","isArguments","bIsArgs","ka","objectKeys","kb","sort","objEquiv","expectedException","test","isPrototypeOf","_throws","shouldThrow","block","error","_tryBlock","userProvidedMessage","isUnexpectedException","isError","options","generatedMessage","getMessage","captureStackTrace","err","stack","out","fn_name","idx","next_line","substring","inherits","equal","notEqual","deepEqual","deepStrictEqual","notDeepEqual","notDeepStrictEqual","strictEqual","notStrictEqual","throws","doesNotThrow","ifError","create","ctor","superCtor","super_","constructor","TempCtor","copy","fill","readUInt8","process","formatRegExp","format","isString","objects","join","args","str","replace","JSON","stringify","_","isNull","isObject","deprecate","fn","msg","isUndefined","noDeprecation","warned","throwDeprecation","traceDeprecation","console","trace","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","customInspect","stylizeWithColor","formatValue","styleType","style","styles","recurseTimes","ret","primitive","simple","isNumber","formatPrimitive","visibleKeys","array","hash","val","arrayToHash","getOwnPropertyNames","formatError","RegExp","Date","output","base","braces","isArray","toUTCString","l","formatProperty","formatArray","map","pop","reduce","prev","cur","numLinesEst","reduceToSingleString","desc","get","set","split","line","substr","ar","re","objectToString","d","pad","debuglog","env","NODE_DEBUG","toUpperCase","pid","bold","italic","underline","inverse","white","grey","black","blue","cyan","green","magenta","red","yellow","special","number","boolean","null","string","date","regexp","isNullOrUndefined","isSymbol","months","prop","log","time","getHours","getMinutes","getSeconds","getDate","getMonth","origin","add","_process","FableCoreServiceProviderBase","pOptions","pServiceHash","fable","serviceType","UUID","concat","floor","random","Hash","connectFable","pFable","FableServiceProviderBase","isFable","getUUID","servicesMap","services","CoreServiceProviderBase","UTF8_DATA","HEX","A","B","C","D","E","F","hexCodeToInt","shift","uri","percentPosition","decoded","last","codepoint","startOfOctets","state","byte","type","charCodeAt","fromCharCode","flags","valueOf","parse","fastQuerystring","default","hexTable","from","noEscape","Int8Array","encodeString","lastPos","outer","fastDecode","plusRegex","Empty","result","inputLength","startingIndex","equalityIndex","shouldDecodeKey","shouldDecodeValue","keyHasPlus","valueHasPlus","hasBothKeyValuePair","currentValue","getAsPrimitive","isFinite","keyLength","valueLength","encodedKey","j","querystring","isRegexSafe","prettyPrintTree","StaticNode","NODE_TYPES","Constrainer","httpMethods","httpMethodStrategy","safeDecodeURI","safeDecodeURIComponent","FULL_PATH_REGEXP","OPTIONAL_PARAM_REGEXP","Router","_opts","defaultRoute","onBadUrl","buildPrettyMeta","defaultBuildPrettyMeta","querystringParser","query","caseSensitive","ignoreTrailingSlash","ignoreDuplicateSlashes","maxParamLength","allowUnsafeRegex","constrainer","constraints","routes","trees","on","method","path","handler","store","optionalParamMatch","index","pathFull","pathOptional","route","removeDuplicateSlashes","trimLastSlash","methods","includes","_on","validateConstraints","noteUsage","pattern","prefix","currentRoot","staticChildren","currentNode","parentNodePathIndex","params","isParametricNode","isWildcardNode","staticNodePath","toLowerCase","createStaticChild","isRegexNode","regexps","lastParamStartIndex","charCode","isRegexParam","isStaticPart","isEndOfNode","paramName","endOfRegexIndex","getClosingParenthensePosition","regexString","trimRegExpStartAndEnd","staticPartStartIndex","staticPart","nodePattern","nodePath","createParametricChild","createWildcardChild","existRoute","routeConstraints","addRoute","hasConstraintStrategy","strategyName","addConstraintStrategy","_rebuild","reset","off","_off","matcherWithoutConstraints","predicate","newRoutes","lookup","req","done","deriveConstraints","handle","find","url","callHandler","_defaultRoute","searchParams","derivedConstraints","sanitizedUrl","shouldDecodeParam","_onBadUrl","originPath","pathIndex","pathLen","brothersNodesStack","isLeafNode","handlerStorage","getMatchingHandler","_createParamsObject","node","getNextNode","brotherNodeState","brotherPathIndex","splice","paramsCount","brotherNode","kind","STATIC","WILDCARD","PARAMETRIC","paramEndIndex","param","isRegex","matchedParameters","exec","matchedParam","statusCode","end","prettyPrint","bind","tree","_this$constrainer$str","strategies","version","host","mergedRouter","mergedRoutes","MERGED","m","methodName","parentheses","assign","all","acceptVersionStrategy","acceptHostStrategy","customStrategies","strategiesInUse","Set","asyncStrategiesInUse","strategy","values","isStrategyUsed","has","customConstraintStrategy","isCustom","storage","deriveConstraint","isAsync","mustMatchWhenDerived","deriveSyncConstraints","deriveAsyncConstraints","beforeSize","size","_buildDeriveConstraints","newStoreForConstraint","constraint","validate","asyncConstraintsCount","constraintValue","lines","Function","unconstrainedHandler","handlers","constrainedHandlerStores","_getHandlerMatchingConstraints","addHandler","handlerObject","_compileCreateParamsObject","constraintsNames","unshift","isMergedTree","_compileGetHandlerMatchingConstraints","_buildConstraintStore","indexes","_constrainedIndexBitmask","mask","matchMask","HandlerStorage","Node","ParentNode","super","findStaticMatchingChild","staticChild","charAt","matchPrefix","label","wildcardChild","parametricChildren","_compilePrefixMatch","staticSuffix","regexpSource","parametricChild","child","nodePaths","ParametricNode","child1","child2","endsWith","WildcardNode","parentNode","parentPrefix","childPrefix","staticNode","nodeStack","parametricBrotherNodeIndex","treeDataSymbol","printObjectTree","isLast","parseMeta","meta","fName","trim","parseFunctionName","normalizeRoute","serializeRoute","serializedRoute","metaData","serializedMetaData","entries","serializeMetaData","serializeNode","includeMeta","metaDataObject","filteredMetaData","includeMetaKeys","Reflect","metaKey","serializedKey","metaValue","serializedValue","getRouteMetaData","nodeRoute","mergeSimilarRoutes","buildObjectTree","commonPrefix","root","objectTree","hosts","regexHosts","exact","SemVerStore","maxMajor","maxMinors","maxPatches","major","minor","patch","decodeComponentChar","highCharCode","lowCharCode","shouldDecode","decodeURI","uriComponent","startIndex","decodedChar","propIsEnumerable","test1","test2","test3","letter","shouldUseNative","to","toObject","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","nextTick","title","browser","argv","versions","addListener","once","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","types","replimit","limit","reps","walk","starHeight","REPETITION","sets","positions","regexpStr","start","ROOT","lastGroup","groupStack","repeatErr","strToChars","wordBoundary","nonWordBoundary","words","notWords","ints","notInts","whitespace","notWhitespace","REFERENCE","parseInt","CHAR","begin","not","classTokens","tokenizeClass","SET","anyChar","group","GROUP","remember","followedBy","notFollowedBy","max","rs","Infinity","POSITION","INTS","RANGE","WORDS","WHITESPACE","SLSH","v","lbs","a16","b16","c8","dctrl","eslsh","tokens","SyntaxError","Product","ProductVersion","ServicePort","libFableServiceProviderBase","ServiceServerType","Name","settings","URL","Port","Active","listen","pPort","fCallback","close","bodyParser","pRequest","pResponse","fNext","use","fHandlerFunction","doGet","pRoute","_len","fRouteProcessingFunctions","_key","getWithBodyParser","_len2","_key2","doPut","put","_len3","_key3","putWithBodyParser","_len4","_key4","doPost","post","_len5","_key5","postWithBodyParser","_len6","_key6","doDel","del","_len7","_key7","delWithBodyParser","_len8","_key8","doPatch","_len9","_key9","patchWithBodyParser","_len10","_key10","doOpts","_len11","_key11","optsWithBodyParser","_len12","_key12","doHead","head","headWithBodyParser","_len13","_key13","invoke","pMethod","pData","debug","pHandler","pLog","pRequestGUID","requestGUID","responseData","responseStatus","send","libOratorServiceServerBase","libOratorServiceServerIPCSynthesizedResponse","libFindMyWay","router","preBehaviorFunctions","behaviorMap","postBehaviorFunctions","addPreBehaviorFunction","executePreBehaviorFunctions","tmpAnticipate","serviceManager","instantiateServiceProviderWithoutRegistration","tmpPreBehaviorFunction","anticipate","fStageComplete","wait","pError","pFunctionIndex","addPostBehaviorFunction","executePostBehaviorFunctions","tmpPostBehaviorFunction","addRouteProcessor","pRouteFunctionArray","buildFindMyWayHandler","tmpRouteFunctionArray","tmpRouteFunction","Promise","fResolve","fReject","pBehaviorFunctionError","_len14","_key14","_len15","_key15","_len16","_key16","_len17","_key17","_len18","_key18","_len19","_key19","_len20","_key20","tmpCallback","tmpRequest","guid","tmpHandler","tmpSynthesizedResponseData","then","pResults","Route","Data","libDefaultOratorServiceServer","defaultOratorConfiguration","serviceServer","serviceServerProvider","pServiceProvider","APIServerPort","onBeforeInitialize","LogNoisiness","onBeforeInitializeAsync","warn","OratorServiceServer","tmpServiceServerOptions","ServiceServerOptions","addServiceType","instantiateServiceProvider","webServer","onInitialize","onInitializeAsync","onAfterInitialize","onAfterInitializeAsync","initialize","initializeTimestamp","getTimeStamp","onBeforeStartService","onStartService","info","onAfterStartService","startService","tmpNext","startServiceTimestamp","stopService","tmpMessage","startWebServer","stopWebServer","getWebServer","initializeServiceServer","ServiceServerBase","ServiceServerIPC"],"mappings":"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,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,GAAA,EAAA,EAAA,EAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAIA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,GAAA,EAAA,EAAA,EAAA,EAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GAAA,GACA,EAAA,GAAA,GAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,EAAA,EAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,GAAA,GAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,GAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,GAAA,GAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,EAAA,GAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EACA,EAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAIA,IAAA,GAAA,GAAA,GAAA,EAAA,GAAA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","file":"orator.min.js","sourcesContent":["(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.Orator = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){\n(function (global){(function (){\n'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license MIT\n */\nfunction compare(a, b) {\n if (a === b) {\n return 0;\n }\n\n var x = a.length;\n var y = b.length;\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i];\n y = b[i];\n break;\n }\n }\n\n if (x < y) {\n return -1;\n }\n if (y < x) {\n return 1;\n }\n return 0;\n}\nfunction isBuffer(b) {\n if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n return global.Buffer.isBuffer(b);\n }\n return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n// node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n if (isBuffer(arrbuf)) {\n return false;\n }\n if (typeof global.ArrayBuffer !== 'function') {\n return false;\n }\n if (typeof ArrayBuffer.isView === 'function') {\n return ArrayBuffer.isView(arrbuf);\n }\n if (!arrbuf) {\n return false;\n }\n if (arrbuf instanceof DataView) {\n return true;\n }\n if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n return true;\n }\n return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n// actual: actual,\n// expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n if (!util.isFunction(func)) {\n return;\n }\n if (functionsHaveNames) {\n return func.name;\n }\n var str = func.toString();\n var match = str.match(regex);\n return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n this.name = 'AssertionError';\n this.actual = options.actual;\n this.expected = options.expected;\n this.operator = options.operator;\n if (options.message) {\n this.message = options.message;\n this.generatedMessage = false;\n } else {\n this.message = getMessage(this);\n this.generatedMessage = true;\n }\n var stackStartFunction = options.stackStartFunction || fail;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, stackStartFunction);\n } else {\n // non v8 browsers so we can have a stacktrace\n var err = new Error();\n if (err.stack) {\n var out = err.stack;\n\n // try to strip useless frames\n var fn_name = getName(stackStartFunction);\n var idx = out.indexOf('\\n' + fn_name);\n if (idx >= 0) {\n // once we have located the function frame\n // we need to strip out everything before it (and its line)\n var next_line = out.indexOf('\\n', idx + 1);\n out = out.substring(next_line + 1);\n }\n\n this.stack = out;\n }\n }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n if (typeof s === 'string') {\n return s.length < n ? s : s.slice(0, n);\n } else {\n return s;\n }\n}\nfunction inspect(something) {\n if (functionsHaveNames || !util.isFunction(something)) {\n return util.inspect(something);\n }\n var rawname = getName(something);\n var name = rawname ? ': ' + rawname : '';\n return '[Function' + name + ']';\n}\nfunction getMessage(self) {\n return truncate(inspect(self.actual), 128) + ' ' +\n self.operator + ' ' +\n truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided. All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n throw new assert.AssertionError({\n message: message,\n actual: actual,\n expected: expected,\n operator: operator,\n stackStartFunction: stackStartFunction\n });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n if (actual == expected) {\n fail(actual, expected, message, '!=', assert.notEqual);\n }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n if (!_deepEqual(actual, expected, false)) {\n fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n if (!_deepEqual(actual, expected, true)) {\n fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n // 7.1. All identical values are equivalent, as determined by ===.\n if (actual === expected) {\n return true;\n } else if (isBuffer(actual) && isBuffer(expected)) {\n return compare(actual, expected) === 0;\n\n // 7.2. If the expected value is a Date object, the actual value is\n // equivalent if it is also a Date object that refers to the same time.\n } else if (util.isDate(actual) && util.isDate(expected)) {\n return actual.getTime() === expected.getTime();\n\n // 7.3 If the expected value is a RegExp object, the actual value is\n // equivalent if it is also a RegExp object with the same source and\n // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n return actual.source === expected.source &&\n actual.global === expected.global &&\n actual.multiline === expected.multiline &&\n actual.lastIndex === expected.lastIndex &&\n actual.ignoreCase === expected.ignoreCase;\n\n // 7.4. Other pairs that do not both pass typeof value == 'object',\n // equivalence is determined by ==.\n } else if ((actual === null || typeof actual !== 'object') &&\n (expected === null || typeof expected !== 'object')) {\n return strict ? actual === expected : actual == expected;\n\n // If both values are instances of typed arrays, wrap their underlying\n // ArrayBuffers in a Buffer each to increase performance\n // This optimization requires the arrays to have the same type as checked by\n // Object.prototype.toString (aka pToString). Never perform binary\n // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n // bit patterns are not identical.\n } else if (isView(actual) && isView(expected) &&\n pToString(actual) === pToString(expected) &&\n !(actual instanceof Float32Array ||\n actual instanceof Float64Array)) {\n return compare(new Uint8Array(actual.buffer),\n new Uint8Array(expected.buffer)) === 0;\n\n // 7.5 For all other Object pairs, including Array objects, equivalence is\n // determined by having the same number of owned properties (as verified\n // with Object.prototype.hasOwnProperty.call), the same set of keys\n // (although not necessarily the same order), equivalent values for every\n // corresponding key, and an identical 'prototype' property. Note: this\n // accounts for both named and indexed properties on Arrays.\n } else if (isBuffer(actual) !== isBuffer(expected)) {\n return false;\n } else {\n memos = memos || {actual: [], expected: []};\n\n var actualIndex = memos.actual.indexOf(actual);\n if (actualIndex !== -1) {\n if (actualIndex === memos.expected.indexOf(expected)) {\n return true;\n }\n }\n\n memos.actual.push(actual);\n memos.expected.push(expected);\n\n return objEquiv(actual, expected, strict, memos);\n }\n}\n\nfunction isArguments(object) {\n return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n if (a === null || a === undefined || b === null || b === undefined)\n return false;\n // if one is a primitive, the other must be same\n if (util.isPrimitive(a) || util.isPrimitive(b))\n return a === b;\n if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n return false;\n var aIsArgs = isArguments(a);\n var bIsArgs = isArguments(b);\n if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n return false;\n if (aIsArgs) {\n a = pSlice.call(a);\n b = pSlice.call(b);\n return _deepEqual(a, b, strict);\n }\n var ka = objectKeys(a);\n var kb = objectKeys(b);\n var key, i;\n // having the same number of owned properties (keys incorporates\n // hasOwnProperty)\n if (ka.length !== kb.length)\n return false;\n //the same set of keys (although not necessarily the same order),\n ka.sort();\n kb.sort();\n //~~~cheap key test\n for (i = ka.length - 1; i >= 0; i--) {\n if (ka[i] !== kb[i])\n return false;\n }\n //equivalent values for every corresponding key, and\n //~~~possibly expensive deep test\n for (i = ka.length - 1; i >= 0; i--) {\n key = ka[i];\n if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n return false;\n }\n return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n if (_deepEqual(actual, expected, false)) {\n fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n if (_deepEqual(actual, expected, true)) {\n fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n if (actual !== expected) {\n fail(actual, expected, message, '===', assert.strictEqual);\n }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==. assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n if (actual === expected) {\n fail(actual, expected, message, '!==', assert.notStrictEqual);\n }\n};\n\nfunction expectedException(actual, expected) {\n if (!actual || !expected) {\n return false;\n }\n\n if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n return expected.test(actual);\n }\n\n try {\n if (actual instanceof expected) {\n return true;\n }\n } catch (e) {\n // Ignore. The instanceof check doesn't work for arrow functions.\n }\n\n if (Error.isPrototypeOf(expected)) {\n return false;\n }\n\n return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n var error;\n try {\n block();\n } catch (e) {\n error = e;\n }\n return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n var actual;\n\n if (typeof block !== 'function') {\n throw new TypeError('\"block\" argument must be a function');\n }\n\n if (typeof expected === 'string') {\n message = expected;\n expected = null;\n }\n\n actual = _tryBlock(block);\n\n message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n (message ? ' ' + message : '.');\n\n if (shouldThrow && !actual) {\n fail(actual, expected, 'Missing expected exception' + message);\n }\n\n var userProvidedMessage = typeof message === 'string';\n var isUnwantedException = !shouldThrow && util.isError(actual);\n var isUnexpectedException = !shouldThrow && actual && !expected;\n\n if ((isUnwantedException &&\n userProvidedMessage &&\n expectedException(actual, expected)) ||\n isUnexpectedException) {\n fail(actual, expected, 'Got unwanted exception' + message);\n }\n\n if ((shouldThrow && actual && expected &&\n !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n throw actual;\n }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n equal: assert.strictEqual,\n deepEqual: assert.deepStrictEqual,\n notEqual: assert.notStrictEqual,\n notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n for (var key in obj) {\n if (hasOwn.call(obj, key)) keys.push(key);\n }\n return keys;\n};\n\n}).call(this)}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n\n},{\"object-assign\":23,\"util/\":4}],2:[function(require,module,exports){\nif (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n}\n\n},{}],3:[function(require,module,exports){\nmodule.exports = function isBuffer(arg) {\n return arg && typeof arg === 'object'\n && typeof arg.copy === 'function'\n && typeof arg.fill === 'function'\n && typeof arg.readUInt8 === 'function';\n}\n},{}],4:[function(require,module,exports){\n(function (process,global){(function (){\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n if (!isString(f)) {\n var objects = [];\n for (var i = 0; i < arguments.length; i++) {\n objects.push(inspect(arguments[i]));\n }\n return objects.join(' ');\n }\n\n var i = 1;\n var args = arguments;\n var len = args.length;\n var str = String(f).replace(formatRegExp, function(x) {\n if (x === '%%') return '%';\n if (i >= len) return x;\n switch (x) {\n case '%s': return String(args[i++]);\n case '%d': return Number(args[i++]);\n case '%j':\n try {\n return JSON.stringify(args[i++]);\n } catch (_) {\n return '[Circular]';\n }\n default:\n return x;\n }\n });\n for (var x = args[i]; i < len; x = args[++i]) {\n if (isNull(x) || !isObject(x)) {\n str += ' ' + x;\n } else {\n str += ' ' + inspect(x);\n }\n }\n return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n // Allow for deprecating things in the process of starting up.\n if (isUndefined(global.process)) {\n return function() {\n return exports.deprecate(fn, msg).apply(this, arguments);\n };\n }\n\n if (process.noDeprecation === true) {\n return fn;\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (process.throwDeprecation) {\n throw new Error(msg);\n } else if (process.traceDeprecation) {\n console.trace(msg);\n } else {\n console.error(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n if (isUndefined(debugEnviron))\n debugEnviron = process.env.NODE_DEBUG || '';\n set = set.toUpperCase();\n if (!debugs[set]) {\n if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n var pid = process.pid;\n debugs[set] = function() {\n var msg = exports.format.apply(exports, arguments);\n console.error('%s %d: %s', set, pid, msg);\n };\n } else {\n debugs[set] = function() {};\n }\n }\n return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n // default options\n var ctx = {\n seen: [],\n stylize: stylizeNoColor\n };\n // legacy...\n if (arguments.length >= 3) ctx.depth = arguments[2];\n if (arguments.length >= 4) ctx.colors = arguments[3];\n if (isBoolean(opts)) {\n // legacy...\n ctx.showHidden = opts;\n } else if (opts) {\n // got an \"options\" object\n exports._extend(ctx, opts);\n }\n // set default options\n if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n if (isUndefined(ctx.depth)) ctx.depth = 2;\n if (isUndefined(ctx.colors)) ctx.colors = false;\n if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n if (ctx.colors) ctx.stylize = stylizeWithColor;\n return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n 'bold' : [1, 22],\n 'italic' : [3, 23],\n 'underline' : [4, 24],\n 'inverse' : [7, 27],\n 'white' : [37, 39],\n 'grey' : [90, 39],\n 'black' : [30, 39],\n 'blue' : [34, 39],\n 'cyan' : [36, 39],\n 'green' : [32, 39],\n 'magenta' : [35, 39],\n 'red' : [31, 39],\n 'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n 'special': 'cyan',\n 'number': 'yellow',\n 'boolean': 'yellow',\n 'undefined': 'grey',\n 'null': 'bold',\n 'string': 'green',\n 'date': 'magenta',\n // \"name\": intentionally not styling\n 'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n var style = inspect.styles[styleType];\n\n if (style) {\n return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n '\\u001b[' + inspect.colors[style][1] + 'm';\n } else {\n return str;\n }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n return str;\n}\n\n\nfunction arrayToHash(array) {\n var hash = {};\n\n array.forEach(function(val, idx) {\n hash[val] = true;\n });\n\n return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n // Provide a hook for user-specified inspect functions.\n // Check that value is an object with an inspect function on it\n if (ctx.customInspect &&\n value &&\n isFunction(value.inspect) &&\n // Filter out the util module, it's inspect function is special\n value.inspect !== exports.inspect &&\n // Also filter out any prototype objects using the circular check.\n !(value.constructor && value.constructor.prototype === value)) {\n var ret = value.inspect(recurseTimes, ctx);\n if (!isString(ret)) {\n ret = formatValue(ctx, ret, recurseTimes);\n }\n return ret;\n }\n\n // Primitive types cannot have properties\n var primitive = formatPrimitive(ctx, value);\n if (primitive) {\n return primitive;\n }\n\n // Look up the keys of the object.\n var keys = Object.keys(value);\n var visibleKeys = arrayToHash(keys);\n\n if (ctx.showHidden) {\n keys = Object.getOwnPropertyNames(value);\n }\n\n // IE doesn't make error fields non-enumerable\n // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n if (isError(value)\n && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n return formatError(value);\n }\n\n // Some type of object without properties can be shortcutted.\n if (keys.length === 0) {\n if (isFunction(value)) {\n var name = value.name ? ': ' + value.name : '';\n return ctx.stylize('[Function' + name + ']', 'special');\n }\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n }\n if (isDate(value)) {\n return ctx.stylize(Date.prototype.toString.call(value), 'date');\n }\n if (isError(value)) {\n return formatError(value);\n }\n }\n\n var base = '', array = false, braces = ['{', '}'];\n\n // Make Array say that they are Array\n if (isArray(value)) {\n array = true;\n braces = ['[', ']'];\n }\n\n // Make functions say that they are functions\n if (isFunction(value)) {\n var n = value.name ? ': ' + value.name : '';\n base = ' [Function' + n + ']';\n }\n\n // Make RegExps say that they are RegExps\n if (isRegExp(value)) {\n base = ' ' + RegExp.prototype.toString.call(value);\n }\n\n // Make dates with properties first say the date\n if (isDate(value)) {\n base = ' ' + Date.prototype.toUTCString.call(value);\n }\n\n // Make error with message first say the error\n if (isError(value)) {\n base = ' ' + formatError(value);\n }\n\n if (keys.length === 0 && (!array || value.length == 0)) {\n return braces[0] + base + braces[1];\n }\n\n if (recurseTimes < 0) {\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n } else {\n return ctx.stylize('[Object]', 'special');\n }\n }\n\n ctx.seen.push(value);\n\n var output;\n if (array) {\n output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n } else {\n output = keys.map(function(key) {\n return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n });\n }\n\n ctx.seen.pop();\n\n return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n if (isUndefined(value))\n return ctx.stylize('undefined', 'undefined');\n if (isString(value)) {\n var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n .replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"') + '\\'';\n return ctx.stylize(simple, 'string');\n }\n if (isNumber(value))\n return ctx.stylize('' + value, 'number');\n if (isBoolean(value))\n return ctx.stylize('' + value, 'boolean');\n // For some reason typeof null is \"object\", so special case here.\n if (isNull(value))\n return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n var output = [];\n for (var i = 0, l = value.length; i < l; ++i) {\n if (hasOwnProperty(value, String(i))) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n String(i), true));\n } else {\n output.push('');\n }\n }\n keys.forEach(function(key) {\n if (!key.match(/^\\d+$/)) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n key, true));\n }\n });\n return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n var name, str, desc;\n desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n if (desc.get) {\n if (desc.set) {\n str = ctx.stylize('[Getter/Setter]', 'special');\n } else {\n str = ctx.stylize('[Getter]', 'special');\n }\n } else {\n if (desc.set) {\n str = ctx.stylize('[Setter]', 'special');\n }\n }\n if (!hasOwnProperty(visibleKeys, key)) {\n name = '[' + key + ']';\n }\n if (!str) {\n if (ctx.seen.indexOf(desc.value) < 0) {\n if (isNull(recurseTimes)) {\n str = formatValue(ctx, desc.value, null);\n } else {\n str = formatValue(ctx, desc.value, recurseTimes - 1);\n }\n if (str.indexOf('\\n') > -1) {\n if (array) {\n str = str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n').substr(2);\n } else {\n str = '\\n' + str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n');\n }\n }\n } else {\n str = ctx.stylize('[Circular]', 'special');\n }\n }\n if (isUndefined(name)) {\n if (array && key.match(/^\\d+$/)) {\n return str;\n }\n name = JSON.stringify('' + key);\n if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n name = name.substr(1, name.length - 2);\n name = ctx.stylize(name, 'name');\n } else {\n name = name.replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"')\n .replace(/(^\"|\"$)/g, \"'\");\n name = ctx.stylize(name, 'string');\n }\n }\n\n return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n var numLinesEst = 0;\n var length = output.reduce(function(prev, cur) {\n numLinesEst++;\n if (cur.indexOf('\\n') >= 0) numLinesEst++;\n return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n }, 0);\n\n if (length > 60) {\n return braces[0] +\n (base === '' ? '' : base + '\\n ') +\n ' ' +\n output.join(',\\n ') +\n ' ' +\n braces[1];\n }\n\n return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n return isObject(e) &&\n (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n return arg === null ||\n typeof arg === 'boolean' ||\n typeof arg === 'number' ||\n typeof arg === 'string' ||\n typeof arg === 'symbol' || // ES6 symbol\n typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n 'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n var d = new Date();\n var time = [pad(d.getHours()),\n pad(d.getMinutes()),\n pad(d.getSeconds())].join(':');\n return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n * prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n // Don't do anything if add isn't an object\n if (!add || !isObject(add)) return origin;\n\n var keys = Object.keys(add);\n var i = keys.length;\n while (i--) {\n origin[keys[i]] = add[keys[i]];\n }\n return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\n}).call(this)}).call(this,require('_process'),typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n\n},{\"./support/isBuffer\":3,\"_process\":24,\"inherits\":2}],5:[function(require,module,exports){\n/**\n* Fable Core Pre-initialization Service Base\n*\n* For a couple services, we need to be able to instantiate them before the Fable object is fully initialized.\n* This is a base class for those services.\n*\n* @author <steven@velozo.com>\n*/\n\nclass FableCoreServiceProviderBase\n{\n\tconstructor(pOptions, pServiceHash)\n\t{\n\t\tthis.fable = false;\n\n\t\tthis.options = (typeof(pOptions) === 'object') ? pOptions : {};\n\n\t\tthis.serviceType = 'Unknown';\n\n\t\t// The hash will be a non-standard UUID ... the UUID service uses this base class!\n\t\tthis.UUID = `CORESVC-${Math.floor((Math.random() * (99999 - 10000)) + 10000)}`;\n\n\t\tthis.Hash = (typeof(pServiceHash) === 'string') ? pServiceHash : `${this.UUID}`;\n\t}\n\n\n\tstatic isFableService = true;\n\n\t// After fable is initialized, it would be expected to be wired in as a normal service.\n\tconnectFable(pFable)\n\t{\n\t\tthis.fable = pFable;\n\n\t\treturn true;\n\t}\n}\n\nmodule.exports = FableCoreServiceProviderBase;\n\n},{}],6:[function(require,module,exports){\n/**\n* Fable Service Base\n* @author <steven@velozo.com>\n*/\n\nclass FableServiceProviderBase\n{\n\tconstructor(pFable, pOptions, pServiceHash)\n\t{\n\t\tthis.fable = pFable;\n\n\t\tthis.options = (typeof(pOptions) === 'object') ? pOptions\n\t\t\t\t\t\t: ((typeof(pFable) === 'object') && !pFable.isFable) ? pFable\n\t\t\t\t\t\t: {};\n\n\t\tthis.serviceType = 'Unknown';\n\n\t\tif (typeof(pFable.getUUID) == 'function')\n\t\t{\n\t\t\tthis.UUID = pFable.getUUID();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.UUID = `NoFABLESVC-${Math.floor((Math.random() * (99999 - 10000)) + 10000)}`\n\t\t}\n\n\t\tthis.Hash = (typeof(pServiceHash) === 'string') ? pServiceHash : `${this.UUID}`;\n\n\t\t// Pull back a few things\n\t\tthis.log = this.fable.log;\n\t\tthis.servicesMap = this.fable.servicesMap;\n\t\tthis.services = this.fable.services;\n\t}\n\n\tstatic isFableService = true;\n}\n\nmodule.exports = FableServiceProviderBase;\n\nmodule.exports.CoreServiceProviderBase = require('./Fable-ServiceProviderBase-Preinit.js');\n},{\"./Fable-ServiceProviderBase-Preinit.js\":5}],7:[function(require,module,exports){\n'use strict'\n\nvar UTF8_ACCEPT = 12\nvar UTF8_REJECT = 0\nvar UTF8_DATA = [\n // The first part of the table maps bytes to character to a transition.\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 7,\n 10, 9, 9, 9, 11, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n\n // The second part of the table maps a state to a new state when adding a\n // transition.\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 12, 0, 0, 0, 0, 24, 36, 48, 60, 72, 84, 96,\n 0, 12, 12, 12, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 48, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n\n // The third part maps the current transition to a mask that needs to apply\n // to the byte.\n 0x7F, 0x3F, 0x3F, 0x3F, 0x00, 0x1F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x07\n]\n\nfunction decodeURIComponent (uri) {\n var percentPosition = uri.indexOf('%')\n if (percentPosition === -1) return uri\n\n var length = uri.length\n var decoded = ''\n var last = 0\n var codepoint = 0\n var startOfOctets = percentPosition\n var state = UTF8_ACCEPT\n\n while (percentPosition > -1 && percentPosition < length) {\n var high = hexCodeToInt(uri[percentPosition + 1], 4)\n var low = hexCodeToInt(uri[percentPosition + 2], 0)\n var byte = high | low\n var type = UTF8_DATA[byte]\n state = UTF8_DATA[256 + state + type]\n codepoint = (codepoint << 6) | (byte & UTF8_DATA[364 + type])\n\n if (state === UTF8_ACCEPT) {\n decoded += uri.slice(last, startOfOctets)\n\n decoded += (codepoint <= 0xFFFF)\n ? String.fromCharCode(codepoint)\n : String.fromCharCode(\n (0xD7C0 + (codepoint >> 10)),\n (0xDC00 + (codepoint & 0x3FF))\n )\n\n codepoint = 0\n last = percentPosition + 3\n percentPosition = startOfOctets = uri.indexOf('%', last)\n } else if (state === UTF8_REJECT) {\n return null\n } else {\n percentPosition += 3\n if (percentPosition < length && uri.charCodeAt(percentPosition) === 37) continue\n return null\n }\n }\n\n return decoded + uri.slice(last)\n}\n\nvar HEX = {\n '0': 0,\n '1': 1,\n '2': 2,\n '3': 3,\n '4': 4,\n '5': 5,\n '6': 6,\n '7': 7,\n '8': 8,\n '9': 9,\n 'a': 10,\n 'A': 10,\n 'b': 11,\n 'B': 11,\n 'c': 12,\n 'C': 12,\n 'd': 13,\n 'D': 13,\n 'e': 14,\n 'E': 14,\n 'f': 15,\n 'F': 15\n}\n\nfunction hexCodeToInt (c, shift) {\n var i = HEX[c]\n return i === undefined ? 255 : i << shift\n}\n\nmodule.exports = decodeURIComponent\n\n},{}],8:[function(require,module,exports){\n'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n if (a === b) return true;\n\n if (a && b && typeof a == 'object' && typeof b == 'object') {\n if (a.constructor !== b.constructor) return false;\n\n var length, i, keys;\n if (Array.isArray(a)) {\n length = a.length;\n if (length != b.length) return false;\n for (i = length; i-- !== 0;)\n if (!equal(a[i], b[i])) return false;\n return true;\n }\n\n\n\n if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n keys = Object.keys(a);\n length = keys.length;\n if (length !== Object.keys(b).length) return false;\n\n for (i = length; i-- !== 0;)\n if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n for (i = length; i-- !== 0;) {\n var key = keys[i];\n\n if (!equal(a[key], b[key])) return false;\n }\n\n return true;\n }\n\n // true if both NaN, false otherwise\n return a!==a && b!==b;\n};\n\n},{}],9:[function(require,module,exports){\n\"use strict\";\n\nconst parse = require(\"./parse\");\nconst stringify = require(\"./stringify\");\n\nconst fastQuerystring = {\n parse,\n stringify,\n};\n\n/**\n * Enable TS and JS support\n *\n * - `const qs = require('fast-querystring')`\n * - `import qs from 'fast-querystring'`\n */\nmodule.exports = fastQuerystring;\nmodule.exports.default = fastQuerystring;\nmodule.exports.parse = parse;\nmodule.exports.stringify = stringify;\n\n},{\"./parse\":11,\"./stringify\":12}],10:[function(require,module,exports){\n// This file is taken from Node.js project.\n// Full implementation can be found from https://github.com/nodejs/node/blob/main/lib/internal/querystring.js\n\nconst hexTable = Array.from(\n { length: 256 },\n (_, i) => \"%\" + ((i < 16 ? \"0\" : \"\") + i.toString(16)).toUpperCase(),\n);\n\n// These characters do not need escaping when generating query strings:\n// ! - . _ ~\n// ' ( ) *\n// digits\n// alpha (uppercase)\n// alpha (lowercase)\n// rome-ignore format: the array should not be formatted\nconst noEscape = new Int8Array([\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31\n 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, // 32 - 47\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63\n 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 80 - 95\n 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, // 112 - 127\n]);\n\n/**\n * @param {string} str\n * @returns {string}\n */\nfunction encodeString(str) {\n const len = str.length;\n if (len === 0) return \"\";\n\n let out = \"\";\n let lastPos = 0;\n let i = 0;\n\n outer: for (; i < len; i++) {\n let c = str.charCodeAt(i);\n\n // ASCII\n while (c < 0x80) {\n if (noEscape[c] !== 1) {\n if (lastPos < i) out += str.slice(lastPos, i);\n lastPos = i + 1;\n out += hexTable[c];\n }\n\n if (++i === len) break outer;\n\n c = str.charCodeAt(i);\n }\n\n if (lastPos < i) out += str.slice(lastPos, i);\n\n // Multi-byte characters ...\n if (c < 0x800) {\n lastPos = i + 1;\n out += hexTable[0xc0 | (c >> 6)] + hexTable[0x80 | (c & 0x3f)];\n continue;\n }\n if (c < 0xd800 || c >= 0xe000) {\n lastPos = i + 1;\n out +=\n hexTable[0xe0 | (c >> 12)] +\n hexTable[0x80 | ((c >> 6) & 0x3f)] +\n hexTable[0x80 | (c & 0x3f)];\n continue;\n }\n // Surrogate pair\n ++i;\n\n // This branch should never happen because all URLSearchParams entries\n // should already be converted to USVString. But, included for\n // completion's sake anyway.\n if (i >= len) {\n throw new Error(\"URI malformed\");\n }\n\n const c2 = str.charCodeAt(i) & 0x3ff;\n\n lastPos = i + 1;\n c = 0x10000 + (((c & 0x3ff) << 10) | c2);\n out +=\n hexTable[0xf0 | (c >> 18)] +\n hexTable[0x80 | ((c >> 12) & 0x3f)] +\n hexTable[0x80 | ((c >> 6) & 0x3f)] +\n hexTable[0x80 | (c & 0x3f)];\n }\n if (lastPos === 0) return str;\n if (lastPos < len) return out + str.slice(lastPos);\n return out;\n}\n\nmodule.exports = { encodeString };\n\n},{}],11:[function(require,module,exports){\n\"use strict\";\n\nconst fastDecode = require(\"fast-decode-uri-component\");\n\nconst plusRegex = /\\+/g;\nconst Empty = function () {};\nEmpty.prototype = Object.create(null);\n\n/**\n * @callback parse\n * @param {string} input\n */\nfunction parse(input) {\n // Optimization: Use new Empty() instead of Object.create(null) for performance\n // v8 has a better optimization for initializing functions compared to Object\n const result = new Empty();\n\n if (typeof input !== \"string\") {\n return result;\n }\n\n let inputLength = input.length;\n let key = \"\";\n let value = \"\";\n let startingIndex = -1;\n let equalityIndex = -1;\n let shouldDecodeKey = false;\n let shouldDecodeValue = false;\n let keyHasPlus = false;\n let valueHasPlus = false;\n let hasBothKeyValuePair = false;\n let c = 0;\n\n // Have a boundary of input.length + 1 to access last pair inside the loop.\n for (let i = 0; i < inputLength + 1; i++) {\n c = i !== inputLength ? input.charCodeAt(i) : 38;\n\n // Handle '&' and end of line to pass the current values to result\n if (c === 38) {\n hasBothKeyValuePair = equalityIndex > startingIndex;\n\n // Optimization: Reuse equality index to store the end of key\n if (!hasBothKeyValuePair) {\n equalityIndex = i;\n }\n\n key = input.slice(startingIndex + 1, equalityIndex);\n\n // Add key/value pair only if the range size is greater than 1; a.k.a. contains at least \"=\"\n if (hasBothKeyValuePair || key.length > 0) {\n // Optimization: Replace '+' with space\n if (keyHasPlus) {\n key = key.replace(plusRegex, \" \");\n }\n\n // Optimization: Do not decode if it's not necessary.\n if (shouldDecodeKey) {\n key = fastDecode(key) || key;\n }\n\n if (hasBothKeyValuePair) {\n value = input.slice(equalityIndex + 1, i);\n\n if (valueHasPlus) {\n value = value.replace(plusRegex, \" \");\n }\n\n if (shouldDecodeValue) {\n value = fastDecode(value) || value;\n }\n }\n const currentValue = result[key];\n\n if (currentValue === undefined) {\n result[key] = value;\n } else {\n // Optimization: value.pop is faster than Array.isArray(value)\n if (currentValue.pop) {\n currentValue.push(value);\n } else {\n result[key] = [currentValue, value];\n }\n }\n }\n\n // Reset reading key value pairs\n value = \"\";\n startingIndex = i;\n equalityIndex = i;\n shouldDecodeKey = false;\n shouldDecodeValue = false;\n keyHasPlus = false;\n valueHasPlus = false;\n }\n // Check '='\n else if (c === 61) {\n if (equalityIndex <= startingIndex) {\n equalityIndex = i;\n }\n // If '=' character occurs again, we should decode the input.\n else {\n shouldDecodeValue = true;\n }\n }\n // Check '+', and remember to replace it with empty space.\n else if (c === 43) {\n if (equalityIndex > startingIndex) {\n valueHasPlus = true;\n } else {\n keyHasPlus = true;\n }\n }\n // Check '%' character for encoding\n else if (c === 37) {\n if (equalityIndex > startingIndex) {\n shouldDecodeValue = true;\n } else {\n shouldDecodeKey = true;\n }\n }\n }\n\n return result;\n}\n\nmodule.exports = parse;\n\n},{\"fast-decode-uri-component\":7}],12:[function(require,module,exports){\n\"use strict\";\n\nconst { encodeString } = require(\"./internals/querystring\");\n\nfunction getAsPrimitive(value) {\n const type = typeof value;\n\n if (type === \"string\") {\n // Length check is handled inside encodeString function\n return encodeString(value);\n } else if (type === \"bigint\") {\n return value.toString();\n } else if (type === \"boolean\") {\n return value ? \"true\" : \"false\";\n } else if (type === \"number\" && Number.isFinite(value)) {\n return value < 1e21 ? \"\" + value : encodeString(\"\" + value);\n }\n\n return \"\";\n}\n\n/**\n * @param {Record<string, string | number | boolean\n * | ReadonlyArray<string | number | boolean> | null>} input\n * @returns {string}\n */\nfunction stringify(input) {\n let result = \"\";\n\n if (input === null || typeof input !== \"object\") {\n return result;\n }\n\n const separator = \"&\";\n const keys = Object.keys(input);\n const keyLength = keys.length;\n let valueLength = 0;\n\n for (let i = 0; i < keyLength; i++) {\n const key = keys[i];\n const value = input[key];\n const encodedKey = encodeString(key) + \"=\";\n\n if (i) {\n result += separator;\n }\n\n if (Array.isArray(value)) {\n valueLength = value.length;\n for (let j = 0; j < valueLength; j++) {\n if (j) {\n result += separator;\n }\n\n // Optimization: Dividing into multiple lines improves the performance.\n // Since v8 does not need to care about the '+' character if it was one-liner.\n result += encodedKey;\n result += getAsPrimitive(value[j]);\n }\n } else {\n result += encodedKey;\n result += getAsPrimitive(value);\n }\n }\n\n return result;\n}\n\nmodule.exports = stringify;\n\n},{\"./internals/querystring\":10}],13:[function(require,module,exports){\n'use strict'\n\n/*\n Char codes:\n '!': 33 - !\n '#': 35 - %23\n '$': 36 - %24\n '%': 37 - %25\n '&': 38 - %26\n ''': 39 - '\n '(': 40 - (\n ')': 41 - )\n '*': 42 - *\n '+': 43 - %2B\n ',': 44 - %2C\n '-': 45 - -\n '.': 46 - .\n '/': 47 - %2F\n ':': 58 - %3A\n ';': 59 - %3B\n '=': 61 - %3D\n '?': 63 - %3F\n '@': 64 - %40\n '_': 95 - _\n '~': 126 - ~\n*/\n\nconst assert = require('assert')\nconst querystring = require('fast-querystring')\nconst isRegexSafe = require('safe-regex2')\nconst deepEqual = require('fast-deep-equal')\nconst { prettyPrintTree } = require('./lib/pretty-print')\nconst { StaticNode, NODE_TYPES } = require('./lib/node')\nconst Constrainer = require('./lib/constrainer')\nconst httpMethods = require('./lib/http-methods')\nconst httpMethodStrategy = require('./lib/strategies/http-method')\nconst { safeDecodeURI, safeDecodeURIComponent } = require('./lib/url-sanitizer')\n\nconst FULL_PATH_REGEXP = /^https?:\\/\\/.*?\\//\nconst OPTIONAL_PARAM_REGEXP = /(\\/:[^/()]*?)\\?(\\/?)/\n\nif (!isRegexSafe(FULL_PATH_REGEXP)) {\n throw new Error('the FULL_PATH_REGEXP is not safe, update this module')\n}\n\nif (!isRegexSafe(OPTIONAL_PARAM_REGEXP)) {\n throw new Error('the OPTIONAL_PARAM_REGEXP is not safe, update this module')\n}\n\nfunction Router (opts) {\n if (!(this instanceof Router)) {\n return new Router(opts)\n }\n opts = opts || {}\n this._opts = opts\n\n if (opts.defaultRoute) {\n assert(typeof opts.defaultRoute === 'function', 'The default route must be a function')\n this.defaultRoute = opts.defaultRoute\n } else {\n this.defaultRoute = null\n }\n\n if (opts.onBadUrl) {\n assert(typeof opts.onBadUrl === 'function', 'The bad url handler must be a function')\n this.onBadUrl = opts.onBadUrl\n } else {\n this.onBadUrl = null\n }\n\n if (opts.buildPrettyMeta) {\n assert(typeof opts.buildPrettyMeta === 'function', 'buildPrettyMeta must be a function')\n this.buildPrettyMeta = opts.buildPrettyMeta\n } else {\n this.buildPrettyMeta = defaultBuildPrettyMeta\n }\n\n if (opts.querystringParser) {\n assert(typeof opts.querystringParser === 'function', 'querystringParser must be a function')\n this.querystringParser = opts.querystringParser\n } else {\n this.querystringParser = (query) => query === '' ? {} : querystring.parse(query)\n }\n\n this.caseSensitive = opts.caseSensitive === undefined ? true : opts.caseSensitive\n this.ignoreTrailingSlash = opts.ignoreTrailingSlash || false\n this.ignoreDuplicateSlashes = opts.ignoreDuplicateSlashes || false\n this.maxParamLength = opts.maxParamLength || 100\n this.allowUnsafeRegex = opts.allowUnsafeRegex || false\n this.constrainer = new Constrainer(opts.constraints)\n\n this.routes = []\n this.trees = {}\n}\n\nRouter.prototype.on = function on (method, path, opts, handler, store) {\n if (typeof opts === 'function') {\n if (handler !== undefined) {\n store = handler\n }\n handler = opts\n opts = {}\n }\n // path validation\n assert(typeof path === 'string', 'Path should be a string')\n assert(path.length > 0, 'The path could not be empty')\n assert(path[0] === '/' || path[0] === '*', 'The first character of a path should be `/` or `*`')\n // handler validation\n assert(typeof handler === 'function', 'Handler should be a function')\n\n // path ends with optional parameter\n const optionalParamMatch = path.match(OPTIONAL_PARAM_REGEXP)\n if (optionalParamMatch) {\n assert(path.length === optionalParamMatch.index + optionalParamMatch[0].length, 'Optional Parameter needs to be the last parameter of the path')\n\n const pathFull = path.replace(OPTIONAL_PARAM_REGEXP, '$1$2')\n const pathOptional = path.replace(OPTIONAL_PARAM_REGEXP, '$2')\n\n this.on(method, pathFull, opts, handler, store)\n this.on(method, pathOptional, opts, handler, store)\n return\n }\n\n const route = path\n\n if (this.ignoreDuplicateSlashes) {\n path = removeDuplicateSlashes(path)\n }\n\n if (this.ignoreTrailingSlash) {\n path = trimLastSlash(path)\n }\n\n const methods = Array.isArray(method) ? method : [method]\n for (const method of methods) {\n assert(typeof method === 'string', 'Method should be a string')\n assert(httpMethods.includes(method), `Method '${method}' is not an http method.`)\n this._on(method, path, opts, handler, store, route)\n }\n}\n\nRouter.prototype._on = function _on (method, path, opts, handler, store) {\n let constraints = {}\n if (opts.constraints !== undefined) {\n assert(typeof opts.constraints === 'object' && opts.constraints !== null, 'Constraints should be an object')\n if (Object.keys(opts.constraints).length !== 0) {\n constraints = opts.constraints\n }\n }\n\n this.constrainer.validateConstraints(constraints)\n // Let the constrainer know if any constraints are being used now\n this.constrainer.noteUsage(constraints)\n\n // Boot the tree for this method if it doesn't exist yet\n if (this.trees[method] === undefined) {\n this.trees[method] = new StaticNode('/')\n }\n\n let pattern = path\n if (pattern === '*' && this.trees[method].prefix.length !== 0) {\n const currentRoot = this.trees[method]\n this.trees[method] = new StaticNode('')\n this.trees[method].staticChildren['/'] = currentRoot\n }\n\n let currentNode = this.trees[method]\n let parentNodePathIndex = currentNode.prefix.length\n\n const params = []\n for (let i = 0; i <= pattern.length; i++) {\n if (pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) === 58) {\n // It's a double colon\n i++\n continue\n }\n\n const isParametricNode = pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) !== 58\n const isWildcardNode = pattern.charCodeAt(i) === 42\n\n if (isParametricNode || isWildcardNode || (i === pattern.length && i !== parentNodePathIndex)) {\n let staticNodePath = pattern.slice(parentNodePathIndex, i)\n if (!this.caseSensitive) {\n staticNodePath = staticNodePath.toLowerCase()\n }\n staticNodePath = staticNodePath.split('::').join(':')\n staticNodePath = staticNodePath.split('%').join('%25')\n // add the static part of the route to the tree\n currentNode = currentNode.createStaticChild(staticNodePath)\n }\n\n if (isParametricNode) {\n let isRegexNode = false\n const regexps = []\n\n let lastParamStartIndex = i + 1\n for (let j = lastParamStartIndex; ; j++) {\n const charCode = pattern.charCodeAt(j)\n\n const isRegexParam = charCode === 40\n const isStaticPart = charCode === 45 || charCode === 46\n const isEndOfNode = charCode === 47 || j === pattern.length\n\n if (isRegexParam || isStaticPart || isEndOfNode) {\n const paramName = pattern.slice(lastParamStartIndex, j)\n params.push(paramName)\n\n isRegexNode = isRegexNode || isRegexParam || isStaticPart\n\n if (isRegexParam) {\n const endOfRegexIndex = getClosingParenthensePosition(pattern, j)\n const regexString = pattern.slice(j, endOfRegexIndex + 1)\n\n if (!this.allowUnsafeRegex) {\n assert(isRegexSafe(new RegExp(regexString)), `The regex '${regexString}' is not safe!`)\n }\n\n regexps.push(trimRegExpStartAndEnd(regexString))\n\n j = endOfRegexIndex + 1\n } else {\n regexps.push('(.*?)')\n }\n\n const staticPartStartIndex = j\n for (; j < pattern.length; j++) {\n const charCode = pattern.charCodeAt(j)\n if (charCode === 47) break\n if (charCode === 58) {\n const nextCharCode = pattern.charCodeAt(j + 1)\n if (nextCharCode === 58) j++\n else break\n }\n }\n\n let staticPart = pattern.slice(staticPartStartIndex, j)\n if (staticPart) {\n staticPart = staticPart.split('::').join(':')\n staticPart = staticPart.split('%').join('%25')\n regexps.push(escapeRegExp(staticPart))\n }\n\n lastParamStartIndex = j + 1\n\n if (isEndOfNode || pattern.charCodeAt(j) === 47 || j === pattern.length) {\n const nodePattern = isRegexNode ? '()' + staticPart : staticPart\n const nodePath = pattern.slice(i, j)\n\n pattern = pattern.slice(0, i + 1) + nodePattern + pattern.slice(j)\n i += nodePattern.length\n\n const regex = isRegexNode ? new RegExp('^' + regexps.join('') + '$') : null\n currentNode = currentNode.createParametricChild(regex, staticPart || null, nodePath)\n parentNodePathIndex = i + 1\n break\n }\n }\n }\n } else if (isWildcardNode) {\n // add the wildcard parameter\n params.push('*')\n currentNode = currentNode.createWildcardChild()\n parentNodePathIndex = i + 1\n\n if (i !== pattern.length - 1) {\n throw new Error('Wildcard must be the last character in the route')\n }\n }\n }\n\n if (!this.caseSensitive) {\n pattern = pattern.toLowerCase()\n }\n\n if (pattern === '*') {\n pattern = '/*'\n }\n\n for (const existRoute of this.routes) {\n const routeConstraints = existRoute.opts.constraints || {}\n if (\n existRoute.method === method &&\n existRoute.pattern === pattern &&\n deepEqual(routeConstraints, constraints)\n ) {\n throw new Error(`Method '${method}' already declared for route '${pattern}' with constraints '${JSON.stringify(constraints)}'`)\n }\n }\n\n const route = { method, path, pattern, params, opts, handler, store }\n this.routes.push(route)\n currentNode.addRoute(route, this.constrainer)\n}\n\nRouter.prototype.hasConstraintStrategy = function (strategyName) {\n return this.constrainer.hasConstraintStrategy(strategyName)\n}\n\nRouter.prototype.addConstraintStrategy = function (constraints) {\n this.constrainer.addConstraintStrategy(constraints)\n this._rebuild(this.routes)\n}\n\nRouter.prototype.reset = function reset () {\n this.trees = {}\n this.routes = []\n}\n\nRouter.prototype.off = function off (method, path, constraints) {\n // path validation\n assert(typeof path === 'string', 'Path should be a string')\n assert(path.length > 0, 'The path could not be empty')\n assert(path[0] === '/' || path[0] === '*', 'The first character of a path should be `/` or `*`')\n // options validation\n assert(\n typeof constraints === 'undefined' ||\n (typeof constraints === 'object' && !Array.isArray(constraints) && constraints !== null),\n 'Constraints should be an object or undefined.')\n\n // path ends with optional parameter\n const optionalParamMatch = path.match(OPTIONAL_PARAM_REGEXP)\n if (optionalParamMatch) {\n assert(path.length === optionalParamMatch.index + optionalParamMatch[0].length, 'Optional Parameter needs to be the last parameter of the path')\n\n const pathFull = path.replace(OPTIONAL_PARAM_REGEXP, '$1$2')\n const pathOptional = path.replace(OPTIONAL_PARAM_REGEXP, '$2')\n\n this.off(method, pathFull, constraints)\n this.off(method, pathOptional, constraints)\n return\n }\n\n if (this.ignoreDuplicateSlashes) {\n path = removeDuplicateSlashes(path)\n }\n\n if (this.ignoreTrailingSlash) {\n path = trimLastSlash(path)\n }\n\n const methods = Array.isArray(method) ? method : [method]\n for (const method of methods) {\n this._off(method, path, constraints)\n }\n}\n\nRouter.prototype._off = function _off (method, path, constraints) {\n // method validation\n assert(typeof method === 'string', 'Method should be a string')\n assert(httpMethods.includes(method), `Method '${method}' is not an http method.`)\n\n function matcherWithoutConstraints (route) {\n return method !== route.method || path !== route.path\n }\n\n function matcherWithConstraints (route) {\n return matcherWithoutConstraints(route) || !deepEqual(constraints, route.opts.constraints || {})\n }\n\n const predicate = constraints ? matcherWithConstraints : matcherWithoutConstraints\n\n // Rebuild tree without the specific route\n const newRoutes = this.routes.filter(predicate)\n this._rebuild(newRoutes)\n}\n\nRouter.prototype.lookup = function lookup (req, res, ctx, done) {\n if (typeof ctx === 'function') {\n done = ctx\n ctx = undefined\n }\n\n if (done === undefined) {\n const constraints = this.constrainer.deriveConstraints(req, ctx)\n const handle = this.find(req.method, req.url, constraints)\n return this.callHandler(handle, req, res, ctx)\n }\n\n this.constrainer.deriveConstraints(req, ctx, (err, constraints) => {\n if (err !== null) {\n done(err)\n return\n }\n\n try {\n const handle = this.find(req.method, req.url, constraints)\n const result = this.callHandler(handle, req, res, ctx)\n done(null, result)\n } catch (err) {\n done(err)\n }\n })\n}\n\nRouter.prototype.callHandler = function callHandler (handle, req, res, ctx) {\n if (handle === null) return this._defaultRoute(req, res, ctx)\n return ctx === undefined\n ? handle.handler(req, res, handle.params, handle.store, handle.searchParams)\n : handle.handler.call(ctx, req, res, handle.params, handle.store, handle.searchParams)\n}\n\nRouter.prototype.find = function find (method, path, derivedConstraints) {\n let currentNode = this.trees[method]\n if (currentNode === undefined) return null\n\n if (path.charCodeAt(0) !== 47) { // 47 is '/'\n path = path.replace(FULL_PATH_REGEXP, '/')\n }\n\n // This must be run before sanitizeUrl as the resulting function\n // .sliceParameter must be constructed with same URL string used\n // throughout the rest of this function.\n if (this.ignoreDuplicateSlashes) {\n path = removeDuplicateSlashes(path)\n }\n\n let sanitizedUrl\n let querystring\n let shouldDecodeParam\n\n try {\n sanitizedUrl = safeDecodeURI(path)\n path = sanitizedUrl.path\n querystring = sanitizedUrl.querystring\n shouldDecodeParam = sanitizedUrl.shouldDecodeParam\n } catch (error) {\n return this._onBadUrl(path)\n }\n\n if (this.ignoreTrailingSlash) {\n path = trimLastSlash(path)\n }\n\n const originPath = path\n\n if (this.caseSensitive === false) {\n path = path.toLowerCase()\n }\n\n const maxParamLength = this.maxParamLength\n\n let pathIndex = currentNode.prefix.length\n const params = []\n const pathLen = path.length\n\n const brothersNodesStack = []\n\n while (true) {\n if (pathIndex === pathLen && currentNode.isLeafNode) {\n const handle = currentNode.handlerStorage.getMatchingHandler(derivedConstraints)\n if (handle !== null) {\n return {\n handler: handle.handler,\n store: handle.store,\n params: handle._createParamsObject(params),\n searchParams: this.querystringParser(querystring)\n }\n }\n }\n\n let node = currentNode.getNextNode(path, pathIndex, brothersNodesStack, params.length)\n\n if (node === null) {\n if (brothersNodesStack.length === 0) {\n return null\n }\n\n const brotherNodeState = brothersNodesStack.pop()\n pathIndex = brotherNodeState.brotherPathIndex\n params.splice(brotherNodeState.paramsCount)\n node = brotherNodeState.brotherNode\n }\n\n currentNode = node\n\n // static route\n if (currentNode.kind === NODE_TYPES.STATIC) {\n pathIndex += currentNode.prefix.length\n continue\n }\n\n if (currentNode.kind === NODE_TYPES.WILDCARD) {\n let param = originPath.slice(pathIndex)\n if (shouldDecodeParam) {\n param = safeDecodeURIComponent(param)\n }\n\n params.push(param)\n pathIndex = pathLen\n continue\n }\n\n if (currentNode.kind === NODE_TYPES.PARAMETRIC) {\n let paramEndIndex = originPath.indexOf('/', pathIndex)\n if (paramEndIndex === -1) {\n paramEndIndex = pathLen\n }\n\n let param = originPath.slice(pathIndex, paramEndIndex)\n if (shouldDecodeParam) {\n param = safeDecodeURIComponent(param)\n }\n\n if (currentNode.isRegex) {\n const matchedParameters = currentNode.regex.exec(param)\n if (matchedParameters === null) continue\n\n for (let i = 1; i < matchedParameters.length; i++) {\n const matchedParam = matchedParameters[i]\n if (matchedParam.length > maxParamLength) {\n return null\n }\n params.push(matchedParam)\n }\n } else {\n if (param.length > maxParamLength) {\n return null\n }\n params.push(param)\n }\n\n pathIndex = paramEndIndex\n }\n }\n}\n\nRouter.prototype._rebuild = function (routes) {\n this.reset()\n\n for (const route of routes) {\n const { method, path, opts, handler, store } = route\n this._on(method, path, opts, handler, store)\n }\n}\n\nRouter.prototype._defaultRoute = function (req, res, ctx) {\n if (this.defaultRoute !== null) {\n return ctx === undefined\n ? this.defaultRoute(req, res)\n : this.defaultRoute.call(ctx, req, res)\n } else {\n res.statusCode = 404\n res.end()\n }\n}\n\nRouter.prototype._onBadUrl = function (path) {\n if (this.onBadUrl === null) {\n return null\n }\n const onBadUrl = this.onBadUrl\n return {\n handler: (req, res, ctx) => onBadUrl(path, req, res),\n params: {},\n store: null\n }\n}\n\nRouter.prototype.prettyPrint = function (options = {}) {\n const method = options.method\n\n options.buildPrettyMeta = this.buildPrettyMeta.bind(this)\n\n let tree = null\n if (method === undefined) {\n const { version, host, ...constraints } = this.constrainer.strategies\n constraints[httpMethodStrategy.name] = httpMethodStrategy\n\n const mergedRouter = new Router({ ...this._opts, constraints })\n const mergedRoutes = this.routes.map(route => {\n const constraints = {\n ...route.opts.constraints,\n [httpMethodStrategy.name]: route.method\n }\n return { ...route, method: 'MERGED', opts: { constraints } }\n })\n mergedRouter._rebuild(mergedRoutes)\n tree = mergedRouter.trees.MERGED\n } else {\n tree = this.trees[method]\n }\n\n if (tree == null) return '(empty tree)'\n return prettyPrintTree(tree, options)\n}\n\nfor (var i in httpMethods) {\n /* eslint no-prototype-builtins: \"off\" */\n if (!httpMethods.hasOwnProperty(i)) continue\n const m = httpMethods[i]\n const methodName = m.toLowerCase()\n\n if (Router.prototype[methodName]) throw new Error('Method already exists: ' + methodName)\n\n Router.prototype[methodName] = function (path, handler, store) {\n return this.on(m, path, handler, store)\n }\n}\n\nRouter.prototype.all = function (path, handler, store) {\n this.on(httpMethods, path, handler, store)\n}\n\nmodule.exports = Router\n\nfunction escapeRegExp (string) {\n return string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\nfunction removeDuplicateSlashes (path) {\n return path.replace(/\\/\\/+/g, '/')\n}\n\nfunction trimLastSlash (path) {\n if (path.length > 1 && path.charCodeAt(path.length - 1) === 47) {\n return path.slice(0, -1)\n }\n return path\n}\n\nfunction trimRegExpStartAndEnd (regexString) {\n // removes chars that marks start \"^\" and end \"$\" of regexp\n if (regexString.charCodeAt(1) === 94) {\n regexString = regexString.slice(0, 1) + regexString.slice(2)\n }\n\n if (regexString.charCodeAt(regexString.length - 2) === 36) {\n regexString = regexString.slice(0, regexString.length - 2) + regexString.slice(regexString.length - 1)\n }\n\n return regexString\n}\n\nfunction getClosingParenthensePosition (path, idx) {\n // `path.indexOf()` will always return the first position of the closing parenthese,\n // but it's inefficient for grouped or wrong regexp expressions.\n // see issues #62 and #63 for more info\n\n var parentheses = 1\n\n while (idx < path.length) {\n idx++\n\n // ignore skipped chars\n if (path[idx] === '\\\\') {\n idx++\n continue\n }\n\n if (path[idx] === ')') {\n parentheses--\n } else if (path[idx] === '(') {\n parentheses++\n }\n\n if (!parentheses) return idx\n }\n\n throw new TypeError('Invalid regexp expression in \"' + path + '\"')\n}\n\nfunction defaultBuildPrettyMeta (route) {\n // buildPrettyMeta function must return an object, which will be parsed into key/value pairs for display\n if (!route) return {}\n if (!route.store) return {}\n return Object.assign({}, route.store)\n}\n\n},{\"./lib/constrainer\":14,\"./lib/http-methods\":16,\"./lib/node\":17,\"./lib/pretty-print\":18,\"./lib/strategies/http-method\":21,\"./lib/url-sanitizer\":22,\"assert\":1,\"fast-deep-equal\":8,\"fast-querystring\":9,\"safe-regex2\":25}],14:[function(require,module,exports){\n'use strict'\n\nconst acceptVersionStrategy = require('./strategies/accept-version')\nconst acceptHostStrategy = require('./strategies/accept-host')\nconst assert = require('assert')\n\nclass Constrainer {\n constructor (customStrategies) {\n this.strategies = {\n version: acceptVersionStrategy,\n host: acceptHostStrategy\n }\n\n this.strategiesInUse = new Set()\n this.asyncStrategiesInUse = new Set()\n\n // validate and optimize prototypes of given custom strategies\n if (customStrategies) {\n for (const strategy of Object.values(customStrategies)) {\n this.addConstraintStrategy(strategy)\n }\n }\n }\n\n isStrategyUsed (strategyName) {\n return this.strategiesInUse.has(strategyName) ||\n this.asyncStrategiesInUse.has(strategyName)\n }\n\n hasConstraintStrategy (strategyName) {\n const customConstraintStrategy = this.strategies[strategyName]\n if (customConstraintStrategy !== undefined) {\n return customConstraintStrategy.isCustom ||\n this.isStrategyUsed(strategyName)\n }\n return false\n }\n\n addConstraintStrategy (strategy) {\n assert(typeof strategy.name === 'string' && strategy.name !== '', 'strategy.name is required.')\n assert(strategy.storage && typeof strategy.storage === 'function', 'strategy.storage function is required.')\n assert(strategy.deriveConstraint && typeof strategy.deriveConstraint === 'function', 'strategy.deriveConstraint function is required.')\n\n if (this.strategies[strategy.name] && this.strategies[strategy.name].isCustom) {\n throw new Error(`There already exists a custom constraint with the name ${strategy.name}.`)\n }\n\n if (this.isStrategyUsed(strategy.name)) {\n throw new Error(`There already exists a route with ${strategy.name} constraint.`)\n }\n\n strategy.isCustom = true\n strategy.isAsync = strategy.deriveConstraint.length === 3\n this.strategies[strategy.name] = strategy\n\n if (strategy.mustMatchWhenDerived) {\n this.noteUsage({ [strategy.name]: strategy })\n }\n }\n\n deriveConstraints (req, ctx, done) {\n const constraints = this.deriveSyncConstraints(req, ctx)\n\n if (done === undefined) {\n return constraints\n }\n\n this.deriveAsyncConstraints(constraints, req, ctx, done)\n }\n\n deriveSyncConstraints (req, ctx) {\n return undefined\n }\n\n // When new constraints start getting used, we need to rebuild the deriver to derive them. Do so if we see novel constraints used.\n noteUsage (constraints) {\n if (constraints) {\n const beforeSize = this.strategiesInUse.size\n for (const key in constraints) {\n const strategy = this.strategies[key]\n if (strategy.isAsync) {\n this.asyncStrategiesInUse.add(key)\n } else {\n this.strategiesInUse.add(key)\n }\n }\n if (beforeSize !== this.strategiesInUse.size) {\n this._buildDeriveConstraints()\n }\n }\n }\n\n newStoreForConstraint (constraint) {\n if (!this.strategies[constraint]) {\n throw new Error(`No strategy registered for constraint key ${constraint}`)\n }\n return this.strategies[constraint].storage()\n }\n\n validateConstraints (constraints) {\n for (const key in constraints) {\n const value = constraints[key]\n if (typeof value === 'undefined') {\n throw new Error('Can\\'t pass an undefined constraint value, must pass null or no key at all')\n }\n const strategy = this.strategies[key]\n if (!strategy) {\n throw new Error(`No strategy registered for constraint key ${key}`)\n }\n if (strategy.validate) {\n strategy.validate(value)\n }\n }\n }\n\n deriveAsyncConstraints (constraints, req, ctx, done) {\n let asyncConstraintsCount = this.asyncStrategiesInUse.size\n\n if (asyncConstraintsCount === 0) {\n done(null, constraints)\n return\n }\n\n constraints = constraints || {}\n for (const key of this.asyncStrategiesInUse) {\n const strategy = this.strategies[key]\n strategy.deriveConstraint(req, ctx, (err, constraintValue) => {\n if (err !== null) {\n done(err)\n return\n }\n\n constraints[key] = constraintValue\n\n if (--asyncConstraintsCount === 0) {\n done(null, constraints)\n }\n })\n }\n }\n\n // Optimization: build a fast function for deriving the constraints for all the strategies at once. We inline the definitions of the version constraint and the host constraint for performance.\n // If no constraining strategies are in use (no routes constrain on host, or version, or any custom strategies) then we don't need to derive constraints for each route match, so don't do anything special, and just return undefined\n // This allows us to not allocate an object to hold constraint values if no constraints are defined.\n _buildDeriveConstraints () {\n if (this.strategiesInUse.size === 0) return\n\n const lines = ['return {']\n\n for (const key of this.strategiesInUse) {\n const strategy = this.strategies[key]\n // Optimization: inline the derivation for the common built in constraints\n if (!strategy.isCustom) {\n if (key === 'version') {\n lines.push(' version: req.headers[\\'accept-version\\'],')\n } else if (key === 'host') {\n lines.push(' host: req.headers.host || req.headers[\\':authority\\'],')\n } else {\n throw new Error('unknown non-custom strategy for compiling constraint derivation function')\n }\n } else {\n lines.push(` ${strategy.name}: this.strategies.${key}.deriveConstraint(req, ctx),`)\n }\n }\n\n lines.push('}')\n\n this.deriveSyncConstraints = new Function('req', 'ctx', lines.join('\\n')).bind(this) // eslint-disable-line\n }\n}\n\nmodule.exports = Constrainer\n\n},{\"./strategies/accept-host\":19,\"./strategies/accept-version\":20,\"assert\":1}],15:[function(require,module,exports){\n'use strict'\n\nconst httpMethodStrategy = require('./strategies/http-method')\n\nclass HandlerStorage {\n constructor () {\n this.unconstrainedHandler = null // optimized reference to the handler that will match most of the time\n this.constraints = []\n this.handlers = [] // unoptimized list of handler objects for which the fast matcher function will be compiled\n this.constrainedHandlerStores = null\n }\n\n // This is the hot path for node handler finding -- change with care!\n getMatchingHandler (derivedConstraints) {\n if (derivedConstraints === undefined) {\n return this.unconstrainedHandler\n }\n return this._getHandlerMatchingConstraints(derivedConstraints)\n }\n\n addHandler (constrainer, route) {\n const params = route.params\n const constraints = route.opts.constraints || {}\n\n const handlerObject = {\n params,\n constraints,\n handler: route.handler,\n store: route.store || null,\n _createParamsObject: this._compileCreateParamsObject(params)\n }\n\n const constraintsNames = Object.keys(constraints)\n if (constraintsNames.length === 0) {\n this.unconstrainedHandler = handlerObject\n }\n\n for (const constraint of constraintsNames) {\n if (!this.constraints.includes(constraint)) {\n if (constraint === 'version') {\n // always check the version constraint first as it is the most selective\n this.constraints.unshift(constraint)\n } else {\n this.constraints.push(constraint)\n }\n }\n }\n\n const isMergedTree = constraintsNames.includes(httpMethodStrategy.name)\n if (!isMergedTree && this.handlers.length >= 32) {\n throw new Error('find-my-way supports a maximum of 32 route handlers per node when there are constraints, limit reached')\n }\n\n this.handlers.push(handlerObject)\n // Sort the most constrained handlers to the front of the list of handlers so they are tested first.\n this.handlers.sort((a, b) => Object.keys(a.constraints).length - Object.keys(b.constraints).length)\n\n if (!isMergedTree) {\n this._compileGetHandlerMatchingConstraints(constrainer, constraints)\n }\n }\n\n _compileCreateParamsObject (params) {\n const lines = []\n for (let i = 0; i < params.length; i++) {\n lines.push(`'${params[i]}': paramsArray[${i}]`)\n }\n return new Function('paramsArray', `return {${lines.join(',')}}`) // eslint-disable-line\n }\n\n _getHandlerMatchingConstraints () {\n return null\n }\n\n // Builds a store object that maps from constraint values to a bitmap of handler indexes which pass the constraint for a value\n // So for a host constraint, this might look like { \"fastify.io\": 0b0010, \"google.ca\": 0b0101 }, meaning the 3rd handler is constrainted to fastify.io, and the 2nd and 4th handlers are constrained to google.ca.\n // The store's implementation comes from the strategies provided to the Router.\n _buildConstraintStore (store, constraint) {\n for (let i = 0; i < this.handlers.length; i++) {\n const handler = this.handlers[i]\n const constraintValue = handler.constraints[constraint]\n if (constraintValue !== undefined) {\n let indexes = store.get(constraintValue) || 0\n indexes |= 1 << i // set the i-th bit for the mask because this handler is constrained by this value https://stackoverflow.com/questions/1436438/how-do-you-set-clear-and-toggle-a-single-bit-in-javascrip\n store.set(constraintValue, indexes)\n }\n }\n }\n\n // Builds a bitmask for a given constraint that has a bit for each handler index that is 0 when that handler *is* constrained and 1 when the handler *isnt* constrainted. This is opposite to what might be obvious, but is just for convienience when doing the bitwise operations.\n _constrainedIndexBitmask (constraint) {\n let mask = 0\n for (let i = 0; i < this.handlers.length; i++) {\n const handler = this.handlers[i]\n const constraintValue = handler.constraints[constraint]\n if (constraintValue !== undefined) {\n mask |= 1 << i\n }\n }\n return ~mask\n }\n\n // Compile a fast function to match the handlers for this node\n // The function implements a general case multi-constraint matching algorithm.\n // The general idea is this: we have a bunch of handlers, each with a potentially different set of constraints, and sometimes none at all. We're given a list of constraint values and we have to use the constraint-value-comparison strategies to see which handlers match the constraint values passed in.\n // We do this by asking each constraint store which handler indexes match the given constraint value for each store. Trickily, the handlers that a store says match are the handlers constrained by that store, but handlers that aren't constrained at all by that store could still match just fine. So, each constraint store can only describe matches for it, and it won't have any bearing on the handlers it doesn't care about. For this reason, we have to ask each stores which handlers match and track which have been matched (or not cared about) by all of them.\n // We use bitmaps to represent these lists of matches so we can use bitwise operations to implement this efficiently. Bitmaps are cheap to allocate, let us implement this masking behaviour in one CPU instruction, and are quite compact in memory. We start with a bitmap set to all 1s representing every handler that is a match candidate, and then for each constraint, see which handlers match using the store, and then mask the result by the mask of handlers that that store applies to, and bitwise AND with the candidate list. Phew.\n // We consider all this compiling function complexity to be worth it, because the naive implementation that just loops over the handlers asking which stores match is quite a bit slower.\n _compileGetHandlerMatchingConstraints (constrainer) {\n this.constrainedHandlerStores = {}\n\n for (const constraint of this.constraints) {\n const store = constrainer.newStoreForConstraint(constraint)\n this.constrainedHandlerStores[constraint] = store\n\n this._buildConstraintStore(store, constraint)\n }\n\n const lines = []\n lines.push(`\n let candidates = ${(1 << this.handlers.length) - 1}\n let mask, matches\n `)\n for (const constraint of this.constraints) {\n // Setup the mask for indexes this constraint applies to. The mask bits are set to 1 for each position if the constraint applies.\n lines.push(`\n mask = ${this._constrainedIndexBitmask(constraint)}\n value = derivedConstraints.${constraint}\n `)\n\n // If there's no constraint value, none of the handlers constrained by this constraint can match. Remove them from the candidates.\n // If there is a constraint value, get the matching indexes bitmap from the store, and mask it down to only the indexes this constraint applies to, and then bitwise and with the candidates list to leave only matching candidates left.\n const strategy = constrainer.strategies[constraint]\n const matchMask = strategy.mustMatchWhenDerived ? 'matches' : '(matches | mask)'\n\n lines.push(`\n if (value === undefined) {\n candidates &= mask\n } else {\n matches = this.constrainedHandlerStores.${constraint}.get(value) || 0\n candidates &= ${matchMask}\n }\n if (candidates === 0) return null;\n `)\n }\n\n // There are some constraints that can be derived and marked as \"must match\", where if they are derived, they only match routes that actually have a constraint on the value, like the SemVer version constraint.\n // An example: a request comes in for version 1.x, and this node has a handler that matches the path, but there's no version constraint. For SemVer, the find-my-way semantics do not match this handler to that request.\n // This function is used by Nodes with handlers to match when they don't have any constrained routes to exclude request that do have must match derived constraints present.\n for (const constraint in constrainer.strategies) {\n const strategy = constrainer.strategies[constraint]\n if (strategy.mustMatchWhenDerived && !this.constraints.includes(constraint)) {\n lines.push(`if (derivedConstraints.${constraint} !== undefined) return null`)\n }\n }\n\n // Return the first handler who's bit is set in the candidates https://stackoverflow.com/questions/18134985/how-to-find-index-of-first-set-bit\n lines.push('return this.handlers[Math.floor(Math.log2(candidates))]')\n\n this._getHandlerMatchingConstraints = new Function('derivedConstraints', lines.join('\\n')) // eslint-disable-line\n }\n}\n\nmodule.exports = HandlerStorage\n\n},{\"./strategies/http-method\":21}],16:[function(require,module,exports){\n'use strict'\n\n// defined by Node.js http module, a snapshot from Node.js 18.12.0\nconst httpMethods = [\n 'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE',\n 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE',\n 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS',\n 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT',\n 'REBIND', 'REPORT', 'SEARCH', 'SOURCE', 'SUBSCRIBE', 'TRACE',\n 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE'\n]\n\nmodule.exports = httpMethods\n\n},{}],17:[function(require,module,exports){\n'use strict'\n\nconst HandlerStorage = require('./handler-storage')\n\nconst NODE_TYPES = {\n STATIC: 0,\n PARAMETRIC: 1,\n WILDCARD: 2\n}\n\nclass Node {\n constructor () {\n this.isLeafNode = false\n this.routes = null\n this.handlerStorage = null\n }\n\n addRoute (route, constrainer) {\n if (this.routes === null) {\n this.routes = []\n }\n if (this.handlerStorage === null) {\n this.handlerStorage = new HandlerStorage()\n }\n this.isLeafNode = true\n this.routes.push(route)\n this.handlerStorage.addHandler(constrainer, route)\n }\n}\n\nclass ParentNode extends Node {\n constructor () {\n super()\n this.staticChildren = {}\n }\n\n findStaticMatchingChild (path, pathIndex) {\n const staticChild = this.staticChildren[path.charAt(pathIndex)]\n if (staticChild === undefined || !staticChild.matchPrefix(path, pathIndex)) {\n return null\n }\n return staticChild\n }\n\n createStaticChild (path) {\n if (path.length === 0) {\n return this\n }\n\n let staticChild = this.staticChildren[path.charAt(0)]\n if (staticChild) {\n let i = 1\n for (; i < staticChild.prefix.length; i++) {\n if (path.charCodeAt(i) !== staticChild.prefix.charCodeAt(i)) {\n staticChild = staticChild.split(this, i)\n break\n }\n }\n return staticChild.createStaticChild(path.slice(i))\n }\n\n const label = path.charAt(0)\n this.staticChildren[label] = new StaticNode(path)\n return this.staticChildren[label]\n }\n}\n\nclass StaticNode extends ParentNode {\n constructor (prefix) {\n super()\n this.prefix = prefix\n this.wildcardChild = null\n this.parametricChildren = []\n this.kind = NODE_TYPES.STATIC\n this._compilePrefixMatch()\n }\n\n createParametricChild (regex, staticSuffix, nodePath) {\n const regexpSource = regex && regex.source\n\n let parametricChild = this.parametricChildren.find(child => {\n const childRegexSource = child.regex && child.regex.source\n return childRegexSource === regexpSource\n })\n\n if (parametricChild) {\n parametricChild.nodePaths.add(nodePath)\n return parametricChild\n }\n\n parametricChild = new ParametricNode(regex, staticSuffix, nodePath)\n this.parametricChildren.push(parametricChild)\n this.parametricChildren.sort((child1, child2) => {\n if (!child1.isRegex) return 1\n if (!child2.isRegex) return -1\n\n if (child1.staticSuffix === null) return 1\n if (child2.staticSuffix === null) return -1\n\n if (child2.staticSuffix.endsWith(child1.staticSuffix)) return 1\n if (child1.staticSuffix.endsWith(child2.staticSuffix)) return -1\n\n return 0\n })\n\n return parametricChild\n }\n\n createWildcardChild () {\n if (this.wildcardChild) {\n return this.wildcardChild\n }\n\n this.wildcardChild = new WildcardNode()\n return this.wildcardChild\n }\n\n split (parentNode, length) {\n const parentPrefix = this.prefix.slice(0, length)\n const childPrefix = this.prefix.slice(length)\n\n this.prefix = childPrefix\n this._compilePrefixMatch()\n\n const staticNode = new StaticNode(parentPrefix)\n staticNode.staticChildren[childPrefix.charAt(0)] = this\n parentNode.staticChildren[parentPrefix.charAt(0)] = staticNode\n\n return staticNode\n }\n\n getNextNode (path, pathIndex, nodeStack, paramsCount) {\n let node = this.findStaticMatchingChild(path, pathIndex)\n let parametricBrotherNodeIndex = 0\n\n if (node === null) {\n if (this.parametricChildren.length === 0) {\n return this.wildcardChild\n }\n\n node = this.parametricChildren[0]\n parametricBrotherNodeIndex = 1\n }\n\n if (this.wildcardChild !== null) {\n nodeStack.push({\n paramsCount,\n brotherPathIndex: pathIndex,\n brotherNode: this.wildcardChild\n })\n }\n\n for (let i = this.parametricChildren.length - 1; i >= parametricBrotherNodeIndex; i--) {\n nodeStack.push({\n paramsCount,\n brotherPathIndex: pathIndex,\n brotherNode: this.parametricChildren[i]\n })\n }\n\n return node\n }\n\n _compilePrefixMatch () {\n if (this.prefix.length === 1) {\n this.matchPrefix = () => true\n return\n }\n\n const lines = []\n for (let i = 1; i < this.prefix.length; i++) {\n const charCode = this.prefix.charCodeAt(i)\n lines.push(`path.charCodeAt(i + ${i}) === ${charCode}`)\n }\n this.matchPrefix = new Function('path', 'i', `return ${lines.join(' && ')}`) // eslint-disable-line\n }\n}\n\nclass ParametricNode extends ParentNode {\n constructor (regex, staticSuffix, nodePath) {\n super()\n this.isRegex = !!regex\n this.regex = regex || null\n this.staticSuffix = staticSuffix || null\n this.kind = NODE_TYPES.PARAMETRIC\n\n this.nodePaths = new Set([nodePath])\n }\n\n getNextNode (path, pathIndex) {\n return this.findStaticMatchingChild(path, pathIndex)\n }\n}\n\nclass WildcardNode extends Node {\n constructor () {\n super()\n this.kind = NODE_TYPES.WILDCARD\n }\n\n getNextNode () {\n return null\n }\n}\n\nmodule.exports = { StaticNode, ParametricNode, WildcardNode, NODE_TYPES }\n\n},{\"./handler-storage\":15}],18:[function(require,module,exports){\n'use strict'\n\nconst deepEqual = require('fast-deep-equal')\n\nconst httpMethodStrategy = require('./strategies/http-method')\nconst treeDataSymbol = Symbol('treeData')\n\nfunction printObjectTree (obj, parentPrefix = '') {\n let tree = ''\n const keys = Object.keys(obj)\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i]\n const value = obj[key]\n const isLast = i === keys.length - 1\n\n const nodePrefix = isLast ? '└── ' : '├── '\n const childPrefix = isLast ? ' ' : '│ '\n\n const nodeData = value[treeDataSymbol] || ''\n const prefixedNodeData = nodeData.split('\\n').join('\\n' + parentPrefix + childPrefix)\n\n tree += parentPrefix + nodePrefix + key + prefixedNodeData + '\\n'\n tree += printObjectTree(value, parentPrefix + childPrefix)\n }\n return tree\n}\n\nfunction parseFunctionName (fn) {\n let fName = fn.name || ''\n\n fName = fName.replace('bound', '').trim()\n fName = (fName || 'anonymous') + '()'\n return fName\n}\n\nfunction parseMeta (meta) {\n if (Array.isArray(meta)) return meta.map(m => parseMeta(m))\n if (typeof meta === 'symbol') return meta.toString()\n if (typeof meta === 'function') return parseFunctionName(meta)\n return meta\n}\n\nfunction getRouteMetaData (route, options) {\n if (!options.includeMeta) return {}\n\n const metaDataObject = options.buildPrettyMeta(route)\n const filteredMetaData = {}\n\n let includeMetaKeys = options.includeMeta\n if (!Array.isArray(includeMetaKeys)) {\n includeMetaKeys = Reflect.ownKeys(metaDataObject)\n }\n\n for (const metaKey of includeMetaKeys) {\n if (!Object.prototype.hasOwnProperty.call(metaDataObject, metaKey)) continue\n\n const serializedKey = metaKey.toString()\n const metaValue = metaDataObject[metaKey]\n\n if (metaValue !== undefined && metaValue !== null) {\n const serializedValue = JSON.stringify(parseMeta(metaValue))\n filteredMetaData[serializedKey] = serializedValue\n }\n }\n\n return filteredMetaData\n}\n\nfunction serializeMetaData (metaData) {\n let serializedMetaData = ''\n for (const [key, value] of Object.entries(metaData)) {\n serializedMetaData += `\\n• (${key}) ${value}`\n }\n return serializedMetaData\n}\n\n// get original merged tree node route\nfunction normalizeRoute (route) {\n const constraints = { ...route.opts.constraints }\n const method = constraints[httpMethodStrategy.name]\n delete constraints[httpMethodStrategy.name]\n return { ...route, method, opts: { constraints } }\n}\n\nfunction serializeRoute (route) {\n let serializedRoute = ` (${route.method})`\n\n const constraints = route.opts.constraints || {}\n if (Object.keys(constraints).length !== 0) {\n serializedRoute += ' ' + JSON.stringify(constraints)\n }\n\n serializedRoute += serializeMetaData(route.metaData)\n return serializedRoute\n}\n\nfunction mergeSimilarRoutes (routes) {\n return routes.reduce((mergedRoutes, route) => {\n for (const nodeRoute of mergedRoutes) {\n if (\n deepEqual(route.opts.constraints, nodeRoute.opts.constraints) &&\n deepEqual(route.metaData, nodeRoute.metaData)\n ) {\n nodeRoute.method += ', ' + route.method\n return mergedRoutes\n }\n }\n mergedRoutes.push(route)\n return mergedRoutes\n }, [])\n}\n\nfunction serializeNode (node, prefix, options) {\n let routes = node.routes\n\n if (options.method === undefined) {\n routes = routes.map(normalizeRoute)\n }\n\n routes = routes.map(route => {\n route.metaData = getRouteMetaData(route, options)\n return route\n })\n\n if (options.method === undefined) {\n routes = mergeSimilarRoutes(routes)\n }\n\n return routes.map(serializeRoute).join(`\\n${prefix}`)\n}\n\nfunction buildObjectTree (node, tree, prefix, options) {\n if (node.isLeafNode || options.commonPrefix !== false) {\n prefix = prefix || '(empty root node)'\n tree = tree[prefix] = {}\n\n if (node.isLeafNode) {\n tree[treeDataSymbol] = serializeNode(node, prefix, options)\n }\n\n prefix = ''\n }\n\n if (node.staticChildren) {\n for (const child of Object.values(node.staticChildren)) {\n buildObjectTree(child, tree, prefix + child.prefix, options)\n }\n }\n\n if (node.parametricChildren) {\n for (const child of Object.values(node.parametricChildren)) {\n const childPrefix = Array.from(child.nodePaths).join('|')\n buildObjectTree(child, tree, prefix + childPrefix, options)\n }\n }\n\n if (node.wildcardChild) {\n buildObjectTree(node.wildcardChild, tree, '*', options)\n }\n}\n\nfunction prettyPrintTree (root, options) {\n const objectTree = {}\n buildObjectTree(root, objectTree, root.prefix, options)\n return printObjectTree(objectTree)\n}\n\nmodule.exports = { prettyPrintTree }\n\n},{\"./strategies/http-method\":21,\"fast-deep-equal\":8}],19:[function(require,module,exports){\n'use strict'\nconst assert = require('assert')\n\nfunction HostStorage () {\n const hosts = {}\n const regexHosts = []\n return {\n get: (host) => {\n const exact = hosts[host]\n if (exact) {\n return exact\n }\n for (const regex of regexHosts) {\n if (regex.host.test(host)) {\n return regex.value\n }\n }\n },\n set: (host, value) => {\n if (host instanceof RegExp) {\n regexHosts.push({ host, value })\n } else {\n hosts[host] = value\n }\n }\n }\n}\n\nmodule.exports = {\n name: 'host',\n mustMatchWhenDerived: false,\n storage: HostStorage,\n validate (value) {\n assert(typeof value === 'string' || Object.prototype.toString.call(value) === '[object RegExp]', 'Host should be a string or a RegExp')\n }\n}\n\n},{\"assert\":1}],20:[function(require,module,exports){\n'use strict'\n\nconst assert = require('assert')\n\nfunction SemVerStore () {\n if (!(this instanceof SemVerStore)) {\n return new SemVerStore()\n }\n\n this.store = {}\n\n this.maxMajor = 0\n this.maxMinors = {}\n this.maxPatches = {}\n}\n\nSemVerStore.prototype.set = function (version, store) {\n if (typeof version !== 'string') {\n throw new TypeError('Version should be a string')\n }\n let [major, minor, patch] = version.split('.')\n\n major = Number(major) || 0\n minor = Number(minor) || 0\n patch = Number(patch) || 0\n\n if (major >= this.maxMajor) {\n this.maxMajor = major\n this.store.x = store\n this.store['*'] = store\n this.store['x.x'] = store\n this.store['x.x.x'] = store\n }\n\n if (minor >= (this.maxMinors[major] || 0)) {\n this.maxMinors[major] = minor\n this.store[`${major}.x`] = store\n this.store[`${major}.x.x`] = store\n }\n\n if (patch >= (this.store[`${major}.${minor}`] || 0)) {\n this.maxPatches[`${major}.${minor}`] = patch\n this.store[`${major}.${minor}.x`] = store\n }\n\n this.store[`${major}.${minor}.${patch}`] = store\n return this\n}\n\nSemVerStore.prototype.get = function (version) {\n return this.store[version]\n}\n\nmodule.exports = {\n name: 'version',\n mustMatchWhenDerived: true,\n storage: SemVerStore,\n validate (value) {\n assert(typeof value === 'string', 'Version should be a string')\n }\n}\n\n},{\"assert\":1}],21:[function(require,module,exports){\n'use strict'\n\nmodule.exports = {\n name: '__fmw_internal_strategy_merged_tree_http_method__',\n storage: function () {\n const handlers = {}\n return {\n get: (type) => { return handlers[type] || null },\n set: (type, store) => { handlers[type] = store }\n }\n },\n deriveConstraint: (req) => {\n /* istanbul ignore next */\n return req.method\n },\n mustMatchWhenDerived: true\n}\n\n},{}],22:[function(require,module,exports){\n'use strict'\n\n// It must spot all the chars where decodeURIComponent(x) !== decodeURI(x)\n// The chars are: # $ & + , / : ; = ? @\nfunction decodeComponentChar (highCharCode, lowCharCode) {\n if (highCharCode === 50) {\n if (lowCharCode === 53) return '%'\n\n if (lowCharCode === 51) return '#'\n if (lowCharCode === 52) return '$'\n if (lowCharCode === 54) return '&'\n if (lowCharCode === 66) return '+'\n if (lowCharCode === 98) return '+'\n if (lowCharCode === 67) return ','\n if (lowCharCode === 99) return ','\n if (lowCharCode === 70) return '/'\n if (lowCharCode === 102) return '/'\n return null\n }\n if (highCharCode === 51) {\n if (lowCharCode === 65) return ':'\n if (lowCharCode === 97) return ':'\n if (lowCharCode === 66) return ';'\n if (lowCharCode === 98) return ';'\n if (lowCharCode === 68) return '='\n if (lowCharCode === 100) return '='\n if (lowCharCode === 70) return '?'\n if (lowCharCode === 102) return '?'\n return null\n }\n if (highCharCode === 52 && lowCharCode === 48) {\n return '@'\n }\n return null\n}\n\nfunction safeDecodeURI (path) {\n let shouldDecode = false\n let shouldDecodeParam = false\n\n let querystring = ''\n\n for (let i = 1; i < path.length; i++) {\n const charCode = path.charCodeAt(i)\n\n if (charCode === 37) {\n const highCharCode = path.charCodeAt(i + 1)\n const lowCharCode = path.charCodeAt(i + 2)\n\n if (decodeComponentChar(highCharCode, lowCharCode) === null) {\n shouldDecode = true\n } else {\n shouldDecodeParam = true\n // %25 - encoded % char. We need to encode one more time to prevent double decoding\n if (highCharCode === 50 && lowCharCode === 53) {\n shouldDecode = true\n path = path.slice(0, i + 1) + '25' + path.slice(i + 1)\n i += 2\n }\n i += 2\n }\n // Some systems do not follow RFC and separate the path and query\n // string with a `;` character (code 59), e.g. `/foo;jsessionid=123456`.\n // Thus, we need to split on `;` as well as `?` and `#`.\n } else if (charCode === 63 || charCode === 59 || charCode === 35) {\n querystring = path.slice(i + 1)\n path = path.slice(0, i)\n break\n }\n }\n const decodedPath = shouldDecode ? decodeURI(path) : path\n return { path: decodedPath, querystring, shouldDecodeParam }\n}\n\nfunction safeDecodeURIComponent (uriComponent) {\n const startIndex = uriComponent.indexOf('%')\n if (startIndex === -1) return uriComponent\n\n let decoded = ''\n let lastIndex = startIndex\n\n for (let i = startIndex; i < uriComponent.length; i++) {\n if (uriComponent.charCodeAt(i) === 37) {\n const highCharCode = uriComponent.charCodeAt(i + 1)\n const lowCharCode = uriComponent.charCodeAt(i + 2)\n\n const decodedChar = decodeComponentChar(highCharCode, lowCharCode)\n decoded += uriComponent.slice(lastIndex, i) + decodedChar\n\n lastIndex = i + 3\n }\n }\n return uriComponent.slice(0, startIndex) + decoded + uriComponent.slice(lastIndex)\n}\n\nmodule.exports = { safeDecodeURI, safeDecodeURIComponent }\n\n},{}],23:[function(require,module,exports){\n/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc'); // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n\n},{}],24:[function(require,module,exports){\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n},{}],25:[function(require,module,exports){\n'use strict'\n\nvar parse = require('ret')\nvar types = parse.types\n\nmodule.exports = function (re, opts) {\n if (!opts) opts = {}\n var replimit = opts.limit === undefined ? 25 : opts.limit\n\n if (isRegExp(re)) re = re.source\n else if (typeof re !== 'string') re = String(re)\n\n try { re = parse(re) } catch (err) { return false }\n\n var reps = 0\n return (function walk (node, starHeight) {\n var i\n var ok\n var len\n\n if (node.type === types.REPETITION) {\n starHeight++\n reps++\n if (starHeight > 1) return false\n if (reps > replimit) return false\n }\n\n if (node.options) {\n for (i = 0, len = node.options.length; i < len; i++) {\n ok = walk({ stack: node.options[i] }, starHeight)\n if (!ok) return false\n }\n }\n var stack = node.stack || (node.value && node.value.stack)\n if (!stack) return true\n\n for (i = 0; i < stack.length; i++) {\n ok = walk(stack[i], starHeight)\n if (!ok) return false\n }\n\n return true\n })(re, 0)\n}\n\nfunction isRegExp (x) {\n return {}.toString.call(x) === '[object RegExp]'\n}\n\n},{\"ret\":26}],26:[function(require,module,exports){\nconst util = require('./util');\nconst types = require('./types');\nconst sets = require('./sets');\nconst positions = require('./positions');\n\n\nmodule.exports = (regexpStr) => {\n var i = 0, l, c,\n start = { type: types.ROOT, stack: []},\n\n // Keep track of last clause/group and stack.\n lastGroup = start,\n last = start.stack,\n groupStack = [];\n\n\n var repeatErr = (i) => {\n util.error(regexpStr, `Nothing to repeat at column ${i - 1}`);\n };\n\n // Decode a few escaped characters.\n var str = util.strToChars(regexpStr);\n l = str.length;\n\n // Iterate through each character in string.\n while (i < l) {\n c = str[i++];\n\n switch (c) {\n // Handle escaped characters, inclues a few sets.\n case '\\\\':\n c = str[i++];\n\n switch (c) {\n case 'b':\n last.push(positions.wordBoundary());\n break;\n\n case 'B':\n last.push(positions.nonWordBoundary());\n break;\n\n case 'w':\n last.push(sets.words());\n break;\n\n case 'W':\n last.push(sets.notWords());\n break;\n\n case 'd':\n last.push(sets.ints());\n break;\n\n case 'D':\n last.push(sets.notInts());\n break;\n\n case 's':\n last.push(sets.whitespace());\n break;\n\n case 'S':\n last.push(sets.notWhitespace());\n break;\n\n default:\n // Check if c is integer.\n // In which case it's a reference.\n if (/\\d/.test(c)) {\n last.push({ type: types.REFERENCE, value: parseInt(c, 10) });\n\n // Escaped character.\n } else {\n last.push({ type: types.CHAR, value: c.charCodeAt(0) });\n }\n }\n\n break;\n\n\n // Positionals.\n case '^':\n last.push(positions.begin());\n break;\n\n case '$':\n last.push(positions.end());\n break;\n\n\n // Handle custom sets.\n case '[':\n // Check if this class is 'anti' i.e. [^abc].\n var not;\n if (str[i] === '^') {\n not = true;\n i++;\n } else {\n not = false;\n }\n\n // Get all the characters in class.\n var classTokens = util.tokenizeClass(str.slice(i), regexpStr);\n\n // Increase index by length of class.\n i += classTokens[1];\n last.push({\n type: types.SET,\n set: classTokens[0],\n not,\n });\n\n break;\n\n\n // Class of any character except \\n.\n case '.':\n last.push(sets.anyChar());\n break;\n\n\n // Push group onto stack.\n case '(':\n // Create group.\n var group = {\n type: types.GROUP,\n stack: [],\n remember: true,\n };\n\n c = str[i];\n\n // If if this is a special kind of group.\n if (c === '?') {\n c = str[i + 1];\n i += 2;\n\n // Match if followed by.\n if (c === '=') {\n group.followedBy = true;\n\n // Match if not followed by.\n } else if (c === '!') {\n group.notFollowedBy = true;\n\n } else if (c !== ':') {\n util.error(regexpStr,\n `Invalid group, character '${c}'` +\n ` after '?' at column ${i - 1}`);\n }\n\n group.remember = false;\n }\n\n // Insert subgroup into current group stack.\n last.push(group);\n\n // Remember the current group for when the group closes.\n groupStack.push(lastGroup);\n\n // Make this new group the current group.\n lastGroup = group;\n last = group.stack;\n break;\n\n\n // Pop group out of stack.\n case ')':\n if (groupStack.length === 0) {\n util.error(regexpStr, `Unmatched ) at column ${i - 1}`);\n }\n lastGroup = groupStack.pop();\n\n // Check if this group has a PIPE.\n // To get back the correct last stack.\n last = lastGroup.options ?\n lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;\n break;\n\n\n // Use pipe character to give more choices.\n case '|':\n // Create array where options are if this is the first PIPE\n // in this clause.\n if (!lastGroup.options) {\n lastGroup.options = [lastGroup.stack];\n delete lastGroup.stack;\n }\n\n // Create a new stack and add to options for rest of clause.\n var stack = [];\n lastGroup.options.push(stack);\n last = stack;\n break;\n\n\n // Repetition.\n // For every repetition, remove last element from last stack\n // then insert back a RANGE object.\n // This design is chosen because there could be more than\n // one repetition symbols in a regex i.e. `a?+{2,3}`.\n case '{':\n var rs = /^(\\d+)(,(\\d+)?)?\\}/.exec(str.slice(i)), min, max;\n if (rs !== null) {\n if (last.length === 0) {\n repeatErr(i);\n }\n min = parseInt(rs[1], 10);\n max = rs[2] ? rs[3] ? parseInt(rs[3], 10) : Infinity : min;\n i += rs[0].length;\n\n last.push({\n type: types.REPETITION,\n min,\n max,\n value: last.pop(),\n });\n } else {\n last.push({\n type: types.CHAR,\n value: 123,\n });\n }\n break;\n\n case '?':\n if (last.length === 0) {\n repeatErr(i);\n }\n last.push({\n type: types.REPETITION,\n min: 0,\n max: 1,\n value: last.pop(),\n });\n break;\n\n case '+':\n if (last.length === 0) {\n repeatErr(i);\n }\n last.push({\n type: types.REPETITION,\n min: 1,\n max: Infinity,\n value: last.pop(),\n });\n break;\n\n case '*':\n if (last.length === 0) {\n repeatErr(i);\n }\n last.push({\n type: types.REPETITION,\n min: 0,\n max: Infinity,\n value: last.pop(),\n });\n break;\n\n\n // Default is a character that is not `\\[](){}?+*^$`.\n default:\n last.push({\n type: types.CHAR,\n value: c.charCodeAt(0),\n });\n }\n\n }\n\n // Check if any groups have not been closed.\n if (groupStack.length !== 0) {\n util.error(regexpStr, 'Unterminated group');\n }\n\n return start;\n};\n\nmodule.exports.types = types;\n\n},{\"./positions\":27,\"./sets\":28,\"./types\":29,\"./util\":30}],27:[function(require,module,exports){\nconst types = require('./types');\nexports.wordBoundary = () => ({ type: types.POSITION, value: 'b' });\nexports.nonWordBoundary = () => ({ type: types.POSITION, value: 'B' });\nexports.begin = () => ({ type: types.POSITION, value: '^' });\nexports.end = () => ({ type: types.POSITION, value: '$' });\n\n},{\"./types\":29}],28:[function(require,module,exports){\nconst types = require('./types');\n\nconst INTS = () => [{ type: types.RANGE , from: 48, to: 57 }];\n\nconst WORDS = () => {\n return [\n { type: types.CHAR, value: 95 },\n { type: types.RANGE, from: 97, to: 122 },\n { type: types.RANGE, from: 65, to: 90 }\n ].concat(INTS());\n};\n\nconst WHITESPACE = () => {\n return [\n { type: types.CHAR, value: 9 },\n { type: types.CHAR, value: 10 },\n { type: types.CHAR, value: 11 },\n { type: types.CHAR, value: 12 },\n { type: types.CHAR, value: 13 },\n { type: types.CHAR, value: 32 },\n { type: types.CHAR, value: 160 },\n { type: types.CHAR, value: 5760 },\n { type: types.RANGE, from: 8192, to: 8202 },\n { type: types.CHAR, value: 8232 },\n { type: types.CHAR, value: 8233 },\n { type: types.CHAR, value: 8239 },\n { type: types.CHAR, value: 8287 },\n { type: types.CHAR, value: 12288 },\n { type: types.CHAR, value: 65279 }\n ];\n};\n\nconst NOTANYCHAR = () => {\n return [\n { type: types.CHAR, value: 10 },\n { type: types.CHAR, value: 13 },\n { type: types.CHAR, value: 8232 },\n { type: types.CHAR, value: 8233 },\n ];\n};\n\n// Predefined class objects.\nexports.words = () => ({ type: types.SET, set: WORDS(), not: false });\nexports.notWords = () => ({ type: types.SET, set: WORDS(), not: true });\nexports.ints = () => ({ type: types.SET, set: INTS(), not: false });\nexports.notInts = () => ({ type: types.SET, set: INTS(), not: true });\nexports.whitespace = () => ({ type: types.SET, set: WHITESPACE(), not: false });\nexports.notWhitespace = () => ({ type: types.SET, set: WHITESPACE(), not: true });\nexports.anyChar = () => ({ type: types.SET, set: NOTANYCHAR(), not: true });\n\n},{\"./types\":29}],29:[function(require,module,exports){\nmodule.exports = {\n ROOT : 0,\n GROUP : 1,\n POSITION : 2,\n SET : 3,\n RANGE : 4,\n REPETITION : 5,\n REFERENCE : 6,\n CHAR : 7,\n};\n\n},{}],30:[function(require,module,exports){\nconst types = require('./types');\nconst sets = require('./sets');\n\n\nconst CTRL = '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^ ?';\nconst SLSH = { '0': 0, 't': 9, 'n': 10, 'v': 11, 'f': 12, 'r': 13 };\n\n/**\n * Finds character representations in str and convert all to\n * their respective characters\n *\n * @param {String} str\n * @return {String}\n */\nexports.strToChars = function(str) {\n /* jshint maxlen: false */\n var chars_regex = /(\\[\\\\b\\])|(\\\\)?\\\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|(0?[0-7]{2})|c([@A-Z[\\\\\\]^?])|([0tnvfr]))/g;\n str = str.replace(chars_regex, function(s, b, lbs, a16, b16, c8, dctrl, eslsh) {\n if (lbs) {\n return s;\n }\n\n var code = b ? 8 :\n a16 ? parseInt(a16, 16) :\n b16 ? parseInt(b16, 16) :\n c8 ? parseInt(c8, 8) :\n dctrl ? CTRL.indexOf(dctrl) :\n SLSH[eslsh];\n\n var c = String.fromCharCode(code);\n\n // Escape special regex characters.\n if (/[[\\]{}^$.|?*+()]/.test(c)) {\n c = '\\\\' + c;\n }\n\n return c;\n });\n\n return str;\n};\n\n\n/**\n * turns class into tokens\n * reads str until it encounters a ] not preceeded by a \\\n *\n * @param {String} str\n * @param {String} regexpStr\n * @return {Array.<Array.<Object>, Number>}\n */\nexports.tokenizeClass = (str, regexpStr) => {\n /* jshint maxlen: false */\n var tokens = [];\n var regexp = /\\\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\\\)(.)|([^\\]\\\\]))-(?:\\\\)?([^\\]]))|(\\])|(?:\\\\)?([^])/g;\n var rs, c;\n\n\n while ((rs = regexp.exec(str)) != null) {\n if (rs[1]) {\n tokens.push(sets.words());\n\n } else if (rs[2]) {\n tokens.push(sets.ints());\n\n } else if (rs[3]) {\n tokens.push(sets.whitespace());\n\n } else if (rs[4]) {\n tokens.push(sets.notWords());\n\n } else if (rs[5]) {\n tokens.push(sets.notInts());\n\n } else if (rs[6]) {\n tokens.push(sets.notWhitespace());\n\n } else if (rs[7]) {\n tokens.push({\n type: types.RANGE,\n from: (rs[8] || rs[9]).charCodeAt(0),\n to: rs[10].charCodeAt(0),\n });\n\n } else if ((c = rs[12])) {\n tokens.push({\n type: types.CHAR,\n value: c.charCodeAt(0),\n });\n\n } else {\n return [tokens, regexp.lastIndex];\n }\n }\n\n exports.error(regexpStr, 'Unterminated character class');\n};\n\n\n/**\n * Shortcut to throw errors.\n *\n * @param {String} regexp\n * @param {String} msg\n */\nexports.error = (regexp, msg) => {\n throw new SyntaxError('Invalid regular expression: /' + regexp + '/: ' + msg);\n};\n\n},{\"./sets\":28,\"./types\":29}],31:[function(require,module,exports){\n// Simple default configuration for application, when none is provided\n\nmodule.exports = (\n{\n\t\"Product\": \"Unnamed_Service\",\n\t\"ProductVersion\": \"0.0.1\",\n\n\t\"ServicePort\": 8080\n});\n\n\n},{}],32:[function(require,module,exports){\n/**\n* Default Service Server\n*/\nmodule.exports = require('./Orator-ServiceServer-IPC.js')\n},{\"./Orator-ServiceServer-IPC.js\":35}],33:[function(require,module,exports){\nconst libFableServiceProviderBase = require('fable-serviceproviderbase');\n\nclass OratorServiceServerBase extends libFableServiceProviderBase\n{\n\tconstructor(pFable, pOptions, pServiceHash)\n\t{\n super(pFable, pOptions, pServiceHash);\n\n this.serviceType = 'OratorServiceServer';\n\n\t\tthis.ServiceServerType = 'Base';\n\n\t\tthis.Name = this.fable.settings.Product;\n\t\tthis.URL = 'BASE_SERVICE_SERVER';\n\t\tthis.Port = this.options.ServicePort;\n\n\t\tthis.Active = false;\n\t}\n\n\t/*\n\t * Service Lifecycle Functions\n\t *************************************************************************/\n\tlisten(pPort, fCallback)\n\t{\n\t\t// Sometimes, listen does not listen on network calls.\n\t\tthis.Active = true;\n\n\t\treturn fCallback();\n\t}\n\n\tclose(fCallback)\n\t{\n\t\tthis.Active = false;\n\n\t\treturn fCallback();\n\t}\n\t/*************************************************************************\n\t * End of Service Lifecycle Functions\n\t */\n\n\t/*\n\t * Content parsing functions\n\t *************************************************************************/\n\tbodyParser(pOptions)\n\t{\n\t\treturn (pRequest, pResponse, fNext) => \n\t\t\t{\n\t\t\t\tfNext();\n\t\t\t};\n\t}\n\t/*************************************************************************\n\t * End of Service Lifecycle Functions\n\t */\n\n\t/*\n\t * Service Route Creation Functions\n\t *\n\t * These base functions provide basic validation for the routes, but don't actually \n\t * do anything with them. The design intent here is to allow derived classes to call\n\t * these functions to validate that they conform to expected standards.\n\t *\n\t * Something like:\n\n\t\tget (pRoute, ...fRouteProcessingFunctions)\n\t\t{\n\t\t\tif (!super.get(pRoute, ...fRouteProcessingFunctions))\n\t\t\t{\n\t\t\t\tthis.log.error(`Restify provider failed to map route [${pRoute}]!`);\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t//...now we can do our actual get mapping function!....\n\t\t}\n\n\t * This pattern and calling super is totally optional, obviously.\n\t *************************************************************************/\n\tuse(fHandlerFunction)\n\t{\n\t\tif (typeof(fHandlerFunction) != 'function')\n\t\t{\n\t\t\tthis.log.error(`Orator USE global handler mapping failed -- parameter was expected to be a function with prototype function(Request, Response, Next) but type was ${typeof(fHandlerFunction)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t}\n\n\tdoGet(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tget(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator GET Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doGet(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tgetWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.get(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoPut(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tput(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator PUT Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doPut(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tputWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.put(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoPost(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tpost(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator POST Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doPost(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tpostWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.post(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoDel(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tdel(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator DEL Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doDel(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tdelWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.del(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoPatch(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tpatch(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator PATCH Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doPatch(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tpatchWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.patch(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoOpts(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\topts(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator OPTS Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doOpts(pRoute, ...fRouteProcessingFunctions);\n\t}\n\toptsWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.opts(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoHead(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\thead(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator HEAD Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t}\n\theadWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.head(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\t/*************************************************************************\n\t * End of Service Route Creation Functions\n\t */\n\n\t// Programmatically invoke a route\n\tinvoke(pMethod, pRoute, pData, fCallback)\n\t{\n\t\t// The base class version of this does nothing\n\t\tthis.log.debug(`Orator invoke called for route [${pRoute}] and landed on the base class; the service provider likely does not implement programmatic invoke capabilities.`, pData);\n\t\treturn false;\n\t}\n}\n\nmodule.exports = OratorServiceServerBase;\n},{\"fable-serviceproviderbase\":6}],34:[function(require,module,exports){\nclass OratorServiceServerIPCSynthesizedResponse\n{\n\tconstructor(pHandler, pLog, pRequestGUID)\n\t{\n\t\tthis.log = pLog;\n\n\t\tif (pHandler.hasOwnProperty('params'))\n\t\t{\n\t\t\tthis.params = pHandler.params;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.params = {};\n\t\t}\n\t\tif (pHandler.hasOwnProperty('searchParams'))\n\t\t{\n\t\t\tthis.searchParams = pHandler.searchParams;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.searchParams = {};\n\t\t}\n\n\t\tthis.requestGUID = pRequestGUID;\n\n\t\tthis.responseData = null;\n\t\tthis.responseStatus = -1;\n\t}\n\n\tsend(pData)\n\t{\n\t\tif (typeof(pData) == 'string')\n\t\t{\n\t\t\t// This is a string! Append it to the responsedata.\n\t\t\tif (this.responseData === null)\n\t\t\t{\n\t\t\t\tthis.responseData = pData;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse if (typeof(this.responseData) == 'string')\n\t\t\t{\n\t\t\t\tthis.responseData = this.responseData+pData;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tthis.log(`Request ${this.requestGUID} has tried to send() a string value after send()ing data type ${typeof(this.responseData)}.`, pData)\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\telse if (typeof(pData) == 'object')\n\t\t{\n\t\t\tif (this.responseData === null)\n\t\t\t{\n\t\t\t\tthis.responseData = JSON.stringify(pData);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse if (typeof(this.responseData) == 'string')\n\t\t\t{\n\t\t\t\t// TODO: Discuss best way to handle this / if to handle this\n\t\t\t\tthis.responseData += this.responseData+JSON.stringify(pData);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tthis.log(`Request ${this.requestGUID} has tried to send() an object value to be auto stringified after send()ing data type ${typeof(this.responseData)}.`, pData)\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t}\n}\n\nmodule.exports = OratorServiceServerIPCSynthesizedResponse;\n},{}],35:[function(require,module,exports){\nconst libOratorServiceServerBase = require('./Orator-ServiceServer-Base.js');\n\n// A synthesized response object, for simple IPC.\nconst libOratorServiceServerIPCSynthesizedResponse = require('./Orator-ServiceServer-IPC-SynthesizedResponse.js');\n// A simple constrainer for the find-my-way router since we aren't using any kind of headers to pass version or host\n//const libOratorServiceServerIPCCustomConstrainer = require('./Orator-ServiceServer-IPC-RouterConstrainer.js');\n\n// This library is the default router for our services\nconst libFindMyWay = require('find-my-way');\n\nclass OratorServiceServerIPC extends libOratorServiceServerBase\n{\n\tconstructor(pFable, pOptions, pServiceHash)\n\t{\n super(pFable, pOptions, pServiceHash);\n\n\t\tthis.router = libFindMyWay(this.options);\n\t\t//this.router.addConstraintStrategy(libOratorServiceServerIPCCustomConstrainer);\n\n\t\tthis.ServiceServerType = 'IPC';\n\n\t\tthis.URL = 'IPC';\n\t\tthis.Port = 0;\n\n\t\tthis.preBehaviorFunctions = [];\n\t\tthis.behaviorMap = {};\n\t\tthis.postBehaviorFunctions = [];\n\t}\n\n\tuse(fHandlerFunction)\n\t{\n\t\treturn this.addPreBehaviorFunction(fHandlerFunction);\n\t}\n\n\taddPreBehaviorFunction(fHandlerFunction)\n\t{\n\t\tif (!super.use(fHandlerFunction))\n\t\t{\n\t\t\tthis.log.error(`IPC provider failed to map USE handler function!`);\n\t\t\treturn false;\n\t\t}\n\n\t\tthis.preBehaviorFunctions.push(fHandlerFunction);\n\t\treturn true;\n\t}\n\n\texecutePreBehaviorFunctions(pRequest, pResponse, fNext)\n\t{\n\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\tfor (let i = 0; i < this.preBehaviorFunctions.length; i++)\n\t\t{\n\t\t\tlet tmpPreBehaviorFunction = this.preBehaviorFunctions[i];\n\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t(fStageComplete) =>\n\t\t\t\t{\n\t\t\t\t\treturn tmpPreBehaviorFunction(pRequest, pResponse, fStageComplete);\n\t\t\t\t});\n\t\t}\n\n\t\ttmpAnticipate.wait(\n\t\t\t(pError) =>\n\t\t\t{\n\t\t\t\tif (pError)\n\t\t\t\t{\n\t\t\t\t\tthis.log.error(`IPC Provider preBehaviorFunction ${pFunctionIndex} failed with error: ${pError}`, pError);\n\t\t\t\t}\n\t\t\t\treturn fNext(pError);\n\t\t\t});\n\t}\n\n\taddPostBehaviorFunction(fHandlerFunction)\n\t{\n\t\tif (!super.use(fHandlerFunction))\n\t\t{\n\t\t\tthis.log.error(`IPC provider failed to map USE handler function!`);\n\t\t\treturn false;\n\t\t}\n\n\t\tthis.postBehaviorFunctions.push(fHandlerFunction);\n\t\treturn true;\n\t}\n\n\texecutePostBehaviorFunctions(pRequest, pResponse, fNext)\n\t{\n\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\tfor (let i = 0; i < this.postBehaviorFunctions.length; i++)\n\t\t{\n\t\t\tlet tmpPostBehaviorFunction = this.postBehaviorFunctions[i];\n\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t(fStageComplete) =>\n\t\t\t\t{\n\t\t\t\t\treturn tmpPostBehaviorFunction(pRequest, pResponse, fStageComplete);\n\t\t\t\t});\n\t\t}\n\n\t\ttmpAnticipate.wait(\n\t\t\t(pError) =>\n\t\t\t{\n\t\t\t\tif (pError)\n\t\t\t\t{\n\t\t\t\t\tthis.log.error(`IPC Provider postBehaviorFunction ${pFunctionIndex} failed with error: ${pError}`, pError);\n\t\t\t\t}\n\t\t\t\treturn fNext(pError);\n\t\t\t});\n\t}\n\n\t/*\n\t * Service Route Creation Functions\n\t *\n\t * These base functions provide basic validation for the routes, but don't actually \n\t * do anything with them. The design intent here is to allow derived classes to call\n\t * these functions to validate that they conform to expected standards.\n\t *\n\t * Something like:\n\n\t\tget (pRoute, ...fRouteProcessingFunctions)\n\t\t{\n\t\t\t//...now we can do our actual get mapping function!....\n\t\t}\n\n\t * This pattern and calling super is totally optional, obviously.\n\t *************************************************************************/\n\taddRouteProcessor(pMethod, pRoute, pRouteFunctionArray)\n\t{\n\t\t// We have a constrainer on IPC so we can control channels eventually, if we like.\n\t\t// For now it just makes sure it was added with an IPC service server.\n\t\tthis.router.on(pMethod, pRoute, this.buildFindMyWayHandler(pRouteFunctionArray));\n\t\treturn true;\n\t}\n\n\tbuildFindMyWayHandler(pRouteFunctionArray)\n\t{\n\t\tlet tmpRouteFunctionArray = pRouteFunctionArray;\n\t\treturn (\n\t\t\t(pRequest, pResponse, pData) =>\n\t\t\t{\n\t\t\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t\t(fNext)=>\n\t\t\t\t\t{\n\t\t\t\t\t\treturn this.executePreBehaviorFunctions(pRequest, pResponse, fNext);\n\t\t\t\t\t});\n\n\t\t\t\tfor (let i = 0; i < tmpRouteFunctionArray.length; i++)\n\t\t\t\t{\n\t\t\t\t\tlet tmpRouteFunction = tmpRouteFunctionArray[i];\n\t\t\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t\t\t(fNext) =>\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\treturn tmpRouteFunction(pRequest, pResponse, fNext);\n\t\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t\t(fStageComplete)=>\n\t\t\t\t\t{\n\t\t\t\t\t\treturn this.executePostBehaviorFunctions(pRequest, pResponse, fStageComplete);\n\t\t\t\t\t});\n\n\t\t\t\treturn new Promise(\n\t\t\t\t\t(fResolve, fReject) =>\n\t\t\t\t\t{\n\t\t\t\t\t\ttmpAnticipate.wait(\n\t\t\t\t\t\t\t(pBehaviorFunctionError) =>\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tif (pBehaviorFunctionError)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tthis.log.error(`IPC Provider behavior function ${pFunctionIndex} failed with error: ${pBehaviorFunctionError}`, pBehaviorFunctionError);\n\t\t\t\t\t\t\t\t\treturn fReject(pBehaviorFunctionError);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\treturn fResolve();\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\t}\n\n\t// This is the virtualized \"body parser\"\n\tbodyParser()\n\t{\n\t\treturn (pRequest, pResponse, fNext) =>\n\t\t{\n\t\t\treturn fNext();\n\t\t};\n\t}\n\n\tdoGet(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('GET', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoPut(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('PUT', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoPost(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('POST', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoDel(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('DELETE', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoPatch(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('PATCH', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoOpts(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('OPTIONS', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoHead(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('HEAD', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\t/*************************************************************************\n\t * End of Service Route Creation Functions\n\t */\n\n\t// Programmatically invoke a route\n\tinvoke(pMethod, pRoute, pData, fCallback)\n\t{\n\t\t// If the data is skipped and a callback is parameter 3, do the right thing\n\t\tlet tmpCallback = (typeof(fCallback) == 'function') ? fCallback :\n\t\t\t\t\t\t\t(typeof(pData) == 'function') ? pData :\n\t\t\t\t\t\t\tfalse;\n\n\t\tif (!tmpCallback)\n\t\t{\n\t\t\tthrow new Error(`IPC Provider invoke() called without a callback function.`);\n\t\t}\n\n\t\t// Create a bare minimum request object for IPC to pass to our router\n\t\tlet tmpRequest = (\n\t\t\t{\n\t\t\t\tmethod: pMethod,\n\t\t\t\turl: pRoute,\n\t\t\t\tguid: this.fable.getUUID()\n\t\t\t});\n\n\t\t// For now, dealing with no handler constraints.\n\t\tlet tmpHandler = this.router.find( tmpRequest.method, tmpRequest.url);\n\n\t\t// Create a container for the IPC response data to be aggregated to from send() methodds\n\t\tlet tmpSynthesizedResponseData = new libOratorServiceServerIPCSynthesizedResponse(tmpHandler, this.log, tmpRequest.guid);\n\n\t\t// Map parsed params back to the request object\n\t\ttmpRequest.params = tmpSynthesizedResponseData.params;\n\t\ttmpRequest.searchParams = tmpSynthesizedResponseData.searchParams;\n\n\t\t//params: handle._createParamsObject(params)//,\n //searchParams: this.querystringParser(querystring)\n\n\t\ttmpHandler.handler(tmpRequest, tmpSynthesizedResponseData, pData).then(\n\t\t\t(pResults)=>\n\t\t\t{\n\t\t\t\treturn tmpCallback(null, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData, pResults);\n\t\t\t},\n\t\t\t(pError)=>\n\t\t\t{\n\t\t\t\tthis.log.trace('IPC Response Received', {Error: pError});\n\t\t\t\tif (pError)\n\t\t\t\t{\n\t\t\t\t\tthis.log.error(`IPC Request Error Request GUID [${tmpRequest.guid}] handling route [${pRoute}]: ${pError}`, {Error: pError, Route: pRoute, Data: pData});\n\t\t\t\t}\n\t\t\t\treturn tmpCallback(pError, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData);\n\t\t\t}\n\t\t);\n\t}\n}\n\nmodule.exports = OratorServiceServerIPC;\n},{\"./Orator-ServiceServer-Base.js\":33,\"./Orator-ServiceServer-IPC-SynthesizedResponse.js\":34,\"find-my-way\":13}],36:[function(require,module,exports){\n/**\n* Orator Service Abstraction\n*\n* @license MIT\n*\n* @author Steven Velozo <steven@velozo.com>\n* @module Orator Service\n*/\n\nconst libFableServiceProviderBase = require('fable-serviceproviderbase');\n\nconst libDefaultOratorServiceServer = require('./Orator-Default-ServiceServer.js');\n\nconst defaultOratorConfiguration = require('./Orator-Default-Configuration.js');\n\nclass Orator extends libFableServiceProviderBase\n{\n\tconstructor(pFable, pOptions, pServiceHash)\n\t{\n super(pFable, pOptions, pServiceHash);\n\n this.serviceType = 'Orator';\n\n\t\t// Create the empty, important logic containers\n\t\tthis.serviceServer = false;\n\t\tthis.serviceServerProvider = false;\n\n\t\tif (typeof(pServiceProvider) !== 'undefined')\n\t\t{\n\t\t\tthis.serviceServerProvider = pServiceProvider;\n\t\t}\n\n\t\t// Now check to see that the ServicePort is set (this used to be APIServerPort)\n\t\tif (!this.options.hasOwnProperty('ServicePort'))\n\t\t{\n\t\t\tif (this.fable.settings.hasOwnProperty('APIServerPort'))\n\t\t\t{\n\t\t\t\t// Automatically migrate the legacy APIServerPort to ServicePort\n\t\t\t\tthis.options.ServicePort = this.fable.settings.APIServerPort;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// Default to whatever the ... default is!\n\t\t\t\tthis.options.ServicePort = defaultOratorConfiguration.ServicePort;\n\t\t\t}\n\t\t}\n\n\t\t// Now check to see that the Product name is set\n\t\tif (!this.options.hasOwnProperty('Product'))\n\t\t{\n\t\t\tthis.options.Product = defaultOratorConfiguration.Product;\n\t\t}\n\t}\n\n\tonBeforeInitialize()\n\t{\n\t\tif (this.fable.settings.LogNoisiness > 3)\n\t\t{\n\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onBeforeInitialize:`);\n\t\t}\n\t}\n\tonBeforeInitializeAsync(fNext)\n\t{\n\t\tthis.onBeforeInitialize();\n\t\t// Check to see if there is a service server active; if not instantiate one (and use IPC if none is registered with Fable as the default provider)\n\t\tif (!this.serviceServer)\n\t\t{\n\t\t\t// If the developer hasn't set this to a service provider class of their own choosing, \n\t\t\t// TODO: Give the developer a chance to set a service provider instantiation address of their own choosing.\n\t\t\t// use the built-in network-less one.\n\t\t\tif (!this.fable.OratorServiceServer)\n\t\t\t{\n\t\t\t\t// If there isn't a default Service Server setup, create one.\n\t\t\t\tlet tmpServiceServerOptions = (typeof(this.options.ServiceServerOptions) == 'undefined') ? {} : this.options.ServiceServerOptions;\n\t\t\t\tif (!this.fable.serviceManager.servicesMap.hasOwnProperty('OratorServiceServer'))\n\t\t\t\t{\n\t\t\t\t\t// Only register IPC if there isn't one yet.\n\t\t\t\t\tthis.fable.serviceManager.addServiceType('OratorServiceServer', libDefaultOratorServiceServer);\n\t\t\t\t}\n\t\t\t\tthis.fable.serviceManager.instantiateServiceProvider('OratorServiceServer', tmpServiceServerOptions, 'OratorServiceServer-AutoInit');\n\t\t\t}\n\t\t\tthis.serviceServer = this.fable.OratorServiceServer;\n\t\t\t// For legacy reasons, we also will provide this under the \"webServer\" variable.\n\t\t\tthis.webServer = this.serviceServer;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.log.warn(`Orator attempting to initialize a service server after initialization has already completed.`)\n\t\t}\n\t\tfNext();\n\t}\n\n\tonInitialize()\n\t{\n\t\tif (this.fable.settings.LogNoisiness > 3)\n\t\t{\n\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onInitialize:`);\n\t\t}\n\t}\n\tonInitializeAsync(fNext)\n\t{\n\t\tthis.onInitialize();\n\t\treturn fNext();\n\t}\n\n\tonAfterInitialize()\n\t{\n\t\tif (this.fable.settings.LogNoisiness > 3)\n\t\t{\n\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onAfterInitialize:`);\n\t\t}\n\t}\n\tonAfterInitializeAsync(fNext)\n\t{\n\t\tthis.onAfterInitialize();\n\t\treturn fNext();\n\t}\n\n\tinitialize(fCallback)\n\t{\n\t\t// I hate this -- is there a reason to not require a callback?\n\t\tlet tmpCallback = (typeof(fCallback) === 'function') ? fCallback : () => {};\n\n\t\tif (!this.initializeTimestamp)\n\t\t{\n\t\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\t\tif (this.fable.LogNoisiness > 3)\n\t\t\t{\n\t\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} beginning initialization steps...`);\n\t\t\t}\n\n\t\t\ttmpAnticipate.anticipate(this.onBeforeInitializeAsync.bind(this));\n\t\t\ttmpAnticipate.anticipate(this.onInitializeAsync.bind(this));\n\t\t\ttmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));\n\n\t\t\ttmpAnticipate.wait(\n\t\t\t\t(pError) =>\n\t\t\t\t{\n\t\t\t\t\tthis.initializeTimestamp = this.fable.log.getTimeStamp();\n\t\t\t\t\tif (this.fable.LogNoisiness > 2)\n\t\t\t\t\t{\n\t\t\t\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} initialization steps complete.`);\n\t\t\t\t\t}\n\t\t\t\t\treturn tmpCallback(pError);\n\t\t\t\t});\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.log.warn(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} async initialize called but initialization is already completed. Aborting.`);\n\t\t\t// TODO: Should this be returning an error?\n\t\t\treturn tmpCallback();\n\t\t}\n\t}\n\n\tonBeforeStartService(fNext)\n\t{\n\t\treturn fNext();\n\t}\n\tonStartService(fNext)\n\t{\n\t\tthis.onAfterInitialize();\n\t\treturn this.serviceServer.listen\n\t\t(\n\t\t\tthis.options.ServicePort,\n\t\t\t(pError)\t=>\n\t\t\t{\n\t\t\t\tthis.log.info(`${this.serviceServer.Name} listening at ${this.serviceServer.URL} port ${this.serviceServer.Port}`);\n\t\t\t\treturn fNext(pError);\n\t\t\t}\n\t\t);\n\t}\n\tonAfterStartService(fNext)\n\t{\n\t\treturn fNext();\n\t}\n\n\tstartService(fNext)\n\t{\n\t\tvar tmpNext = (typeof(fNext) === 'function') ? fNext : ()=>{};\n\n\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\tif (this.fable.LogNoisiness > 3)\n\t\t{\n\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} beginning startService steps...`);\n\t\t}\n\n\t\t// Auto initialize if there is no serviceServer\n\t\tif (!this.serviceServer)\n\t\t{\n\t\t\ttmpAnticipate.anticipate(this.initialize.bind(this));\n\t\t}\n\n\t\ttmpAnticipate.anticipate(this.onBeforeStartService.bind(this));\n\t\ttmpAnticipate.anticipate(this.onStartService.bind(this));\n\t\ttmpAnticipate.anticipate(this.onAfterStartService.bind(this));\n\n\t\ttmpAnticipate.wait(\n\t\t\t(pError) =>\n\t\t\t{\n\t\t\t\tthis.startServiceTimestamp = this.fable.log.getTimeStamp();\n\t\t\t\tif (this.fable.LogNoisiness > 2)\n\t\t\t\t{\n\t\t\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} startService steps complete.`);\n\t\t\t\t}\n\t\t\t\treturn tmpNext(pError);\n\t\t\t});\n\t}\n\n\tstopService(fCallback)\n\t{\n\t\tvar tmpCallback = (typeof(fCallback) === 'function') ? fCallback : ()=>{};\n\n\t\tif (!this.serviceServer)\n\t\t{\n\t\t\tlet tmpMessage = `Orator attempting to stop a service server but the service server has not been intialized yet.`;\n\t\t\tthis.log.warn(tmpMessage);\n\t\t\treturn tmpCallback(tmpMessage);\n\t\t}\n\n\t\tif (!this.serviceServer.Active)\n\t\t{\n\t\t\tlet tmpMessage = `Orator attempting to stop a service server but the service server is not actively running.`;\n\t\t\tthis.log.warn(tmpMessage);\n\t\t\treturn tmpCallback(tmpMessage);\n\t\t}\n\n\t\treturn this.serviceServer.close(tmpCallback);\n\t}\n\n\tinvoke(pMethod, pRoute, pData, fCallback)\n\t{\n\t\t//this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} invoking ${pMethod} ${pRoute}`);\n\t\treturn this.serviceServer.invoke(pMethod, pRoute, pData, fCallback);\n\t}\n\n\n\t/*\n\t * Legacy Orator Functions\n\t *************************************************************************/\n\tstartWebServer(fNext)\n\t{\n\t\treturn this.startService(fNext);\n\t}\n\n\t// For legacy purposes\n\tstopWebServer(fNext)\n\t{\n\t\treturn this.stopService(fNext);\n\t}\n\n\t// For legacy purposes\n\tgetWebServer()\n\t{\n\t\t// The old behavior was to lazily construct the service the first time \n\t\t// this accessor function is called.\n\t\tif (!this.serviceServer)\n\t\t{\n\t\t\tthis.initializeServiceServer();\n\t\t}\n\n\t\treturn this.serviceServer;\n\t}\n\t/*************************************************************************\n\t * End of Legacy Orator Functions\n\t */\n}\n\nmodule.exports = Orator;\nmodule.exports.ServiceServerBase = require('./Orator-ServiceServer-Base.js');\nmodule.exports.ServiceServerIPC = require('./Orator-ServiceServer-IPC.js');\n\n},{\"./Orator-Default-Configuration.js\":31,\"./Orator-Default-ServiceServer.js\":32,\"./Orator-ServiceServer-Base.js\":33,\"./Orator-ServiceServer-IPC.js\":35,\"fable-serviceproviderbase\":6}]},{},[36])(36)\n});\n\n","(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license MIT\n */\nfunction compare(a, b) {\n if (a === b) {\n return 0;\n }\n\n var x = a.length;\n var y = b.length;\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i];\n y = b[i];\n break;\n }\n }\n\n if (x < y) {\n return -1;\n }\n if (y < x) {\n return 1;\n }\n return 0;\n}\nfunction isBuffer(b) {\n if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n return global.Buffer.isBuffer(b);\n }\n return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n// node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n if (isBuffer(arrbuf)) {\n return false;\n }\n if (typeof global.ArrayBuffer !== 'function') {\n return false;\n }\n if (typeof ArrayBuffer.isView === 'function') {\n return ArrayBuffer.isView(arrbuf);\n }\n if (!arrbuf) {\n return false;\n }\n if (arrbuf instanceof DataView) {\n return true;\n }\n if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n return true;\n }\n return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n// actual: actual,\n// expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n if (!util.isFunction(func)) {\n return;\n }\n if (functionsHaveNames) {\n return func.name;\n }\n var str = func.toString();\n var match = str.match(regex);\n return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n this.name = 'AssertionError';\n this.actual = options.actual;\n this.expected = options.expected;\n this.operator = options.operator;\n if (options.message) {\n this.message = options.message;\n this.generatedMessage = false;\n } else {\n this.message = getMessage(this);\n this.generatedMessage = true;\n }\n var stackStartFunction = options.stackStartFunction || fail;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, stackStartFunction);\n } else {\n // non v8 browsers so we can have a stacktrace\n var err = new Error();\n if (err.stack) {\n var out = err.stack;\n\n // try to strip useless frames\n var fn_name = getName(stackStartFunction);\n var idx = out.indexOf('\\n' + fn_name);\n if (idx >= 0) {\n // once we have located the function frame\n // we need to strip out everything before it (and its line)\n var next_line = out.indexOf('\\n', idx + 1);\n out = out.substring(next_line + 1);\n }\n\n this.stack = out;\n }\n }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n if (typeof s === 'string') {\n return s.length < n ? s : s.slice(0, n);\n } else {\n return s;\n }\n}\nfunction inspect(something) {\n if (functionsHaveNames || !util.isFunction(something)) {\n return util.inspect(something);\n }\n var rawname = getName(something);\n var name = rawname ? ': ' + rawname : '';\n return '[Function' + name + ']';\n}\nfunction getMessage(self) {\n return truncate(inspect(self.actual), 128) + ' ' +\n self.operator + ' ' +\n truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided. All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n throw new assert.AssertionError({\n message: message,\n actual: actual,\n expected: expected,\n operator: operator,\n stackStartFunction: stackStartFunction\n });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n if (actual == expected) {\n fail(actual, expected, message, '!=', assert.notEqual);\n }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n if (!_deepEqual(actual, expected, false)) {\n fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n if (!_deepEqual(actual, expected, true)) {\n fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n // 7.1. All identical values are equivalent, as determined by ===.\n if (actual === expected) {\n return true;\n } else if (isBuffer(actual) && isBuffer(expected)) {\n return compare(actual, expected) === 0;\n\n // 7.2. If the expected value is a Date object, the actual value is\n // equivalent if it is also a Date object that refers to the same time.\n } else if (util.isDate(actual) && util.isDate(expected)) {\n return actual.getTime() === expected.getTime();\n\n // 7.3 If the expected value is a RegExp object, the actual value is\n // equivalent if it is also a RegExp object with the same source and\n // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n return actual.source === expected.source &&\n actual.global === expected.global &&\n actual.multiline === expected.multiline &&\n actual.lastIndex === expected.lastIndex &&\n actual.ignoreCase === expected.ignoreCase;\n\n // 7.4. Other pairs that do not both pass typeof value == 'object',\n // equivalence is determined by ==.\n } else if ((actual === null || typeof actual !== 'object') &&\n (expected === null || typeof expected !== 'object')) {\n return strict ? actual === expected : actual == expected;\n\n // If both values are instances of typed arrays, wrap their underlying\n // ArrayBuffers in a Buffer each to increase performance\n // This optimization requires the arrays to have the same type as checked by\n // Object.prototype.toString (aka pToString). Never perform binary\n // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n // bit patterns are not identical.\n } else if (isView(actual) && isView(expected) &&\n pToString(actual) === pToString(expected) &&\n !(actual instanceof Float32Array ||\n actual instanceof Float64Array)) {\n return compare(new Uint8Array(actual.buffer),\n new Uint8Array(expected.buffer)) === 0;\n\n // 7.5 For all other Object pairs, including Array objects, equivalence is\n // determined by having the same number of owned properties (as verified\n // with Object.prototype.hasOwnProperty.call), the same set of keys\n // (although not necessarily the same order), equivalent values for every\n // corresponding key, and an identical 'prototype' property. Note: this\n // accounts for both named and indexed properties on Arrays.\n } else if (isBuffer(actual) !== isBuffer(expected)) {\n return false;\n } else {\n memos = memos || {actual: [], expected: []};\n\n var actualIndex = memos.actual.indexOf(actual);\n if (actualIndex !== -1) {\n if (actualIndex === memos.expected.indexOf(expected)) {\n return true;\n }\n }\n\n memos.actual.push(actual);\n memos.expected.push(expected);\n\n return objEquiv(actual, expected, strict, memos);\n }\n}\n\nfunction isArguments(object) {\n return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n if (a === null || a === undefined || b === null || b === undefined)\n return false;\n // if one is a primitive, the other must be same\n if (util.isPrimitive(a) || util.isPrimitive(b))\n return a === b;\n if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n return false;\n var aIsArgs = isArguments(a);\n var bIsArgs = isArguments(b);\n if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n return false;\n if (aIsArgs) {\n a = pSlice.call(a);\n b = pSlice.call(b);\n return _deepEqual(a, b, strict);\n }\n var ka = objectKeys(a);\n var kb = objectKeys(b);\n var key, i;\n // having the same number of owned properties (keys incorporates\n // hasOwnProperty)\n if (ka.length !== kb.length)\n return false;\n //the same set of keys (although not necessarily the same order),\n ka.sort();\n kb.sort();\n //~~~cheap key test\n for (i = ka.length - 1; i >= 0; i--) {\n if (ka[i] !== kb[i])\n return false;\n }\n //equivalent values for every corresponding key, and\n //~~~possibly expensive deep test\n for (i = ka.length - 1; i >= 0; i--) {\n key = ka[i];\n if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n return false;\n }\n return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n if (_deepEqual(actual, expected, false)) {\n fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n if (_deepEqual(actual, expected, true)) {\n fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n if (actual !== expected) {\n fail(actual, expected, message, '===', assert.strictEqual);\n }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==. assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n if (actual === expected) {\n fail(actual, expected, message, '!==', assert.notStrictEqual);\n }\n};\n\nfunction expectedException(actual, expected) {\n if (!actual || !expected) {\n return false;\n }\n\n if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n return expected.test(actual);\n }\n\n try {\n if (actual instanceof expected) {\n return true;\n }\n } catch (e) {\n // Ignore. The instanceof check doesn't work for arrow functions.\n }\n\n if (Error.isPrototypeOf(expected)) {\n return false;\n }\n\n return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n var error;\n try {\n block();\n } catch (e) {\n error = e;\n }\n return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n var actual;\n\n if (typeof block !== 'function') {\n throw new TypeError('\"block\" argument must be a function');\n }\n\n if (typeof expected === 'string') {\n message = expected;\n expected = null;\n }\n\n actual = _tryBlock(block);\n\n message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n (message ? ' ' + message : '.');\n\n if (shouldThrow && !actual) {\n fail(actual, expected, 'Missing expected exception' + message);\n }\n\n var userProvidedMessage = typeof message === 'string';\n var isUnwantedException = !shouldThrow && util.isError(actual);\n var isUnexpectedException = !shouldThrow && actual && !expected;\n\n if ((isUnwantedException &&\n userProvidedMessage &&\n expectedException(actual, expected)) ||\n isUnexpectedException) {\n fail(actual, expected, 'Got unwanted exception' + message);\n }\n\n if ((shouldThrow && actual && expected &&\n !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n throw actual;\n }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n equal: assert.strictEqual,\n deepEqual: assert.deepStrictEqual,\n notEqual: assert.notStrictEqual,\n notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n for (var key in obj) {\n if (hasOwn.call(obj, key)) keys.push(key);\n }\n return keys;\n};\n","if (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n}\n","module.exports = function isBuffer(arg) {\n return arg && typeof arg === 'object'\n && typeof arg.copy === 'function'\n && typeof arg.fill === 'function'\n && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n if (!isString(f)) {\n var objects = [];\n for (var i = 0; i < arguments.length; i++) {\n objects.push(inspect(arguments[i]));\n }\n return objects.join(' ');\n }\n\n var i = 1;\n var args = arguments;\n var len = args.length;\n var str = String(f).replace(formatRegExp, function(x) {\n if (x === '%%') return '%';\n if (i >= len) return x;\n switch (x) {\n case '%s': return String(args[i++]);\n case '%d': return Number(args[i++]);\n case '%j':\n try {\n return JSON.stringify(args[i++]);\n } catch (_) {\n return '[Circular]';\n }\n default:\n return x;\n }\n });\n for (var x = args[i]; i < len; x = args[++i]) {\n if (isNull(x) || !isObject(x)) {\n str += ' ' + x;\n } else {\n str += ' ' + inspect(x);\n }\n }\n return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n // Allow for deprecating things in the process of starting up.\n if (isUndefined(global.process)) {\n return function() {\n return exports.deprecate(fn, msg).apply(this, arguments);\n };\n }\n\n if (process.noDeprecation === true) {\n return fn;\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (process.throwDeprecation) {\n throw new Error(msg);\n } else if (process.traceDeprecation) {\n console.trace(msg);\n } else {\n console.error(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n if (isUndefined(debugEnviron))\n debugEnviron = process.env.NODE_DEBUG || '';\n set = set.toUpperCase();\n if (!debugs[set]) {\n if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n var pid = process.pid;\n debugs[set] = function() {\n var msg = exports.format.apply(exports, arguments);\n console.error('%s %d: %s', set, pid, msg);\n };\n } else {\n debugs[set] = function() {};\n }\n }\n return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n // default options\n var ctx = {\n seen: [],\n stylize: stylizeNoColor\n };\n // legacy...\n if (arguments.length >= 3) ctx.depth = arguments[2];\n if (arguments.length >= 4) ctx.colors = arguments[3];\n if (isBoolean(opts)) {\n // legacy...\n ctx.showHidden = opts;\n } else if (opts) {\n // got an \"options\" object\n exports._extend(ctx, opts);\n }\n // set default options\n if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n if (isUndefined(ctx.depth)) ctx.depth = 2;\n if (isUndefined(ctx.colors)) ctx.colors = false;\n if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n if (ctx.colors) ctx.stylize = stylizeWithColor;\n return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n 'bold' : [1, 22],\n 'italic' : [3, 23],\n 'underline' : [4, 24],\n 'inverse' : [7, 27],\n 'white' : [37, 39],\n 'grey' : [90, 39],\n 'black' : [30, 39],\n 'blue' : [34, 39],\n 'cyan' : [36, 39],\n 'green' : [32, 39],\n 'magenta' : [35, 39],\n 'red' : [31, 39],\n 'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n 'special': 'cyan',\n 'number': 'yellow',\n 'boolean': 'yellow',\n 'undefined': 'grey',\n 'null': 'bold',\n 'string': 'green',\n 'date': 'magenta',\n // \"name\": intentionally not styling\n 'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n var style = inspect.styles[styleType];\n\n if (style) {\n return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n '\\u001b[' + inspect.colors[style][1] + 'm';\n } else {\n return str;\n }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n return str;\n}\n\n\nfunction arrayToHash(array) {\n var hash = {};\n\n array.forEach(function(val, idx) {\n hash[val] = true;\n });\n\n return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n // Provide a hook for user-specified inspect functions.\n // Check that value is an object with an inspect function on it\n if (ctx.customInspect &&\n value &&\n isFunction(value.inspect) &&\n // Filter out the util module, it's inspect function is special\n value.inspect !== exports.inspect &&\n // Also filter out any prototype objects using the circular check.\n !(value.constructor && value.constructor.prototype === value)) {\n var ret = value.inspect(recurseTimes, ctx);\n if (!isString(ret)) {\n ret = formatValue(ctx, ret, recurseTimes);\n }\n return ret;\n }\n\n // Primitive types cannot have properties\n var primitive = formatPrimitive(ctx, value);\n if (primitive) {\n return primitive;\n }\n\n // Look up the keys of the object.\n var keys = Object.keys(value);\n var visibleKeys = arrayToHash(keys);\n\n if (ctx.showHidden) {\n keys = Object.getOwnPropertyNames(value);\n }\n\n // IE doesn't make error fields non-enumerable\n // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n if (isError(value)\n && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n return formatError(value);\n }\n\n // Some type of object without properties can be shortcutted.\n if (keys.length === 0) {\n if (isFunction(value)) {\n var name = value.name ? ': ' + value.name : '';\n return ctx.stylize('[Function' + name + ']', 'special');\n }\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n }\n if (isDate(value)) {\n return ctx.stylize(Date.prototype.toString.call(value), 'date');\n }\n if (isError(value)) {\n return formatError(value);\n }\n }\n\n var base = '', array = false, braces = ['{', '}'];\n\n // Make Array say that they are Array\n if (isArray(value)) {\n array = true;\n braces = ['[', ']'];\n }\n\n // Make functions say that they are functions\n if (isFunction(value)) {\n var n = value.name ? ': ' + value.name : '';\n base = ' [Function' + n + ']';\n }\n\n // Make RegExps say that they are RegExps\n if (isRegExp(value)) {\n base = ' ' + RegExp.prototype.toString.call(value);\n }\n\n // Make dates with properties first say the date\n if (isDate(value)) {\n base = ' ' + Date.prototype.toUTCString.call(value);\n }\n\n // Make error with message first say the error\n if (isError(value)) {\n base = ' ' + formatError(value);\n }\n\n if (keys.length === 0 && (!array || value.length == 0)) {\n return braces[0] + base + braces[1];\n }\n\n if (recurseTimes < 0) {\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n } else {\n return ctx.stylize('[Object]', 'special');\n }\n }\n\n ctx.seen.push(value);\n\n var output;\n if (array) {\n output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n } else {\n output = keys.map(function(key) {\n return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n });\n }\n\n ctx.seen.pop();\n\n return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n if (isUndefined(value))\n return ctx.stylize('undefined', 'undefined');\n if (isString(value)) {\n var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n .replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"') + '\\'';\n return ctx.stylize(simple, 'string');\n }\n if (isNumber(value))\n return ctx.stylize('' + value, 'number');\n if (isBoolean(value))\n return ctx.stylize('' + value, 'boolean');\n // For some reason typeof null is \"object\", so special case here.\n if (isNull(value))\n return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n var output = [];\n for (var i = 0, l = value.length; i < l; ++i) {\n if (hasOwnProperty(value, String(i))) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n String(i), true));\n } else {\n output.push('');\n }\n }\n keys.forEach(function(key) {\n if (!key.match(/^\\d+$/)) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n key, true));\n }\n });\n return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n var name, str, desc;\n desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n if (desc.get) {\n if (desc.set) {\n str = ctx.stylize('[Getter/Setter]', 'special');\n } else {\n str = ctx.stylize('[Getter]', 'special');\n }\n } else {\n if (desc.set) {\n str = ctx.stylize('[Setter]', 'special');\n }\n }\n if (!hasOwnProperty(visibleKeys, key)) {\n name = '[' + key + ']';\n }\n if (!str) {\n if (ctx.seen.indexOf(desc.value) < 0) {\n if (isNull(recurseTimes)) {\n str = formatValue(ctx, desc.value, null);\n } else {\n str = formatValue(ctx, desc.value, recurseTimes - 1);\n }\n if (str.indexOf('\\n') > -1) {\n if (array) {\n str = str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n').substr(2);\n } else {\n str = '\\n' + str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n');\n }\n }\n } else {\n str = ctx.stylize('[Circular]', 'special');\n }\n }\n if (isUndefined(name)) {\n if (array && key.match(/^\\d+$/)) {\n return str;\n }\n name = JSON.stringify('' + key);\n if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n name = name.substr(1, name.length - 2);\n name = ctx.stylize(name, 'name');\n } else {\n name = name.replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"')\n .replace(/(^\"|\"$)/g, \"'\");\n name = ctx.stylize(name, 'string');\n }\n }\n\n return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n var numLinesEst = 0;\n var length = output.reduce(function(prev, cur) {\n numLinesEst++;\n if (cur.indexOf('\\n') >= 0) numLinesEst++;\n return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n }, 0);\n\n if (length > 60) {\n return braces[0] +\n (base === '' ? '' : base + '\\n ') +\n ' ' +\n output.join(',\\n ') +\n ' ' +\n braces[1];\n }\n\n return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n return isObject(e) &&\n (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n return arg === null ||\n typeof arg === 'boolean' ||\n typeof arg === 'number' ||\n typeof arg === 'string' ||\n typeof arg === 'symbol' || // ES6 symbol\n typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n 'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n var d = new Date();\n var time = [pad(d.getHours()),\n pad(d.getMinutes()),\n pad(d.getSeconds())].join(':');\n return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n * prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n // Don't do anything if add isn't an object\n if (!add || !isObject(add)) return origin;\n\n var keys = Object.keys(add);\n var i = keys.length;\n while (i--) {\n origin[keys[i]] = add[keys[i]];\n }\n return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n","/**\n* Fable Core Pre-initialization Service Base\n*\n* For a couple services, we need to be able to instantiate them before the Fable object is fully initialized.\n* This is a base class for those services.\n*\n* @author <steven@velozo.com>\n*/\n\nclass FableCoreServiceProviderBase\n{\n\tconstructor(pOptions, pServiceHash)\n\t{\n\t\tthis.fable = false;\n\n\t\tthis.options = (typeof(pOptions) === 'object') ? pOptions : {};\n\n\t\tthis.serviceType = 'Unknown';\n\n\t\t// The hash will be a non-standard UUID ... the UUID service uses this base class!\n\t\tthis.UUID = `CORESVC-${Math.floor((Math.random() * (99999 - 10000)) + 10000)}`;\n\n\t\tthis.Hash = (typeof(pServiceHash) === 'string') ? pServiceHash : `${this.UUID}`;\n\t}\n\n\n\tstatic isFableService = true;\n\n\t// After fable is initialized, it would be expected to be wired in as a normal service.\n\tconnectFable(pFable)\n\t{\n\t\tthis.fable = pFable;\n\n\t\treturn true;\n\t}\n}\n\nmodule.exports = FableCoreServiceProviderBase;\n","/**\n* Fable Service Base\n* @author <steven@velozo.com>\n*/\n\nclass FableServiceProviderBase\n{\n\tconstructor(pFable, pOptions, pServiceHash)\n\t{\n\t\tthis.fable = pFable;\n\n\t\tthis.options = (typeof(pOptions) === 'object') ? pOptions\n\t\t\t\t\t\t: ((typeof(pFable) === 'object') && !pFable.isFable) ? pFable\n\t\t\t\t\t\t: {};\n\n\t\tthis.serviceType = 'Unknown';\n\n\t\tif (typeof(pFable.getUUID) == 'function')\n\t\t{\n\t\t\tthis.UUID = pFable.getUUID();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.UUID = `NoFABLESVC-${Math.floor((Math.random() * (99999 - 10000)) + 10000)}`\n\t\t}\n\n\t\tthis.Hash = (typeof(pServiceHash) === 'string') ? pServiceHash : `${this.UUID}`;\n\n\t\t// Pull back a few things\n\t\tthis.log = this.fable.log;\n\t\tthis.servicesMap = this.fable.servicesMap;\n\t\tthis.services = this.fable.services;\n\t}\n\n\tstatic isFableService = true;\n}\n\nmodule.exports = FableServiceProviderBase;\n\nmodule.exports.CoreServiceProviderBase = require('./Fable-ServiceProviderBase-Preinit.js');","'use strict'\n\nvar UTF8_ACCEPT = 12\nvar UTF8_REJECT = 0\nvar UTF8_DATA = [\n // The first part of the table maps bytes to character to a transition.\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 7,\n 10, 9, 9, 9, 11, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n\n // The second part of the table maps a state to a new state when adding a\n // transition.\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 12, 0, 0, 0, 0, 24, 36, 48, 60, 72, 84, 96,\n 0, 12, 12, 12, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 48, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n\n // The third part maps the current transition to a mask that needs to apply\n // to the byte.\n 0x7F, 0x3F, 0x3F, 0x3F, 0x00, 0x1F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x07\n]\n\nfunction decodeURIComponent (uri) {\n var percentPosition = uri.indexOf('%')\n if (percentPosition === -1) return uri\n\n var length = uri.length\n var decoded = ''\n var last = 0\n var codepoint = 0\n var startOfOctets = percentPosition\n var state = UTF8_ACCEPT\n\n while (percentPosition > -1 && percentPosition < length) {\n var high = hexCodeToInt(uri[percentPosition + 1], 4)\n var low = hexCodeToInt(uri[percentPosition + 2], 0)\n var byte = high | low\n var type = UTF8_DATA[byte]\n state = UTF8_DATA[256 + state + type]\n codepoint = (codepoint << 6) | (byte & UTF8_DATA[364 + type])\n\n if (state === UTF8_ACCEPT) {\n decoded += uri.slice(last, startOfOctets)\n\n decoded += (codepoint <= 0xFFFF)\n ? String.fromCharCode(codepoint)\n : String.fromCharCode(\n (0xD7C0 + (codepoint >> 10)),\n (0xDC00 + (codepoint & 0x3FF))\n )\n\n codepoint = 0\n last = percentPosition + 3\n percentPosition = startOfOctets = uri.indexOf('%', last)\n } else if (state === UTF8_REJECT) {\n return null\n } else {\n percentPosition += 3\n if (percentPosition < length && uri.charCodeAt(percentPosition) === 37) continue\n return null\n }\n }\n\n return decoded + uri.slice(last)\n}\n\nvar HEX = {\n '0': 0,\n '1': 1,\n '2': 2,\n '3': 3,\n '4': 4,\n '5': 5,\n '6': 6,\n '7': 7,\n '8': 8,\n '9': 9,\n 'a': 10,\n 'A': 10,\n 'b': 11,\n 'B': 11,\n 'c': 12,\n 'C': 12,\n 'd': 13,\n 'D': 13,\n 'e': 14,\n 'E': 14,\n 'f': 15,\n 'F': 15\n}\n\nfunction hexCodeToInt (c, shift) {\n var i = HEX[c]\n return i === undefined ? 255 : i << shift\n}\n\nmodule.exports = decodeURIComponent\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n if (a === b) return true;\n\n if (a && b && typeof a == 'object' && typeof b == 'object') {\n if (a.constructor !== b.constructor) return false;\n\n var length, i, keys;\n if (Array.isArray(a)) {\n length = a.length;\n if (length != b.length) return false;\n for (i = length; i-- !== 0;)\n if (!equal(a[i], b[i])) return false;\n return true;\n }\n\n\n\n if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n keys = Object.keys(a);\n length = keys.length;\n if (length !== Object.keys(b).length) return false;\n\n for (i = length; i-- !== 0;)\n if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n for (i = length; i-- !== 0;) {\n var key = keys[i];\n\n if (!equal(a[key], b[key])) return false;\n }\n\n return true;\n }\n\n // true if both NaN, false otherwise\n return a!==a && b!==b;\n};\n","\"use strict\";\n\nconst parse = require(\"./parse\");\nconst stringify = require(\"./stringify\");\n\nconst fastQuerystring = {\n parse,\n stringify,\n};\n\n/**\n * Enable TS and JS support\n *\n * - `const qs = require('fast-querystring')`\n * - `import qs from 'fast-querystring'`\n */\nmodule.exports = fastQuerystring;\nmodule.exports.default = fastQuerystring;\nmodule.exports.parse = parse;\nmodule.exports.stringify = stringify;\n","// This file is taken from Node.js project.\n// Full implementation can be found from https://github.com/nodejs/node/blob/main/lib/internal/querystring.js\n\nconst hexTable = Array.from(\n { length: 256 },\n (_, i) => \"%\" + ((i < 16 ? \"0\" : \"\") + i.toString(16)).toUpperCase(),\n);\n\n// These characters do not need escaping when generating query strings:\n// ! - . _ ~\n// ' ( ) *\n// digits\n// alpha (uppercase)\n// alpha (lowercase)\n// rome-ignore format: the array should not be formatted\nconst noEscape = new Int8Array([\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31\n 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, // 32 - 47\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63\n 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 80 - 95\n 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, // 112 - 127\n]);\n\n/**\n * @param {string} str\n * @returns {string}\n */\nfunction encodeString(str) {\n const len = str.length;\n if (len === 0) return \"\";\n\n let out = \"\";\n let lastPos = 0;\n let i = 0;\n\n outer: for (; i < len; i++) {\n let c = str.charCodeAt(i);\n\n // ASCII\n while (c < 0x80) {\n if (noEscape[c] !== 1) {\n if (lastPos < i) out += str.slice(lastPos, i);\n lastPos = i + 1;\n out += hexTable[c];\n }\n\n if (++i === len) break outer;\n\n c = str.charCodeAt(i);\n }\n\n if (lastPos < i) out += str.slice(lastPos, i);\n\n // Multi-byte characters ...\n if (c < 0x800) {\n lastPos = i + 1;\n out += hexTable[0xc0 | (c >> 6)] + hexTable[0x80 | (c & 0x3f)];\n continue;\n }\n if (c < 0xd800 || c >= 0xe000) {\n lastPos = i + 1;\n out +=\n hexTable[0xe0 | (c >> 12)] +\n hexTable[0x80 | ((c >> 6) & 0x3f)] +\n hexTable[0x80 | (c & 0x3f)];\n continue;\n }\n // Surrogate pair\n ++i;\n\n // This branch should never happen because all URLSearchParams entries\n // should already be converted to USVString. But, included for\n // completion's sake anyway.\n if (i >= len) {\n throw new Error(\"URI malformed\");\n }\n\n const c2 = str.charCodeAt(i) & 0x3ff;\n\n lastPos = i + 1;\n c = 0x10000 + (((c & 0x3ff) << 10) | c2);\n out +=\n hexTable[0xf0 | (c >> 18)] +\n hexTable[0x80 | ((c >> 12) & 0x3f)] +\n hexTable[0x80 | ((c >> 6) & 0x3f)] +\n hexTable[0x80 | (c & 0x3f)];\n }\n if (lastPos === 0) return str;\n if (lastPos < len) return out + str.slice(lastPos);\n return out;\n}\n\nmodule.exports = { encodeString };\n","\"use strict\";\n\nconst fastDecode = require(\"fast-decode-uri-component\");\n\nconst plusRegex = /\\+/g;\nconst Empty = function () {};\nEmpty.prototype = Object.create(null);\n\n/**\n * @callback parse\n * @param {string} input\n */\nfunction parse(input) {\n // Optimization: Use new Empty() instead of Object.create(null) for performance\n // v8 has a better optimization for initializing functions compared to Object\n const result = new Empty();\n\n if (typeof input !== \"string\") {\n return result;\n }\n\n let inputLength = input.length;\n let key = \"\";\n let value = \"\";\n let startingIndex = -1;\n let equalityIndex = -1;\n let shouldDecodeKey = false;\n let shouldDecodeValue = false;\n let keyHasPlus = false;\n let valueHasPlus = false;\n let hasBothKeyValuePair = false;\n let c = 0;\n\n // Have a boundary of input.length + 1 to access last pair inside the loop.\n for (let i = 0; i < inputLength + 1; i++) {\n c = i !== inputLength ? input.charCodeAt(i) : 38;\n\n // Handle '&' and end of line to pass the current values to result\n if (c === 38) {\n hasBothKeyValuePair = equalityIndex > startingIndex;\n\n // Optimization: Reuse equality index to store the end of key\n if (!hasBothKeyValuePair) {\n equalityIndex = i;\n }\n\n key = input.slice(startingIndex + 1, equalityIndex);\n\n // Add key/value pair only if the range size is greater than 1; a.k.a. contains at least \"=\"\n if (hasBothKeyValuePair || key.length > 0) {\n // Optimization: Replace '+' with space\n if (keyHasPlus) {\n key = key.replace(plusRegex, \" \");\n }\n\n // Optimization: Do not decode if it's not necessary.\n if (shouldDecodeKey) {\n key = fastDecode(key) || key;\n }\n\n if (hasBothKeyValuePair) {\n value = input.slice(equalityIndex + 1, i);\n\n if (valueHasPlus) {\n value = value.replace(plusRegex, \" \");\n }\n\n if (shouldDecodeValue) {\n value = fastDecode(value) || value;\n }\n }\n const currentValue = result[key];\n\n if (currentValue === undefined) {\n result[key] = value;\n } else {\n // Optimization: value.pop is faster than Array.isArray(value)\n if (currentValue.pop) {\n currentValue.push(value);\n } else {\n result[key] = [currentValue, value];\n }\n }\n }\n\n // Reset reading key value pairs\n value = \"\";\n startingIndex = i;\n equalityIndex = i;\n shouldDecodeKey = false;\n shouldDecodeValue = false;\n keyHasPlus = false;\n valueHasPlus = false;\n }\n // Check '='\n else if (c === 61) {\n if (equalityIndex <= startingIndex) {\n equalityIndex = i;\n }\n // If '=' character occurs again, we should decode the input.\n else {\n shouldDecodeValue = true;\n }\n }\n // Check '+', and remember to replace it with empty space.\n else if (c === 43) {\n if (equalityIndex > startingIndex) {\n valueHasPlus = true;\n } else {\n keyHasPlus = true;\n }\n }\n // Check '%' character for encoding\n else if (c === 37) {\n if (equalityIndex > startingIndex) {\n shouldDecodeValue = true;\n } else {\n shouldDecodeKey = true;\n }\n }\n }\n\n return result;\n}\n\nmodule.exports = parse;\n","\"use strict\";\n\nconst { encodeString } = require(\"./internals/querystring\");\n\nfunction getAsPrimitive(value) {\n const type = typeof value;\n\n if (type === \"string\") {\n // Length check is handled inside encodeString function\n return encodeString(value);\n } else if (type === \"bigint\") {\n return value.toString();\n } else if (type === \"boolean\") {\n return value ? \"true\" : \"false\";\n } else if (type === \"number\" && Number.isFinite(value)) {\n return value < 1e21 ? \"\" + value : encodeString(\"\" + value);\n }\n\n return \"\";\n}\n\n/**\n * @param {Record<string, string | number | boolean\n * | ReadonlyArray<string | number | boolean> | null>} input\n * @returns {string}\n */\nfunction stringify(input) {\n let result = \"\";\n\n if (input === null || typeof input !== \"object\") {\n return result;\n }\n\n const separator = \"&\";\n const keys = Object.keys(input);\n const keyLength = keys.length;\n let valueLength = 0;\n\n for (let i = 0; i < keyLength; i++) {\n const key = keys[i];\n const value = input[key];\n const encodedKey = encodeString(key) + \"=\";\n\n if (i) {\n result += separator;\n }\n\n if (Array.isArray(value)) {\n valueLength = value.length;\n for (let j = 0; j < valueLength; j++) {\n if (j) {\n result += separator;\n }\n\n // Optimization: Dividing into multiple lines improves the performance.\n // Since v8 does not need to care about the '+' character if it was one-liner.\n result += encodedKey;\n result += getAsPrimitive(value[j]);\n }\n } else {\n result += encodedKey;\n result += getAsPrimitive(value);\n }\n }\n\n return result;\n}\n\nmodule.exports = stringify;\n","'use strict'\n\n/*\n Char codes:\n '!': 33 - !\n '#': 35 - %23\n '$': 36 - %24\n '%': 37 - %25\n '&': 38 - %26\n ''': 39 - '\n '(': 40 - (\n ')': 41 - )\n '*': 42 - *\n '+': 43 - %2B\n ',': 44 - %2C\n '-': 45 - -\n '.': 46 - .\n '/': 47 - %2F\n ':': 58 - %3A\n ';': 59 - %3B\n '=': 61 - %3D\n '?': 63 - %3F\n '@': 64 - %40\n '_': 95 - _\n '~': 126 - ~\n*/\n\nconst assert = require('assert')\nconst querystring = require('fast-querystring')\nconst isRegexSafe = require('safe-regex2')\nconst deepEqual = require('fast-deep-equal')\nconst { prettyPrintTree } = require('./lib/pretty-print')\nconst { StaticNode, NODE_TYPES } = require('./lib/node')\nconst Constrainer = require('./lib/constrainer')\nconst httpMethods = require('./lib/http-methods')\nconst httpMethodStrategy = require('./lib/strategies/http-method')\nconst { safeDecodeURI, safeDecodeURIComponent } = require('./lib/url-sanitizer')\n\nconst FULL_PATH_REGEXP = /^https?:\\/\\/.*?\\//\nconst OPTIONAL_PARAM_REGEXP = /(\\/:[^/()]*?)\\?(\\/?)/\n\nif (!isRegexSafe(FULL_PATH_REGEXP)) {\n throw new Error('the FULL_PATH_REGEXP is not safe, update this module')\n}\n\nif (!isRegexSafe(OPTIONAL_PARAM_REGEXP)) {\n throw new Error('the OPTIONAL_PARAM_REGEXP is not safe, update this module')\n}\n\nfunction Router (opts) {\n if (!(this instanceof Router)) {\n return new Router(opts)\n }\n opts = opts || {}\n this._opts = opts\n\n if (opts.defaultRoute) {\n assert(typeof opts.defaultRoute === 'function', 'The default route must be a function')\n this.defaultRoute = opts.defaultRoute\n } else {\n this.defaultRoute = null\n }\n\n if (opts.onBadUrl) {\n assert(typeof opts.onBadUrl === 'function', 'The bad url handler must be a function')\n this.onBadUrl = opts.onBadUrl\n } else {\n this.onBadUrl = null\n }\n\n if (opts.buildPrettyMeta) {\n assert(typeof opts.buildPrettyMeta === 'function', 'buildPrettyMeta must be a function')\n this.buildPrettyMeta = opts.buildPrettyMeta\n } else {\n this.buildPrettyMeta = defaultBuildPrettyMeta\n }\n\n if (opts.querystringParser) {\n assert(typeof opts.querystringParser === 'function', 'querystringParser must be a function')\n this.querystringParser = opts.querystringParser\n } else {\n this.querystringParser = (query) => query === '' ? {} : querystring.parse(query)\n }\n\n this.caseSensitive = opts.caseSensitive === undefined ? true : opts.caseSensitive\n this.ignoreTrailingSlash = opts.ignoreTrailingSlash || false\n this.ignoreDuplicateSlashes = opts.ignoreDuplicateSlashes || false\n this.maxParamLength = opts.maxParamLength || 100\n this.allowUnsafeRegex = opts.allowUnsafeRegex || false\n this.constrainer = new Constrainer(opts.constraints)\n\n this.routes = []\n this.trees = {}\n}\n\nRouter.prototype.on = function on (method, path, opts, handler, store) {\n if (typeof opts === 'function') {\n if (handler !== undefined) {\n store = handler\n }\n handler = opts\n opts = {}\n }\n // path validation\n assert(typeof path === 'string', 'Path should be a string')\n assert(path.length > 0, 'The path could not be empty')\n assert(path[0] === '/' || path[0] === '*', 'The first character of a path should be `/` or `*`')\n // handler validation\n assert(typeof handler === 'function', 'Handler should be a function')\n\n // path ends with optional parameter\n const optionalParamMatch = path.match(OPTIONAL_PARAM_REGEXP)\n if (optionalParamMatch) {\n assert(path.length === optionalParamMatch.index + optionalParamMatch[0].length, 'Optional Parameter needs to be the last parameter of the path')\n\n const pathFull = path.replace(OPTIONAL_PARAM_REGEXP, '$1$2')\n const pathOptional = path.replace(OPTIONAL_PARAM_REGEXP, '$2')\n\n this.on(method, pathFull, opts, handler, store)\n this.on(method, pathOptional, opts, handler, store)\n return\n }\n\n const route = path\n\n if (this.ignoreDuplicateSlashes) {\n path = removeDuplicateSlashes(path)\n }\n\n if (this.ignoreTrailingSlash) {\n path = trimLastSlash(path)\n }\n\n const methods = Array.isArray(method) ? method : [method]\n for (const method of methods) {\n assert(typeof method === 'string', 'Method should be a string')\n assert(httpMethods.includes(method), `Method '${method}' is not an http method.`)\n this._on(method, path, opts, handler, store, route)\n }\n}\n\nRouter.prototype._on = function _on (method, path, opts, handler, store) {\n let constraints = {}\n if (opts.constraints !== undefined) {\n assert(typeof opts.constraints === 'object' && opts.constraints !== null, 'Constraints should be an object')\n if (Object.keys(opts.constraints).length !== 0) {\n constraints = opts.constraints\n }\n }\n\n this.constrainer.validateConstraints(constraints)\n // Let the constrainer know if any constraints are being used now\n this.constrainer.noteUsage(constraints)\n\n // Boot the tree for this method if it doesn't exist yet\n if (this.trees[method] === undefined) {\n this.trees[method] = new StaticNode('/')\n }\n\n let pattern = path\n if (pattern === '*' && this.trees[method].prefix.length !== 0) {\n const currentRoot = this.trees[method]\n this.trees[method] = new StaticNode('')\n this.trees[method].staticChildren['/'] = currentRoot\n }\n\n let currentNode = this.trees[method]\n let parentNodePathIndex = currentNode.prefix.length\n\n const params = []\n for (let i = 0; i <= pattern.length; i++) {\n if (pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) === 58) {\n // It's a double colon\n i++\n continue\n }\n\n const isParametricNode = pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) !== 58\n const isWildcardNode = pattern.charCodeAt(i) === 42\n\n if (isParametricNode || isWildcardNode || (i === pattern.length && i !== parentNodePathIndex)) {\n let staticNodePath = pattern.slice(parentNodePathIndex, i)\n if (!this.caseSensitive) {\n staticNodePath = staticNodePath.toLowerCase()\n }\n staticNodePath = staticNodePath.split('::').join(':')\n staticNodePath = staticNodePath.split('%').join('%25')\n // add the static part of the route to the tree\n currentNode = currentNode.createStaticChild(staticNodePath)\n }\n\n if (isParametricNode) {\n let isRegexNode = false\n const regexps = []\n\n let lastParamStartIndex = i + 1\n for (let j = lastParamStartIndex; ; j++) {\n const charCode = pattern.charCodeAt(j)\n\n const isRegexParam = charCode === 40\n const isStaticPart = charCode === 45 || charCode === 46\n const isEndOfNode = charCode === 47 || j === pattern.length\n\n if (isRegexParam || isStaticPart || isEndOfNode) {\n const paramName = pattern.slice(lastParamStartIndex, j)\n params.push(paramName)\n\n isRegexNode = isRegexNode || isRegexParam || isStaticPart\n\n if (isRegexParam) {\n const endOfRegexIndex = getClosingParenthensePosition(pattern, j)\n const regexString = pattern.slice(j, endOfRegexIndex + 1)\n\n if (!this.allowUnsafeRegex) {\n assert(isRegexSafe(new RegExp(regexString)), `The regex '${regexString}' is not safe!`)\n }\n\n regexps.push(trimRegExpStartAndEnd(regexString))\n\n j = endOfRegexIndex + 1\n } else {\n regexps.push('(.*?)')\n }\n\n const staticPartStartIndex = j\n for (; j < pattern.length; j++) {\n const charCode = pattern.charCodeAt(j)\n if (charCode === 47) break\n if (charCode === 58) {\n const nextCharCode = pattern.charCodeAt(j + 1)\n if (nextCharCode === 58) j++\n else break\n }\n }\n\n let staticPart = pattern.slice(staticPartStartIndex, j)\n if (staticPart) {\n staticPart = staticPart.split('::').join(':')\n staticPart = staticPart.split('%').join('%25')\n regexps.push(escapeRegExp(staticPart))\n }\n\n lastParamStartIndex = j + 1\n\n if (isEndOfNode || pattern.charCodeAt(j) === 47 || j === pattern.length) {\n const nodePattern = isRegexNode ? '()' + staticPart : staticPart\n const nodePath = pattern.slice(i, j)\n\n pattern = pattern.slice(0, i + 1) + nodePattern + pattern.slice(j)\n i += nodePattern.length\n\n const regex = isRegexNode ? new RegExp('^' + regexps.join('') + '$') : null\n currentNode = currentNode.createParametricChild(regex, staticPart || null, nodePath)\n parentNodePathIndex = i + 1\n break\n }\n }\n }\n } else if (isWildcardNode) {\n // add the wildcard parameter\n params.push('*')\n currentNode = currentNode.createWildcardChild()\n parentNodePathIndex = i + 1\n\n if (i !== pattern.length - 1) {\n throw new Error('Wildcard must be the last character in the route')\n }\n }\n }\n\n if (!this.caseSensitive) {\n pattern = pattern.toLowerCase()\n }\n\n if (pattern === '*') {\n pattern = '/*'\n }\n\n for (const existRoute of this.routes) {\n const routeConstraints = existRoute.opts.constraints || {}\n if (\n existRoute.method === method &&\n existRoute.pattern === pattern &&\n deepEqual(routeConstraints, constraints)\n ) {\n throw new Error(`Method '${method}' already declared for route '${pattern}' with constraints '${JSON.stringify(constraints)}'`)\n }\n }\n\n const route = { method, path, pattern, params, opts, handler, store }\n this.routes.push(route)\n currentNode.addRoute(route, this.constrainer)\n}\n\nRouter.prototype.hasConstraintStrategy = function (strategyName) {\n return this.constrainer.hasConstraintStrategy(strategyName)\n}\n\nRouter.prototype.addConstraintStrategy = function (constraints) {\n this.constrainer.addConstraintStrategy(constraints)\n this._rebuild(this.routes)\n}\n\nRouter.prototype.reset = function reset () {\n this.trees = {}\n this.routes = []\n}\n\nRouter.prototype.off = function off (method, path, constraints) {\n // path validation\n assert(typeof path === 'string', 'Path should be a string')\n assert(path.length > 0, 'The path could not be empty')\n assert(path[0] === '/' || path[0] === '*', 'The first character of a path should be `/` or `*`')\n // options validation\n assert(\n typeof constraints === 'undefined' ||\n (typeof constraints === 'object' && !Array.isArray(constraints) && constraints !== null),\n 'Constraints should be an object or undefined.')\n\n // path ends with optional parameter\n const optionalParamMatch = path.match(OPTIONAL_PARAM_REGEXP)\n if (optionalParamMatch) {\n assert(path.length === optionalParamMatch.index + optionalParamMatch[0].length, 'Optional Parameter needs to be the last parameter of the path')\n\n const pathFull = path.replace(OPTIONAL_PARAM_REGEXP, '$1$2')\n const pathOptional = path.replace(OPTIONAL_PARAM_REGEXP, '$2')\n\n this.off(method, pathFull, constraints)\n this.off(method, pathOptional, constraints)\n return\n }\n\n if (this.ignoreDuplicateSlashes) {\n path = removeDuplicateSlashes(path)\n }\n\n if (this.ignoreTrailingSlash) {\n path = trimLastSlash(path)\n }\n\n const methods = Array.isArray(method) ? method : [method]\n for (const method of methods) {\n this._off(method, path, constraints)\n }\n}\n\nRouter.prototype._off = function _off (method, path, constraints) {\n // method validation\n assert(typeof method === 'string', 'Method should be a string')\n assert(httpMethods.includes(method), `Method '${method}' is not an http method.`)\n\n function matcherWithoutConstraints (route) {\n return method !== route.method || path !== route.path\n }\n\n function matcherWithConstraints (route) {\n return matcherWithoutConstraints(route) || !deepEqual(constraints, route.opts.constraints || {})\n }\n\n const predicate = constraints ? matcherWithConstraints : matcherWithoutConstraints\n\n // Rebuild tree without the specific route\n const newRoutes = this.routes.filter(predicate)\n this._rebuild(newRoutes)\n}\n\nRouter.prototype.lookup = function lookup (req, res, ctx, done) {\n if (typeof ctx === 'function') {\n done = ctx\n ctx = undefined\n }\n\n if (done === undefined) {\n const constraints = this.constrainer.deriveConstraints(req, ctx)\n const handle = this.find(req.method, req.url, constraints)\n return this.callHandler(handle, req, res, ctx)\n }\n\n this.constrainer.deriveConstraints(req, ctx, (err, constraints) => {\n if (err !== null) {\n done(err)\n return\n }\n\n try {\n const handle = this.find(req.method, req.url, constraints)\n const result = this.callHandler(handle, req, res, ctx)\n done(null, result)\n } catch (err) {\n done(err)\n }\n })\n}\n\nRouter.prototype.callHandler = function callHandler (handle, req, res, ctx) {\n if (handle === null) return this._defaultRoute(req, res, ctx)\n return ctx === undefined\n ? handle.handler(req, res, handle.params, handle.store, handle.searchParams)\n : handle.handler.call(ctx, req, res, handle.params, handle.store, handle.searchParams)\n}\n\nRouter.prototype.find = function find (method, path, derivedConstraints) {\n let currentNode = this.trees[method]\n if (currentNode === undefined) return null\n\n if (path.charCodeAt(0) !== 47) { // 47 is '/'\n path = path.replace(FULL_PATH_REGEXP, '/')\n }\n\n // This must be run before sanitizeUrl as the resulting function\n // .sliceParameter must be constructed with same URL string used\n // throughout the rest of this function.\n if (this.ignoreDuplicateSlashes) {\n path = removeDuplicateSlashes(path)\n }\n\n let sanitizedUrl\n let querystring\n let shouldDecodeParam\n\n try {\n sanitizedUrl = safeDecodeURI(path)\n path = sanitizedUrl.path\n querystring = sanitizedUrl.querystring\n shouldDecodeParam = sanitizedUrl.shouldDecodeParam\n } catch (error) {\n return this._onBadUrl(path)\n }\n\n if (this.ignoreTrailingSlash) {\n path = trimLastSlash(path)\n }\n\n const originPath = path\n\n if (this.caseSensitive === false) {\n path = path.toLowerCase()\n }\n\n const maxParamLength = this.maxParamLength\n\n let pathIndex = currentNode.prefix.length\n const params = []\n const pathLen = path.length\n\n const brothersNodesStack = []\n\n while (true) {\n if (pathIndex === pathLen && currentNode.isLeafNode) {\n const handle = currentNode.handlerStorage.getMatchingHandler(derivedConstraints)\n if (handle !== null) {\n return {\n handler: handle.handler,\n store: handle.store,\n params: handle._createParamsObject(params),\n searchParams: this.querystringParser(querystring)\n }\n }\n }\n\n let node = currentNode.getNextNode(path, pathIndex, brothersNodesStack, params.length)\n\n if (node === null) {\n if (brothersNodesStack.length === 0) {\n return null\n }\n\n const brotherNodeState = brothersNodesStack.pop()\n pathIndex = brotherNodeState.brotherPathIndex\n params.splice(brotherNodeState.paramsCount)\n node = brotherNodeState.brotherNode\n }\n\n currentNode = node\n\n // static route\n if (currentNode.kind === NODE_TYPES.STATIC) {\n pathIndex += currentNode.prefix.length\n continue\n }\n\n if (currentNode.kind === NODE_TYPES.WILDCARD) {\n let param = originPath.slice(pathIndex)\n if (shouldDecodeParam) {\n param = safeDecodeURIComponent(param)\n }\n\n params.push(param)\n pathIndex = pathLen\n continue\n }\n\n if (currentNode.kind === NODE_TYPES.PARAMETRIC) {\n let paramEndIndex = originPath.indexOf('/', pathIndex)\n if (paramEndIndex === -1) {\n paramEndIndex = pathLen\n }\n\n let param = originPath.slice(pathIndex, paramEndIndex)\n if (shouldDecodeParam) {\n param = safeDecodeURIComponent(param)\n }\n\n if (currentNode.isRegex) {\n const matchedParameters = currentNode.regex.exec(param)\n if (matchedParameters === null) continue\n\n for (let i = 1; i < matchedParameters.length; i++) {\n const matchedParam = matchedParameters[i]\n if (matchedParam.length > maxParamLength) {\n return null\n }\n params.push(matchedParam)\n }\n } else {\n if (param.length > maxParamLength) {\n return null\n }\n params.push(param)\n }\n\n pathIndex = paramEndIndex\n }\n }\n}\n\nRouter.prototype._rebuild = function (routes) {\n this.reset()\n\n for (const route of routes) {\n const { method, path, opts, handler, store } = route\n this._on(method, path, opts, handler, store)\n }\n}\n\nRouter.prototype._defaultRoute = function (req, res, ctx) {\n if (this.defaultRoute !== null) {\n return ctx === undefined\n ? this.defaultRoute(req, res)\n : this.defaultRoute.call(ctx, req, res)\n } else {\n res.statusCode = 404\n res.end()\n }\n}\n\nRouter.prototype._onBadUrl = function (path) {\n if (this.onBadUrl === null) {\n return null\n }\n const onBadUrl = this.onBadUrl\n return {\n handler: (req, res, ctx) => onBadUrl(path, req, res),\n params: {},\n store: null\n }\n}\n\nRouter.prototype.prettyPrint = function (options = {}) {\n const method = options.method\n\n options.buildPrettyMeta = this.buildPrettyMeta.bind(this)\n\n let tree = null\n if (method === undefined) {\n const { version, host, ...constraints } = this.constrainer.strategies\n constraints[httpMethodStrategy.name] = httpMethodStrategy\n\n const mergedRouter = new Router({ ...this._opts, constraints })\n const mergedRoutes = this.routes.map(route => {\n const constraints = {\n ...route.opts.constraints,\n [httpMethodStrategy.name]: route.method\n }\n return { ...route, method: 'MERGED', opts: { constraints } }\n })\n mergedRouter._rebuild(mergedRoutes)\n tree = mergedRouter.trees.MERGED\n } else {\n tree = this.trees[method]\n }\n\n if (tree == null) return '(empty tree)'\n return prettyPrintTree(tree, options)\n}\n\nfor (var i in httpMethods) {\n /* eslint no-prototype-builtins: \"off\" */\n if (!httpMethods.hasOwnProperty(i)) continue\n const m = httpMethods[i]\n const methodName = m.toLowerCase()\n\n if (Router.prototype[methodName]) throw new Error('Method already exists: ' + methodName)\n\n Router.prototype[methodName] = function (path, handler, store) {\n return this.on(m, path, handler, store)\n }\n}\n\nRouter.prototype.all = function (path, handler, store) {\n this.on(httpMethods, path, handler, store)\n}\n\nmodule.exports = Router\n\nfunction escapeRegExp (string) {\n return string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\nfunction removeDuplicateSlashes (path) {\n return path.replace(/\\/\\/+/g, '/')\n}\n\nfunction trimLastSlash (path) {\n if (path.length > 1 && path.charCodeAt(path.length - 1) === 47) {\n return path.slice(0, -1)\n }\n return path\n}\n\nfunction trimRegExpStartAndEnd (regexString) {\n // removes chars that marks start \"^\" and end \"$\" of regexp\n if (regexString.charCodeAt(1) === 94) {\n regexString = regexString.slice(0, 1) + regexString.slice(2)\n }\n\n if (regexString.charCodeAt(regexString.length - 2) === 36) {\n regexString = regexString.slice(0, regexString.length - 2) + regexString.slice(regexString.length - 1)\n }\n\n return regexString\n}\n\nfunction getClosingParenthensePosition (path, idx) {\n // `path.indexOf()` will always return the first position of the closing parenthese,\n // but it's inefficient for grouped or wrong regexp expressions.\n // see issues #62 and #63 for more info\n\n var parentheses = 1\n\n while (idx < path.length) {\n idx++\n\n // ignore skipped chars\n if (path[idx] === '\\\\') {\n idx++\n continue\n }\n\n if (path[idx] === ')') {\n parentheses--\n } else if (path[idx] === '(') {\n parentheses++\n }\n\n if (!parentheses) return idx\n }\n\n throw new TypeError('Invalid regexp expression in \"' + path + '\"')\n}\n\nfunction defaultBuildPrettyMeta (route) {\n // buildPrettyMeta function must return an object, which will be parsed into key/value pairs for display\n if (!route) return {}\n if (!route.store) return {}\n return Object.assign({}, route.store)\n}\n","'use strict'\n\nconst acceptVersionStrategy = require('./strategies/accept-version')\nconst acceptHostStrategy = require('./strategies/accept-host')\nconst assert = require('assert')\n\nclass Constrainer {\n constructor (customStrategies) {\n this.strategies = {\n version: acceptVersionStrategy,\n host: acceptHostStrategy\n }\n\n this.strategiesInUse = new Set()\n this.asyncStrategiesInUse = new Set()\n\n // validate and optimize prototypes of given custom strategies\n if (customStrategies) {\n for (const strategy of Object.values(customStrategies)) {\n this.addConstraintStrategy(strategy)\n }\n }\n }\n\n isStrategyUsed (strategyName) {\n return this.strategiesInUse.has(strategyName) ||\n this.asyncStrategiesInUse.has(strategyName)\n }\n\n hasConstraintStrategy (strategyName) {\n const customConstraintStrategy = this.strategies[strategyName]\n if (customConstraintStrategy !== undefined) {\n return customConstraintStrategy.isCustom ||\n this.isStrategyUsed(strategyName)\n }\n return false\n }\n\n addConstraintStrategy (strategy) {\n assert(typeof strategy.name === 'string' && strategy.name !== '', 'strategy.name is required.')\n assert(strategy.storage && typeof strategy.storage === 'function', 'strategy.storage function is required.')\n assert(strategy.deriveConstraint && typeof strategy.deriveConstraint === 'function', 'strategy.deriveConstraint function is required.')\n\n if (this.strategies[strategy.name] && this.strategies[strategy.name].isCustom) {\n throw new Error(`There already exists a custom constraint with the name ${strategy.name}.`)\n }\n\n if (this.isStrategyUsed(strategy.name)) {\n throw new Error(`There already exists a route with ${strategy.name} constraint.`)\n }\n\n strategy.isCustom = true\n strategy.isAsync = strategy.deriveConstraint.length === 3\n this.strategies[strategy.name] = strategy\n\n if (strategy.mustMatchWhenDerived) {\n this.noteUsage({ [strategy.name]: strategy })\n }\n }\n\n deriveConstraints (req, ctx, done) {\n const constraints = this.deriveSyncConstraints(req, ctx)\n\n if (done === undefined) {\n return constraints\n }\n\n this.deriveAsyncConstraints(constraints, req, ctx, done)\n }\n\n deriveSyncConstraints (req, ctx) {\n return undefined\n }\n\n // When new constraints start getting used, we need to rebuild the deriver to derive them. Do so if we see novel constraints used.\n noteUsage (constraints) {\n if (constraints) {\n const beforeSize = this.strategiesInUse.size\n for (const key in constraints) {\n const strategy = this.strategies[key]\n if (strategy.isAsync) {\n this.asyncStrategiesInUse.add(key)\n } else {\n this.strategiesInUse.add(key)\n }\n }\n if (beforeSize !== this.strategiesInUse.size) {\n this._buildDeriveConstraints()\n }\n }\n }\n\n newStoreForConstraint (constraint) {\n if (!this.strategies[constraint]) {\n throw new Error(`No strategy registered for constraint key ${constraint}`)\n }\n return this.strategies[constraint].storage()\n }\n\n validateConstraints (constraints) {\n for (const key in constraints) {\n const value = constraints[key]\n if (typeof value === 'undefined') {\n throw new Error('Can\\'t pass an undefined constraint value, must pass null or no key at all')\n }\n const strategy = this.strategies[key]\n if (!strategy) {\n throw new Error(`No strategy registered for constraint key ${key}`)\n }\n if (strategy.validate) {\n strategy.validate(value)\n }\n }\n }\n\n deriveAsyncConstraints (constraints, req, ctx, done) {\n let asyncConstraintsCount = this.asyncStrategiesInUse.size\n\n if (asyncConstraintsCount === 0) {\n done(null, constraints)\n return\n }\n\n constraints = constraints || {}\n for (const key of this.asyncStrategiesInUse) {\n const strategy = this.strategies[key]\n strategy.deriveConstraint(req, ctx, (err, constraintValue) => {\n if (err !== null) {\n done(err)\n return\n }\n\n constraints[key] = constraintValue\n\n if (--asyncConstraintsCount === 0) {\n done(null, constraints)\n }\n })\n }\n }\n\n // Optimization: build a fast function for deriving the constraints for all the strategies at once. We inline the definitions of the version constraint and the host constraint for performance.\n // If no constraining strategies are in use (no routes constrain on host, or version, or any custom strategies) then we don't need to derive constraints for each route match, so don't do anything special, and just return undefined\n // This allows us to not allocate an object to hold constraint values if no constraints are defined.\n _buildDeriveConstraints () {\n if (this.strategiesInUse.size === 0) return\n\n const lines = ['return {']\n\n for (const key of this.strategiesInUse) {\n const strategy = this.strategies[key]\n // Optimization: inline the derivation for the common built in constraints\n if (!strategy.isCustom) {\n if (key === 'version') {\n lines.push(' version: req.headers[\\'accept-version\\'],')\n } else if (key === 'host') {\n lines.push(' host: req.headers.host || req.headers[\\':authority\\'],')\n } else {\n throw new Error('unknown non-custom strategy for compiling constraint derivation function')\n }\n } else {\n lines.push(` ${strategy.name}: this.strategies.${key}.deriveConstraint(req, ctx),`)\n }\n }\n\n lines.push('}')\n\n this.deriveSyncConstraints = new Function('req', 'ctx', lines.join('\\n')).bind(this) // eslint-disable-line\n }\n}\n\nmodule.exports = Constrainer\n","'use strict'\n\nconst httpMethodStrategy = require('./strategies/http-method')\n\nclass HandlerStorage {\n constructor () {\n this.unconstrainedHandler = null // optimized reference to the handler that will match most of the time\n this.constraints = []\n this.handlers = [] // unoptimized list of handler objects for which the fast matcher function will be compiled\n this.constrainedHandlerStores = null\n }\n\n // This is the hot path for node handler finding -- change with care!\n getMatchingHandler (derivedConstraints) {\n if (derivedConstraints === undefined) {\n return this.unconstrainedHandler\n }\n return this._getHandlerMatchingConstraints(derivedConstraints)\n }\n\n addHandler (constrainer, route) {\n const params = route.params\n const constraints = route.opts.constraints || {}\n\n const handlerObject = {\n params,\n constraints,\n handler: route.handler,\n store: route.store || null,\n _createParamsObject: this._compileCreateParamsObject(params)\n }\n\n const constraintsNames = Object.keys(constraints)\n if (constraintsNames.length === 0) {\n this.unconstrainedHandler = handlerObject\n }\n\n for (const constraint of constraintsNames) {\n if (!this.constraints.includes(constraint)) {\n if (constraint === 'version') {\n // always check the version constraint first as it is the most selective\n this.constraints.unshift(constraint)\n } else {\n this.constraints.push(constraint)\n }\n }\n }\n\n const isMergedTree = constraintsNames.includes(httpMethodStrategy.name)\n if (!isMergedTree && this.handlers.length >= 32) {\n throw new Error('find-my-way supports a maximum of 32 route handlers per node when there are constraints, limit reached')\n }\n\n this.handlers.push(handlerObject)\n // Sort the most constrained handlers to the front of the list of handlers so they are tested first.\n this.handlers.sort((a, b) => Object.keys(a.constraints).length - Object.keys(b.constraints).length)\n\n if (!isMergedTree) {\n this._compileGetHandlerMatchingConstraints(constrainer, constraints)\n }\n }\n\n _compileCreateParamsObject (params) {\n const lines = []\n for (let i = 0; i < params.length; i++) {\n lines.push(`'${params[i]}': paramsArray[${i}]`)\n }\n return new Function('paramsArray', `return {${lines.join(',')}}`) // eslint-disable-line\n }\n\n _getHandlerMatchingConstraints () {\n return null\n }\n\n // Builds a store object that maps from constraint values to a bitmap of handler indexes which pass the constraint for a value\n // So for a host constraint, this might look like { \"fastify.io\": 0b0010, \"google.ca\": 0b0101 }, meaning the 3rd handler is constrainted to fastify.io, and the 2nd and 4th handlers are constrained to google.ca.\n // The store's implementation comes from the strategies provided to the Router.\n _buildConstraintStore (store, constraint) {\n for (let i = 0; i < this.handlers.length; i++) {\n const handler = this.handlers[i]\n const constraintValue = handler.constraints[constraint]\n if (constraintValue !== undefined) {\n let indexes = store.get(constraintValue) || 0\n indexes |= 1 << i // set the i-th bit for the mask because this handler is constrained by this value https://stackoverflow.com/questions/1436438/how-do-you-set-clear-and-toggle-a-single-bit-in-javascrip\n store.set(constraintValue, indexes)\n }\n }\n }\n\n // Builds a bitmask for a given constraint that has a bit for each handler index that is 0 when that handler *is* constrained and 1 when the handler *isnt* constrainted. This is opposite to what might be obvious, but is just for convienience when doing the bitwise operations.\n _constrainedIndexBitmask (constraint) {\n let mask = 0\n for (let i = 0; i < this.handlers.length; i++) {\n const handler = this.handlers[i]\n const constraintValue = handler.constraints[constraint]\n if (constraintValue !== undefined) {\n mask |= 1 << i\n }\n }\n return ~mask\n }\n\n // Compile a fast function to match the handlers for this node\n // The function implements a general case multi-constraint matching algorithm.\n // The general idea is this: we have a bunch of handlers, each with a potentially different set of constraints, and sometimes none at all. We're given a list of constraint values and we have to use the constraint-value-comparison strategies to see which handlers match the constraint values passed in.\n // We do this by asking each constraint store which handler indexes match the given constraint value for each store. Trickily, the handlers that a store says match are the handlers constrained by that store, but handlers that aren't constrained at all by that store could still match just fine. So, each constraint store can only describe matches for it, and it won't have any bearing on the handlers it doesn't care about. For this reason, we have to ask each stores which handlers match and track which have been matched (or not cared about) by all of them.\n // We use bitmaps to represent these lists of matches so we can use bitwise operations to implement this efficiently. Bitmaps are cheap to allocate, let us implement this masking behaviour in one CPU instruction, and are quite compact in memory. We start with a bitmap set to all 1s representing every handler that is a match candidate, and then for each constraint, see which handlers match using the store, and then mask the result by the mask of handlers that that store applies to, and bitwise AND with the candidate list. Phew.\n // We consider all this compiling function complexity to be worth it, because the naive implementation that just loops over the handlers asking which stores match is quite a bit slower.\n _compileGetHandlerMatchingConstraints (constrainer) {\n this.constrainedHandlerStores = {}\n\n for (const constraint of this.constraints) {\n const store = constrainer.newStoreForConstraint(constraint)\n this.constrainedHandlerStores[constraint] = store\n\n this._buildConstraintStore(store, constraint)\n }\n\n const lines = []\n lines.push(`\n let candidates = ${(1 << this.handlers.length) - 1}\n let mask, matches\n `)\n for (const constraint of this.constraints) {\n // Setup the mask for indexes this constraint applies to. The mask bits are set to 1 for each position if the constraint applies.\n lines.push(`\n mask = ${this._constrainedIndexBitmask(constraint)}\n value = derivedConstraints.${constraint}\n `)\n\n // If there's no constraint value, none of the handlers constrained by this constraint can match. Remove them from the candidates.\n // If there is a constraint value, get the matching indexes bitmap from the store, and mask it down to only the indexes this constraint applies to, and then bitwise and with the candidates list to leave only matching candidates left.\n const strategy = constrainer.strategies[constraint]\n const matchMask = strategy.mustMatchWhenDerived ? 'matches' : '(matches | mask)'\n\n lines.push(`\n if (value === undefined) {\n candidates &= mask\n } else {\n matches = this.constrainedHandlerStores.${constraint}.get(value) || 0\n candidates &= ${matchMask}\n }\n if (candidates === 0) return null;\n `)\n }\n\n // There are some constraints that can be derived and marked as \"must match\", where if they are derived, they only match routes that actually have a constraint on the value, like the SemVer version constraint.\n // An example: a request comes in for version 1.x, and this node has a handler that matches the path, but there's no version constraint. For SemVer, the find-my-way semantics do not match this handler to that request.\n // This function is used by Nodes with handlers to match when they don't have any constrained routes to exclude request that do have must match derived constraints present.\n for (const constraint in constrainer.strategies) {\n const strategy = constrainer.strategies[constraint]\n if (strategy.mustMatchWhenDerived && !this.constraints.includes(constraint)) {\n lines.push(`if (derivedConstraints.${constraint} !== undefined) return null`)\n }\n }\n\n // Return the first handler who's bit is set in the candidates https://stackoverflow.com/questions/18134985/how-to-find-index-of-first-set-bit\n lines.push('return this.handlers[Math.floor(Math.log2(candidates))]')\n\n this._getHandlerMatchingConstraints = new Function('derivedConstraints', lines.join('\\n')) // eslint-disable-line\n }\n}\n\nmodule.exports = HandlerStorage\n","'use strict'\n\n// defined by Node.js http module, a snapshot from Node.js 18.12.0\nconst httpMethods = [\n 'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE',\n 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE',\n 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS',\n 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT',\n 'REBIND', 'REPORT', 'SEARCH', 'SOURCE', 'SUBSCRIBE', 'TRACE',\n 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE'\n]\n\nmodule.exports = httpMethods\n","'use strict'\n\nconst HandlerStorage = require('./handler-storage')\n\nconst NODE_TYPES = {\n STATIC: 0,\n PARAMETRIC: 1,\n WILDCARD: 2\n}\n\nclass Node {\n constructor () {\n this.isLeafNode = false\n this.routes = null\n this.handlerStorage = null\n }\n\n addRoute (route, constrainer) {\n if (this.routes === null) {\n this.routes = []\n }\n if (this.handlerStorage === null) {\n this.handlerStorage = new HandlerStorage()\n }\n this.isLeafNode = true\n this.routes.push(route)\n this.handlerStorage.addHandler(constrainer, route)\n }\n}\n\nclass ParentNode extends Node {\n constructor () {\n super()\n this.staticChildren = {}\n }\n\n findStaticMatchingChild (path, pathIndex) {\n const staticChild = this.staticChildren[path.charAt(pathIndex)]\n if (staticChild === undefined || !staticChild.matchPrefix(path, pathIndex)) {\n return null\n }\n return staticChild\n }\n\n createStaticChild (path) {\n if (path.length === 0) {\n return this\n }\n\n let staticChild = this.staticChildren[path.charAt(0)]\n if (staticChild) {\n let i = 1\n for (; i < staticChild.prefix.length; i++) {\n if (path.charCodeAt(i) !== staticChild.prefix.charCodeAt(i)) {\n staticChild = staticChild.split(this, i)\n break\n }\n }\n return staticChild.createStaticChild(path.slice(i))\n }\n\n const label = path.charAt(0)\n this.staticChildren[label] = new StaticNode(path)\n return this.staticChildren[label]\n }\n}\n\nclass StaticNode extends ParentNode {\n constructor (prefix) {\n super()\n this.prefix = prefix\n this.wildcardChild = null\n this.parametricChildren = []\n this.kind = NODE_TYPES.STATIC\n this._compilePrefixMatch()\n }\n\n createParametricChild (regex, staticSuffix, nodePath) {\n const regexpSource = regex && regex.source\n\n let parametricChild = this.parametricChildren.find(child => {\n const childRegexSource = child.regex && child.regex.source\n return childRegexSource === regexpSource\n })\n\n if (parametricChild) {\n parametricChild.nodePaths.add(nodePath)\n return parametricChild\n }\n\n parametricChild = new ParametricNode(regex, staticSuffix, nodePath)\n this.parametricChildren.push(parametricChild)\n this.parametricChildren.sort((child1, child2) => {\n if (!child1.isRegex) return 1\n if (!child2.isRegex) return -1\n\n if (child1.staticSuffix === null) return 1\n if (child2.staticSuffix === null) return -1\n\n if (child2.staticSuffix.endsWith(child1.staticSuffix)) return 1\n if (child1.staticSuffix.endsWith(child2.staticSuffix)) return -1\n\n return 0\n })\n\n return parametricChild\n }\n\n createWildcardChild () {\n if (this.wildcardChild) {\n return this.wildcardChild\n }\n\n this.wildcardChild = new WildcardNode()\n return this.wildcardChild\n }\n\n split (parentNode, length) {\n const parentPrefix = this.prefix.slice(0, length)\n const childPrefix = this.prefix.slice(length)\n\n this.prefix = childPrefix\n this._compilePrefixMatch()\n\n const staticNode = new StaticNode(parentPrefix)\n staticNode.staticChildren[childPrefix.charAt(0)] = this\n parentNode.staticChildren[parentPrefix.charAt(0)] = staticNode\n\n return staticNode\n }\n\n getNextNode (path, pathIndex, nodeStack, paramsCount) {\n let node = this.findStaticMatchingChild(path, pathIndex)\n let parametricBrotherNodeIndex = 0\n\n if (node === null) {\n if (this.parametricChildren.length === 0) {\n return this.wildcardChild\n }\n\n node = this.parametricChildren[0]\n parametricBrotherNodeIndex = 1\n }\n\n if (this.wildcardChild !== null) {\n nodeStack.push({\n paramsCount,\n brotherPathIndex: pathIndex,\n brotherNode: this.wildcardChild\n })\n }\n\n for (let i = this.parametricChildren.length - 1; i >= parametricBrotherNodeIndex; i--) {\n nodeStack.push({\n paramsCount,\n brotherPathIndex: pathIndex,\n brotherNode: this.parametricChildren[i]\n })\n }\n\n return node\n }\n\n _compilePrefixMatch () {\n if (this.prefix.length === 1) {\n this.matchPrefix = () => true\n return\n }\n\n const lines = []\n for (let i = 1; i < this.prefix.length; i++) {\n const charCode = this.prefix.charCodeAt(i)\n lines.push(`path.charCodeAt(i + ${i}) === ${charCode}`)\n }\n this.matchPrefix = new Function('path', 'i', `return ${lines.join(' && ')}`) // eslint-disable-line\n }\n}\n\nclass ParametricNode extends ParentNode {\n constructor (regex, staticSuffix, nodePath) {\n super()\n this.isRegex = !!regex\n this.regex = regex || null\n this.staticSuffix = staticSuffix || null\n this.kind = NODE_TYPES.PARAMETRIC\n\n this.nodePaths = new Set([nodePath])\n }\n\n getNextNode (path, pathIndex) {\n return this.findStaticMatchingChild(path, pathIndex)\n }\n}\n\nclass WildcardNode extends Node {\n constructor () {\n super()\n this.kind = NODE_TYPES.WILDCARD\n }\n\n getNextNode () {\n return null\n }\n}\n\nmodule.exports = { StaticNode, ParametricNode, WildcardNode, NODE_TYPES }\n","'use strict'\n\nconst deepEqual = require('fast-deep-equal')\n\nconst httpMethodStrategy = require('./strategies/http-method')\nconst treeDataSymbol = Symbol('treeData')\n\nfunction printObjectTree (obj, parentPrefix = '') {\n let tree = ''\n const keys = Object.keys(obj)\n for (let i = 0; i < keys.length; i++) {\n const key = keys[i]\n const value = obj[key]\n const isLast = i === keys.length - 1\n\n const nodePrefix = isLast ? '└── ' : '├── '\n const childPrefix = isLast ? ' ' : '│ '\n\n const nodeData = value[treeDataSymbol] || ''\n const prefixedNodeData = nodeData.split('\\n').join('\\n' + parentPrefix + childPrefix)\n\n tree += parentPrefix + nodePrefix + key + prefixedNodeData + '\\n'\n tree += printObjectTree(value, parentPrefix + childPrefix)\n }\n return tree\n}\n\nfunction parseFunctionName (fn) {\n let fName = fn.name || ''\n\n fName = fName.replace('bound', '').trim()\n fName = (fName || 'anonymous') + '()'\n return fName\n}\n\nfunction parseMeta (meta) {\n if (Array.isArray(meta)) return meta.map(m => parseMeta(m))\n if (typeof meta === 'symbol') return meta.toString()\n if (typeof meta === 'function') return parseFunctionName(meta)\n return meta\n}\n\nfunction getRouteMetaData (route, options) {\n if (!options.includeMeta) return {}\n\n const metaDataObject = options.buildPrettyMeta(route)\n const filteredMetaData = {}\n\n let includeMetaKeys = options.includeMeta\n if (!Array.isArray(includeMetaKeys)) {\n includeMetaKeys = Reflect.ownKeys(metaDataObject)\n }\n\n for (const metaKey of includeMetaKeys) {\n if (!Object.prototype.hasOwnProperty.call(metaDataObject, metaKey)) continue\n\n const serializedKey = metaKey.toString()\n const metaValue = metaDataObject[metaKey]\n\n if (metaValue !== undefined && metaValue !== null) {\n const serializedValue = JSON.stringify(parseMeta(metaValue))\n filteredMetaData[serializedKey] = serializedValue\n }\n }\n\n return filteredMetaData\n}\n\nfunction serializeMetaData (metaData) {\n let serializedMetaData = ''\n for (const [key, value] of Object.entries(metaData)) {\n serializedMetaData += `\\n• (${key}) ${value}`\n }\n return serializedMetaData\n}\n\n// get original merged tree node route\nfunction normalizeRoute (route) {\n const constraints = { ...route.opts.constraints }\n const method = constraints[httpMethodStrategy.name]\n delete constraints[httpMethodStrategy.name]\n return { ...route, method, opts: { constraints } }\n}\n\nfunction serializeRoute (route) {\n let serializedRoute = ` (${route.method})`\n\n const constraints = route.opts.constraints || {}\n if (Object.keys(constraints).length !== 0) {\n serializedRoute += ' ' + JSON.stringify(constraints)\n }\n\n serializedRoute += serializeMetaData(route.metaData)\n return serializedRoute\n}\n\nfunction mergeSimilarRoutes (routes) {\n return routes.reduce((mergedRoutes, route) => {\n for (const nodeRoute of mergedRoutes) {\n if (\n deepEqual(route.opts.constraints, nodeRoute.opts.constraints) &&\n deepEqual(route.metaData, nodeRoute.metaData)\n ) {\n nodeRoute.method += ', ' + route.method\n return mergedRoutes\n }\n }\n mergedRoutes.push(route)\n return mergedRoutes\n }, [])\n}\n\nfunction serializeNode (node, prefix, options) {\n let routes = node.routes\n\n if (options.method === undefined) {\n routes = routes.map(normalizeRoute)\n }\n\n routes = routes.map(route => {\n route.metaData = getRouteMetaData(route, options)\n return route\n })\n\n if (options.method === undefined) {\n routes = mergeSimilarRoutes(routes)\n }\n\n return routes.map(serializeRoute).join(`\\n${prefix}`)\n}\n\nfunction buildObjectTree (node, tree, prefix, options) {\n if (node.isLeafNode || options.commonPrefix !== false) {\n prefix = prefix || '(empty root node)'\n tree = tree[prefix] = {}\n\n if (node.isLeafNode) {\n tree[treeDataSymbol] = serializeNode(node, prefix, options)\n }\n\n prefix = ''\n }\n\n if (node.staticChildren) {\n for (const child of Object.values(node.staticChildren)) {\n buildObjectTree(child, tree, prefix + child.prefix, options)\n }\n }\n\n if (node.parametricChildren) {\n for (const child of Object.values(node.parametricChildren)) {\n const childPrefix = Array.from(child.nodePaths).join('|')\n buildObjectTree(child, tree, prefix + childPrefix, options)\n }\n }\n\n if (node.wildcardChild) {\n buildObjectTree(node.wildcardChild, tree, '*', options)\n }\n}\n\nfunction prettyPrintTree (root, options) {\n const objectTree = {}\n buildObjectTree(root, objectTree, root.prefix, options)\n return printObjectTree(objectTree)\n}\n\nmodule.exports = { prettyPrintTree }\n","'use strict'\nconst assert = require('assert')\n\nfunction HostStorage () {\n const hosts = {}\n const regexHosts = []\n return {\n get: (host) => {\n const exact = hosts[host]\n if (exact) {\n return exact\n }\n for (const regex of regexHosts) {\n if (regex.host.test(host)) {\n return regex.value\n }\n }\n },\n set: (host, value) => {\n if (host instanceof RegExp) {\n regexHosts.push({ host, value })\n } else {\n hosts[host] = value\n }\n }\n }\n}\n\nmodule.exports = {\n name: 'host',\n mustMatchWhenDerived: false,\n storage: HostStorage,\n validate (value) {\n assert(typeof value === 'string' || Object.prototype.toString.call(value) === '[object RegExp]', 'Host should be a string or a RegExp')\n }\n}\n","'use strict'\n\nconst assert = require('assert')\n\nfunction SemVerStore () {\n if (!(this instanceof SemVerStore)) {\n return new SemVerStore()\n }\n\n this.store = {}\n\n this.maxMajor = 0\n this.maxMinors = {}\n this.maxPatches = {}\n}\n\nSemVerStore.prototype.set = function (version, store) {\n if (typeof version !== 'string') {\n throw new TypeError('Version should be a string')\n }\n let [major, minor, patch] = version.split('.')\n\n major = Number(major) || 0\n minor = Number(minor) || 0\n patch = Number(patch) || 0\n\n if (major >= this.maxMajor) {\n this.maxMajor = major\n this.store.x = store\n this.store['*'] = store\n this.store['x.x'] = store\n this.store['x.x.x'] = store\n }\n\n if (minor >= (this.maxMinors[major] || 0)) {\n this.maxMinors[major] = minor\n this.store[`${major}.x`] = store\n this.store[`${major}.x.x`] = store\n }\n\n if (patch >= (this.store[`${major}.${minor}`] || 0)) {\n this.maxPatches[`${major}.${minor}`] = patch\n this.store[`${major}.${minor}.x`] = store\n }\n\n this.store[`${major}.${minor}.${patch}`] = store\n return this\n}\n\nSemVerStore.prototype.get = function (version) {\n return this.store[version]\n}\n\nmodule.exports = {\n name: 'version',\n mustMatchWhenDerived: true,\n storage: SemVerStore,\n validate (value) {\n assert(typeof value === 'string', 'Version should be a string')\n }\n}\n","'use strict'\n\nmodule.exports = {\n name: '__fmw_internal_strategy_merged_tree_http_method__',\n storage: function () {\n const handlers = {}\n return {\n get: (type) => { return handlers[type] || null },\n set: (type, store) => { handlers[type] = store }\n }\n },\n deriveConstraint: (req) => {\n /* istanbul ignore next */\n return req.method\n },\n mustMatchWhenDerived: true\n}\n","'use strict'\n\n// It must spot all the chars where decodeURIComponent(x) !== decodeURI(x)\n// The chars are: # $ & + , / : ; = ? @\nfunction decodeComponentChar (highCharCode, lowCharCode) {\n if (highCharCode === 50) {\n if (lowCharCode === 53) return '%'\n\n if (lowCharCode === 51) return '#'\n if (lowCharCode === 52) return '$'\n if (lowCharCode === 54) return '&'\n if (lowCharCode === 66) return '+'\n if (lowCharCode === 98) return '+'\n if (lowCharCode === 67) return ','\n if (lowCharCode === 99) return ','\n if (lowCharCode === 70) return '/'\n if (lowCharCode === 102) return '/'\n return null\n }\n if (highCharCode === 51) {\n if (lowCharCode === 65) return ':'\n if (lowCharCode === 97) return ':'\n if (lowCharCode === 66) return ';'\n if (lowCharCode === 98) return ';'\n if (lowCharCode === 68) return '='\n if (lowCharCode === 100) return '='\n if (lowCharCode === 70) return '?'\n if (lowCharCode === 102) return '?'\n return null\n }\n if (highCharCode === 52 && lowCharCode === 48) {\n return '@'\n }\n return null\n}\n\nfunction safeDecodeURI (path) {\n let shouldDecode = false\n let shouldDecodeParam = false\n\n let querystring = ''\n\n for (let i = 1; i < path.length; i++) {\n const charCode = path.charCodeAt(i)\n\n if (charCode === 37) {\n const highCharCode = path.charCodeAt(i + 1)\n const lowCharCode = path.charCodeAt(i + 2)\n\n if (decodeComponentChar(highCharCode, lowCharCode) === null) {\n shouldDecode = true\n } else {\n shouldDecodeParam = true\n // %25 - encoded % char. We need to encode one more time to prevent double decoding\n if (highCharCode === 50 && lowCharCode === 53) {\n shouldDecode = true\n path = path.slice(0, i + 1) + '25' + path.slice(i + 1)\n i += 2\n }\n i += 2\n }\n // Some systems do not follow RFC and separate the path and query\n // string with a `;` character (code 59), e.g. `/foo;jsessionid=123456`.\n // Thus, we need to split on `;` as well as `?` and `#`.\n } else if (charCode === 63 || charCode === 59 || charCode === 35) {\n querystring = path.slice(i + 1)\n path = path.slice(0, i)\n break\n }\n }\n const decodedPath = shouldDecode ? decodeURI(path) : path\n return { path: decodedPath, querystring, shouldDecodeParam }\n}\n\nfunction safeDecodeURIComponent (uriComponent) {\n const startIndex = uriComponent.indexOf('%')\n if (startIndex === -1) return uriComponent\n\n let decoded = ''\n let lastIndex = startIndex\n\n for (let i = startIndex; i < uriComponent.length; i++) {\n if (uriComponent.charCodeAt(i) === 37) {\n const highCharCode = uriComponent.charCodeAt(i + 1)\n const lowCharCode = uriComponent.charCodeAt(i + 2)\n\n const decodedChar = decodeComponentChar(highCharCode, lowCharCode)\n decoded += uriComponent.slice(lastIndex, i) + decodedChar\n\n lastIndex = i + 3\n }\n }\n return uriComponent.slice(0, startIndex) + decoded + uriComponent.slice(lastIndex)\n}\n\nmodule.exports = { safeDecodeURI, safeDecodeURIComponent }\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc'); // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","'use strict'\n\nvar parse = require('ret')\nvar types = parse.types\n\nmodule.exports = function (re, opts) {\n if (!opts) opts = {}\n var replimit = opts.limit === undefined ? 25 : opts.limit\n\n if (isRegExp(re)) re = re.source\n else if (typeof re !== 'string') re = String(re)\n\n try { re = parse(re) } catch (err) { return false }\n\n var reps = 0\n return (function walk (node, starHeight) {\n var i\n var ok\n var len\n\n if (node.type === types.REPETITION) {\n starHeight++\n reps++\n if (starHeight > 1) return false\n if (reps > replimit) return false\n }\n\n if (node.options) {\n for (i = 0, len = node.options.length; i < len; i++) {\n ok = walk({ stack: node.options[i] }, starHeight)\n if (!ok) return false\n }\n }\n var stack = node.stack || (node.value && node.value.stack)\n if (!stack) return true\n\n for (i = 0; i < stack.length; i++) {\n ok = walk(stack[i], starHeight)\n if (!ok) return false\n }\n\n return true\n })(re, 0)\n}\n\nfunction isRegExp (x) {\n return {}.toString.call(x) === '[object RegExp]'\n}\n","const util = require('./util');\nconst types = require('./types');\nconst sets = require('./sets');\nconst positions = require('./positions');\n\n\nmodule.exports = (regexpStr) => {\n var i = 0, l, c,\n start = { type: types.ROOT, stack: []},\n\n // Keep track of last clause/group and stack.\n lastGroup = start,\n last = start.stack,\n groupStack = [];\n\n\n var repeatErr = (i) => {\n util.error(regexpStr, `Nothing to repeat at column ${i - 1}`);\n };\n\n // Decode a few escaped characters.\n var str = util.strToChars(regexpStr);\n l = str.length;\n\n // Iterate through each character in string.\n while (i < l) {\n c = str[i++];\n\n switch (c) {\n // Handle escaped characters, inclues a few sets.\n case '\\\\':\n c = str[i++];\n\n switch (c) {\n case 'b':\n last.push(positions.wordBoundary());\n break;\n\n case 'B':\n last.push(positions.nonWordBoundary());\n break;\n\n case 'w':\n last.push(sets.words());\n break;\n\n case 'W':\n last.push(sets.notWords());\n break;\n\n case 'd':\n last.push(sets.ints());\n break;\n\n case 'D':\n last.push(sets.notInts());\n break;\n\n case 's':\n last.push(sets.whitespace());\n break;\n\n case 'S':\n last.push(sets.notWhitespace());\n break;\n\n default:\n // Check if c is integer.\n // In which case it's a reference.\n if (/\\d/.test(c)) {\n last.push({ type: types.REFERENCE, value: parseInt(c, 10) });\n\n // Escaped character.\n } else {\n last.push({ type: types.CHAR, value: c.charCodeAt(0) });\n }\n }\n\n break;\n\n\n // Positionals.\n case '^':\n last.push(positions.begin());\n break;\n\n case '$':\n last.push(positions.end());\n break;\n\n\n // Handle custom sets.\n case '[':\n // Check if this class is 'anti' i.e. [^abc].\n var not;\n if (str[i] === '^') {\n not = true;\n i++;\n } else {\n not = false;\n }\n\n // Get all the characters in class.\n var classTokens = util.tokenizeClass(str.slice(i), regexpStr);\n\n // Increase index by length of class.\n i += classTokens[1];\n last.push({\n type: types.SET,\n set: classTokens[0],\n not,\n });\n\n break;\n\n\n // Class of any character except \\n.\n case '.':\n last.push(sets.anyChar());\n break;\n\n\n // Push group onto stack.\n case '(':\n // Create group.\n var group = {\n type: types.GROUP,\n stack: [],\n remember: true,\n };\n\n c = str[i];\n\n // If if this is a special kind of group.\n if (c === '?') {\n c = str[i + 1];\n i += 2;\n\n // Match if followed by.\n if (c === '=') {\n group.followedBy = true;\n\n // Match if not followed by.\n } else if (c === '!') {\n group.notFollowedBy = true;\n\n } else if (c !== ':') {\n util.error(regexpStr,\n `Invalid group, character '${c}'` +\n ` after '?' at column ${i - 1}`);\n }\n\n group.remember = false;\n }\n\n // Insert subgroup into current group stack.\n last.push(group);\n\n // Remember the current group for when the group closes.\n groupStack.push(lastGroup);\n\n // Make this new group the current group.\n lastGroup = group;\n last = group.stack;\n break;\n\n\n // Pop group out of stack.\n case ')':\n if (groupStack.length === 0) {\n util.error(regexpStr, `Unmatched ) at column ${i - 1}`);\n }\n lastGroup = groupStack.pop();\n\n // Check if this group has a PIPE.\n // To get back the correct last stack.\n last = lastGroup.options ?\n lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;\n break;\n\n\n // Use pipe character to give more choices.\n case '|':\n // Create array where options are if this is the first PIPE\n // in this clause.\n if (!lastGroup.options) {\n lastGroup.options = [lastGroup.stack];\n delete lastGroup.stack;\n }\n\n // Create a new stack and add to options for rest of clause.\n var stack = [];\n lastGroup.options.push(stack);\n last = stack;\n break;\n\n\n // Repetition.\n // For every repetition, remove last element from last stack\n // then insert back a RANGE object.\n // This design is chosen because there could be more than\n // one repetition symbols in a regex i.e. `a?+{2,3}`.\n case '{':\n var rs = /^(\\d+)(,(\\d+)?)?\\}/.exec(str.slice(i)), min, max;\n if (rs !== null) {\n if (last.length === 0) {\n repeatErr(i);\n }\n min = parseInt(rs[1], 10);\n max = rs[2] ? rs[3] ? parseInt(rs[3], 10) : Infinity : min;\n i += rs[0].length;\n\n last.push({\n type: types.REPETITION,\n min,\n max,\n value: last.pop(),\n });\n } else {\n last.push({\n type: types.CHAR,\n value: 123,\n });\n }\n break;\n\n case '?':\n if (last.length === 0) {\n repeatErr(i);\n }\n last.push({\n type: types.REPETITION,\n min: 0,\n max: 1,\n value: last.pop(),\n });\n break;\n\n case '+':\n if (last.length === 0) {\n repeatErr(i);\n }\n last.push({\n type: types.REPETITION,\n min: 1,\n max: Infinity,\n value: last.pop(),\n });\n break;\n\n case '*':\n if (last.length === 0) {\n repeatErr(i);\n }\n last.push({\n type: types.REPETITION,\n min: 0,\n max: Infinity,\n value: last.pop(),\n });\n break;\n\n\n // Default is a character that is not `\\[](){}?+*^$`.\n default:\n last.push({\n type: types.CHAR,\n value: c.charCodeAt(0),\n });\n }\n\n }\n\n // Check if any groups have not been closed.\n if (groupStack.length !== 0) {\n util.error(regexpStr, 'Unterminated group');\n }\n\n return start;\n};\n\nmodule.exports.types = types;\n","const types = require('./types');\nexports.wordBoundary = () => ({ type: types.POSITION, value: 'b' });\nexports.nonWordBoundary = () => ({ type: types.POSITION, value: 'B' });\nexports.begin = () => ({ type: types.POSITION, value: '^' });\nexports.end = () => ({ type: types.POSITION, value: '$' });\n","const types = require('./types');\n\nconst INTS = () => [{ type: types.RANGE , from: 48, to: 57 }];\n\nconst WORDS = () => {\n return [\n { type: types.CHAR, value: 95 },\n { type: types.RANGE, from: 97, to: 122 },\n { type: types.RANGE, from: 65, to: 90 }\n ].concat(INTS());\n};\n\nconst WHITESPACE = () => {\n return [\n { type: types.CHAR, value: 9 },\n { type: types.CHAR, value: 10 },\n { type: types.CHAR, value: 11 },\n { type: types.CHAR, value: 12 },\n { type: types.CHAR, value: 13 },\n { type: types.CHAR, value: 32 },\n { type: types.CHAR, value: 160 },\n { type: types.CHAR, value: 5760 },\n { type: types.RANGE, from: 8192, to: 8202 },\n { type: types.CHAR, value: 8232 },\n { type: types.CHAR, value: 8233 },\n { type: types.CHAR, value: 8239 },\n { type: types.CHAR, value: 8287 },\n { type: types.CHAR, value: 12288 },\n { type: types.CHAR, value: 65279 }\n ];\n};\n\nconst NOTANYCHAR = () => {\n return [\n { type: types.CHAR, value: 10 },\n { type: types.CHAR, value: 13 },\n { type: types.CHAR, value: 8232 },\n { type: types.CHAR, value: 8233 },\n ];\n};\n\n// Predefined class objects.\nexports.words = () => ({ type: types.SET, set: WORDS(), not: false });\nexports.notWords = () => ({ type: types.SET, set: WORDS(), not: true });\nexports.ints = () => ({ type: types.SET, set: INTS(), not: false });\nexports.notInts = () => ({ type: types.SET, set: INTS(), not: true });\nexports.whitespace = () => ({ type: types.SET, set: WHITESPACE(), not: false });\nexports.notWhitespace = () => ({ type: types.SET, set: WHITESPACE(), not: true });\nexports.anyChar = () => ({ type: types.SET, set: NOTANYCHAR(), not: true });\n","module.exports = {\n ROOT : 0,\n GROUP : 1,\n POSITION : 2,\n SET : 3,\n RANGE : 4,\n REPETITION : 5,\n REFERENCE : 6,\n CHAR : 7,\n};\n","const types = require('./types');\nconst sets = require('./sets');\n\n\nconst CTRL = '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^ ?';\nconst SLSH = { '0': 0, 't': 9, 'n': 10, 'v': 11, 'f': 12, 'r': 13 };\n\n/**\n * Finds character representations in str and convert all to\n * their respective characters\n *\n * @param {String} str\n * @return {String}\n */\nexports.strToChars = function(str) {\n /* jshint maxlen: false */\n var chars_regex = /(\\[\\\\b\\])|(\\\\)?\\\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|(0?[0-7]{2})|c([@A-Z[\\\\\\]^?])|([0tnvfr]))/g;\n str = str.replace(chars_regex, function(s, b, lbs, a16, b16, c8, dctrl, eslsh) {\n if (lbs) {\n return s;\n }\n\n var code = b ? 8 :\n a16 ? parseInt(a16, 16) :\n b16 ? parseInt(b16, 16) :\n c8 ? parseInt(c8, 8) :\n dctrl ? CTRL.indexOf(dctrl) :\n SLSH[eslsh];\n\n var c = String.fromCharCode(code);\n\n // Escape special regex characters.\n if (/[[\\]{}^$.|?*+()]/.test(c)) {\n c = '\\\\' + c;\n }\n\n return c;\n });\n\n return str;\n};\n\n\n/**\n * turns class into tokens\n * reads str until it encounters a ] not preceeded by a \\\n *\n * @param {String} str\n * @param {String} regexpStr\n * @return {Array.<Array.<Object>, Number>}\n */\nexports.tokenizeClass = (str, regexpStr) => {\n /* jshint maxlen: false */\n var tokens = [];\n var regexp = /\\\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\\\)(.)|([^\\]\\\\]))-(?:\\\\)?([^\\]]))|(\\])|(?:\\\\)?([^])/g;\n var rs, c;\n\n\n while ((rs = regexp.exec(str)) != null) {\n if (rs[1]) {\n tokens.push(sets.words());\n\n } else if (rs[2]) {\n tokens.push(sets.ints());\n\n } else if (rs[3]) {\n tokens.push(sets.whitespace());\n\n } else if (rs[4]) {\n tokens.push(sets.notWords());\n\n } else if (rs[5]) {\n tokens.push(sets.notInts());\n\n } else if (rs[6]) {\n tokens.push(sets.notWhitespace());\n\n } else if (rs[7]) {\n tokens.push({\n type: types.RANGE,\n from: (rs[8] || rs[9]).charCodeAt(0),\n to: rs[10].charCodeAt(0),\n });\n\n } else if ((c = rs[12])) {\n tokens.push({\n type: types.CHAR,\n value: c.charCodeAt(0),\n });\n\n } else {\n return [tokens, regexp.lastIndex];\n }\n }\n\n exports.error(regexpStr, 'Unterminated character class');\n};\n\n\n/**\n * Shortcut to throw errors.\n *\n * @param {String} regexp\n * @param {String} msg\n */\nexports.error = (regexp, msg) => {\n throw new SyntaxError('Invalid regular expression: /' + regexp + '/: ' + msg);\n};\n","// Simple default configuration for application, when none is provided\n\nmodule.exports = (\n{\n\t\"Product\": \"Unnamed_Service\",\n\t\"ProductVersion\": \"0.0.1\",\n\n\t\"ServicePort\": 8080\n});\n\n","/**\n* Default Service Server\n*/\nmodule.exports = require('./Orator-ServiceServer-IPC.js')","const libFableServiceProviderBase = require('fable-serviceproviderbase');\n\nclass OratorServiceServerBase extends libFableServiceProviderBase\n{\n\tconstructor(pFable, pOptions, pServiceHash)\n\t{\n super(pFable, pOptions, pServiceHash);\n\n this.serviceType = 'OratorServiceServer';\n\n\t\tthis.ServiceServerType = 'Base';\n\n\t\tthis.Name = this.fable.settings.Product;\n\t\tthis.URL = 'BASE_SERVICE_SERVER';\n\t\tthis.Port = this.options.ServicePort;\n\n\t\tthis.Active = false;\n\t}\n\n\t/*\n\t * Service Lifecycle Functions\n\t *************************************************************************/\n\tlisten(pPort, fCallback)\n\t{\n\t\t// Sometimes, listen does not listen on network calls.\n\t\tthis.Active = true;\n\n\t\treturn fCallback();\n\t}\n\n\tclose(fCallback)\n\t{\n\t\tthis.Active = false;\n\n\t\treturn fCallback();\n\t}\n\t/*************************************************************************\n\t * End of Service Lifecycle Functions\n\t */\n\n\t/*\n\t * Content parsing functions\n\t *************************************************************************/\n\tbodyParser(pOptions)\n\t{\n\t\treturn (pRequest, pResponse, fNext) => \n\t\t\t{\n\t\t\t\tfNext();\n\t\t\t};\n\t}\n\t/*************************************************************************\n\t * End of Service Lifecycle Functions\n\t */\n\n\t/*\n\t * Service Route Creation Functions\n\t *\n\t * These base functions provide basic validation for the routes, but don't actually \n\t * do anything with them. The design intent here is to allow derived classes to call\n\t * these functions to validate that they conform to expected standards.\n\t *\n\t * Something like:\n\n\t\tget (pRoute, ...fRouteProcessingFunctions)\n\t\t{\n\t\t\tif (!super.get(pRoute, ...fRouteProcessingFunctions))\n\t\t\t{\n\t\t\t\tthis.log.error(`Restify provider failed to map route [${pRoute}]!`);\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t//...now we can do our actual get mapping function!....\n\t\t}\n\n\t * This pattern and calling super is totally optional, obviously.\n\t *************************************************************************/\n\tuse(fHandlerFunction)\n\t{\n\t\tif (typeof(fHandlerFunction) != 'function')\n\t\t{\n\t\t\tthis.log.error(`Orator USE global handler mapping failed -- parameter was expected to be a function with prototype function(Request, Response, Next) but type was ${typeof(fHandlerFunction)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t}\n\n\tdoGet(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tget(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator GET Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doGet(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tgetWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.get(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoPut(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tput(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator PUT Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doPut(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tputWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.put(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoPost(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tpost(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator POST Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doPost(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tpostWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.post(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoDel(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tdel(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator DEL Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doDel(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tdelWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.del(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoPatch(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\tpatch(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator PATCH Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doPatch(pRoute, ...fRouteProcessingFunctions);\n\t}\n\tpatchWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.patch(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoOpts(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\topts(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator OPTS Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\t\treturn this.doOpts(pRoute, ...fRouteProcessingFunctions);\n\t}\n\toptsWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.opts(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\n\tdoHead(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn true;\n\t}\n\thead(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\tif (typeof(pRoute) != 'string')\n\t\t{\n\t\t\tthis.log.error(`Orator HEAD Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t}\n\theadWithBodyParser(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.head(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);\n\t}\n\t/*************************************************************************\n\t * End of Service Route Creation Functions\n\t */\n\n\t// Programmatically invoke a route\n\tinvoke(pMethod, pRoute, pData, fCallback)\n\t{\n\t\t// The base class version of this does nothing\n\t\tthis.log.debug(`Orator invoke called for route [${pRoute}] and landed on the base class; the service provider likely does not implement programmatic invoke capabilities.`, pData);\n\t\treturn false;\n\t}\n}\n\nmodule.exports = OratorServiceServerBase;","class OratorServiceServerIPCSynthesizedResponse\n{\n\tconstructor(pHandler, pLog, pRequestGUID)\n\t{\n\t\tthis.log = pLog;\n\n\t\tif (pHandler.hasOwnProperty('params'))\n\t\t{\n\t\t\tthis.params = pHandler.params;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.params = {};\n\t\t}\n\t\tif (pHandler.hasOwnProperty('searchParams'))\n\t\t{\n\t\t\tthis.searchParams = pHandler.searchParams;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.searchParams = {};\n\t\t}\n\n\t\tthis.requestGUID = pRequestGUID;\n\n\t\tthis.responseData = null;\n\t\tthis.responseStatus = -1;\n\t}\n\n\tsend(pData)\n\t{\n\t\tif (typeof(pData) == 'string')\n\t\t{\n\t\t\t// This is a string! Append it to the responsedata.\n\t\t\tif (this.responseData === null)\n\t\t\t{\n\t\t\t\tthis.responseData = pData;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse if (typeof(this.responseData) == 'string')\n\t\t\t{\n\t\t\t\tthis.responseData = this.responseData+pData;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tthis.log(`Request ${this.requestGUID} has tried to send() a string value after send()ing data type ${typeof(this.responseData)}.`, pData)\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\telse if (typeof(pData) == 'object')\n\t\t{\n\t\t\tif (this.responseData === null)\n\t\t\t{\n\t\t\t\tthis.responseData = JSON.stringify(pData);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse if (typeof(this.responseData) == 'string')\n\t\t\t{\n\t\t\t\t// TODO: Discuss best way to handle this / if to handle this\n\t\t\t\tthis.responseData += this.responseData+JSON.stringify(pData);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tthis.log(`Request ${this.requestGUID} has tried to send() an object value to be auto stringified after send()ing data type ${typeof(this.responseData)}.`, pData)\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t}\n}\n\nmodule.exports = OratorServiceServerIPCSynthesizedResponse;","const libOratorServiceServerBase = require('./Orator-ServiceServer-Base.js');\n\n// A synthesized response object, for simple IPC.\nconst libOratorServiceServerIPCSynthesizedResponse = require('./Orator-ServiceServer-IPC-SynthesizedResponse.js');\n// A simple constrainer for the find-my-way router since we aren't using any kind of headers to pass version or host\n//const libOratorServiceServerIPCCustomConstrainer = require('./Orator-ServiceServer-IPC-RouterConstrainer.js');\n\n// This library is the default router for our services\nconst libFindMyWay = require('find-my-way');\n\nclass OratorServiceServerIPC extends libOratorServiceServerBase\n{\n\tconstructor(pFable, pOptions, pServiceHash)\n\t{\n super(pFable, pOptions, pServiceHash);\n\n\t\tthis.router = libFindMyWay(this.options);\n\t\t//this.router.addConstraintStrategy(libOratorServiceServerIPCCustomConstrainer);\n\n\t\tthis.ServiceServerType = 'IPC';\n\n\t\tthis.URL = 'IPC';\n\t\tthis.Port = 0;\n\n\t\tthis.preBehaviorFunctions = [];\n\t\tthis.behaviorMap = {};\n\t\tthis.postBehaviorFunctions = [];\n\t}\n\n\tuse(fHandlerFunction)\n\t{\n\t\treturn this.addPreBehaviorFunction(fHandlerFunction);\n\t}\n\n\taddPreBehaviorFunction(fHandlerFunction)\n\t{\n\t\tif (!super.use(fHandlerFunction))\n\t\t{\n\t\t\tthis.log.error(`IPC provider failed to map USE handler function!`);\n\t\t\treturn false;\n\t\t}\n\n\t\tthis.preBehaviorFunctions.push(fHandlerFunction);\n\t\treturn true;\n\t}\n\n\texecutePreBehaviorFunctions(pRequest, pResponse, fNext)\n\t{\n\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\tfor (let i = 0; i < this.preBehaviorFunctions.length; i++)\n\t\t{\n\t\t\tlet tmpPreBehaviorFunction = this.preBehaviorFunctions[i];\n\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t(fStageComplete) =>\n\t\t\t\t{\n\t\t\t\t\treturn tmpPreBehaviorFunction(pRequest, pResponse, fStageComplete);\n\t\t\t\t});\n\t\t}\n\n\t\ttmpAnticipate.wait(\n\t\t\t(pError) =>\n\t\t\t{\n\t\t\t\tif (pError)\n\t\t\t\t{\n\t\t\t\t\tthis.log.error(`IPC Provider preBehaviorFunction ${pFunctionIndex} failed with error: ${pError}`, pError);\n\t\t\t\t}\n\t\t\t\treturn fNext(pError);\n\t\t\t});\n\t}\n\n\taddPostBehaviorFunction(fHandlerFunction)\n\t{\n\t\tif (!super.use(fHandlerFunction))\n\t\t{\n\t\t\tthis.log.error(`IPC provider failed to map USE handler function!`);\n\t\t\treturn false;\n\t\t}\n\n\t\tthis.postBehaviorFunctions.push(fHandlerFunction);\n\t\treturn true;\n\t}\n\n\texecutePostBehaviorFunctions(pRequest, pResponse, fNext)\n\t{\n\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\tfor (let i = 0; i < this.postBehaviorFunctions.length; i++)\n\t\t{\n\t\t\tlet tmpPostBehaviorFunction = this.postBehaviorFunctions[i];\n\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t(fStageComplete) =>\n\t\t\t\t{\n\t\t\t\t\treturn tmpPostBehaviorFunction(pRequest, pResponse, fStageComplete);\n\t\t\t\t});\n\t\t}\n\n\t\ttmpAnticipate.wait(\n\t\t\t(pError) =>\n\t\t\t{\n\t\t\t\tif (pError)\n\t\t\t\t{\n\t\t\t\t\tthis.log.error(`IPC Provider postBehaviorFunction ${pFunctionIndex} failed with error: ${pError}`, pError);\n\t\t\t\t}\n\t\t\t\treturn fNext(pError);\n\t\t\t});\n\t}\n\n\t/*\n\t * Service Route Creation Functions\n\t *\n\t * These base functions provide basic validation for the routes, but don't actually \n\t * do anything with them. The design intent here is to allow derived classes to call\n\t * these functions to validate that they conform to expected standards.\n\t *\n\t * Something like:\n\n\t\tget (pRoute, ...fRouteProcessingFunctions)\n\t\t{\n\t\t\t//...now we can do our actual get mapping function!....\n\t\t}\n\n\t * This pattern and calling super is totally optional, obviously.\n\t *************************************************************************/\n\taddRouteProcessor(pMethod, pRoute, pRouteFunctionArray)\n\t{\n\t\t// We have a constrainer on IPC so we can control channels eventually, if we like.\n\t\t// For now it just makes sure it was added with an IPC service server.\n\t\tthis.router.on(pMethod, pRoute, this.buildFindMyWayHandler(pRouteFunctionArray));\n\t\treturn true;\n\t}\n\n\tbuildFindMyWayHandler(pRouteFunctionArray)\n\t{\n\t\tlet tmpRouteFunctionArray = pRouteFunctionArray;\n\t\treturn (\n\t\t\t(pRequest, pResponse, pData) =>\n\t\t\t{\n\t\t\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t\t(fNext)=>\n\t\t\t\t\t{\n\t\t\t\t\t\treturn this.executePreBehaviorFunctions(pRequest, pResponse, fNext);\n\t\t\t\t\t});\n\n\t\t\t\tfor (let i = 0; i < tmpRouteFunctionArray.length; i++)\n\t\t\t\t{\n\t\t\t\t\tlet tmpRouteFunction = tmpRouteFunctionArray[i];\n\t\t\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t\t\t(fNext) =>\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\treturn tmpRouteFunction(pRequest, pResponse, fNext);\n\t\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\ttmpAnticipate.anticipate(\n\t\t\t\t\t(fStageComplete)=>\n\t\t\t\t\t{\n\t\t\t\t\t\treturn this.executePostBehaviorFunctions(pRequest, pResponse, fStageComplete);\n\t\t\t\t\t});\n\n\t\t\t\treturn new Promise(\n\t\t\t\t\t(fResolve, fReject) =>\n\t\t\t\t\t{\n\t\t\t\t\t\ttmpAnticipate.wait(\n\t\t\t\t\t\t\t(pBehaviorFunctionError) =>\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tif (pBehaviorFunctionError)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tthis.log.error(`IPC Provider behavior function ${pFunctionIndex} failed with error: ${pBehaviorFunctionError}`, pBehaviorFunctionError);\n\t\t\t\t\t\t\t\t\treturn fReject(pBehaviorFunctionError);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\treturn fResolve();\n\t\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t});\n\t}\n\n\t// This is the virtualized \"body parser\"\n\tbodyParser()\n\t{\n\t\treturn (pRequest, pResponse, fNext) =>\n\t\t{\n\t\t\treturn fNext();\n\t\t};\n\t}\n\n\tdoGet(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('GET', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoPut(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('PUT', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoPost(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('POST', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoDel(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('DELETE', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoPatch(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('PATCH', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoOpts(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('OPTIONS', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\n\tdoHead(pRoute, ...fRouteProcessingFunctions)\n\t{\n\t\treturn this.addRouteProcessor('HEAD', pRoute, Array.from(fRouteProcessingFunctions));\n\t}\n\t/*************************************************************************\n\t * End of Service Route Creation Functions\n\t */\n\n\t// Programmatically invoke a route\n\tinvoke(pMethod, pRoute, pData, fCallback)\n\t{\n\t\t// If the data is skipped and a callback is parameter 3, do the right thing\n\t\tlet tmpCallback = (typeof(fCallback) == 'function') ? fCallback :\n\t\t\t\t\t\t\t(typeof(pData) == 'function') ? pData :\n\t\t\t\t\t\t\tfalse;\n\n\t\tif (!tmpCallback)\n\t\t{\n\t\t\tthrow new Error(`IPC Provider invoke() called without a callback function.`);\n\t\t}\n\n\t\t// Create a bare minimum request object for IPC to pass to our router\n\t\tlet tmpRequest = (\n\t\t\t{\n\t\t\t\tmethod: pMethod,\n\t\t\t\turl: pRoute,\n\t\t\t\tguid: this.fable.getUUID()\n\t\t\t});\n\n\t\t// For now, dealing with no handler constraints.\n\t\tlet tmpHandler = this.router.find( tmpRequest.method, tmpRequest.url);\n\n\t\t// Create a container for the IPC response data to be aggregated to from send() methodds\n\t\tlet tmpSynthesizedResponseData = new libOratorServiceServerIPCSynthesizedResponse(tmpHandler, this.log, tmpRequest.guid);\n\n\t\t// Map parsed params back to the request object\n\t\ttmpRequest.params = tmpSynthesizedResponseData.params;\n\t\ttmpRequest.searchParams = tmpSynthesizedResponseData.searchParams;\n\n\t\t//params: handle._createParamsObject(params)//,\n //searchParams: this.querystringParser(querystring)\n\n\t\ttmpHandler.handler(tmpRequest, tmpSynthesizedResponseData, pData).then(\n\t\t\t(pResults)=>\n\t\t\t{\n\t\t\t\treturn tmpCallback(null, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData, pResults);\n\t\t\t},\n\t\t\t(pError)=>\n\t\t\t{\n\t\t\t\tthis.log.trace('IPC Response Received', {Error: pError});\n\t\t\t\tif (pError)\n\t\t\t\t{\n\t\t\t\t\tthis.log.error(`IPC Request Error Request GUID [${tmpRequest.guid}] handling route [${pRoute}]: ${pError}`, {Error: pError, Route: pRoute, Data: pData});\n\t\t\t\t}\n\t\t\t\treturn tmpCallback(pError, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData);\n\t\t\t}\n\t\t);\n\t}\n}\n\nmodule.exports = OratorServiceServerIPC;","/**\n* Orator Service Abstraction\n*\n* @license MIT\n*\n* @author Steven Velozo <steven@velozo.com>\n* @module Orator Service\n*/\n\nconst libFableServiceProviderBase = require('fable-serviceproviderbase');\n\nconst libDefaultOratorServiceServer = require('./Orator-Default-ServiceServer.js');\n\nconst defaultOratorConfiguration = require('./Orator-Default-Configuration.js');\n\nclass Orator extends libFableServiceProviderBase\n{\n\tconstructor(pFable, pOptions, pServiceHash)\n\t{\n super(pFable, pOptions, pServiceHash);\n\n this.serviceType = 'Orator';\n\n\t\t// Create the empty, important logic containers\n\t\tthis.serviceServer = false;\n\t\tthis.serviceServerProvider = false;\n\n\t\tif (typeof(pServiceProvider) !== 'undefined')\n\t\t{\n\t\t\tthis.serviceServerProvider = pServiceProvider;\n\t\t}\n\n\t\t// Now check to see that the ServicePort is set (this used to be APIServerPort)\n\t\tif (!this.options.hasOwnProperty('ServicePort'))\n\t\t{\n\t\t\tif (this.fable.settings.hasOwnProperty('APIServerPort'))\n\t\t\t{\n\t\t\t\t// Automatically migrate the legacy APIServerPort to ServicePort\n\t\t\t\tthis.options.ServicePort = this.fable.settings.APIServerPort;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// Default to whatever the ... default is!\n\t\t\t\tthis.options.ServicePort = defaultOratorConfiguration.ServicePort;\n\t\t\t}\n\t\t}\n\n\t\t// Now check to see that the Product name is set\n\t\tif (!this.options.hasOwnProperty('Product'))\n\t\t{\n\t\t\tthis.options.Product = defaultOratorConfiguration.Product;\n\t\t}\n\t}\n\n\tonBeforeInitialize()\n\t{\n\t\tif (this.fable.settings.LogNoisiness > 3)\n\t\t{\n\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onBeforeInitialize:`);\n\t\t}\n\t}\n\tonBeforeInitializeAsync(fNext)\n\t{\n\t\tthis.onBeforeInitialize();\n\t\t// Check to see if there is a service server active; if not instantiate one (and use IPC if none is registered with Fable as the default provider)\n\t\tif (!this.serviceServer)\n\t\t{\n\t\t\t// If the developer hasn't set this to a service provider class of their own choosing, \n\t\t\t// TODO: Give the developer a chance to set a service provider instantiation address of their own choosing.\n\t\t\t// use the built-in network-less one.\n\t\t\tif (!this.fable.OratorServiceServer)\n\t\t\t{\n\t\t\t\t// If there isn't a default Service Server setup, create one.\n\t\t\t\tlet tmpServiceServerOptions = (typeof(this.options.ServiceServerOptions) == 'undefined') ? {} : this.options.ServiceServerOptions;\n\t\t\t\tif (!this.fable.serviceManager.servicesMap.hasOwnProperty('OratorServiceServer'))\n\t\t\t\t{\n\t\t\t\t\t// Only register IPC if there isn't one yet.\n\t\t\t\t\tthis.fable.serviceManager.addServiceType('OratorServiceServer', libDefaultOratorServiceServer);\n\t\t\t\t}\n\t\t\t\tthis.fable.serviceManager.instantiateServiceProvider('OratorServiceServer', tmpServiceServerOptions, 'OratorServiceServer-AutoInit');\n\t\t\t}\n\t\t\tthis.serviceServer = this.fable.OratorServiceServer;\n\t\t\t// For legacy reasons, we also will provide this under the \"webServer\" variable.\n\t\t\tthis.webServer = this.serviceServer;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.log.warn(`Orator attempting to initialize a service server after initialization has already completed.`)\n\t\t}\n\t\tfNext();\n\t}\n\n\tonInitialize()\n\t{\n\t\tif (this.fable.settings.LogNoisiness > 3)\n\t\t{\n\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onInitialize:`);\n\t\t}\n\t}\n\tonInitializeAsync(fNext)\n\t{\n\t\tthis.onInitialize();\n\t\treturn fNext();\n\t}\n\n\tonAfterInitialize()\n\t{\n\t\tif (this.fable.settings.LogNoisiness > 3)\n\t\t{\n\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onAfterInitialize:`);\n\t\t}\n\t}\n\tonAfterInitializeAsync(fNext)\n\t{\n\t\tthis.onAfterInitialize();\n\t\treturn fNext();\n\t}\n\n\tinitialize(fCallback)\n\t{\n\t\t// I hate this -- is there a reason to not require a callback?\n\t\tlet tmpCallback = (typeof(fCallback) === 'function') ? fCallback : () => {};\n\n\t\tif (!this.initializeTimestamp)\n\t\t{\n\t\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\t\tif (this.fable.LogNoisiness > 3)\n\t\t\t{\n\t\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} beginning initialization steps...`);\n\t\t\t}\n\n\t\t\ttmpAnticipate.anticipate(this.onBeforeInitializeAsync.bind(this));\n\t\t\ttmpAnticipate.anticipate(this.onInitializeAsync.bind(this));\n\t\t\ttmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));\n\n\t\t\ttmpAnticipate.wait(\n\t\t\t\t(pError) =>\n\t\t\t\t{\n\t\t\t\t\tthis.initializeTimestamp = this.fable.log.getTimeStamp();\n\t\t\t\t\tif (this.fable.LogNoisiness > 2)\n\t\t\t\t\t{\n\t\t\t\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} initialization steps complete.`);\n\t\t\t\t\t}\n\t\t\t\t\treturn tmpCallback(pError);\n\t\t\t\t});\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.log.warn(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} async initialize called but initialization is already completed. Aborting.`);\n\t\t\t// TODO: Should this be returning an error?\n\t\t\treturn tmpCallback();\n\t\t}\n\t}\n\n\tonBeforeStartService(fNext)\n\t{\n\t\treturn fNext();\n\t}\n\tonStartService(fNext)\n\t{\n\t\tthis.onAfterInitialize();\n\t\treturn this.serviceServer.listen\n\t\t(\n\t\t\tthis.options.ServicePort,\n\t\t\t(pError)\t=>\n\t\t\t{\n\t\t\t\tthis.log.info(`${this.serviceServer.Name} listening at ${this.serviceServer.URL} port ${this.serviceServer.Port}`);\n\t\t\t\treturn fNext(pError);\n\t\t\t}\n\t\t);\n\t}\n\tonAfterStartService(fNext)\n\t{\n\t\treturn fNext();\n\t}\n\n\tstartService(fNext)\n\t{\n\t\tvar tmpNext = (typeof(fNext) === 'function') ? fNext : ()=>{};\n\n\t\tlet tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');\n\n\t\tif (this.fable.LogNoisiness > 3)\n\t\t{\n\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} beginning startService steps...`);\n\t\t}\n\n\t\t// Auto initialize if there is no serviceServer\n\t\tif (!this.serviceServer)\n\t\t{\n\t\t\ttmpAnticipate.anticipate(this.initialize.bind(this));\n\t\t}\n\n\t\ttmpAnticipate.anticipate(this.onBeforeStartService.bind(this));\n\t\ttmpAnticipate.anticipate(this.onStartService.bind(this));\n\t\ttmpAnticipate.anticipate(this.onAfterStartService.bind(this));\n\n\t\ttmpAnticipate.wait(\n\t\t\t(pError) =>\n\t\t\t{\n\t\t\t\tthis.startServiceTimestamp = this.fable.log.getTimeStamp();\n\t\t\t\tif (this.fable.LogNoisiness > 2)\n\t\t\t\t{\n\t\t\t\t\tthis.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} startService steps complete.`);\n\t\t\t\t}\n\t\t\t\treturn tmpNext(pError);\n\t\t\t});\n\t}\n\n\tstopService(fCallback)\n\t{\n\t\tvar tmpCallback = (typeof(fCallback) === 'function') ? fCallback : ()=>{};\n\n\t\tif (!this.serviceServer)\n\t\t{\n\t\t\tlet tmpMessage = `Orator attempting to stop a service server but the service server has not been intialized yet.`;\n\t\t\tthis.log.warn(tmpMessage);\n\t\t\treturn tmpCallback(tmpMessage);\n\t\t}\n\n\t\tif (!this.serviceServer.Active)\n\t\t{\n\t\t\tlet tmpMessage = `Orator attempting to stop a service server but the service server is not actively running.`;\n\t\t\tthis.log.warn(tmpMessage);\n\t\t\treturn tmpCallback(tmpMessage);\n\t\t}\n\n\t\treturn this.serviceServer.close(tmpCallback);\n\t}\n\n\tinvoke(pMethod, pRoute, pData, fCallback)\n\t{\n\t\t//this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} invoking ${pMethod} ${pRoute}`);\n\t\treturn this.serviceServer.invoke(pMethod, pRoute, pData, fCallback);\n\t}\n\n\n\t/*\n\t * Legacy Orator Functions\n\t *************************************************************************/\n\tstartWebServer(fNext)\n\t{\n\t\treturn this.startService(fNext);\n\t}\n\n\t// For legacy purposes\n\tstopWebServer(fNext)\n\t{\n\t\treturn this.stopService(fNext);\n\t}\n\n\t// For legacy purposes\n\tgetWebServer()\n\t{\n\t\t// The old behavior was to lazily construct the service the first time \n\t\t// this accessor function is called.\n\t\tif (!this.serviceServer)\n\t\t{\n\t\t\tthis.initializeServiceServer();\n\t\t}\n\n\t\treturn this.serviceServer;\n\t}\n\t/*************************************************************************\n\t * End of Legacy Orator Functions\n\t */\n}\n\nmodule.exports = Orator;\nmodule.exports.ServiceServerBase = require('./Orator-ServiceServer-Base.js');\nmodule.exports.ServiceServerIPC = require('./Orator-ServiceServer-IPC.js');\n"]}