X-Git-Url: https://juplo.de/gitweb/?a=blobdiff_plain;f=dist%2Fjs%2Fthymol-full.js;fp=dist%2Fjs%2Fthymol-full.js;h=137fcc3fe416d340de60b2e5d6f8880ea40c8817;hb=c694fb8287be7fdb367a607e880744eacc9b50de;hp=0000000000000000000000000000000000000000;hpb=59ae699ea75807a3374c0f88dd397743cc20b5b3;p=website diff --git a/dist/js/thymol-full.js b/dist/js/thymol-full.js new file mode 100644 index 00000000..137fcc3f --- /dev/null +++ b/dist/js/thymol-full.js @@ -0,0 +1,8305 @@ +/*-------------------- Thymol - the flavour of Thymeleaf --------------------* + + Thymol version 2.0.0 Copyright (C) 2012-2015 James J. Benson + jjbenson .AT. users.sf.net (http://www.thymoljs.org/) + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" basis, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either expressed or implied. + See the License for the specific language governing permissions and + limitations under the License. + + *---------------------------------------------------------------------------*/ + +thymol = function() { + thymol.thVersion = "2.0.0"; + thymol.thReleaseDate = "2015-03-31"; + thymol.thURL = "http://www.thymoljs.org"; + thymol.thAltURL = "http://www.thymeleaf.org"; + thymol.thUsingNullPrefix = false; + thymol.thThymeleafPrefixList = []; + thymol.thThymeleafElementsList = []; + thymol.objects = {}; + var textFuncSynonym = "~~~~", varRefExpr = /([$#]{.*?})/, literalTokenExpr = /^[a-zA-Z0-9\[\]\.\-_]*$/, startParserLevelCommentExpr = /^\s*\/\*\s*$/, endParserLevelCommentExpr = /^\s*\*\/\s*$/, startParserLevelCommentExpr2 = /^\/\*[^\/].*/, endParserLevelCommentExpr2 = /.*[^\/]\*\/$/, prototypeOnlyCommentEscpExpr = /\/\*\/(.*)\/\*\//, varExpr3 = /[\$\*#@]{1}\{(.*)\}$/, nonURLExpr = /[\$\*#]{1}\{(?:!?[^}]*)\}/, numericExpr = /^[+\-]?[0-9]*?[.]?[0-9]*?$/, varParExpr = /([^(]*)\s*[(]([^)]*?)[)]/, domSelectExpr = /([\/]{1,2})?([A-Za-z0-9_\-]*(?:[\(][\)])?)?([^\[]\S[A-Za-z0-9_\-]*(?:[\(][\)])?[\/]*(?:[\.\/#]?[^\[]\S[A-Za-z0-9_\-]*(?:[\(][\)])?[\/]*)*)?([\[][^\]]*?[\]])?/, litSubstExpr = /\.*?([\|][^\|]*?[\|])\.*?/; + function Thymol() {} + function isClientSide() { + if (typeof thymol.isServerSide !== "undefined" && !!thymol.isServerSide()) { + thymol.isClientSide = function() { + return false; + }; + return false; + } + thymol.isClientSide = function() { + return true; + }; + return true; + } + function execute(doc) { + if (typeof thymol.protocol === "undefined") { + thymol.protocol = ""; + } + if (typeof thymol.root === "undefined") { + thymol.root = ""; + } + if (typeof thymol.path === "undefined") { + thymol.path = ""; + } + thymol.thDocument = doc; + var theWindow = thymol.thWindow; + if (typeof thymol.thWindow === "undefined") { + if (typeof doc.defaultView !== "undefined") { + theWindow = doc.defaultView; + } else if (typeof doc.parentWindow !== "undefined") { + theWindow = doc.parentWindow; + } + } + thymol.thWindow = theWindow; + var theTop = thymol.thTop; + if (typeof thymol.thTop === "undefined") { + if (typeof top !== "undefined") { + theTop = top; + } + } + thymol.thTop = theTop; + thymol.init(); + var base = new ThNode(thymol.thDocument, false, null, null, null, thymol.thDocument.nodeName, "::", false, thymol.thDocument); + Thymol.prototype.process(base); + postExecute(); + return thymol.thDocument; + } + function jqSetup(jq) { + jq.fn.extend({ + getComments: function() { + return this.filter(function() { + return this.nodeType === 8; + }); + }, + getThDecorated: function(thInst) { + var i, iAttrName, iLength, j, jLength, instances = [], result = null, expanded = false; + if (thInst.escpName !== null) { + instances = this.filter(thInst.escpName); + } + if (thInst.escpSynonym !== null) { + instances = instances.add(this.filter(thInst.escpSynonym)); + } + for (i = 0, iLength = instances.length; i < iLength; i++) { + if (instances[i]) { + for (j = 0, jLength = instances[i].attributes.length; j < jLength; j++) { + if (instances[i].attributes[j]) { + iAttrName = instances[i].attributes[j].name; + if (iAttrName && (thInst.name == iAttrName || thInst.synonym == iAttrName)) { + expanded = thymol.ThUtils.processElement(thInst.process, instances[i], instances[i].attributes[j], thInst); + if (expanded) { + if (result === null) { + result = []; + } + result.push(instances[i]); + } + } + } + } + } + } + return result; + } + }); + } + function ready(func) { + if (typeof thymolDeferredFunctions === "undefined" || thymolDeferredFunctions === null) { + thymolDeferredFunctions = []; + } + thymolDeferredFunctions.push(func); + } + function setupEnv() { + thymol.prefix = Thymol.prototype.getThParam("thPrefix", false, false, thymol.thDefaultPrefix); + thymol.dataPrefix = Thymol.prototype.getThParam("thDataPrefix", false, false, thymol.thDefaultDataPrefix); + thymol.messagePath = Thymol.prototype.getThParam("thMessagePath", false, true, thymol.thDefaultMessagePath); + thymol.resourcePath = Thymol.prototype.getThParam("thResourcePath", false, true, thymol.thDefaultResourcePath); + thymol.messagesBaseName = Thymol.prototype.getThParam("thMessagesBaseName", false, false, thymol.thDefaultMessagesBaseName); + thymol.relativeRootPath = Thymol.prototype.getThParam("thRelativeRootPath", false, true, thymol.thDefaultRelativeRootPath); + thymol.extendedMapping = Thymol.prototype.getThParam("thExtendedMapping", true, false, thymol.thDefaultExtendedMapping); + thymol.localMessages = Thymol.prototype.getThParam("thLocalMessages", true, false, thymol.thDefaultLocalMessages); + thymol.disableMessages = Thymol.prototype.getThParam("thDisableMessages", true, false, thymol.thDefaultDisableMessages); + thymol.templateSuffix = Thymol.prototype.getThParam("thTemplateSuffix", false, false, thymol.thDefaultTemplateSuffix); + thymol.scriptPath = ""; + if (typeof thymol.thScriptPath !== "undefined") { + thymol.scriptPath = Thymol.prototype.getThParam("thScriptPath", false, true, thymol.thScriptPath); + } + thymol.absolutePath = ""; + if (typeof thymol.thAbsolutePath !== "undefined") { + thymol.absolutePath = Thymol.prototype.getThParam("thAbsolutePath", false, true, thymol.thAbsolutePath); + } + thymol.useAbsolutePath = false; + if (typeof thymol.thUseAbsolutePath !== "undefined") { + thymol.useAbsolutePath = Thymol.prototype.getThParam("thUseAbsolutePath", true, false, thymol.thUseAbsolutePath); + } + thymol.useFullURLPath = true; + if (typeof thymol.thUseFullURLPath !== "undefined") { + thymol.useFullURLPath = Thymol.prototype.getThParam("thUseFullURLPath", true, false, thymol.thUseFullURLPath); + } + thymol.indexFile = Thymol.prototype.getThParam("thIndexFile", false, false, null); + thymol.debug = Thymol.prototype.getThParam("thDebug", true, false, false); + thymol.allowNullText = Thymol.prototype.getThParam("thAllowNullText", true, false, true); + thymol.location = thymol.thLocation; + if ("" !== thymol.relativeRootPath) { + thymol.root = thymol.location + thymol.relativeRootPath; + thymol.messagePath = thymol.root + thymol.messagePath; + } else { + if (typeof thymol.thMessagePath !== "undefined") { + thymol.messagePath = Thymol.prototype.getThParam("thMessagePath", false, true, thymol.thMessagePath); + } + if (typeof thymol.thRoot !== "undefined") { + thymol.root = Thymol.prototype.getThParam("thRoot", false, true, thymol.thRoot); + } + } + thymol.root = Thymol.prototype.getThParam("thRoot", false, true, thymol.root); + if (typeof thymol.thPath !== "undefined") { + thymol.path = Thymol.prototype.getThParam("thPath", false, true, thymol.thPath); + } + thymol.path = Thymol.prototype.getThParam("thPath", false, true, thymol.path); + thymol.protocol = thymol.thDocument.location.protocol; + if ("" == thymol.protocol) { + thymol.protocol = thymol.thDefaultProtocol; + } else { + thymol.protocol += "//"; + if ("" == thymol.thDocument.location.host) { + thymol.protocol += "/"; + } + } + thymol.protocol = Thymol.prototype.getThParam("thProtocol", false, false, thymol.protocol); + thymol.resourcePath = Thymol.prototype.getThParam("thResourcePath", false, true, thymol.resourcePath); + } + function updatePrefix(pref) { + thymol.prefix = pref; + thymol.thThymeleafPrefixList = []; + thymol.thThymeleafElementsList = []; + } + function init() { + this.messages = null; + this.mappings = null; + this.debug = null; + getLocations(this); + this.locale = new thymol.ThObject(); + getLanguage(); + var accessor = undefined, i, iLimit, j, jLimit; + if (typeof thVars !== "undefined") { + accessor = new thymol.ThVarsAccessor(thVars, "thVars"); + } + this.applicationContext = thymol.makeContext("application", accessor); + this.sessionContext = thymol.makeContext("session", undefined); + this.sessionContext.persist = function() { + var save = this.serialise(); + thymol.thTop.name = save; + }; + this.requestContext = thymol.makeContext("request", undefined); + this.booleanAndNullTokens = new Array(); + this.booleanAndNullTokens["null"] = this.applicationContext.createVariable("null", null); + this.booleanAndNullTokens["true"] = this.applicationContext.createVariable("true", true); + this.booleanAndNullTokens["false"] = this.applicationContext.createVariable("false", false); + this.allowNullText = null; + setupEnv(); + this.thCache = {}; + this.thExpressionObjects; + this.thDeferredFunctions; + this.thPreExecutionFunctions; + this.thPostExecutionFunctions; + if (typeof this.thExpressionObjects === "undefined" || this.thExpressionObjects === null) { + this.thExpressionObjects = {}; + } + this.thExpressionObjects["#object"] = {}; + this.thExpressionObjects["#locale"] = {}; + this.thExpressionObjects["#ctx"] = []; + this.thExpressionObjects["#ctx"]["variables"] = {}; + thymol.configureModule(thymol.objects.thHttpServletRequestObject); + thymol.configureModule(thymol.objects.thHttpSessionObject); + if (typeof thymol.thObjectsConfigureModules !== "undefined") { + thymol.thObjectsConfigureModules(); + } + var scripts = thymol.thDocument.getElementsByTagName("script"); + for (var i = 0, iLimit = scripts.length; i < iLimit; i++) { + var parameters = scripts[i].getAttribute("data-thymol-load"); + if (!!parameters) { + var splits = parameters.split(","); + for (var j = 0, jLimit = splits.length; j < jLimit; j++) { + thymol.ThUtils.loadScript(splits[j]); + } + } + } + setupEnv(); + if (typeof thymol.thPreExecutionFunctions === "undefined" || thymol.thPreExecutionFunctions === null) { + thymol.thPreExecutionFunctions = []; + } + if (typeof thymol.thPostExecutionFunctions === "undefined" || thymol.thPostExecutionFunctions === null) { + thymol.thPostExecutionFunctions = []; + } + $.ajaxSetup({ + async: false, + isLocal: true, + dataType: "text" + }); + if (!(typeof thVars === "undefined")) { + for (i = 0, iLimit = thVars.length; i < iLimit; i++) { + this.applicationContext.createVariable(thVars[i][0], thVars[i][1]); + } + } + executeDeferred(); + (function() { + var htmlTagAttrs = $("html")[0].attributes, tp = null, tu, nsspec; + $([ thymol.thURL, thymol.thAltURL ]).each(function() { + tu = this; + $(htmlTagAttrs).each(function() { + if (this.value == tu) { + nsspec = this.localName.split(":"); + if (nsspec.length > 0) { + tp = nsspec[nsspec.length - 1]; + return false; + } + } + }); + if (tp) { + thymol.updatePrefix(tp); + return false; + } + }); + })(); + var defaultScriptUrl = ""; + if (!!thymol.thRequest) { + thymol.thWindow.location.search = thymol.thRequest; + } + (function(app, req) { + var e, f, a = /\+/g, r = /([^&=]+)=?([^&]*)/g, d = function(s) { + return decodeURIComponent(s.replace(a, " ")); + }, q = thymol.thWindow.location.search.substring(1), surl, scriptUrl = defaultScriptUrl; + $("script").each(function() { + surl = this.src; + if (surl.indexOf(thymol.thScriptName) >= 0) { + scriptUrl = d(surl); + return false; + } + }); + while (e = r.exec(scriptUrl)) { + f = e[1].split("?"); + switch (f[1]) { + case "thPrefix": + thymol.prefix = e[2]; + break; + + case "thDataPrefix": + thymol.dataPrefix = e[2]; + break; + + case "thMessagePath": + thymol.messagePath = e[2]; + break; + + case "thResourcePath": + thymol.resourcePath = e[2]; + break; + + case "thMessagesBaseName": + thymol.messagesBaseName = e[2]; + break; + + case "thRelativeRootPath": + thymol.relativeRootPath = e[2]; + break; + + case "thExtendedMapping": + thymol.extendedMapping = e[2]; + break; + + case "thTemplateSuffix": + thymol.templateSuffix = e[2]; + break; + + case "thLocalMessages": + thymol.localMessages = e[2]; + break; + + case "thDisableMessages": + thymol.disableMessages = e[2]; + break; + + case "thIndexFile": + thymol.indexFile = e[2]; + break; + + case "thProtocol": + thymol.protocol = e[2]; + break; + + case "thDebug": + thymol.debug = e[2]; + break; + + case "thRoot": + thymol.root = e[2]; + break; + + case "thPath": + thymol.path = e[2]; + break; + + case "thAllowNullText": + thymol.allowNullText = e[2]; + break; + + case "thLocale": + thymol.locale.value = e[2]; + break; + + case "thDefaultPrecision": + thymol.thDefaultPrecision = e[2]; + break; + + case "thDefaultPrecedence": + thymol.thDefaultPrecedence = e[2]; + break; + + default: + app.createVariable(e[1], e[2]); + } + } + while (e = r.exec(q)) { + req.createVariable(d(e[1]), e[2], true); + } + })(this.applicationContext, this.requestContext); + thymol.thInclude = new thymol.ThAttr("include", null, 100, null, thymol.prefix); + thymol.thReplace = new thymol.ThAttr("replace", null, 100, null, thymol.prefix); + thymol.thSubstituteby = new thymol.ThAttr("substituteby", null, 100, null, thymol.prefix); + thymol.thFragment = new thymol.ThAttr("fragment", null, 2e4, null, thymol.prefix); + thymol.thRemove = null; + thymol.thBlock = new thymol.ThElement("block", function(element) { + var i, limit = element.childNodes.length; + for (i = 0; i < limit; i++) { + if (element.childNodes[i].nodeType === 1) { + element.childNodes[i].isBlockChild = true; + } + } + }, thymol.prefix); + this.applicationContext.resolveJSONReferences(); + thymol.setupAttrList(); + preExecute(this.applicationContext); + this.thExpressionObjects["#vars"] = this.applicationContext; + this.thExpressionObjects["#root"] = this.applicationContext; + this.sessionContext.init(); + this.sessionContext.resolveJSONReferences(); + this.requestContext.resolveJSONReferences(); + this.thExpressionObjects["#ctx"]["variables"] = this.applicationContext; + this.thExpressionObjects["#ctx"]["requestParameters"] = this.requestContext; + this.thExpressionObjects["#ctx"]["servletContext"] = this.applicationContext; + this.thExpressionObjects["#ctx"]["httpServletRequest"] = this.thExpressionObjects["#httpServletRequest"]; + this.thExpressionObjects["#ctx"]["httpSession"] = this.thExpressionObjects["#httpSession"]; + this.protocol = Thymol.prototype.override("thProtocol", this.protocol); + this.debug = Thymol.prototype.override("thDebug", this.debug); + this.root = Thymol.prototype.override("thRoot", this.root); + if ("" !== this.relativeRootPath) { + var rootURI = thymol.thDocument.location.href; + var quePos = rootURI.indexOf("?"); + if (quePos >= 0) { + rootURI = rootURI.substring(0, quePos); + } + var sepPos = rootURI.lastIndexOf("/"); + if (sepPos >= 0) { + rootURI = rootURI.substring(0, sepPos + 1); + } + var newThRoot = rootURI + this.thLocation + this.relativeRootPath; + this.thRoot = Thymol.prototype.getThParam("thRoot", false, true, newThRoot); + } + this.path = Thymol.prototype.override("thPath", this.path); + this.allowNullText = Thymol.prototype.override("thAllowNullText", this.allowNullText); + this.locale.value = Thymol.prototype.override("thLocale", this.locale.value); + if (!(typeof thMappings === "undefined")) { + this.mappings = []; + for (j = 0, jLimit = thMappings.length; j < jLimit; j++) { + this.mappings.push([ thMappings[j][0], thMappings[j][1] ]); + } + this.mappings.sort(function(a, b) { + return a[0].length > b[0].length ? -1 : 1; + }); + } + this.messages = {}; + setLocaleValue(); + if (!(typeof thMessages === "undefined")) { + this.messages[""] = []; + for (j = 0, jLimit = thMessages.length; j < jLimit; j++) { + this.messages[""][thMessages[j][0]] = thMessages[j][1]; + } + for (var k in thMessages) { + if (thMessages.hasOwnProperty(k)) { + if (!k.match(numericExpr)) { + this.messages[k] = []; + for (j = 0, jLimit = thMessages[k].length; j < jLimit; j++) { + this.messages[k][thMessages[k][j][0]] = thMessages[k][j][1]; + } + } + } + } + } + if (!(typeof thDisable === "undefined")) { + for (j = 0, jLimit = thDisable.length; j < jLimit; j++) { + Thymol.prototype.doDisable(thDisable[j]); + } + } + thymol.thRemove = Thymol.prototype.getThAttrByName("remove"); + } + function getLocations(thiz) { + thiz.templateName = ""; + thiz.templatePath = ""; + if (!!thymol.thDocument.location.href) { + var templateName = templatePath = thymol.thDocument.location.href; + thiz.templateName = templateName.substring(0, templateName.indexOf(".") == -1 ? templateName.length : templateName.lastIndexOf(".")); + thiz.templatePath = templatePath.substring(0, templatePath.indexOf("/") == -1 ? 0 : templatePath.lastIndexOf("/") + 1); + } + } + function getCtx() { + return thymol.thExpressionObjects["#ctx"]; + } + function configureModule(module) { + if (typeof thymol.thExpressionObjects === "undefined" || thymol.thExpressionObjects === null) { + thymol.thExpressionObjects = {}; + } + thymol.thExpressionObjects[module.thExpressionObjectName] = module; + } + function configureAttributeProcessor(prefix, suffix, func, prec, dataAttr) { + var p = prefix + ":"; + if (p !== null) { + if (thymol.thThymeleafPrefixList.indexOf(p) < 0) { + thymol.thThymeleafPrefixList.push(p); + } + } else { + thymol.thUsingNullPrefix = true; + } + p = new thymol.ThAttr(suffix, func, prec, thymol.thThymeleafPrefixList, prefix, dataAttr); + } + function configureElementProcessor(prefix, suffix, func) { + var p = new thymol.ThElement(suffix, func, prefix); + } + function configurePreExecution(func) { + if (typeof thymol.thPreExecutionFunctions === "undefined" || thymol.thPreExecutionFunctions === null) { + thymol.thPreExecutionFunctions = []; + } + thymol.thPreExecutionFunctions.push(func); + } + function configurePostExecution(func) { + if (typeof thymol.thPostExecutionFunctions === "undefined" || thymol.thPostExecutionFunctions === null) { + thymol.thPostExecutionFunctions = []; + } + thymol.thPostExecutionFunctions.push(func); + } + function executeDeferred() { + if (typeof thymolDeferredFunctions !== "undefined" && thymolDeferredFunctions !== null) { + while (thymolDeferredFunctions.length > 0) { + var func = thymolDeferredFunctions.pop(); + func(); + } + } + } + function preExecute(context) { + while (thymol.thPreExecutionFunctions.length > 0) { + var func = thymol.thPreExecutionFunctions.pop(); + func(); + context.resolveJSONReferences(); + } + } + function postExecute() { + while (thymol.thPostExecutionFunctions.length > 0) { + var func = thymol.thPostExecutionFunctions.pop(); + func(); + } + } + function preProcess(expr, element) { + var result = expr, fp, lp; + do { + fp = result.indexOf("__"); + if (fp >= 0) { + lp = -1; + if (result.length > 4) { + lp = result.lastIndexOf("__"); + } + if (lp <= 0) { + throw new thymol.ThError("Mismatched pre-processing indicators", element); + } + var head = result.substring(0, fp); + var centre = result.substring(fp + 2, lp); + centre = this.getParsedExpr(centre, element); + var tail = result.substring(lp + 2); + result = head + centre + tail; + fp = result.indexOf("__"); + } + } while (fp >= 0); + result = result.replace(/\\_\\_/g, "__"); + return result; + } + function substituteParam(argValue, mode, element) { + var result = argValue, varName = argValue, subs = null, msg, expo; + if (result) { + if (mode === 4) { + msg = thymol.getMessage(varName); + if (msg) { + subs = msg; + } + } else if (mode === 6) { + subs = argValue; + } else { + var token = thymol.booleanAndNullTokens[result]; + if (!(typeof token === "undefined")) { + if (token === null) { + subs = null; + } else { + subs = token.value; + } + } else { + if (varName.charAt(0) === "#") { + if ("#object" === varName) { + if (element.thObjectVar) { + subs = element.thObjectVar; + } + } else { + expo = thymol.thExpressionObjects[varName]; + if (typeof expo !== "undefined" && expo !== null) { + subs = expo; + } + } + } + if ((typeof subs === "undefined" || subs == null) && element.thObjectVar) { + subs = element.thObjectVar[varName]; + } + if ((typeof subs === "undefined" || subs == null) && element.thLocalVars) { + subs = element.thLocalVars[varName]; + } + if (typeof subs === "undefined" || subs == null) { + subs = thymol.ThUtils.getParameter(varName); + } + if (typeof subs === "undefined" || subs == null) { + if ("param" === varName) { + subs = thymol.requestContext; + } + if ("session" === varName) { + subs = thymol.sessionContext; + } + if ("application" === varName) { + subs = thymol.applicationContext; + } + } + if (mode === 2 && (typeof subs === "undefined" || subs == null)) { + subs = argValue; + } + } + } + result = subs; + if (subs instanceof thymol.ThParam) { + result = subs.value; + } + } + return result; + } + function getStandardURL(initial) { + var result = initial.trim(), mapped, head; + mapped = thymol.getMapped(result, thymol.extendedMapping); + if (mapped) { + result = mapped; + } + if ("/" === result && !!thymol.indexFile) { + result += thymol.indexFile; + } + if (!/.*:\/\/.*/.test(result)) { + if (/^~?\/.*$/.test(result)) { + if (/^~.*$/.test(result)) { + result = result.substring(1); + } + if (!/^\/\/.*$/.test(result)) { + if (thymol.useFullURLPath) { + head = thymol.root + thymol.resourcePath; + if (head != "") { + if (head.charAt(head.length - 1) !== "/") { + head = head + "/"; + } + if (result.charAt(0) === "/") { + result = head + result.substring(1); + } else { + result = head + result; + } + } + } else { + result = thymol.resourcePath + result; + } + } + } + } + return result; + } + function getExpression(argValue, element) { + var result = argValue, subst = false, initial, shortCut, args, negate, token, lsp; + if (typeof argValue === "string") { + initial = argValue.trim(); + result = initial; + if (result) { + shortCut = thymol.ThUtils.getParameter(result); + if (!shortCut) { + args = result.match(varExpr3); + if (args) { + if (args[1] && args[1].length > 0) { + shortCut = thymol.ThUtils.getParameter(args[1]); + } + } + } + if (shortCut) { + if (shortCut instanceof thymol.ThParam) { + result = shortCut.value; + } else { + result = shortCut; + } + if (typeof result === "string" && result.match(numericExpr)) { + result = parseInt(result); + } + } else { + initial = thymol.ThUtils.unParenthesise(result); + negate = false; + if (initial.charAt(0) == "!") { + negate = true; + initial = initial.substring(1, initial.length); + initial = thymol.ThUtils.unParenthesise(initial); + } + if (literalTokenExpr.test(initial)) { + token = thymol.booleanAndNullTokens[initial]; + if (!(typeof token === "undefined")) { + result = token.value; + subst = true; + } + } + lsp = null; + if (!subst) { + lsp = initial.match(litSubstExpr); + if (lsp && lsp.length > 0) { + if (thymol.ThUtils.charOcurrences(lsp[1], "'") < 2) { + initial = Thymol.prototype.doLiteralSubstExpr(initial, lsp[1]); + } + } + result = ""; + if (initial != "") { + initial = thymol.ThUtils.unParenthesise(initial); + initial = thymol.preProcess(initial, element); + result = thymol.getParsedExpr(initial, element, true); + } + } + if (result == initial && typeof result == typeof initial) { + result = null; + } else if (typeof result === "string") { + if (!lsp) { + result = result.replace(/[\\][\\]/g, "\\"); + } + result = result.replace(/'/g, "'").replace(/'/gi, "'"); + } + if (negate) { + if (typeof result === "boolean") { + result = !result; + } else if (typeof result === "number") { + result = result == 0; + } else if (typeof result === "string") { + result = !thymol.ThUtils.testLiteralFalse(result); + } + } + } + } + } + return result; + } + function getMapped(uri, extended) { + var mapped = null, i, iLimit, key; + if (uri && typeof uri === "string") { + if (thymol.mappings) { + for (i = 0, iLimit = thymol.mappings.length; i < iLimit; i++) { + key = thymol.mappings[i][0]; + if (uri == key) { + mapped = thymol.mappings[i][1]; + break; + } else if (extended) { + if (uri.indexOf(key) == 0) { + mapped = uri.substring(key.length); + mapped = thymol.mappings[i][1] + mapped; + break; + } + } + } + } + } + return mapped; + } + function substitute(initial, element, lenient) { + var argValue = initial, result, args, token, re, subs, saved; + if (typeof argValue === "string") { + argValue = argValue.trim(); + } + result = argValue; + args = ""; + while (args != null) { + args = argValue.match(/.*([$\*#@]{(!?[^}]*)}).*/); + if (args != null && args.length > 0) { + if (args.length == 3) { + token = args[1]; + token = token.replace(/[$]/g, "[$]").replace(/[*]/g, "[*]").replace(/[\']/g, "[']").replace(/[+]/g, "[+]").replace(/[\(]/g, "[(]").replace(/[\)]/g, "[)]"); + re = new RegExp(token); + subs = this.getExpression(args[2], element); + if (subs != args[2]) { + result = result.replace(re, subs, "g"); + if (result == "null") { + result = null; + } + } else { + subs = ""; + if (thymol.debug && !lenient) { + thymol.thWindow.alert('thymol variable substitution failed: "' + initial + '"'); + } + } + saved = argValue; + argValue = argValue.replace(re, subs, "g"); + if (saved == argValue) { + argValue = ""; + } + } + } + } + return result; + } + function getWith(element, content) { + var argValue = content.trim(), argCount = 0; + if (argValue) { + do { + var argsExpr = thymol.ThParser.parse(argValue, true, false); + var identifier = argsExpr.tokens.shift(); + if (identifier.type_ === 3) { + var result = argsExpr.evaluate(element); + var varName = identifier.index_; + if (!!varName) { + argCount++; + if (!element.thLocalVars) { + element.thLocalVars = {}; + } + element.thLocalVars[varName] = result; + } + argValue = argValue.substring(argsExpr.position); + } else { + break; + } + } while (argValue.length > 0); + } + return argCount; + } + function getParsedExpr(initial, element, preprocessed) { + var expr, result = initial; + expr = thymol.ThParser.parse(result, false, preprocessed); + expr = expr.simplify(); + result = expr.evaluate(element); + if (typeof result === "number") { + result = thymol.ThUtils.getToPrecision(result, expr.precision); + } + return result; + } + function getBooleanValue(param) { + var flag = false, val, args; + if (param != null) { + if (typeof param === "boolean") { + flag = param; + } else if (typeof param === "number") { + flag = param != 0; + } else { + val = param; + if (Object.prototype.toString.call(val) === "[object Array]") { + if (val.length === 1) { + val = val[0]; + } else { + val = true; + } + } + if (typeof val === "boolean") { + flag = val; + } else if (typeof val === "number") { + flag = val != 0; + } else if (typeof val === "string") { + args = val.match(nonURLExpr); + if (args) { + val = args[1]; + flag = this.testParam(val); + } else { + flag = !thymol.ThUtils.testLiteralFalse(val); + } + } else if (val instanceof thymol.ThParam) { + flag = val.getBooleanValue(); + } else { + flag = typeof val !== "undefined" && val !== null; + } + } + } + return flag; + } + function isFragmentChild(element) { + var result = false, parent = element.parentElement; + while (parent) { + if (parent.getAttribute(thymol.thFragment.name) || parent.getAttribute(thymol.thFragment.synonym)) { + result = true; + break; + } + parent = parent.parentElement; + } + return result; + } + function setLocale(locValue) { + thymol.locale.value = locValue; + setLocaleValue(); + } + function getLocale() { + return thymol.locale.value; + } + function getLanguage() { + if (!thymol.locale.value) { + if (typeof navigator !== "undefined" && !!navigator) { + var userLang = navigator.language || navigator.userLanguage || navigator.browserLanguage || navigator.systemLanguage; + if (!!userLang) { + thymol.locale.value = userLang.replace(/\-/g, "_"); + } + } + } + } + function setLocaleValue() { + if (!thymol.locale.value) { + thymol.locale.value = thymol.thDefaultLocale; + } + var sepPos; + var locale = thymol.locale.value.replace(/\-/g, "_"); + var level = thymol.locale.value; + var levels = []; + var part, parts = []; + do { + levels.push(level); + sepPos = locale.lastIndexOf("_"); + if (sepPos >= 0) { + part = locale.substring(sepPos + 1); + parts.push(part); + locale = locale.substring(0, sepPos); + level = level.substring(0, sepPos); + } + } while (sepPos >= 0); + thymol.locale.language = level; + if (!!parts) { + parts.reverse(); + for (var i = 0, iLimit = parts.length; i < iLimit; i++) { + if (i === 0) { + thymol.locale.country = parts[i]; + } else if (i === 1) { + thymol.locale.variant = parts[i]; + } + } + } + thymol.locale.levels = levels; + thymol.thExpressionObjects["#ctx"]["locale"] = thymol.locale; + thymol.thExpressionObjects["#locale"] = thymol.locale; + } + function getMessage(varName, parameters, returnStringAlways) { + if (thymol.disableMessages) { + return undefined; + } + var msgKey = null; + var locale; + if (!!thymol.locale.levels) { + var prefix = "$"; + var ident, section, jLower = thymol.localMessages ? 0 : 1; + for (var j = jLower; j < 2; j++) { + for (var i = 0, iLimit = thymol.locale.levels.length; i < iLimit + 1; i++) { + ident = prefix; + if (i < iLimit) { + locale = thymol.locale.levels[i]; + } else { + locale = ""; + } + ident = ident + locale; + section = thymol.messages[ident]; + if (!section) { + if (j < 1) { + section = getLocalMessages(locale); + } else { + section = getDefaultMessages(locale); + } + } + if (!!section) { + thymol.messages[ident] = section; + msgKey = section[varName]; + if (!!msgKey) { + break; + } + } + } + if (!!msgKey) { + break; + } + prefix += "$"; + } + } + if (!msgKey) { + for (var i = 0, iLimit = thymol.locale.levels.length; i <= iLimit; i++) { + if (i < iLimit) { + locale = thymol.locale.levels[i]; + } else { + locale = ""; + } + if (!!thymol.messages[locale]) { + msgKey = thymol.messages[locale][varName]; + if (!!msgKey) { + break; + } + } + } + } + if (!!msgKey) { + if (typeof parameters === "undefined") { + return msgKey; + } else { + return thymol.ThUtils.renderMessage(msgKey, parameters); + } + } else if (returnStringAlways !== undefined && returnStringAlways) { + return "??" + varName + "_" + thymol.locale.value + "??"; + } + return null; + } + function getProperties(propFile) { + var props = null; + var messages = []; + $.get(propFile, function(textContent, status) { + var err = null; + try { + if ("success" == status) { + props = textContent; + } else if (thymol.debug) { + thymol.thWindow.alert("read failed: " + propFile); + } + } catch (err) { + if (thymol.debug) { + thymol.thWindow.alert("properties file read failed: " + propFile + " error: " + err); + } + } + }, "text"); + if (props !== null) { + var splits = props.split("\n"); + if (splits.length > 0) { + for (var i = 0, iLimit = splits.length; i < iLimit; i++) { + var line = splits[i].trim(); + if (line.charAt(0) !== "#") { + var p = line.split("="); + if (p.length > 1) { + messages[p[0].trim()] = thymol.ThUtils.unicodeUnescape(p[1].trim()); + } + } + } + } + } + return messages; + } + function getLocalMessages(locale) { + var messages = []; + if (!!thymol.thDocument.location.href) { + var propsFile = thymol.templateName; + if (!!locale && locale !== "") { + propsFile += "_" + locale; + } + propsFile += ".properties"; + messages = getProperties(propsFile); + } + return messages; + } + function getDefaultMessages(locale) { + var messages = null; + var propsPath = ""; + if (thymol.useAbsolutePath) { + propsPath += thymol.protocol + thymol.root + thymol.path; + } + propsPath += thymol.messagePath; + if (propsPath !== "") { + propsPath += "/"; + } + var propsFile = propsPath + thymol.messagesBaseName; + if (!!locale && locale !== "") { + propsFile += "_" + locale; + } + propsFile += ".properties"; + messages = getProperties(propsFile); + return messages; + } + Thymol.prototype = { + process: function(rootNode) { + var n = rootNode; + try { + while (n.thDoc) { + this.getChildren(n); + if (n.firstChild && n.firstChild.thDoc && !n.visited) { + n.visited = true; + n = n.firstChild; + } else { + if (n.element != n.thDoc) { + this.doReplace(n.isNode, n.element, n.thDoc); + if (!n.isNode) { + n.thDoc = n.element; + } + } + if (n.nextSibling && n.nextSibling.thDoc) { + n = n.nextSibling; + } else { + if (n == rootNode) { + break; + } + n = n.parentDoc; + } + } + } + this.processChildren(rootNode); + } catch (err) { + if (thymol.debug) { + if (err instanceof thymol.ThError) { + if (!err.suppress) { + thymol.thWindow.alert(err); + } + } else { + thymol.thWindow.alert(err); + } + } + } + }, + getChildren: function(rootNode) { + var count = 0, last = null, changed = false, child, froot, fstar, fchildren, i, iLimit, j, jLimit, element, matches, theAttr; + if (!rootNode.visited) { + this.processComments(rootNode); + var rnd = this.getContentRoot(rootNode); + froot = $(rnd); + fstar = $(froot).add(froot.find("*")); + fchildren = fstar.filter(thymol.thInclude.escpName).add(fstar.filter(thymol.thInclude.escpSynonym)).add(fstar.filter(thymol.thReplace.escpName)).add(fstar.filter(thymol.thReplace.escpSynonym)).add(fstar.filter(thymol.thSubstituteby.escpName)).add(fstar.filter(thymol.thSubstituteby.escpSynonym)); + for (i = 0, iLimit = fchildren.length; i < iLimit; i++) { + element = fchildren[i], matches = []; + for (j = 0, jLimit = element.attributes.length; j < jLimit; j++) { + theAttr = element.attributes[j]; + if (thymol.thInclude.name == theAttr.name || thymol.thInclude.synonym == theAttr.name || thymol.thReplace.name == theAttr.name || thymol.thReplace.synonym == theAttr.name || thymol.thSubstituteby.name == theAttr.name || thymol.thSubstituteby.synonym == theAttr.name) { + matches.push(theAttr); + } + } + for (j = 0, jLimit = matches.length; j < jLimit; j++) { + child = this.processImport(element, rootNode, matches[j]); + if (child != null) { + changed = true; + if (count == 0) { + rootNode.firstChild = child; + } else { + last.nextSibling = child; + } + last = child; + count++; + } + } + } + } + return changed; + }, + processChildren: function(rootNode) { + var i, iLimit, j, jLimit, k, kLimit; + var elements = rootNode.thDoc.getElementsByTagName("*"); + for (k = 0, kLimit = elements.length; k < kLimit; k++) { + var element = elements[k]; + for (j = 0, jLimit = thymol.thThymeleafElementsList.length; j < jLimit; j++) { + if (element.localName == thymol.thThymeleafElementsList[j].name || element.localName == thymol.thThymeleafElementsList[j].synonym) { + var updated = thymol.thThymeleafElementsList[j].process(element); + if (updated) { + elements = rootNode.thDoc.getElementsByTagName("*"); + k--; + kLimit = elements.length; + } + break; + } + } + var allAttributes = element.attributes; + if (allAttributes && allAttributes.length > 0) { + var attributes = [], aii = 0; + if (!thymol.thUsingNullPrefix) { + for (i = 0, iLimit = allAttributes.length; i < iLimit; i++) { + var ai = allAttributes[i]; + if (ai) { + for (j = 0, jLimit = thymol.thThymeleafPrefixList.length; j < jLimit; j++) { + var attrName = ai.name.toString(); + if (attrName.length > thymol.thThymeleafPrefixList[j].length) { + attrName = attrName.substring(0, thymol.thThymeleafPrefixList[j].length); + if (attrName === thymol.thThymeleafPrefixList[j]) { + ai.order = i; + attributes[aii++] = ai; + } + } + } + } + } + } else { + attributes = allAttributes; + } + if (attributes.length > 0) { + attributes.sort(function(a, b) { + return b.order - a.order; + }); + var matchedAttributes = []; + for (i = 0, iLimit = attributes.length; i < iLimit; i++) { + var splits = attributes[i].name.toString().split(":"); + if (splits && splits.length > 0) { + var prefix = "", name; + if (splits.length > 1) { + prefix = splits[0]; + name = splits[1]; + } else { + name = splits[0]; + var hpos = name.lastIndexOf("-"); + if (hpos >= 0) { + prefix = name.substring(0, hpos + 1); + } + } + var attrList = thymol.thThymeleafPrefixList[prefix]; + if (splits.length > 1) { + prefix += ":"; + } + if (attrList) { + for (j = 0, jLimit = attrList.length; j < jLimit; j++) { + var matched = false; + if (name === attrList[j].suffix || name === attrList[j].synonym) { + matched = true; + } else if (attrList[j].regex !== null) { + var fqn = prefix + name; + matched = attrList[j].regex.test(fqn); + } + if (matched) { + var matchedAttribute = {}; + matchedAttribute.attr = attrList[j]; + matchedAttribute.elementAttr = attributes[i]; + matchedAttributes.push(matchedAttribute); + break; + } + } + } + } + } + if (matchedAttributes.length > 0) { + matchedAttributes.sort(function(a, b) { + return a.attr.precedence - b.attr.precedence; + }); + var updated = false; + for (i = 0, iLimit = matchedAttributes.length; i < iLimit; i++) { + var exp = thymol.ThUtils.processElement(matchedAttributes[i].attr.process, element, matchedAttributes[i].elementAttr, matchedAttributes[i].attr, 1); + updated = exp || updated; + } + if (updated) { + elements = rootNode.thDoc.getElementsByTagName("*"); + k--; + kLimit = elements.length; + } + } + } + } + } + elements = rootNode.thDoc.getElementsByTagName("*"); + var kc = 0; + for (k = 0, kLimit = elements.length; k < kLimit; k++) { + var element = elements[kc]; + var elName = element.nodeName.toLowerCase(); + if (elName == thymol.thBlock.name || elName == thymol.thBlock.synonym) { + thymol.ThUtils.removeTag(element); + elements = rootNode.thDoc.getElementsByTagName("*"); + } else { + kc++; + } + } + }, + override: function(paramName, paramValue) { + var param = paramValue, thv; + thv = thymol.thWindow[paramName]; + if (typeof thv === "undefined") { + thv = thymol.applicationContext.javascriptify(paramName); + } + if (thv) { + if (thv instanceof thymol.ThParam) { + param = thv.value; + } else { + param = thv; + } + } + thv = thymol.applicationContext[paramName]; + if (thv) { + if (thv instanceof thymol.ThParam) { + param = thv.value; + } else { + param = thv; + } + } + thv = thymol.requestContext[paramName]; + if (thv) { + if (thv instanceof thymol.ThParam) { + param = thv.value; + } else { + param = thv; + } + } + return param; + }, + doDisable: function(attrName) { + var tha = this.getThAttrByName(attrName); + if (tha !== null) { + tha.disable(); + } else { + if (thymol.debug) { + thymol.thWindow.alert('cannot disable unknown attribute "' + attrName + '"'); + } + } + }, + getThAttrByName: function(name) { + var attrList = thymol.thThymeleafPrefixList[thymol.prefix]; + attrList.push(thymol.thInclude); + attrList.push(thymol.thReplace); + attrList.push(thymol.thSubstituteby); + attrList.push(thymol.thFragment); + var i, iLimit = attrList.length; + for (i = 0; i < iLimit; i++) { + if (name === attrList[i].suffix) { + return attrList[i]; + } + } + return null; + }, + getContents: function(rootNode) { + var rnd = this.getContentRoot(rootNode); + var froot = $(rnd); + var fstar = froot.find("*"); + return fstar; + }, + getContentRoot: function(rn) { + var rnd = rn.thDoc; + if (rnd.nodeName !== "#document") { + rnd = rnd.childNodes; + } + return rnd; + }, + processComments: function(rootNode) { + var comments = null, fstar, changed, i, iLimit, startComment, parent, startValue, pointer, nextPointer; + do { + fstar = this.getContents(rootNode); + comments = fstar.contents().getComments(); + changed = false; + for (i = 0, iLimit = comments.length; i < iLimit; i++) { + startComment = comments[i]; + parent = startComment.parentNode; + startValue = startComment.nodeValue.trim(); + if (startParserLevelCommentExpr.test(startValue)) { + pointer = startComment; + while (pointer != null) { + if (endParserLevelCommentExpr.test(pointer.nodeValue)) { + changed = parent.removeChild(pointer) != null; + break; + } + nextPointer = pointer.nextSibling; + changed = parent.removeChild(pointer) != null; + pointer = nextPointer; + } + } else if (startParserLevelCommentExpr2.test(startValue) && endParserLevelCommentExpr2.test(startValue)) { + parent.removeChild(startComment); + changed = true; + } + } + } while (changed); + this.processPrototypeOnlyComments(rootNode); + }, + processPrototypeOnlyComments: function(rootNode) { + var comments = null, fstar, changed, indexOfLast, i, iLimit, j, jLimit, k, kLimit, startComment, parent, deletions, res, fullText, innerNodes, done, next, commentText, res2, blockElement, blockDoc, blockDocBody, blockBase, newNode, newDoc; + do { + fstar = this.getContents(rootNode); + comments = fstar.contents().getComments(); + changed = false; + indexOfLast = comments.length - 1; + for (i = 0, iLimit = comments.length; i < iLimit; i++) { + startComment = comments[i]; + parent = startComment.parentNode; + if (parent != null) { + startValue = startComment.nodeValue.trim(); + deletions = []; + deletions.push(startComment); + startValue = startValue.replace(/\n/g, ""); + res = startValue.match(prototypeOnlyCommentEscpExpr); + if (res) { + fullText = startValue; + if (parent.localName == "table" || parent.localName == "tbody") { + if (startValue.indexOf(thymol.thBlock.name) >= 0 || startValue.indexOf(thymol.thBlock.synonym) >= 0) { + if (startValue.indexOf(thymol.thBlock.endName) < 0 || startValue.indexOf(thymol.thBlock.endSynonym) < 0) { + fullText = fullText.replace(res[0], res[1]); + innerNodes = []; + done = false; + next = startComment; + do { + next = next.nextSibling; + if (next != null) { + deletions.push(next); + if (i < indexOfLast) { + if (next == comments[i + 1]) { + commentText = next.nodeValue; + if (commentText.indexOf(thymol.thBlock.endName) >= 0 || commentText.indexOf(thymol.thBlock.endSynonym) >= 0) { + res2 = commentText.match(prototypeOnlyCommentEscpExpr); + if (res2) { + commentText = commentText.replace(res2[0], res2[1]); + fullText = fullText + commentText; + } + done = true; + } + } else { + innerNodes.push(next); + } + } + } else { + done = true; + } + } while (!done); + blockElement = null; + blockDoc = new thymol.thDomParser().parseFromString(fullText, "text/html"); + blockDocBody = $(blockDoc).find("body")[0]; + for (j = 0, jLimit = blockDocBody.childNodes.length; j < jLimit; j++) { + if (blockDocBody.childNodes[j].localName == thymol.thBlock.name || blockDocBody.childNodes[j].localName == thymol.thBlock.synonym) { + blockElement = blockDocBody.childNodes[j]; + for (k = 0, kLimit = innerNodes.length; k < kLimit; k++) { + newNode = blockDoc.importNode(innerNodes[k], true); + blockElement.appendChild(newNode); + } + } + } + if (blockElement != null) { + blockBase = new ThNode(blockDoc, false, null, null, null, blockDoc.nodeName, "::", false, blockDoc); + this.processChildren(blockBase); + changed = this.insertUncommented(blockBase.thDoc, deletions, parent); + } else { + parent.removeChild(startComment); + changed = true; + } + } else { + parent.removeChild(startComment); + changed = true; + } + } + } else { + startValue = startValue.substring(3, startValue.length - 3); + newDoc = new thymol.thDomParser().parseFromString(startValue, "text/html"); + changed = this.insertUncommented(newDoc, deletions, parent); + } + } + } + } + } while (changed); + }, + insertUncommented: function(doc, deletions, parent) { + var docBody = $(doc).find("body")[0], i, iLimit, newNode; + for (i = 0, iLimit = docBody.childNodes.length; i < iLimit; i++) { + if (parent.ownerDocument === doc) { + newNode = docBody.childNodes[i].cloneNode(true); + } else { + newNode = parent.ownerDocument.importNode(docBody.childNodes[i], true); + newNode.parentNode = parent; + } + parent.insertBefore(newNode, deletions[0]); + } + for (i = 0, iLimit = deletions.length; i < iLimit; i++) { + parent.removeChild(deletions[i]); + } + return true; + }, + getList: function(element, content) { + var argValue = content.trim(), argsCount = 0, argsList = [], assigs, i, iLimit, val; + if (argValue) { + assigs = argValue.split(","); + for (i = 0, iLimit = assigs.length; i < iLimit; i++) { + val = thymol.getExpression(assigs[i], element); + argsList[i] = val; + } + if (!element.thLocalVars) { + element.thLocalVars = {}; + } + element.thLocalVars["..."] = argsList; + argsCount = argsList.length; + } + return argsCount; + }, + testParam: function(param) { + var initial = param, result = false, theParam = null, negate = false; + if (typeof initial === "boolean") { + result = initial; + } else { + theParam = null; + negate = false; + if (typeof initial === "object" && initial instanceof thymol.ThParam) { + theParam = initial; + } else { + initial = initial.valueOf(); + if (initial.charAt(0) == "!") { + negate = true; + initial = initial.substring(1); + } + } + theParam = thymol.applicationContext[initial]; + if (theParam != null) { + result = theParam.getBooleanValue(); + } + if (negate) { + result = !result; + } + } + return result ? true : false; + }, + processImport: function(element, rootNode, attr) { + var importNode = null, filePart, fragmentPart, names, parts, fragmentArgsList, isNode, fragment, fileName, content, importError; + filePart = null; + if (attr.value.indexOf("::") < 0) { + filePart = attr.value; + fragmentPart = "::"; + } else { + names = attr.value.split("::"); + filePart = names[0].trim(); + fragmentPart = names[1].trim(); + } + if ("this" === filePart) { + filePart = ""; + } else { + filePart = this.getFilePath(filePart, element); + } + if (filePart != null) { + parts = filePart.match(varParExpr); + fragmentArgsList = null; + if (parts) { + if (parts.length > 1) { + filePart = parts[1].trim(); + } + if (parts.length > 2) { + fragmentArgsList = parts[2].trim(); + } + } + if (filePart != "" || !isFragmentChild(element)) { + isNode = thymol.thReplace.name == attr.localName || thymol.thReplace.synonym == attr.localName || thymol.thSubstituteby.name == attr.localName || thymol.thSubstituteby.synonym == attr.localName; + if (thymol.thCache[filePart] != null && thymol.thCache[filePart][fragmentPart] != null) { + isNode = isNode || fragmentPart == "::"; + importNode = new ThNode(thymol.thCache[filePart][fragmentPart], false, rootNode, null, null, filePart, fragmentPart, isNode, element); + } else { + fragment = null; + importError = null; + if (filePart != "") { + fileName = filePart + thymol.templateSuffix; + $.get(fileName, function(textContent, status) { + try { + if ("success" == status) { + content = new thymol.thDomParser().parseFromString(textContent, "text/html"); + fragment = Thymol.prototype.getImportNode(element, filePart, fragmentPart, fragmentArgsList, content); + } else if (thymol.debug) { + thymol.thWindow.alert("thymol.processImport file read failed: " + filePart + " fragment: " + fragmentPart); + } + } catch (err) { + importError = err; + } + }, "text"); + } else { + fragment = this.getImportNode(element, filePart, fragmentPart, fragmentArgsList, thymol.thDocument); + } + if (fragment == null) { + if (importError !== null) { + throw importError; + } + if (thymol.debug) { + thymol.thWindow.alert("thymol.processImport fragment import failed: " + filePart + " fragment: " + fragmentPart); + } + } else { + importNode = new ThNode(fragment, false, rootNode, null, null, filePart, fragmentPart, isNode, element); + } + } + } + } + element.removeAttribute(attr.name); + return importNode; + }, + getImportNode: function(element, filePart, fragmentArg, fragmentArgsList, content) { + var result = null, fragmentName = fragmentArg.trim(), fragmentPart = fragmentName, parts, argsCount, matched, fragment, htmlContent, fragArray, i, iLimit, j, jLimit, k, clean, bare, vlParts, vlArgs, argsList, varName, newElement; + fragmentName = fragmentName.replace(/text\(\)/g, textFuncSynonym); + parts = fragmentName.match(varParExpr); + if (parts == null && fragmentArgsList != null) { + parts = []; + parts[1] = fragmentName; + parts[2] = fragmentArgsList; + } + argsCount = 0; + if (parts) { + if (parts.length > 1) { + fragmentName = parts[1].trim(); + if (parts.length > 2) { + if (parts[2].indexOf("=") > 0) { + argsCount = thymol.getWith(element, parts[2]); + } else { + argsCount = this.getList(element, parts[2]); + } + } + } + } + if (thymol.thCache[filePart] == null) { + thymol.thCache[filePart] = new Object(); + } + matched = false; + fragment = null; + if (fragmentName == "::") { + htmlContent = $("html", content)[0]; + result = htmlContent; + matched = true; + } else { + fragArray = $(thymol.thFragment.escpName, content); + for (i = 0, iLimit = fragArray.length; i < iLimit; i++) { + fragment = fragArray[i]; + for (j = 0, jLimit = fragment.attributes.length; j < jLimit; j++) { + clean = fragment.attributes[j]; + clean = clean.value.replace(/\s/g, ""); + bare = null; + vlParts = clean.match(varParExpr); + if (vlParts) { + if (vlParts.length > 1) { + bare = vlParts[1].trim(); + } + } + if (fragmentName == bare && argsCount > 0) { + if (vlParts.length > 2) { + vlArgs = vlParts[2].trim().split(","); + if (vlArgs) { + if (vlArgs.length == argsCount) { + argsList = element.thLocalVars["..."]; + if (argsList != null) { + for (k = 0; k < argsCount; k++) { + varName = vlArgs[k].trim(); + element.thLocalVars[varName] = argsList[k]; + } + element.thLocalVars["..."] = null; + } + matched = true; + break; + } else if (vlArgs.length > argsCount) { + break; + } + } + } + } + if (fragmentName == clean || fragmentPart == clean || fragmentName == bare) { + matched = true; + break; + } + } + if (matched) { + result = fragment; + break; + } + } + } + if (!matched) { + fragment = this.getDOMSelection(fragmentName, content); + if (fragment) { + matched = true; + result = fragment; + } else { + if (!element.isBlockChild) { + throw new thymol.ThError('getImportNode cannot match fragment: "' + fragmentName + '"', element); + } + } + } + thymol.thCache[filePart][fragmentPart] = result; + if (matched) { + newElement = result.cloneNode(true); + if (newElement.nodeType == 1) { + newElement.removeAttribute(thymol.thFragment.name); + newElement.removeAttribute(thymol.thFragment.synonym); + } + result = newElement; + result.thLocalVars = element.thLocalVars; + } + return result; + }, + getDOMSelection: function(initial, content) { + var spec = initial, result = null, scope = "", query = new Array(), parts = "", innr = thymol.ThUtils.unBracket(spec), i, iLimit, j, jLimit, k, kLimit, m, mLimit, token, indx, saved, indxed, start, selection, descend, subQuery, exprFrags, classSpecs, qTerms, subSelect, partial, html, newNode; + if (spec != innr && innr.charAt(innr.length - 1) == "]") { + spec = innr; + } + while (spec != "") { + parts = spec.match(domSelectExpr); + if (parts != null && parts.length > 1) { + for (i = 1, iLimit = parts.length; i < iLimit; i++) { + if (parts[i] != null) { + token = parts[i]; + indx = null; + innr = thymol.ThUtils.unBracket(token); + if (token != innr) { + if (innr.match(numericExpr)) { + indx = innr; + } + } + saved = spec; + spec = spec.replace(token, ""); + if (saved == spec) { + spec = ""; + } + if (indx) { + token = query[query.length - 1]; + indxed = new String(token); + indxed.indx = indx; + query[query.length - 1] = indxed; + } else { + query.push(token.trim()); + } + break; + } + } + } else { + break; + } + } + start = 0; + if (query.length > 0 && query[0] != "" && query[0].charAt(0) == "/") { + scope = query[0]; + start = 1; + } + selection = []; + selection.push(content); + descend = false; + for (i = start, iLimit = query.length; i < iLimit; i++) { + subQuery = query[i]; + innr = thymol.ThUtils.unBracket(subQuery); + if (subQuery != innr) { + innr = innr.replace(/[']/g, '"'); + subQuery = ""; + exprFrags = innr.split(/\s{1}\s*((?:and)|(?:or))\s{1}\s*/); + for (j = 0, jLimit = exprFrags.length; j < jLimit; j++) { + if (exprFrags[j] != "and" && exprFrags[j] != "or") { + classSpecs = exprFrags[j].match(/[@]?\s*(?:class)\s*(\W?[=])\s*[\"]((?:\w*[\-_]*)*)[\"]/); + if (classSpecs && classSpecs.length > 0) { + if (classSpecs[1] == "=") { + subQuery = subQuery + "[class~='" + classSpecs[2] + "']"; + } + if (classSpecs[1] == "^=") { + subQuery = subQuery + "[class^='" + classSpecs[2] + "'],[class*=' " + classSpecs[2] + "']"; + } + } else { + subQuery = subQuery + "[" + exprFrags[j] + "]"; + } + } else if (exprFrags[j] == "or") { + subQuery = subQuery + ","; + } + } + } + qTerms = subQuery.split("/"); + for (j = 0, jLimit = qTerms.length; j < jLimit; j++) { + if (qTerms[j] != "") { + qTerms[j] = qTerms[j].replace(/[@]/g, ""); + if (subQuery.indx != null) { + qTerms[j] = qTerms[j] + ":eq(" + subQuery.indx + ")"; + } + subSelect = []; + for (k = 0, kLimit = selection.length; k < kLimit; k++) { + partial = null; + if (qTerms[j] == textFuncSynonym) { + partial = $(selection[k]).contents().filter(function() { + return this.nodeType === 3; + }); + } else if (descend) { + partial = $(selection[k]).children(qTerms[j]); + } else if (j == 0) { + if (scope == "/") { + html = $("html", selection[k]); + if (html.length > 0) { + selection[k] = html; + } + partial = $(selection[k]).children("body").children(qTerms[j]); + scope = ""; + } else { + if (i == 0 || scope == "//") { + partial = $(selection[k]).find(qTerms[j]); + scope = ""; + } else { + partial = $(selection[k]).filter(qTerms[j]); + } + } + } else { + partial = $(selection[k]).children(qTerms[j]); + } + if (partial != null) { + for (m = 0, mLimit = partial.length; m < mLimit; m++) { + subSelect.push(partial[m]); + } + } + } + selection = subSelect; + } + } + descend = qTerms[qTerms.length - 1] == ""; + } + result = selection; + if (result != null && !(result.length === undefined)) { + if (result.length > 1) { + newNode = thymol.thDocument.createDocumentFragment(); + for (i = 0, iLimit = result.length; i < iLimit; i++) { + var newChild = thymol.thDocument.importNode(result[i], true); + newNode.appendChild(newChild); + } + result = newNode; + } else { + result = result[0]; + } + } + return result; + }, + getFilePath: function(part, element) { + var result = thymol.substitute(part, element), mapped = null, slashpos; + if (result) { + if (thymol.mappings) { + mapped = thymol.getMapped(result, false); + } + } + if (mapped) { + result = mapped; + } else { + var dotFirst = result.charAt(0) === "."; + if (result && (thymol.useAbsolutePath || !dotFirst)) { + slashpos = result.indexOf("/"); + if (thymol.useAbsolutePath || slashpos >= 0) { + if (slashpos == 0 && !thymol.useAbsolutePath) { + result = result.substring(1); + } + var proto = ""; + if (thymol.useAbsolutePath) { + proto = thymol.protocol; + } + if (thymol.useAbsolutePath && !!thymol.absolutePath) { + result = proto + thymol.absolutePath + result; + } else { + if (dotFirst) { + result = thymol.templatePath + result; + } else { + result = proto + thymol.root + thymol.path + result; + } + } + } + } + } + return result; + }, + doLiteralSubstExpr: function(param, primary) { + var result = param.trim(), term, subst, lsp; + if (thymol.ThUtils.isLiteralSubst(result)) { + result = this.decodeLiteralSubst(result); + } else { + term = primary; + while (term != null) { + if (thymol.ThUtils.isLiteralSubst(term)) { + subst = this.decodeLiteralSubst(term); + result = result.replace(term, subst); + lsp = result.match(litSubstExpr); + if (lsp && lsp.length > 0) { + term = lsp[1]; + } else { + break; + } + } else { + break; + } + } + } + return result; + }, + decodeLiteralSubst: function(param) { + var result = param, parts, rep, i, iLimit; + result = result.trim(); + result = result.substring(1, result.length - 1); + result = result.replace(/[\']/g, "'"); + parts = result.split(varRefExpr); + if (parts && parts.length > 0) { + rep = ""; + for (i = 0, iLimit = parts.length; i < iLimit; i++) { + if (parts[i] != "") { + if (!parts[i].match(varRefExpr)) { + parts[i] = "'" + parts[i] + "'"; + } + if (rep == "") { + rep = parts[i]; + } else { + rep = rep + "+" + parts[i]; + } + } + } + result = rep; + } + return result; + }, + doReplace: function(isNode, element, content) { + if (isNode) { + var parent = element.parentNode; + if (content.nodeName.toLowerCase() == "html") { + this.doInsertion(element, content, function(e, n) { + if (n.nodeType == 1) { + n.removeAttribute(thymol.thFragment.name); + n.removeAttribute(thymol.thFragment.synonym); + } + e.parentNode.insertBefore(n, e); + }); + parent.removeChild(element); + } else { + var node = this.doClone(content, parent.ownerDocument); + if (node.nodeType == 1) { + node.removeAttribute(thymol.thFragment.name); + node.removeAttribute(thymol.thFragment.synonym); + } + parent.replaceChild(node, element); + node.parentNode = parent; + } + } else { + try { + while (element.firstChild != null) { + element.removeChild(element.firstChild); + if (element.firstChild == null) { + break; + } + } + this.doInsertion(element, content, function(e, n) { + if (n.nodeType == 1) { + n.removeAttribute(thymol.thFragment.name); + n.removeAttribute(thymol.thFragment.synonym); + } + e.appendChild(n); + }); + } catch (err) { + element.innerHTML = content.innerHTML; + } + } + }, + doClone: function(old, targetDoc) { + var node, cNodes, i, iNode, aNode; + if (!!old.parentNode && old.parentNode.ownerDocument === targetDoc) { + node = old.cloneNode(false); + } else { + node = targetDoc.importNode(old, false); + } + if (node !== null) { + if (node.nodeType == 1) { + if (old.thLocalVars !== null) { + node.thLocalVars = old.thLocalVars; + } + } + if (old.childNodes !== null) { + cNodes = old.childNodes.length; + if (cNodes > 0) { + for (i = 0; i < cNodes; i++) { + iNode = old.childNodes[i]; + if (iNode !== null) { + aNode = this.doClone(iNode, targetDoc); + if (aNode !== null) { + node.appendChild(aNode); + } + } + } + } + } + } + return node; + }, + doInsertion: function(element, content, func) { + var topLevel = true, parent = element.parentElement, i, iLimit, iNode, elementName, j, jLimit, jNode, cJNode, cINode; + if (parent != null) { + topLevel = element.parentElement.nodeName.toLowerCase() == "html"; + } + for (i = 0, iLimit = content.childNodes.length; i < iLimit; i++) { + iNode = content.childNodes[i]; + if (iNode) { + if (!topLevel) { + elementName = iNode.nodeName.toLowerCase(); + if (elementName != "head") { + if (elementName == "body") { + for (j = 0, jLimit = iNode.childNodes.length; j < jLimit; j++) { + jNode = iNode.childNodes[j]; + if (jNode) { + cJNode = this.doClone(jNode, parent.ownerDocument); + func(element, cJNode); + } + } + } else { + cINode = this.doClone(iNode, parent.ownerDocument); + func(element, cINode); + } + } + } else { + cINode = this.doClone(iNode, parent.ownerDocument); + func(element, cINode); + } + } + } + }, + getThParam: function(paramName, isBoolean, isPath, defaultValue) { + var localValue = defaultValue, globalValue = thymol.thWindow[paramName], theParam = thymol.ThUtils.getParameter(paramName); + if (typeof globalValue === "undefined") { + globalValue = thymol.applicationContext.javascriptify(paramName); + } + if (!!theParam) { + if (theParam instanceof ThParam) { + if (theParam.globalValue !== globalValue) { + theParam.globalValue = globalValue; + theParam.value = globalValue; + localValue = globalValue; + } + } + if (isBoolean) { + localValue = theParam.getBooleanValue(); + } + } else { + if (!(typeof globalValue === "undefined")) { + if (globalValue != null) { + if (isBoolean) { + localValue = globalValue == true; + } else { + localValue = globalValue; + } + } + } + } + if (!isBoolean && isPath && localValue.length > 0 && localValue.charAt(localValue.length - 1) != "/") { + localValue = localValue + "/"; + } + thymol.applicationContext.createVariable(paramName, localValue); + return localValue; + } + }; + function addDialect(spec) { + var i, iLimit, prec = thymol.thDefaultPrecedence; + if (spec !== null && typeof spec !== "undefined") { + if (spec.attributeProcessors !== null && typeof spec.attributeProcessors !== "undefined") { + for (i = 0, iLimit = spec.attributeProcessors.length; i < iLimit; i++) { + if (spec.attributeProcessors[i].precedence !== null && typeof spec.attributeProcessors[i].precedence !== "undefined") { + prec = spec.attributeProcessors[i].precedence; + } else { + prec = thymol.thDefaultPrecedence; + } + configureAttributeProcessor(spec.prefix, spec.attributeProcessors[i].name, spec.attributeProcessors[i].processor, prec, null); + } + } + if (spec.elementProcessors !== null && typeof spec.elementProcessors !== "undefined") { + for (i = 0, iLimit = spec.elementProcessors.length; i < iLimit; i++) { + configureElementProcessor(spec.prefix, spec.elementProcessors[i].name, spec.elementProcessors[i].processor); + } + } + if (spec.objects !== null && typeof spec.objects !== "undefined") { + for (i = 0, iLimit = spec.objects.length; i < iLimit; i++) { + if (spec.objects[i].name !== null && typeof spec.objects[i].name !== "undefined") { + spec.objects[i].object.thExpressionObjectName = spec.objects[i].name; + configureModule(spec.objects[i].object); + } else { + configureModule(spec.objects[i]); + } + } + } + } + } + function ThNode(thDocParam, visitedParam, parentDocParam, firstChildParam, nextSiblingParam, fileNameParam, fragNameParam, isNodeParam, elementParam) { + this.thDoc = thDocParam; + this.visited = visitedParam; + this.parentDoc = parentDocParam; + this.firstChild = firstChildParam; + this.nextSibling = nextSiblingParam; + this.fileName = fileNameParam; + this.fragName = fragNameParam; + this.isNode = isNodeParam; + this.element = elementParam; + } + function ThError(message, element, source) { + this.name = "ThError"; + this.message = message || "Default Message"; + if (element !== null && typeof element !== "undefined" && element.isBlockChild) { + this.suppress = true; + } else { + this.element = element || {}; + this.suppress = false; + } + if (!!source) { + if (!!source.stack) { + this.stack = source.stack; + } + } + } + ThError.prototype = new Error(); + ThError.prototype.constructor = ThError; + function ThParam(valueArg) { + this.value = valueArg; + this.globalValue; + this["class"] = new thymol.ThClass("Thymol.ThParam"); + this.getBooleanValue = function() { + return !thymol.ThUtils.testLiteralFalse(this.value); + }; + this.toString = function() { + return this.value; + }; + this.getNumericValue = function() { + return Number(this.value); + }; + } + function ThAttr(suffix, func, prec, list, pref, dataAttr) { + var prefix = "", dataPrefix = null, escpPrefix = ""; + if (typeof pref !== "undefined" && pref !== null) { + prefix = pref + ":"; + if (thymol.thThymeleafPrefixList.indexOf(prefix) < 0) { + thymol.thThymeleafPrefixList.push(prefix); + } + escpPrefix = pref + "\\:"; + if (typeof dataAttr === "undefined" || dataAttr === null) { + dataPrefix = thymol.dataPrefix + "-" + pref + "-"; + if (thymol.thThymeleafPrefixList.indexOf(dataPrefix) < 0) { + thymol.thThymeleafPrefixList.push(dataPrefix); + } + } else { + dataPrefix = dataAttr; + } + } + this.suffix = suffix; + this.name = prefix + suffix; + this.regex = null; + if (suffix.indexOf("*") >= 0 || suffix.indexOf("?") >= 0 || suffix.indexOf("+") >= 0 || suffix.indexOf("\\") >= 0 || suffix.indexOf("|") >= 0 || suffix.indexOf("[") >= 0 || suffix.indexOf("]") >= 0 || suffix.indexOf("{") >= 0 || suffix.indexOf("}") >= 0) { + if ("*" === suffix) { + suffix = ".*"; + } + suffix = prefix + suffix; + this.regex = new RegExp(suffix); + } + this.escpName = "[" + escpPrefix + suffix + "]"; + if (dataPrefix !== null) { + this.synonym = dataPrefix + suffix; + this.escpSynonym = "[" + this.synonym + "]"; + } else { + this.synonym = null; + this.escpSynonym = null; + } + if (typeof prec !== "undefined" && prec !== null) { + this.precedence = prec; + } else { + this.precedence = thymol.thDefaultPrecedence; + } + if (!!list) { + var attrList = list[pref]; + if (!attrList) { + attrList = []; + list[pref] = attrList; + if (dataPrefix !== null) { + list[dataPrefix] = attrList; + } + } + attrList.push(this); + } + this.process = function() { + thymol.thWindow.alert('unsupported processing function for attribute "' + this.name + '"'); + }; + if (!(typeof func === "undefined")) { + this.process = func; + } + this.disable = function() { + this.name = null; + this.escpName = null; + this.escpSynonym = null; + this.process = function() {}; + }; + } + function ThElement(suffix, func, pref) { + var tha = new thymol.ThAttr(suffix, null, 0, null, pref); + this.name = tha.name; + this.synonym = tha.synonym; + this.endName = "/" + tha.name; + this.endSynonym = "/" + tha.synonym; + this.process = function() { + thymol.thWindow.alert('unsupported processing function for element "' + this.name + '"'); + }; + if (!(typeof func === "undefined")) { + this.process = func; + } + this.disable = function() { + this.name = null; + this.synonym = null; + this.endName = null; + this.endSynonym = null; + this.process = null; + }; + thymol.thThymeleafElementsList.push(this); + } + function ThSet() { + this.that = this; + this.setSize = 0; + this.isContent = function(k) { + return this.hasOwnProperty(k) && typeof this[k] !== "function" && k !== "that" && k !== "setSize"; + }; + this.add = function(k) { + var contained = typeof this[k] !== "undefined"; + this[k] = k; + if (contained !== (typeof this[k] !== "undefined")) { + this.setSize++; + } + }; + this.addAll = function(other) { + var k = null, value; + for (k in other) { + if (other.hasOwnProperty(k)) { + value = other[k]; + if (typeof value !== "function") { + add(value); + } + } + } + }; + this.clear = function() { + for (var k in this) { + if (this.hasOwnProperty(k)) { + delete this[k]; + } + } + setSize = 0; + }; + this.contains = function(k) { + return typeof this[k] !== "undefined"; + }; + this.containsAll = function(keys) { + var keySet = keys, k = null; + if (typeof keys === "Array" || Object.prototype.toString.call(keys) === "[object Array]") { + keySet = ThSet.prototype.fromArray(keys); + } + for (k in keySet) { + if (keySet.hasOwnProperty(k)) { + if (typeof this[k] === "undefined") { + return false; + } + } + } + return true; + }; + this.isEmpty = function() { + return this.setSize === 0; + }; + this.size = function() { + return this.setSize; + }; + this.remove = function(k) { + var contained = typeof this[k] !== "undefined"; + delete this[k]; + if (contained !== (typeof this[k] !== "undefined")) { + this.setSize--; + } + }; + this.toArray = function() { + return getArray(this); + }; + this.toString = function() { + var array = getArray(); + return array.toString(); + }; + function getArray(obj) { + var array = [], k = null, value; + for (k in obj) { + if (obj.hasOwnProperty(k) && k !== "that" && k !== "setSize") { + value = obj[k]; + if (typeof value !== "function") { + array.push(value); + } + } + } + return array; + } + } + ThSet.prototype.fromArray = function(array) { + var set = new thymol.ThSet(), i, iLimit; + for (i = 0, iLimit = array.length; i < iLimit; i++) { + set.add(array[i]); + } + return set; + }; + function ThMap() { + ThSet.apply(this); + this.containsKey = function(k) { + return this.contains(k); + }; + this.containsValue = function(target) { + var k = null, value; + for (k in this.that) { + if (this.that.hasOwnProperty(k) && k !== "that") { + value = this.that[k]; + if (value === target) { + return true; + } + } + } + return false; + }; + this.entrySet = function() { + return this.that; + }; + this.get = function(k) { + return this.that[k]; + }; + this.keySet = function() { + return this.that; + }; + this.put = function(k, v) { + var contained = typeof this[k] !== "undefined"; + this.that[k] = v; + if (contained !== (typeof this[k] !== "undefined")) { + this.setSize++; + } + }; + this.putAll = function(t) { + for (var k in t) { + put(k, t[k]); + } + }; + this.values = function() { + return this.that; + }; + } + ThMap.prototype = new ThSet(); + ThMap.prototype.constructor = ThMap; + function ThObject(dolly) { + for (prop in dolly) { + if (dolly.hasOwnProperty(prop)) { + if (prop) { + if (!this[prop]) { + this[prop] = dolly[prop]; + } + } + } + } + this["class"] = new thymol.ThClass("Thymol.ThObject"); + this.toNonThObject = function() { + var plain = {}; + for (prop in this) { + if (this.hasOwnProperty(prop)) { + if (prop) { + if (!plain[prop]) { + if (prop !== "toNonThObject") { + if (prop !== "class" || prop === "class" && this[prop] !== null && this[prop].name !== "Thymol.ThObject") { + plain[prop] = this[prop]; + } + } + } + } + } + } + return plain; + }; + } + function ThVarsAccessor(storeArg, storeNameArg) { + this.store = storeArg; + this.arrayName = storeNameArg; + this.length = function() { + return this.store.length; + }; + this.get = function(name) { + return this.store[name]; + }; + this.set = function(name, value) { + this.store[name] = value; + }; + } + function ThClass(nValue) { + this.name = nValue; + } + return { + Thymol: Thymol, + ThError: ThError, + ThParam: ThParam, + ThAttr: ThAttr, + ThElement: ThElement, + ThSet: ThSet, + ThMap: ThMap, + ThObject: ThObject, + ThVarsAccessor: ThVarsAccessor, + ThClass: ThClass, + thDomParser: thymol.thDomParser, + thDocument: thymol.thDocument, + thWindow: thymol.thWindow, + thTop: thymol.thTop, + thRequest: thymol.thRequest, + thVersion: thymol.thVersion, + thReleaseDate: thymol.thReleaseDate, + thURL: thymol.thURL, + thAltURL: thymol.thAltURL, + thInclude: thymol.thInclude, + thReplace: thymol.thReplace, + thSubstituteby: thymol.thSubstituteby, + thFragment: thymol.thFragment, + thRemove: thymol.thRemove, + thBlock: thymol.thBlock, + thScriptName: thymol.thScriptName, + thDefaultPrefix: thymol.thDefaultPrefix, + thDefaultDataPrefix: thymol.thDefaultDataPrefix, + thDefaultPrecision: thymol.thDefaultPrecision, + thDefaultProtocol: thymol.thDefaultProtocol, + thDefaultLocale: thymol.thDefaultLocale, + thDefaultPrecedence: thymol.thDefaultPrecedence, + thDefaultMessagePath: thymol.thDefaultMessagePath, + thDefaultResourcePath: thymol.thDefaultResourcePath, + thDefaultMessagesBaseName: thymol.thDefaultMessagesBaseName, + thDefaultRelativeRootPath: thymol.thDefaultRelativeRootPath, + thDefaultExtendedMapping: thymol.thDefaultExtendedMapping, + thDefaultLocalMessages: thymol.thDefaultLocalMessages, + thDefaultDisableMessages: thymol.thDefaultDisableMessages, + thDefaultTemplateSuffix: thymol.thDefaultTemplateSuffix, + thThymeleafPrefixList: thymol.thThymeleafPrefixList, + thThymeleafElementsList: thymol.thThymeleafElementsList, + thLocation: thymol.thLocation, + messagePath: thymol.messagePath, + resourcePath: thymol.resourcePath, + relativeRootPath: thymol.relativeRootPath, + messagesBaseName: thymol.messagesBaseName, + extendedMapping: thymol.extendedMapping, + scriptPath: thymol.scriptPath, + absolutePath: thymol.absolutePath, + useAbsolutePath: thymol.useAbsolutePath, + useFullURLPath: thymol.useFullURLPath, + localMessages: thymol.localMessages, + indexFile: thymol.indexFile, + disableMessages: thymol.disableMessages, + templateSuffix: thymol.templateSuffix, + prefix: thymol.prefix, + dataPrefix: thymol.dataPrefix, + templateName: thymol.templateName, + templatePath: thymol.templatePath, + objects: thymol.objects, + jqSetup: jqSetup, + isClientSide: isClientSide, + execute: execute, + updatePrefix: updatePrefix, + init: init, + ready: ready, + addDialect: addDialect, + isFragmentChild: isFragmentChild, + preProcess: preProcess, + substitute: substitute, + substituteParam: substituteParam, + configureModule: configureModule, + configureAttributeProcessor: configureAttributeProcessor, + configureElementProcessor: configureElementProcessor, + configurePreExecution: configurePreExecution, + configurePostExecution: configurePostExecution, + getStandardURL: getStandardURL, + getMessage: getMessage, + getExpression: getExpression, + getWith: getWith, + getParsedExpr: getParsedExpr, + getLocale: getLocale, + getMapped: getMapped, + getBooleanValue: getBooleanValue, + setLocale: setLocale + }; +}(); + +thymol.makeContext = function(contextNameParam, varAccessorParam) { + var jsonDeclSpec = "(?:\\W*([\\'][A-Za-z]+(?:\\w|[$])*[\\'])\\s*[:])?\\s*([#][A-Za-z]+(?:\\w|[$])*)(?:\\W|[^$])*", jsonDeclExpr = new RegExp(jsonDeclSpec), context = new Array(); + context.contextName = contextNameParam; + context.varAccessor = varAccessorParam; + context.varStore = []; + context.varNamePrefix = ""; + if (typeof varAccessorParam === "undefined") { + context.varAccessor = new thymol.ThVarsAccessor(context.varStore, "varStore"); + } + context.varNamePrefix = context.varAccessor.arrayName + "["; + context.getJSONView = function(param, rootVal) { + var pType = typeof param, view = "", objType; + if (pType === "string") { + view = view + "'" + param + "'"; + } else if (pType === "number" || pType === "boolean") { + view = view + param; + } else if (pType === "object") { + if (param instanceof Object) { + objType = Object.prototype.toString.call(param); + if ("[object Array]" === objType) { + view = this.getJSONViewArray(param, false); + } else if ("[object Object]" === objType) { + view = this.getJSONViewObject(param, false); + } + view = "#" + view; + } + } + return view; + }; + context.init = function() { + var persisted = thymol.thTop.name, paramRow, paramName, params, i, iLimit, paramValue; + if (persisted && persisted !== "") { + params = this.javascriptify(persisted); + if (params && params.length > 0) { + for (i = 0, iLimit = params.length; i < iLimit; i++) { + paramRow = params[i]; + if (paramRow) { + paramName = paramRow[0]; + if (paramName) { + paramValue = paramRow[1]; + this.createVariable(paramName, paramValue); + } + } + } + } + } + }; + context.getJSONViewObject = function(param, rootVal) { + var isRoot = true, key = null, view = "{", value, identifier, definition, suffix, instanceNamePrefix, isTaken, i, iLimit, instanceValue; + if (typeof rootVal === "boolean") { + isRoot = rootVal; + } + for (key in param) { + if (key) { + value = param[key]; + if (typeof value !== "function") { + if (view != "{") { + view = view + ","; + } + identifier = this.getJSONView(key, false); + definition = this.getJSONView(value, false); + view = view + identifier + ":"; + if (!isRoot && typeof value === "object") { + suffix = 1; + instanceNamePrefix = key + "$"; + instanceName = null; + isTaken = false; + do { + instanceName = instanceNamePrefix + suffix++; + instanceValue = context[instanceName]; + if (instanceValue === null || typeof instanceValue === "undefined") { + isTaken = false; + for (i = 0, iLimit = varStore.length; i < iLimit; i++) { + if (instanceName === varStore[i][0]) { + isTaken = true; + break; + } + } + if (!isTaken) { + this.addAttribute(instanceName, definition); + } + } + } while (isTaken); + if (instanceName !== null) { + view = view + "#" + instanceName; + } + } else { + view = view + definition; + } + } + } + } + view = view + "}"; + return view; + }; + context.getJSONViewArray = function(param, rootVal) { + var view = "[", i; + for (i = 0; i < param.length; i++) { + view = view + this.getJSONView(param[i], false); + if (i < param.length - 1) { + view = view + ","; + } + } + view = view + "]"; + return view; + }; + context.getAttribute = function(name) { + return context[name]; + }; + context.addAttribute = function(name, value) { + var entry = []; + entry[0] = name; + entry[1] = value; + varStore.push(entry); + }; + context.serialise = function() { + varStore = []; + var serialised = "[", key = null, value, cn, view, name, i, iLimit; + for (key in context) { + if (key) { + value = context[key]; + if (value != null && typeof value === "object") { + cn = Object.prototype.toString.call(value); + if ("[object Array]" !== cn && !(value instanceof thymol.ThClass) && !(value instanceof thymol.ThVarsAccessor)) { + if (serialised !== "[") { + serialised = serialised + ","; + } + view = this.getJSONView(value, true); + serialised = serialised + "["; + serialised = serialised + '"' + key + '"'; + serialised = serialised + ","; + serialised = serialised + '"' + view + '"'; + serialised = serialised + "]"; + } + } + } + } + for (i = 0, iLimit = varStore.length; i < iLimit; i++) { + name = varStore[i][0]; + view = varStore[i][1]; + serialised = serialised + ",["; + serialised = serialised + '"' + name + '"'; + serialised = serialised + ","; + serialised = serialised + '"' + view + '"'; + serialised = serialised + "]"; + } + serialised = serialised + "]"; + return serialised; + }; + context.javascriptify = function(fn) { + try { + return new Function("return " + fn)(); + } catch (err) { + return undefined; + } + }; + context.createVariable = function(name, valParam, isReq) { + var value = valParam, param, tt, literalBoolean, strValue, initial, existing, newArray; + param = value; + if (!(value instanceof thymol.ThParam)) { + tt = typeof valParam; + if (tt !== "function" && tt !== "object") { + if (tt === "string") { + try { + value = isReq ? decodeURIComponent(value) : decodeURI(value); + } catch (err) {} + } + if (tt === "boolean" || tt === "number") { + param = new thymol.ThParam(value); + } else if (value || value === "") { + literalBoolean = thymol.ThUtils.testLiteralFalse(value); + if (literalBoolean) { + param = false; + } else { + strValue = new String(value); + initial = strValue.trim(); + if (initial.charAt(0) === "#") { + initial = initial.substring(1); + try { + param = this.createJSONVariable(initial); + } catch (err) { + if (err instanceof ReferenceError) {} + if (err instanceof EvalError) {} + if (param == null || isReq) { + param = new thymol.ThParam(value); + } + } + } else { + param = new thymol.ThParam(strValue.toString()); + } + } + } + } + } + if (isReq) { + existing = context[name]; + if (typeof existing !== "undefined" && existing !== null) { + if (Object.prototype.toString.call(existing) === "[object Array]") { + existing.push(param); + } else { + if (thymol.debug) { + thymol.thWindow.alert('request parameters should be of type string array "' + name + '"'); + } + } + } else { + newArray = new Array(); + newArray["class"] = {}; + newArray["class"]["name"] = "[Thymol.ThParam]"; + newArray.push(param); + context[name] = newArray; + } + } else { + context[name] = param; + } + return param; + }; + context.createJSONVariable = function(initial) { + var current = initial.trim(), parts = " ", substIndex, token, re, vName, obj, result; + substIndex = this.varAccessor.length() + 1; + while (parts) { + parts = current.match(jsonDeclExpr); + if (parts && parts.length > 2) { + token = parts[2]; + token = token.replace(/[\']/g, "[']").replace(/[$]/g, "[$]"); + re = new RegExp(token); + vName = this.varNamePrefix + substIndex + "]"; + obj = new Object(); + obj.name = parts[2].substring(1); + this.varAccessor.set(substIndex, obj); + substIndex = substIndex + 1; + current = current.replace(re, "'" + vName + "'", "g"); + } + } + current = current.replace(/[\']/g, '"'); + result = $.parseJSON(current); + if ("[object Array]" !== Object.prototype.toString.call(result)) { + result = new thymol.ThObject(result); + } + return result; + }; + context.resolveJSONReferences = function() { + var key = null, param, prop = null, val, ref, subst, isReq = "request" === this.contextName; + for (key in context) { + if (key) { + param = context[key]; + if (param != null && typeof param === "object") { + if (!(param instanceof thymol.ThVarsAccessor) && !(param instanceof thymol.ThClass)) { + if (!(param instanceof thymol.ThParam)) { + if (isReq && Object.prototype.toString.call(param) === "[object Array]") { + for (var i = 0, iLimit = param.length; i < iLimit; i++) { + var pi = param[i]; + if (!!pi && typeof pi.value === "string" && pi.value.charAt(0) == "#") { + var pv = thymol.ThUtils.getParameter(pi.value.substring(1)); + param[i] = pv; + } + } + } else { + for (prop in param) { + if (prop) { + val = param[prop]; + if (typeof val === "string") { + if (val.indexOf(this.varNamePrefix) == 0) { + subst = null; + if (prop.match(/\d*/)) { + ref = val.substring(this.varNamePrefix.length, val.length - 1); + ref = this.varAccessor.get(ref); + subst = context[ref.name]; + } else { + subst = context[prop]; + } + param[prop] = subst; + } + } + } + } + } + } else if (typeof param.value === "string" && param.value.charAt(0) == "#") { + subst = context[param.value.substring(1)]; + context[key] = subst; + } + } + } + } + } + }; + return context; +}; + +thymol.ThUtils = function() { + function mergeVars(thiz, other) { + var current = thiz, prop = null; + if (!current) { + current = {}; + } + for (prop in other) { + if (other.hasOwnProperty(prop)) { + if (prop) { + if (!current[prop]) { + current[prop] = other[prop]; + } + } + } + } + return current; + } + function processElement(func, element, arg, obj) { + var result = null, parent = element.parentElement; + if (!thymol.isFragmentChild(element)) { + if (!element.thObjectVar) { + parent = element.parentElement; + while (parent) { + if (parent.thObjectVar) { + element.thObjectVar = parent.thObjectVar; + break; + } + parent = parent.parentElement; + } + } + parent = element.parentElement; + while (parent) { + if (parent.thLocalVars) { + element.thLocalVars = mergeVars(element.thLocalVars, parent.thLocalVars); + break; + } + parent = parent.parentElement; + } + result = func(element, arg, obj); + } + return result; + } + function unQuote(param) { + var par = param, pared; + if (par) { + if (typeof par === "string") { + par = par.trim(); + if (par.charAt(0) == '"') { + if (par.charAt(par.length - 1) == '"') { + pared = par.substring(1, par.length - 1); + if (pairParity(pared, '"', '"') == 0) { + par = pared; + } + } + } else if (par.charAt(0) == "'") { + if (par.charAt(par.length - 1) == "'") { + pared = par.substring(1, par.length - 1); + if (pairParity(pared, "'", "'") == 0) { + par = pared; + } + } + } + } + } + return par; + } + function unParenthesise(param) { + var par = param, pared; + if (par) { + if (typeof par === "string") { + par = par.trim(); + if (par.charAt(0) == "(") { + if (par.charAt(par.length - 1) == ")") { + pared = par.substring(1, par.length - 1).trim(); + if (pairParity(pared, "(", ")") == 0) { + par = pared; + } + } + } + } + } + return par; + } + function pairParity(str, left, right) { + var i, ch, strLength = str.length, parity = 0; + for (i = 0; i < strLength; i++) { + ch = str.charAt(i); + if (ch == left) { + parity++; + } else if (ch == right) { + parity--; + if (parity < 0) { + break; + } + } + } + return parity; + } + function unBracket(param) { + var par = param, pared; + if (typeof par === "string") { + par = par.trim(); + } + if (par) { + if (par.charAt(0) == "[") { + if (par.charAt(par.length - 1) == "]") { + pared = par.substring(1, par.length - 1); + if (pairParity(pared, "[", "]") == 0) { + par = pared; + } + } + } + } + return par; + } + function getToPrecision(n, p) { + if (typeof p === "undefined") { + return n; + } + var up = thymol.thDefaultPrecision, ndp = 0, s, sl, dp, v; + if (p > up) { + up = p; + } else { + s = n.toString(); + sl = s.length; + dp = s.indexOf("."); + if (dp >= 0) { + ndp = sl - 1 - dp; + } + if (ndp > up) { + v = n.toPrecision(ndp + 1); + v = truncateDecimals(v); + s = v.toString(); + sl = s.length; + if (dp >= 0) { + ndp = sl - 1 - dp; + } + } + if (p > ndp) { + up = p; + } else if (ndp < up) { + up = ndp; + } + } + v = parseFloat(n); + v = v.toFixed(up); + if (p === 0) { + v = Number(v); + } + return v; + } + function truncateDecimals(valp) { + var val = valp, iLimit = valp.length - 1, i; + for (i = iLimit; i >= 0; i--) { + if (val.charAt(i) === "0") { + val = val.substr(0, i); + } else { + break; + } + } + return val; + } + function getDecimalDigits(val) { + var digits = 0, s, dp; + s = val.toString(); + dp = s.indexOf(".") + 1; + if (dp > 0) { + digits = s.length - dp; + } + return digits; + } + function testLiteralFalse(initial) { + var result = false, val; + if (typeof initial === "string") { + val = initial.toLowerCase(); + result = val == "false" || val == "off" || val == "no"; + } else if (typeof initial === "boolean") { + result = !initial; + } + return result; + } + function renderMessage(msg, values) { + var result = msg, i, iLimit; + if (Object.prototype.toString.call(values) == "[object Array]") { + for (i = 0, iLimit = values.length; i < iLimit; i++) { + result = renderMessageArg(result, i, values[i]); + } + } else { + result = renderMessageArg(msg, 0, values); + } + return result; + } + function renderMessageArg(msg, index, value) { + var result = msg, splits, i, iLimit, iUpper; + splits = msg.split("{" + index + "}"); + if (splits.length > 0) { + result = ""; + for (i = 0, iLimit = splits.length, iUpper = iLimit - 1; i < iLimit; i++) { + result += splits[i]; + if (i < iUpper) { + result += value; + } + } + } + return result; + } + function getParameter(name) { + var result, tor; + result = thymol.requestContext[name]; + tor = typeof result; + if (tor === "undefined") { + result = thymol.sessionContext[name]; + if (typeof result === "undefined") { + result = thymol.applicationContext[name]; + } + } else if (tor === "object") { + if (Object.prototype.toString.call(result) === "[object Array]") { + if (result.length === 1) { + result = result[0]; + } + } + } + return result; + } + function charOcurrences(str, chr) { + var count = 0, i = 0, iLimit = str.length; + for (;i < iLimit; i++) { + if (str.charAt(i) === chr) { + count++; + } + } + return count; + } + function isLiteral(val) { + var first, last; + if (typeof val === "string") { + first = val.charAt(0); + last = val.charAt(val.length - 1); + if (first == "'" && last == "'") { + return true; + } + if (first == '"' && last == '"') { + return true; + } + } + return false; + } + function isLiteralSubst(param) { + var result = false, par = param; + if (typeof par === "string") { + par = par.trim(); + } + if (par) { + if (par.charAt(0) == "|") { + if (par.charAt(par.length - 1) == "|") { + result = true; + } + } + } + return result; + } + function loadScript(file) { + var script = thymol.Thymol.prototype.getFilePath(file); + var status = ""; + var jqxhr = $.ajax({ + type: "GET", + url: script, + dataType: "script", + cache: true, + async: false + }).done(function() { + status = "success"; + }).fail(function() { + status = "error"; + }); + } + function unescape(text) { + var result = text, i, iLimit, iUpper, c, cc; + if (text !== null && typeof text !== "undefined") { + result = ""; + iLimit = text.length; + iUpper = iLimit - 3; + for (i = 0; i < iLimit; i++) { + c = text.charAt(i); + if (i < iUpper) { + if (c === "&") { + cc = text.charAt(i + 1).toLowerCase(); + if ((cc === "g" || cc === "l") && text.charAt(i + 2).toLowerCase() === "t" && text.charAt(i + 3) === ";") { + i += 3; + if (cc === "g") { + c = ">"; + } else { + c = "<"; + } + } else if (i < iUpper - 1 && cc === "a" && text.charAt(i + 2).toLowerCase() === "m" && text.charAt(i + 3).toLowerCase() === "p" && text.charAt(i + 4) === ";") { + i += 4; + } else if (i < iUpper - 2) { + if (cc === "q" && text.charAt(i + 2).toLowerCase() === "u" && text.charAt(i + 3).toLowerCase() === "o" && text.charAt(i + 4).toLowerCase() === "t" && text.charAt(i + 5) === ";") { + i += 5; + c = '"'; + } else if (cc === "a" && text.charAt(i + 2).toLowerCase() === "p" && text.charAt(i + 3).toLowerCase() === "o" && text.charAt(i + 4).toLowerCase() === "s" && text.charAt(i + 5) === ";") { + i += 5; + c = "'"; + } + } + } + } + result += c; + } + } + return result; + } + function unicodeUnescape(initial) { + var result = initial.replace(/\\u([\da-f]{4})/gi, function(match, grp) { + return String.fromCharCode(parseInt(grp, 16)); + }); + result = unescape(result); + return result; + } + function removeTag(element) { + var parent = element.parentNode, i, iLimit, savedObject = element.thObjectVar, savedLocals = element.thLocalVars; + if (!!parent) { + for (i = 0, iLimit = element.childNodes.length; i < iLimit; i++) { + var newNode = element.childNodes[i].cloneNode(true); + if (newNode.nodeType === 1) { + if (!!savedObject) { + newNode.thObjectVar = savedObject; + } + if (!!savedLocals) { + newNode.thLocalVars = savedLocals; + } + } + parent.insertBefore(newNode, element); + } + parent.removeChild(element); + } + } + function getRequestEncoded(initial) { + var result = initial; + result = encodeURIComponent(result); + result = result.replace(/%20/g, "+"); + result = result.replace(/%26/g, "&"); + result = result.replace(/%3A/g, ":"); + result = result.replace(/!/g, "%21"); + result = result.replace(/'/g, "%27"); + result = result.replace(/\(/g, "%28"); + result = result.replace(/\)/g, "%29"); + result = result.replace(/\*/g, "%2A"); + result = result.replace(/~/g, "%7E"); + return result; + } + return { + getParameter: getParameter, + processElement: processElement, + unQuote: unQuote, + unParenthesise: unParenthesise, + unBracket: unBracket, + getToPrecision: getToPrecision, + getDecimalDigits: getDecimalDigits, + testLiteralFalse: testLiteralFalse, + renderMessage: renderMessage, + charOcurrences: charOcurrences, + isLiteral: isLiteral, + isLiteralSubst: isLiteralSubst, + loadScript: loadScript, + unescape: unescape, + unicodeUnescape: unicodeUnescape, + removeTag: removeTag, + getRequestEncoded: getRequestEncoded + }; +}(); + +thymol.ThParser = function(scope) { + function object(o) { + function F() {} + F.prototype = o; + return new F(); + } + function NullReturn(varName) { + this.varName = varName; + } + var TNUMBER = 0; + var TOP1 = 1; + var TOP2 = 2; + var TVAR = 3; + var TFUNCALL = 4; + var MSGSUBST = 5; + var ARGLIST = 6; + function Token(type_p, index_p, prio_p, number_p, mode_p, meta_p) { + this.type_ = type_p; + this.index_ = index_p || 0; + this.prio_ = prio_p || 0; + this.number_ = number_p !== undefined && number_p !== null ? number_p : 0; + this.mode_ = mode_p !== undefined && mode_p !== null ? mode_p : 0; + this.meta_ = meta_p; + this.toString = function() { + switch (this.type_) { + case TNUMBER: + return this.number_; + + case TOP1: + case TOP2: + case TVAR: + return this.index_; + + case TFUNCALL: + case MSGSUBST: + case ARGLIST: + return "CALL"; + + default: + return "Invalid Token"; + } + }; + } + function Expression(tokens, ops1, ops2, functions, precision, position) { + this.tokens = tokens; + this.ops1 = ops1; + this.ops2 = ops2; + this.functions = functions; + this.precision = precision; + this.position = position; + } + Expression.prototype = { + simplify: function(valuesParam) { + var values = valuesParam || {}; + var nstack = []; + var newexpression = []; + var n1; + var n2; + var f; + var L = this.tokens.length; + var item; + var i = 0; + for (i = 0; i < L; i++) { + item = this.tokens[i]; + var type_ = item.type_; + if (type_ === TNUMBER) { + nstack.push(item); + } else if (type_ === TVAR && !(item.index_ in new Object()) && item.index_ in values) { + item = new Token(TNUMBER, 0, 0, values[item.index_]); + nstack.push(item); + } else if (type_ === TOP2 && nstack.length > 1) { + f = this.ops2[item.index_]; + if (!!f) { + n2 = nstack.pop(); + n1 = nstack.pop(); + item = new Token(TNUMBER, 0, 0, f(n1.number_, n2.number_)); + } + nstack.push(item); + } else if (type_ === TOP1 && nstack.length > 0) { + if ("{" == item.index_) { + if (item.mode_ == 2) { + nstack.push(item); + } + } else { + n1 = nstack.pop(); + f = this.ops1[item.index_]; + item = new Token(TNUMBER, 0, 0, f(n1.number_)); + nstack.push(item); + } + } else { + while (nstack.length > 0) { + newexpression.push(nstack.shift()); + } + newexpression.push(item); + } + } + while (nstack.length > 0) { + newexpression.push(nstack.shift()); + } + var res = new Expression(newexpression, object(this.ops1), object(this.ops2), object(this.functions), this.precision); + return res; + }, + evaluate: function(element) { + var nstack = []; + var n1; + var n2; + var f; + var res = null; + var L = this.tokens.length; + var item; + var i = 0; + var result; + for (i = 0; i < L; i++) { + item = this.tokens[i]; + if (i === 0 && thymol.disableMessages && item.mode_ === 4) { + var nullReturn = new thymol.ThClass(); + nullReturn.abort = true; + return nullReturn; + } + var type_ = item.type_; + if (type_ === TNUMBER) { + nstack.push(item.number_); + if (i == L - 1) { + break; + } + } else if (type_ === TOP2) { + n2 = nstack.pop(); + if (typeof n2 === "undefined" || n2 instanceof NullReturn) { + n2 = null; + } + n1 = nstack.pop(); + if (typeof n1 === "undefined" || n1 instanceof NullReturn) { + n1 = null; + } + f = this.ops2[item.index_]; + var pathMatch = false; + try { + if (item.mode_ === 6) { + if (f === dot) { + res = n1 + "[" + n2 + "]"; + } else if (f === append) { + if (!!item.meta_) { + if (!!item.meta_.paths) { + var values = item.meta_.paths[n1]; + if (!!values) { + values.push(n2); + pathMatch = true; + res = null; + } + } + } + if (!pathMatch) { + if (!item.meta_) { + item.meta_ = {}; + } + if (!item.meta_.params) { + item.meta_.params = []; + } + var values = item.meta_.params[n1]; + if (!values) { + values = []; + item.meta_.params[n1] = values; + } + values.push(n2); + pathMatch = true; + } + } else { + res = n2; + nstack.push(n1); + } + } else { + if (f === dot && "class" === n2 && !!n1 && !n1["class"]) { + var tn2 = typeof n2; + if (tn2 === "object" && n2 instanceof thymol.ThParam) { + res = f(n1, n2); + } else { + res = new thymol.ThClass("JavaScript:" + tn2); + } + } else { + res = f(n1, n2); + if (typeof res === "function") { + if (L - 1 > i) { + next = this.tokens[i + 1]; + if (next.type_ === TNUMBER && Object.prototype.toString.call(next.number_) == "[object Array]" && next.number_.length == 0) { + i += 1; + nstack.push(res); + n1.isDirect = true; + res = n1; + } + } + } + } + if (f !== append) { + if (Object.prototype.toString.call(res) == "[object Array]") { + res.arrayResult = true; + } + } + } + } catch (err) { + if (!element.isBlockChild) { + var aValue = n1 == null ? "null" : n1; + var bValue = n2 == null ? "null" : n2; + var message = "while evaluating expression: " + this.tokens[i - 2].index_ + ": " + aValue + ", " + this.tokens[i - 1].index_ + ": " + bValue; + throw new thymol.ThError(message, element, err); + } + } + if (!pathMatch) { + nstack.push(res); + } + } else if (type_ === TVAR) { + var next = null, pushed = nstack.length; + if (item.index_ != null) { + if (L - 1 > i) { + next = this.tokens[i + 1]; + if (next.type_ === TOP2 && next.index_ === ".") { + nstack.push(item.index_); + } + } + if (pushed === nstack.length) { + var val = thymol.substituteParam(item.index_, item.mode_, element); + if (Object.prototype.toString.call(val) == "[object Array]") { + val.arrayResult = true; + } + this.updatePrecision(val); + if (val === null) { + val = new NullReturn(item.index_); + } + nstack.push(val); + } + } else if (pushed === nstack.length && item.index_ in this.functions) { + nstack.push(this.functions[item.index_]); + } else { + if (!element.isBlockChild) { + throw new thymol.ThError("Exception undefined variable: " + item.index_, element); + } + } + } else if (type_ === TOP1) { + n1 = nstack.pop(); + if (typeof n1 === "undefined" || n1 instanceof NullReturn) { + if (item.mode_ === 2) { + n1 = ""; + } else { + n1 = null; + } + } + res = n1; + if ("{" === item.index_) { + var prev = this.tokens[i - 1]; + if (prev.mode_ == 7) { + if (thymol.conversionService) { + n1 = thymol.conversionService(n1); + res = n1; + } + } + if (typeof n1 === "string") { + if (item.mode_ === 2) { + res = thymol.getStandardURL(n1); + } else { + var subst = thymol.substituteParam(n1, item.mode_, element); + if (subst != null) { + this.updatePrecision(subst); + res = subst; + } + } + } + } else { + f = this.ops1[item.index_]; + try { + res = f(n1); + } catch (err) { + if (!element.isBlockChild) { + var aValue = n1 == null ? "null" : n1; + var message = "while evaluating expression: " + this.tokens[i - 2].index_ + ": " + aValue; + throw new thymol.ThError(message, element, err); + } + } + } + if (Object.prototype.toString.call(res) == "[object Array]") { + res.arrayResult = true; + } + nstack.push(res); + } else if (type_ === TFUNCALL || type_ === MSGSUBST || type_ === ARGLIST) { + n1 = nstack.pop(); + f = nstack.pop(); + if (type_ === MSGSUBST) { + if (f instanceof NullReturn) { + res = "??" + f.varName + "_" + thymol.locale.value + "??"; + } else { + res = thymol.ThUtils.renderMessage(f, n1); + } + nstack.push(res); + } else if (type_ === ARGLIST) { + var pathMatch = false; + n2 = nstack.pop(); + if (typeof n2 === "undefined") { + n2 = f; + f = n1; + n1 = ""; + } + if (!!item.meta_) { + if (!!item.meta_.paths) { + var values = item.meta_.paths[f]; + if (!!values) { + values.push(n1); + pathMatch = true; + } + for (var j in item.meta_.paths) { + if (item.meta_.paths.hasOwnProperty(j)) { + var values = item.meta_.paths[j]; + var isReq = n2.indexOf("?") >= 0; + if (!!values && values.length > 0) { + var pathVar = "{" + j + "}"; + var repReg = new RegExp(pathVar, "g"); + var rep = ""; + values.reverse(); + for (var k = 0, kLimit = values.length; k < kLimit; k++) { + if (rep.length > 0) { + rep = rep + ","; + } + if (isReq) { + rep = rep + thymol.ThUtils.getRequestEncoded(values[k]); + } else { + rep = rep + encodeURIComponent(values[k]); + } + } + n2 = n2.replace(repReg, rep); + } + } + } + } + } + if (pathMatch) { + res = n2; + } else { + if (typeof f === "undefined" || f instanceof NullReturn) { + f = ""; + } else { + f = f.toString(); + } + f = thymol.ThUtils.getRequestEncoded(f); + f = "?" + f; + n1 = n1.toString(); + if (f != "?" && n1 != "") { + f = f + "="; + } + if (n1 != "") { + n1 = thymol.ThUtils.getRequestEncoded(n1); + f = f + n1; + } + if (typeof n2 === "undefined" || n2 instanceof NullReturn) { + n2 = ""; + } else { + n2 = n2.toString(); + } + res = n2 + f; + } + if (!!item.meta_) { + var separator = res.indexOf("?") >= 0 ? "&" : "?"; + for (var j in item.meta_.params) { + if (item.meta_.params.hasOwnProperty(j)) { + var values = item.meta_.params[j]; + if (!!values && values.length > 0) { + for (var k = 0, kLimit = values.length; k < kLimit; k++) { + res = res + separator + thymol.ThUtils.getRequestEncoded(j) + "=" + thymol.ThUtils.getRequestEncoded(values[k]); + if (k == 0) { + separator = "&"; + } + } + } + } + } + if (!!item.meta_.urlFragment) { + res = res + item.meta_.urlFragment; + } + } + nstack.push(res); + } else if (f.apply && f.call) { + if (!!n1 && !!n1.isDirect) { + res = f.call(n1); + } else { + if (n1 instanceof NullReturn) { + n1 = null; + } + if (n1 != null && (n1.arrayResult || Object.prototype.toString.call(n1) !== "[object Array]")) { + res = f.call(element, n1); + } else { + res = f.apply(element, n1); + } + } + if (res instanceof String) { + if (res.precision) { + if (typeof this.precision === "undefined" || res.precision > this.precision) { + this.precision = res.precision; + } + } + res = res.toString(); + } else if (Object.prototype.toString.call(res) == "[object Array]") { + res.arrayResult = true; + } + nstack.push(res); + } else { + if (!element.isBlockChild) { + throw new thymol.ThError(f + " is not a function", element); + } + } + } else { + if (!element.isBlockChild) { + throw new thymol.ThError("invalid expression item type: " + type_, element); + } + } + } + if (nstack.length > 1) { + if (!element.isBlockChild) { + throw new thymol.ThError("invalid Expression (parity)", element); + } + } + result = nstack[0]; + return result; + }, + updatePrecision: function(val) { + if (typeof val === "number") { + var p = thymol.ThUtils.getDecimalDigits(val); + if (typeof this.precision === "undefined" || p > this.precision) { + this.precision = p; + } + } + } + }; + function add(a, b) { + return a + b; + } + function assign(a) { + return a; + } + function sub(a, b) { + return a - b; + } + function mul(a, b) { + return a * b; + } + function div(a, b) { + return a / b; + } + function mod(a, b) { + return a % b; + } + function concat(a, b) { + return "" + a + b; + } + function neg(a) { + return -a; + } + function not(a) { + var v = thymol.getBooleanValue(a); + return !v; + } + function random(a) { + return Math.random() * (a || 1); + } + function fac(a) { + var aa = Math.floor(a); + var b = aa; + while (aa > 1) { + b = b * --aa; + } + return b; + } + function append(a, b) { + if (a != null) { + if (a.arrayResult === true || Object.prototype.toString.call(a) != "[object Array]") { + return [ a, b ]; + } + } else { + if (b != null) { + if (b.arrayResult === true || Object.prototype.toString.call(b) != "[object Array]") { + return [ a, b ]; + } + return b; + } + return null; + } + var aa = a.slice(); + aa.push(b); + return aa; + } + function equal(a, b) { + return a == b; + } + function notEqual(a, b) { + return a != b; + } + function gt(a, b) { + return a > b; + } + function ge(a, b) { + return a >= b; + } + function lt(a, b) { + return a < b; + } + function le(a, b) { + return a <= b; + } + function and(a, b) { + return a && b; + } + function or(a, b) { + return a || b; + } + function dot(a, b) { + return a[b]; + } + function binary(a, b) { + return a ? b : null; + } + function elvis(a, b) { + return a != null ? a : b; + } + function getStr(pos, expression, mode, partial, preprocessed) { + var localMode = mode; + var s = ""; + var c = expression.charAt(pos); + var start = pos + 1; + var end = expression.length; + var stopChar = c; + if (localMode === 4 || c === "#") { + stopChar = "}"; + localMode = 4; + } + var i = start; + var inCurly = false; + var curlyPos = null; + var urlFragPos = -1; + var meta = null; + if (localMode !== 4 && c !== "'" && c !== '"') { + for (;i <= end; i++) { + if (c.toUpperCase() === c.toLowerCase()) { + if (c === "{") { + inCurly = true; + curlyPos = i; + if (meta === null) { + meta = {}; + meta.paths = []; + } + } else if (mode === 2 && c === "#") { + urlFragPos = i; + } + if (i === pos || !inCurly && c === "}" || c !== "_" && c !== "?" && c !== ":" && (c < "0" || c > "9")) { + if (!(partial && c == "-") && !((mode === 2 || mode === 6) && (c === "/" || c === "." || c === "~" || c === "?" || c === "=" || c === ":" || c === "-" || c === "_" || c === "[" || c === "]" || c === "#" || inCurly && c === "{" || inCurly && c === "}")) || mode === 6 && c === "=") { + i = i - 1; + break; + } + } + if (inCurly && c === "}") { + inCurly = false; + if (meta === null) { + var message = 'bad path variable definition in expression: "' + expression + '" near column ' + pos; + throw new thymol.ThError(message, element); + } + var curlyVar = expression.substring(curlyPos, i - 1); + var values = []; + meta.paths[curlyVar] = values; + } + } + s += c; + c = expression.charAt(i); + } + if (urlFragPos >= 0) { + var urlFrag = expression.substring(urlFragPos - 1, i); + s = s.substring(0, s.length - urlFrag.length); + if (meta === null) { + meta = {}; + meta.urlFragment = urlFrag; + } + } + } else { + var quoted = false; + var preprocessing = false; + if (c === "'" || c === '"') { + quoted = true; + stopChar = c; + } + while (i <= end) { + if (c === stopChar && i > start && !preprocessing) { + if (localMode !== 4 || quoted) { + s += c; + } else { + i = i - 1; + } + break; + } + var nc = expression.charAt(i); + if (c === "_" && nc === "_" && !preprocessed) { + preprocessing = !preprocessing; + } + if (c === "\\") { + if (nc === "'" && s.charAt(s.length - 1) !== "\\") { + c = "'"; + if (i + 1 > end) { + break; + } + i = i + 1; + nc = expression.charAt(i); + } + } + if (!quoted) { + if (c === ".") { + var exp = thymol.thExpressionObjects[s]; + if (typeof exp !== "undefined" && exp !== null) { + i -= 1; + break; + } + } + if (c === "(") { + i -= 1; + break; + } + } + s += c; + if (i + 1 > end) { + break; + } + i = i + 1; + c = nc; + } + } + var str = new Object(); + str.str = s; + str.pos = i; + if (meta !== null) { + str.meta = meta; + } + return str; + } + function ThParser() { + this.precision; + this.success = false; + this.errormsg = ""; + this.expression = ""; + this.pos = 0; + this.tokennumber = 0; + this.tokenprio = 0; + this.tokenindex = 0; + this.tmpprio = 0; + this.ops1 = { + sin: Math.sin, + cos: Math.cos, + tan: Math.tan, + asin: Math.asin, + acos: Math.acos, + atan: Math.atan, + sqrt: Math.sqrt, + log: Math.log, + abs: Math.abs, + ceil: Math.ceil, + floor: Math.floor, + round: Math.round, + "-": neg, + "!": not, + not: not, + exp: Math.exp, + "=": assign + }; + this.ops2 = { + "?": binary, + ":": elvis, + "?:": elvis, + "+": add, + "-": sub, + "*": mul, + "/": div, + "%": mod, + "^": Math.pow, + ",": append, + "||": concat, + "==": equal, + eq: equal, + "!=": notEqual, + ne: notEqual, + neq: notEqual, + div: div, + mod: mod, + and: and, + or: or, + ">": gt, + gt: gt, + ">=": ge, + "=>": ge, + ge: ge, + "<": lt, + lt: lt, + "<=": le, + "=<": le, + le: le, + ".": dot, + "[": dot + }; + this.functions = { + random: random, + fac: fac, + min: Math.min, + max: Math.max, + pow: Math.pow + }; + this.consts = { + E: Math.E, + PI: Math.PI + }; + } + ThParser.parse = function(expr, partial, preprocessed) { + return new thymol.ThParser().parse(expr, partial, preprocessed); + }; + ThParser.evaluate = function(expr, partial, element) { + return thymol.ThParser.parse(expr, partial, false).evaluate(element); + }; + ThParser.Expression = Expression; + ThParser.values = { + sin: Math.sin, + cos: Math.cos, + tan: Math.tan, + asin: Math.asin, + acos: Math.acos, + atan: Math.atan, + sqrt: Math.sqrt, + log: Math.log, + abs: Math.abs, + ceil: Math.ceil, + floor: Math.floor, + round: Math.round, + random: random, + fac: fac, + exp: Math.exp, + min: Math.min, + max: Math.max, + pow: Math.pow, + E: Math.E, + PI: Math.PI + }; + var PRIMARY = 1 << 0; + var OPERATOR = 1 << 1; + var FUNCTION = 1 << 2; + var LPAREN = 1 << 3; + var RPAREN = 1 << 4; + var COMMA = 1 << 5; + var SIGN = 1 << 6; + var CALL = 1 << 7; + var NULLARY_CALL = 1 << 8; + var LBRACK = 1 << 9; + var RBRACK = 1 << 10; + var LVARBRK = 1 << 11; + var RVARBRK = 1 << 11; + var OPTION = 1 << 12; + var ASSIGN = 1 << 13; + ThParser.prototype = { + parse: function(expr, partial, preprocessed) { + this.errormsg = ""; + this.success = true; + var operstack = []; + var tokenstack = []; + var modestack = []; + this.tmpprio = 0; + var expected = PRIMARY | LPAREN | LVARBRK | FUNCTION | OPERATOR | SIGN | OPTION; + var noperators = 0; + this.expression = expr; + this.pos = 0; + this.mode = 0; + while (this.pos < this.expression.length) { + if (this.isWhite()) {} else if (this.isOperator()) { + if (this.isSign() && expected & SIGN) { + if (this.isNegativeSign()) { + this.tokenprio = 6; + this.tokenindex = "-"; + noperators++; + this.addfunc(tokenstack, operstack, TOP1); + } + expected = PRIMARY | LPAREN | LVARBRK | FUNCTION | SIGN | OPTION; + } else if (this.isAssign() && expected & ASSIGN) { + noperators++; + expected = PRIMARY | LPAREN | LVARBRK | FUNCTION | SIGN | OPTION; + } else if (this.isComment()) {} else { + if (this.tokenindex == "!") { + if ((expected & SIGN) === 0) { + this.error_parsing(this.pos, "unexpected sign"); + } + noperators += 1; + this.addfunc(tokenstack, operstack, TOP1); + } else { + if ((expected & OPERATOR) === 0) { + this.error_parsing(this.pos, "unexpected operator"); + } + noperators += 2; + this.addfunc(tokenstack, operstack, TOP2); + } + if (this.expression.charAt(this.pos - 1) === "[") { + this.tmpprio += 20; + } + expected = PRIMARY | OPERATOR | LPAREN | LVARBRK | FUNCTION | SIGN | OPTION; + } + } else if (this.isNumber()) { + if ((expected & PRIMARY) === 0) { + this.error_parsing(this.pos, "unexpected number"); + } + var token = new Token(TNUMBER, 0, 0, this.tokennumber); + tokenstack.push(token); + expected = OPERATOR | RPAREN | RBRACK | RVARBRK | COMMA; + } else if (this.isLeftParenth()) { + if ((expected & LPAREN) === 0) { + this.error_parsing(this.pos, 'unexpected "("'); + } + modestack.push(this.mode); + if (expected & CALL) { + noperators += 2; + this.tokenprio = -2; + this.tokenindex = -1; + this.tmpprio += 2; + var ft = TFUNCALL; + if (this.mode === 4) { + ft = MSGSUBST; + this.mode = 5; + } else if (this.mode === 2) { + ft = ARGLIST; + this.mode = 6; + var url = tokenstack[tokenstack.length - 1]; + if (!url.meta_) { + url.meta_ = {}; + } + this.meta = url.meta_; + } else { + this.mode = 5; + } + this.addfunc(tokenstack, operstack, ft); + this.tmpprio -= 2; + } + if (this.mode === 5 || this.mode === 6) { + this.tmpprio += 10; + } + expected = PRIMARY | OPERATOR | LPAREN | LVARBRK | FUNCTION | SIGN | OPTION | NULLARY_CALL; + } else if (this.isRightParenth()) { + if (expected & NULLARY_CALL) { + var token = new Token(TNUMBER, 0, 0, []); + tokenstack.push(token); + } else if ((expected & RPAREN) === 0) { + this.error_parsing(this.pos, 'unexpected ")"'); + } + if (this.mode === 5 || this.mode === 6) { + this.tmpprio -= 10; + } + this.mode = modestack.pop(); + expected = OPERATOR | RPAREN | RBRACK | RVARBRK | COMMA | LPAREN | LVARBRK | CALL | OPTION; + } else if (this.isRightBracket()) { + if ((expected & RBRACK) === 0) { + this.error_parsing(this.pos, 'unexpected "]"'); + } + expected = OPERATOR | RPAREN | RBRACK | RVARBRK | COMMA | LPAREN | LVARBRK | CALL | OPTION; + } else if (this.isLeftVarBrk(modestack)) { + if ((expected & LVARBRK) === 0) { + this.error_parsing(this.pos, 'unexpected "{"'); + } + noperators += 1; + this.addfunc(tokenstack, operstack, TOP1); + expected = PRIMARY | LPAREN | LVARBRK | FUNCTION | SIGN | OPTION; + } else if (this.isRightVarBrk()) { + if ((expected & RVARBRK) === 0) { + this.error_parsing(this.pos, 'unexpected "}"'); + } + this.mode = modestack.pop(); + expected = FUNCTION | OPERATOR | RPAREN | RBRACK | RVARBRK | COMMA | LPAREN | LVARBRK | CALL | OPTION; + } else if (this.isLeftCurly()) { + if (this.mode == 1 || this.mode == 2 || this.mode == 3 || this.mode == 4) { + modestack.push(this.mode); + this.mode = 7; + } else { + this.error_parsing(this.pos, 'unexpected "{"'); + } + } else if (this.isRightCurly()) { + if (this.mode == 7) { + this.mode = modestack.pop(); + } else { + this.error_parsing(this.pos, 'unexpected "}"'); + } + } else if (this.isComma()) { + if ((expected & COMMA) === 0) { + this.error_parsing(this.pos, 'unexpected ","'); + } + if (!!partial) { + break; + } + if (this.mode === 5 || this.mode === 6) { + this.tmpprio -= 10; + } + this.tmpprio += 2; + this.addfunc(tokenstack, operstack, TOP2); + this.tmpprio -= 2; + if (this.mode === 5 || this.mode === 6) { + this.tmpprio += 10; + } + noperators += 2; + expected = PRIMARY | LPAREN | LVARBRK | FUNCTION | SIGN | OPTION; + } else if (this.isConst()) { + if ((expected & PRIMARY) === 0) { + this.error_parsing(this.pos, "unexpected constant"); + } + var consttoken = new Token(TNUMBER, 0, 0, this.tokennumber); + tokenstack.push(consttoken); + expected = OPERATOR | RPAREN | RVARBRK | RBRACK | COMMA; + } else { + var str = getStr(this.pos, this.expression, this.mode, partial, preprocessed); + if (this.isOpX(str, this.ops2) && (this.mode !== 2 && "/" !== str)) { + if ("and" === str.str || "or" === str.str) { + this.tokenprio = 3; + } + if ((expected & OPERATOR) === 0) { + this.error_parsing(this.pos, "unexpected binary operator"); + } + this.addfunc(tokenstack, operstack, TOP2); + noperators += 2; + expected = PRIMARY | LPAREN | LVARBRK | FUNCTION | OPERATOR | SIGN | OPTION; + } else if (this.isOpX(str, this.ops1)) { + if ((expected & OPERATOR) === 0) { + this.error_parsing(this.pos, "unexpected unary operator"); + } + this.addfunc(tokenstack, operstack, TOP1); + noperators++; + expected = PRIMARY | LPAREN | LVARBRK | FUNCTION; + } else if (this.isLiteralValue(str)) { + if ((expected & PRIMARY) === 0) { + this.error_parsing(this.pos, "unexpected literal value"); + } + var token = new Token(TNUMBER, 0, 0, this.tokennumber); + tokenstack.push(token); + expected = FUNCTION | OPERATOR | RPAREN | RBRACK | RVARBRK | COMMA | LPAREN | RVARBRK | LBRACK | CALL | OPTION; + if (this.mode === 6) { + expected = expected | ASSIGN; + } + } else if (this.isVar(str)) { + if ((expected & PRIMARY) === 0) { + this.error_parsing(this.pos, "unexpected variable"); + } + var vartoken = new Token(TVAR, this.tokenindex, 0, 0, this.mode, str.meta); + tokenstack.push(vartoken); + expected = FUNCTION | OPERATOR | RPAREN | RBRACK | RVARBRK | COMMA | LPAREN | RVARBRK | LBRACK | CALL | OPTION | ASSIGN; + } else { + if (this.errormsg === "") { + this.error_parsing(this.pos, "unknown character"); + } else { + this.error_parsing(this.pos, this.errormsg); + } + } + } + } + if (this.tmpprio < 0 || this.tmpprio >= 10) { + this.error_parsing(this.pos, 'unmatched "() or []"'); + } + while (operstack.length > 0) { + var tmp = operstack.pop(); + tokenstack.push(tmp); + } + if (noperators + 1 !== tokenstack.length) { + this.error_parsing(this.pos, "parity"); + } + var res = new Expression(tokenstack, object(this.ops1), object(this.ops2), object(this.functions), this.precision, this.pos); + return res; + }, + evaluate: function(expr, element) { + return this.parse(expr).evaluate(element); + }, + error_parsing: function(column, msg) { + this.success = false; + this.errormsg = "parse error [column " + column + "]: " + msg; + throw new Error(this.errormsg); + }, + addfunc: function(tokenstack, operstack, type_) { + var operator = new Token(type_, this.tokenindex, this.tokenprio + this.tmpprio, 0, this.mode, this.meta); + while (operstack.length > 0) { + if (operator.prio_ <= operstack[operstack.length - 1].prio_) { + tokenstack.push(operstack.pop()); + } else { + break; + } + } + operstack.push(operator); + }, + isNumber: function() { + var r = false; + var str = ""; + var prec = -1; + while (this.pos < this.expression.length) { + var code = this.expression.charCodeAt(this.pos); + if (code >= 48 && code <= 57 || code === 46) { + str += this.expression.charAt(this.pos); + if (prec >= 0 || code === 46) { + prec++; + } + this.pos++; + r = true; + } else { + break; + } + } + if (r) { + if (prec >= 0 && (typeof this.precision === "undefined" || prec > this.precision)) { + this.precision = prec; + } + this.tokennumber = parseFloat(str); + } + return r; + }, + isConst: function() { + var str; + for (var i in this.consts) { + if (true) { + var L = i.length; + str = this.expression.substr(this.pos, L); + if (i === str) { + this.tokennumber = this.consts[i]; + this.pos += L; + return true; + } + } + } + return false; + }, + isOperator: function() { + var ch = this.expression.charAt(this.pos); + if (ch === "+") { + this.tokenprio = 0; + this.tokenindex = "+"; + } else if (ch === "-") { + this.tokenprio = 0; + this.tokenindex = "-"; + } else if (ch === "|") { + if (this.expression.charAt(this.pos + 1) === "|") { + this.pos++; + this.tokenprio = 0; + this.tokenindex = "||"; + } else { + return false; + } + } else if (ch === "*") { + if (this.expression.charAt(this.pos + 1) === "{") { + return false; + } + this.tokenprio = 1; + this.tokenindex = "*"; + } else if (ch === "/" && this.mode != 2 && this.pos > 0) { + this.tokenprio = 2; + this.tokenindex = "/"; + } else if (ch === "%") { + this.tokenprio = 2; + this.tokenindex = "%"; + } else if (ch === "^") { + this.tokenprio = 3; + this.tokenindex = "^"; + } else if (ch === "=" || ch === "!") { + if (this.expression.charAt(this.pos + 1) === "=") { + if (ch === "=") { + this.tokenindex = "=="; + } else if (ch === "!") { + this.tokenindex = "!="; + } else { + return false; + } + this.pos++; + this.tokenprio = 6; + } else if (ch === "!") { + this.tokenprio = 7; + this.tokenindex = "!"; + } else if (ch === "=") { + this.tokenindex = "="; + } else { + return false; + } + } else if (ch === "<") { + if (this.expression.charAt(this.pos + 1) === "=") { + this.tokenindex = "<="; + this.pos++; + } else { + this.tokenindex = "<"; + } + this.tokenprio = 4; + } else if (ch === ">") { + if (this.expression.charAt(this.pos + 1) === "=") { + this.tokenindex = ">="; + this.pos++; + } else { + this.tokenindex = ">"; + } + this.tokenprio = 4; + } else if (ch === "." || ch === "[") { + this.tokenprio = 10; + this.tokenindex = "."; + } else { + return false; + } + this.pos++; + return true; + }, + isRightBracket: function() { + var code = this.expression.charCodeAt(this.pos); + if (code === 93) { + this.pos++; + this.tmpprio -= 20; + return true; + } + return false; + }, + isSign: function() { + var code = this.expression.charCodeAt(this.pos - 1); + if (code === 45 || code === 43) { + return true; + } + return false; + }, + isAssign: function() { + var code = this.expression.charCodeAt(this.pos - 1); + if (code === 61) { + var cha = this.expression.charAt(this.pos - 2); + if (cha === "!" || cha === ">" || cha === "<" || cha === "=") { + return false; + } + cha = this.expression.charAt(this.pos); + if (cha === ">" || cha === "<" || cha === "=") { + return false; + } + return true; + } + return false; + }, + isPositiveSign: function() { + var code = this.expression.charCodeAt(this.pos - 1); + if (code === 43) { + return true; + } + return false; + }, + isNegativeSign: function() { + var code = this.expression.charCodeAt(this.pos - 1); + if (code === 45) { + return true; + } + return false; + }, + isLeftParenth: function() { + var code = this.expression.charCodeAt(this.pos); + if (code === 40) { + this.pos++; + this.tmpprio += 10; + return true; + } + return false; + }, + isRightParenth: function() { + var code = this.expression.charCodeAt(this.pos); + if (code === 41) { + this.pos++; + this.tmpprio -= 10; + return true; + } + return false; + }, + isLeftCurly: function() { + var code = this.expression.charCodeAt(this.pos); + if (code === 123) { + this.pos++; + this.tmpprio += 10; + return true; + } + return false; + }, + isRightCurly: function() { + var code = this.expression.charCodeAt(this.pos); + if (code === 125) { + this.pos++; + this.tmpprio -= 10; + return true; + } + return false; + }, + isComma: function() { + var code = this.expression.charCodeAt(this.pos); + if (code === 44) { + this.pos++; + this.tokenprio = -1; + this.tokenindex = ","; + return true; + } + return false; + }, + isWhite: function() { + var code = this.expression.charCodeAt(this.pos); + if (code === 32 || code === 9 || code === 10 || code === 13) { + this.pos++; + return true; + } + return false; + }, + isLeftVarBrk: function(modestack) { + var pp = this.pos, ch = this.expression.charAt(pp); + if (ch === "$" || ch === "@" || ch === "*" || ch === "#") { + pp++; + var ch2 = this.expression.charAt(pp); + if (ch2 === "{") { + pp++; + this.tmpprio += 10; + this.tokenprio = -4; + var oldMode = this.mode; + modestack.push(oldMode); + if (ch === "$") { + this.mode = 1; + } else if (ch === "@") { + this.mode = 2; + } else if (ch === "*") { + this.mode = 3; + } else if (ch === "#") { + this.mode = 4; + } + this.tokenindex = "{"; + this.pos = pp; + return true; + } + } + return false; + }, + isRightVarBrk: function() { + var code = this.expression.charCodeAt(this.pos); + if (code === 125) { + this.pos++; + this.tmpprio -= 10; + return true; + } + return false; + }, + isOpX: function(str, group) { + if (str.str.length > 0) { + if (str.str in new Object()) { + return false; + } + if (str.str in group) { + this.tokenindex = str.str; + this.tokenprio = 5; + this.pos = str.pos; + return true; + } + } + return false; + }, + isLiteralValue: function(str) { + if (typeof str.str === "string") { + var first = str.str.charAt(0); + var last = str.str.charAt(str.str.length - 1); + if (first == "'" && last == "'" || first == '"' && last == '"') { + this.tokennumber = str.str.substring(1, str.str.length - 1); + this.pos = str.pos; + return true; + } + } + return false; + }, + isVar: function(str) { + if (str.str.length > 0) { + this.tokenindex = str.str; + this.tokenprio = 4; + this.pos = str.pos; + return true; + } + return false; + }, + isComment: function() { + var code = this.expression.charCodeAt(this.pos - 1); + if (code === 47 && this.expression.charCodeAt(this.pos) === 42) { + this.pos = this.expression.indexOf("*/", this.pos) + 2; + if (this.pos === 1) { + this.pos = this.expression.length; + } + return true; + } + return false; + } + }; + return ThParser; +}(); + +(function() { + var specAttrModList = [ "abbr", "accept", "accept-charset", "accesskey", "action", "align", "alt", "archive", "audio", "autocomplete", "axis", "background", "bgcolor", "border", "cellpadding", "cellspacing", "challenge", "charset", "cite", "class", "classid", "codebase", "codetype", "cols", "colspan", "compact", "content", "contenteditable", "contextmenu", "data", "datetime", "dir", "draggable", "dropzone", "enctype", "for", "form", "formaction", "formenctype", "formmethod", "formtarget", "frame", "frameborder", "headers", "height", "high", "href", "hreflang", "hspace", "http-equiv", "icon", "id", "keytype", "kind", "label", "lang", "list", "longdesc", "low", "manifest", "marginheight", "marginwidth", "max", "maxlength", "media", "method", "min", "name", "optimum", "pattern", "placeholder", "poster", "preload", "radiogroup", "rel", "rev", "rows", "rowspan", "rules", "sandbox", "scheme", "scope", "scrolling", "size", "sizes", "span", "spellcheck", "src", "srclang", "standby", "start", "step", "style", "summary", "tabindex", "target", "title", "type", "usemap", "value", "valuetype", "vspace", "width", "wrap", "xmlbase", "xmllang", "xmlspace" ]; + var fixedValBoolAttrList = [ "async", "autofocus", "autoplay", "checked", "controls", "declare", "default", "defer", "disabled", "formnovalidate", "hidden", "ismap", "loop", "multiple", "novalidate", "nowrap", "open", "pubdate", "readonly", "required", "reversed", "scoped", "seamless", "selected" ]; + var eventAttrList = [ "onabort", "onafterprint", "onbeforeprint", "onbeforeunload", "onblur", "oncanplay", "oncanplaythrough", "onchange", "onclick", "oncontextmenu", "ondblclick", "ondrag", "ondragend", "ondragenter", "ondragleave", "ondragover", "ondragstart", "ondrop", "ondurationchanged", "onemptied", "onended", "onerror", "onfocus", "onformchange", "onforminput", "onhashchange", "oninput", "oninvalid", "onkeydown", "onkeypress", "onkeyup", "onload", "onloadeddata", "onloadedmetadata", "onloadstart", "onmessage", "onmousedown", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onmousewheel", "onoffline", "ononline", "onpause", "onplay", "onplaying", "onpopstate", "onprogress", "onratechange", "onreadystatechange", "onredo", "onreset", "onresize", "onscroll", "onseeked", "onseeking", "onselect", "onshow", "onstalled", "onstorage", "onsubmit", "onsuspend", "ontimeupdate", "onundo", "onunload", "onvolumechange", "onwaiting" ]; + var literalTokenExpr = /^[a-zA-Z0-9\[\]\.\-_]*$/; + var numericExpr = /^[+\-]?[0-9]*?[.]?[0-9]*?$/; + var nonURLExpr = /[\$\*#]{1}\{(?:!?[^}]*)\}/; + var varExpr = /[\$\*#@]{1}\{(!?[^}]*)\}/; + var textInlineCommentExpr = /\[\[(.*)\]\]/; + var javascriptInlineCommentExpr = /\/\*\[\[(.*)\]\]\*\//; + var javascriptInlineRemainderExpr = /\s*(?:['][^']*['])*(?:["][^"]*["])*(?:[\(][^\(\)]*[\)])*(?:[\{][^\{\}]*[\}])*(?:[\[][^\[\]]*[\]])*((?:[;,\(\)\[\]:\{\}](?=(?:\s*\/\/.*?(?:\n|$)))(?:\s*\/\/.*?(?:\n|$)))|(?:\s*\/\/.*?(?:\n|$))|(?:[;,\(\)\[\]:\{\}](?=(?:\s*(?:\n|$)))(?:\s*(?:\n|$)))|(?:\s*(?:\n|$)))/; + var thCase; + thymol.getThAttribute = function(part, element) { + var result = thymol.ThUtils.unParenthesise(part); + result = thymol.doExpression(result, element); + if (Object.prototype.toString.call(result) === "[object Array]") { + if (result.length === 1) { + result = result[0]; + } + } + if (result instanceof thymol.ThParam) { + result = result.value; + } + return result; + }; + thymol.doExpression = function(part, element) { + var result = thymol.ThUtils.unParenthesise(part), expr, unq, token, mapped; + expr = null; + unq = thymol.ThUtils.unQuote(result); + if (unq != result) { + result = thymol.preProcess(unq, element); + } else { + if (literalTokenExpr.test(result)) { + token = thymol.booleanAndNullTokens[result]; + if (!(typeof token === "undefined")) { + result = token; + } else { + if (result.match(numericExpr)) { + result = thymol.ThUtils.getToPrecision(result, thymol.ThUtils.getDecimalDigits(result)); + } else { + expr = thymol.getExpression(result, element); + if (expr !== undefined && expr !== null && !(expr != expr)) { + result = expr; + } + } + } + } else { + expr = thymol.getExpression(result, element); + if (expr !== null && !(expr != expr)) { + result = expr; + } else { + result = null; + } + } + } + return result; + }; + thymol.processText = function(element, thUrlAttr, thAttr) { + var url = thymol.getThAttribute(thUrlAttr.value, element), updated = false, text, newTextNode, i, iLimit, iUpper; + if (url == null) { + if (!thymol.allowNullText) { + if (thymol.debug) { + thymol.thWindow.alert("thymol.processText cannot process: " + thUrlAttr.name + '="' + thUrlAttr.value + '"\n' + element.innerHTML); + } + return updated; + } + url = ""; + } else { + if (url instanceof thymol.ThParam || url instanceof thymol.ThObject) { + if (url.value) { + url = url.value; + } + } else if (url instanceof thymol.ThClass && url.abort) { + element.removeAttribute(thUrlAttr.name); + return true; + } + } + try { + while (element.firstChild != null) { + element.removeChild(element.firstChild); + updated = true; + if (element.firstChild == null) { + break; + } + } + if ("text" == thAttr.suffix) { + if (Object.prototype.toString.call(url) === "[object Array]") { + text = "["; + for (i = 0, iLimit = url.length, iUpper = url.length - 1; i < iLimit; i++) { + text += url[i].toString(); + if (i < iUpper) { + text += ", "; + } + } + text += "]"; + } else { + text = url.toString(); + } + text = thymol.ThUtils.unescape(text); + newTextNode = element.ownerDocument.createTextNode(text); + element.appendChild(newTextNode); + updated = true; + } + if ("utext" == thAttr.suffix) { + element.innerHTML = url; + } + element.removeAttribute(thUrlAttr.name); + } catch (err) { + if (thymol.debug) { + thymol.thWindow.alert("text replace error"); + } + } + return updated; + }; + thymol.processSpecAttrMod = function(element, thUrlAttr, thAttrObj) { + var url = thymol.getThAttribute(thUrlAttr.value, element); + if (!url || !(url instanceof thymol.ThClass) || !url.abort) { + element.setAttribute(thAttrObj.suffix, url); + } + element.removeAttribute(thUrlAttr.name); + }; + thymol.processAttr = function(element, thUrlAttr, thAttrObj) { + var argValue = thUrlAttr.value.trim(), argsExpr, expr, identifier, attrName = null, ep, lp, url, tt; + if (argValue) { + do { + argsExpr = thymol.ThParser.parse(argValue, true, false); + identifier = argsExpr.tokens.shift(); + if (identifier.type_ === 3) { + attrName = identifier.index_; + if (!!attrName) { + ep = argValue.indexOf("="); + if (ep >= 0) { + lp = argsExpr.position - 1; + if (argsExpr.position === argValue.length) { + lp = argValue.position; + } + expr = argValue.substring(ep + 1, lp).trim(); + if (fixedValBoolAttrList.indexOf(attrName) >= 0) { + thymol.doFixedValBoolAttr(expr, element, attrName); + } else { + url = thymol.getThAttribute(expr, element); + tt = typeof url; + if (thAttrObj.suffix == "attrappend" || thAttrObj.suffix == "attrprepend") { + if (url !== null && (tt === "number" || tt === "string" && url.length > 0)) { + existing = element.getAttribute(attrName); + if (existing) { + if (thAttrObj.suffix == "attrappend") { + url = existing + url; + } else if (thAttrObj.suffix == "attrprepend") { + url = url + existing; + } + } + } + } + if (url !== null && (tt === "number" || tt === "string" && url.length > 0)) { + element.setAttribute(attrName, url); + } + } + } + } + argValue = argValue.substring(argsExpr.position); + } else { + break; + } + } while (argValue.length > 0); + } + element.removeAttribute(thUrlAttr.name); + }; + thymol.processCSSAttr = function(element, thUrlAttr, thAttrObj) { + var parts = thUrlAttr.value.split(","), i, iLimit, expr, attrName, url, tt, existing; + for (i = 0, iLimit = parts.length; i < iLimit; i++) { + expr = parts[i]; + attrName = thAttrObj.suffix == "classappend" ? "class" : "style"; + if (!!attrName) { + if (!!expr) { + url = thymol.getThAttribute(expr, element); + tt = typeof url; + if (url !== null && (tt === "number" || tt === "string" && url.length > 0)) { + existing = element.getAttribute(attrName); + if (existing) { + url = existing + " " + url; + } + } + if (url !== null && (tt === "number" || tt === "string" && url.length > 0)) { + element.setAttribute(attrName, url); + } + } + } + } + element.removeAttribute(thUrlAttr.name); + }; + thymol.processFixedValBoolAttr = function(element, thUrlAttr, thAttrObj) { + var val = thymol.doFixedValBoolAttr(thUrlAttr.value, element, thAttrObj.suffix); + if (val != null) { + element.removeAttribute(thUrlAttr.name); + } else { + if (thymol.debug) { + thymol.thWindow.alert("thymol.processFixedValBoolAttr cannot process: " + thUrlAttr.name + '="' + thUrlAttr.value + '"\n' + element.innerHTML); + } + } + }; + thymol.doFixedValBoolAttr = function(valParam, element, attr) { + var val = thymol.getBoolean(valParam, element); + if (val) { + element.setAttribute(attr, attr); + } + return val; + }; + thymol.processPairedAttr = function(element, thUrlAttr, thAttrObj) { + var url = thymol.getThAttribute(thUrlAttr.value, element); + if (url != "") { + if (thAttrObj.suffix === "alt-title") { + element.setAttribute("alt", url); + element.setAttribute("title", url); + } + if (thAttrObj.suffix === "lang-xmllang") { + element.setAttribute("lang", url); + element.setAttribute("xml:lang", url); + } + element.removeAttribute(thUrlAttr.name); + } else { + if (thymol.debug) { + thymol.thWindow.alert("thymol.processPairedAttr cannot process: " + thUrlAttr.name + '="' + thUrlAttr.value + '"\n' + element.innerHTML); + } + } + }; + thymol.processConditional = function(element, attr, thAttrObj) { + var removed = false; + if (attr.value) { + removed = thymol.doIfOrUnless(element, attr.value, thAttrObj.suffix === "if"); + } + element.removeAttribute(attr.name); + return removed; + }; + thymol.doIfOrUnless = function(element, value, isIf) { + var processed = false, flag; + if (value) { + flag = thymol.getBoolean(value, element); + processed = true; + if (!flag) { + if (isIf) { + element.parentNode.removeChild(element); + return true; + } + } else { + if (!isIf) { + element.parentNode.removeChild(element); + return true; + } + } + } + if (!processed && thymol.debug) { + thymol.thWindow.alert("thymol.processConditional cannot process conditional: " + value + "\n" + element.innerHTML); + } + return false; + }; + thymol.processEach = function(element, thUrlAttr, junk) { + var elementsUpdated = false, initial = thUrlAttr.value.trim(), colonPos, varName, varNames, statVarName, expr, root, node, i, iLimit, tho, stat, count, newNode, next; + colonPos = initial.indexOf(":"); + if (colonPos > 0) { + varName = initial.substring(0, colonPos); + if (varName) { + varName = varName.trim(); + varNames = varName.split(","); + varName = varNames[0].trim(); + if (varNames.length > 1) { + statVarName = varNames[1].trim(); + } else { + statVarName = varName + "Stat"; + } + expr = initial.substr(colonPos + 1); + if (expr) { + expr = expr.trim(); + expr = thymol.getExpression(expr, element); + if (expr instanceof thymol.ThSet) { + expr = expr.toArray(); + } + root = element.parentNode; + if (expr && expr instanceof Object && expr.length > 0) { + node = element; + iLimit = expr.length; + element.removeAttribute(thUrlAttr.name); + for (i = 0; i < iLimit; i++) { + tho = expr[i]; + stat = new Object(); + stat.current = tho; + stat.size = expr.length; + stat.index = i; + count = i + 1; + stat.count = count; + if (i == 0) { + stat.first = true; + } else { + stat.first = false; + } + if (i == expr.length - 1) { + stat.last = true; + } else { + stat.last = false; + } + if (i % 2) { + stat.odd = true; + stat.even = false; + } else { + stat.odd = false; + stat.even = true; + } + if (!node.thLocalVars) { + node.thLocalVars = {}; + } + node.thLocalVars[varName] = tho; + node.thLocalVars[statVarName] = stat; + if (count < expr.length) { + newNode = element.cloneNode(true); + if (node.nextElementSibling != null) { + next = root.insertBefore(newNode, node.nextElementSibling); + } else { + next = root.appendChild(newNode); + } + node = next; + elementsUpdated = true; + } + } + } else { + if (root !== null) { + if (!element.thLocalVars) { + element.thLocalVars = {}; + } + if (!element.thLocalVars[varName]) { + element.thLocalVars[varName] = new Object(); + } + if (!element.thLocalVars[statVarName]) { + element.thLocalVars[statVarName] = new Object(); + } + root.removeChild(element); + elementsUpdated = true; + } + } + } + } + } + return elementsUpdated; + }; + thymol.processObject = function(element, thUrlAttr) { + var argValue = thUrlAttr.value.trim(), val; + if (argValue) { + val = thymol.getExpression(argValue, element); + if (val) { + element.thObjectVar = val; + } + } + element.removeAttribute(thUrlAttr.name); + }; + thymol.processInline = function(element, thUrlAttr, thAttrObj) { + var mode = thymol.getThAttribute(thUrlAttr.value, element); + if (mode == "text") { + thymol.doInlineText(element); + } else if (mode == "javascript" || mode == "dart") { + thymol.doInlineJavascript(element); + } else { + if (thymol.debug) { + thymol.thWindow.alert('thymol.processInline cannot process scripting mode: "' + mode + '" - it isn\'t supported by version "' + thymol.thVersion + '"\n'); + } + } + element.removeAttribute(thUrlAttr.name); + }; + thymol.doInlineText = function(element) { + var changed, value, i, iLimit, expr, term, result; + for (i = 0, iLimit = element.childNodes.length; i < iLimit; i++) { + do { + changed = false; + if (element.childNodes[i].nodeType == 1) { + thymol.doInlineText(element.childNodes[i]); + } else if (element.childNodes[i].nodeType == 3) { + value = element.childNodes[i].nodeValue; + if (value) { + expr = textInlineCommentExpr.exec(value); + if (expr) { + term = ""; + if (expr.length > 1) { + term = "[[" + expr[1] + "]]"; + } + if (expr.length > 1) { + result = thymol.getThAttribute(expr[1], element); + result = value.replace(term, result); + element.childNodes[i].nodeValue = result; + changed = true; + } + expr = null; + } + } + } + } while (changed); + } + }; + thymol.doInlineJavascript = function(element) { + var changed, value, second, i, iLimit, expr, scraps, remainder, termIndx, term, secondIndx, result; + for (i = 0, iLimit = element.childNodes.length; i < iLimit; i++) { + do { + second = null; + changed = false; + value = element.childNodes[i].nodeValue; + if (value) { + expr = javascriptInlineCommentExpr.exec(value); + if (expr) { + termIndx = expr.index; + term = ""; + if (expr.length > 1) { + term = "/*[[" + expr[1] + "]]*/"; + } + termIndx = termIndx + term.length; + remainder = value.substring(termIndx); + scraps = javascriptInlineRemainderExpr.exec(remainder); + if (scraps) { + if (scraps.length > 1) { + secondIndx = remainder.indexOf(scraps[1]); + second = remainder.substring(secondIndx); + value = value.substring(0, termIndx); + value = value + second; + } + } + if (expr.length > 1) { + result = thymol.getExpression(expr[1], element); + if (result instanceof thymol.ThObject) { + result = result.toNonThObject(); + } + if (!thymol.ThUtils.isLiteral(result)) { + result = thymol.getStringView(result); + } + result = value.replace(term, result); + element.childNodes[i].nodeValue = result; + changed = true; + } + expr = null; + scraps = null; + } + } + } while (changed); + } + }; + thymol.getStringView = function(param) { + var view = "", objType; + if (typeof param === "string") { + view = view + "'" + param + "'"; + } else if (typeof param === "number" || typeof param === "boolean") { + view = view + param; + } else if (typeof param === "object") { + if (param instanceof Object) { + objType = Object.prototype.toString.call(param); + if ("[object Array]" == objType) { + view = thymol.getStringViewArray(param); + } else if ("[object Object]" == objType) { + view = thymol.getStringViewObject(param); + } + } + } + return view; + }; + thymol.getStringViewArray = function(param) { + var view = "[", i, iLimit; + for (i = 0, iLimit = param.length; i < iLimit; i++) { + view = view + thymol.getStringView(param[i]); + if (i < param.length - 1) { + view = view + ","; + } + } + view = view + "]"; + return view; + }; + thymol.getStringViewObject = function(param) { + var view = "{", key = null; + for (key in param) { + if (key) { + if (view != "{") { + view = view + ","; + } + view = view + thymol.getStringView(key) + ":"; + view = view + thymol.getStringView(param[key]); + } + } + view = view + "}"; + return view; + }; + thymol.processRemove = function(element, thUrlAttr) { + var haveRemoved = false; + var locals = element.thLocalVars, savedLocals = element.thLocalVars, arg, nodes, first; + if (!locals) { + locals = {}; + } + if (!locals["tag"]) { + locals["tag"] = "tag"; + } + if (!locals["body"]) { + locals["body"] = "body"; + } + if (!locals["none"]) { + locals["none"] = "none"; + } + if (!locals["all"]) { + locals["all"] = "all"; + } + if (!locals["all-but-first"]) { + locals["all-but-first"] = "all-but-first"; + } + element.thLocalVars = locals; + arg = thymol.getThAttribute(thUrlAttr.value, element); + element.thLocalVars = savedLocals; + element.removeAttribute(thUrlAttr.name); + if ("all" == arg) { + if (element.parentNode != null) { + element.parentNode.removeChild(element); + haveRemoved = true; + } + } else if ("body" == arg) { + element.innerHTML = ""; + haveRemoved = true; + } else if ("tag" == arg) { + thymol.ThUtils.removeTag(element); + haveRemoved = true; + } else if ("all-but-first" == arg) { + nodes = element.childNodes; + first = true; + $(nodes).each(function() { + if (this.nodeType == 1) { + if (!first) { + element.removeChild(this); + haveRemoved = true; + } + first = false; + } + }); + } else if ("none" == arg || null == arg) {} + return haveRemoved; + }; + thymol.processSwitch = function(element, attr) { + var val = thymol.ThUtils.unParenthesise(attr.value), updated = false, args, matched = false, thCaseSpecs, caseClause, remove, ccAttr; + val = thymol.getThAttribute(val, element); + if (typeof val === "string") { + args = val.match(nonURLExpr); + if (args) { + val = args[1]; + } + } + val = thymol.ThUtils.unQuote(val); + thCaseSpecs = $(thCase.escpName, element); + thCaseSpecs.each(function() { + caseClause = this; + remove = true; + $(caseClause.attributes).each(function() { + ccAttr = this; + if (thCase.name == ccAttr.name || thCase.synonym == ccAttr.name) { + if (!matched) { + matched = thymol.processCase(element, ccAttr, val); + if (matched) { + remove = false; + } + } + caseClause.removeAttribute(ccAttr.name); + } + }); + if (remove) { + element.removeChild(caseClause); + updated = true; + } + }); + return updated; + }; + thymol.processCase = function(element, attr, param) { + var val = thymol.substitute(attr.value, element); + val = thymol.ThUtils.unQuote(val); + if (val == "*" || param && param == val) { + return true; + } + return false; + }; + thymol.processWith = function(element, thUrlAttr) { + thymol.getWith(element, thUrlAttr.value); + element.removeAttribute(thUrlAttr.name); + }; + thymol.processAssert = function(element, thUrlAttr) { + var argValue = thUrlAttr.value.trim(), result = true, term = "", terms, i, iLimit, expr, val, flag; + if (argValue) { + terms = argValue.split(","); + for (i = 0, iLimit = terms.length; i < iLimit; i++) { + term = terms[i]; + expr = thymol.ThUtils.unParenthesise(term); + if (expr != null) { + val = thymol.getExpression(expr, element); + if (val) { + flag = thymol.getBoolean(val, element); + if (!flag) { + result = false; + break; + } + } else { + result = false; + break; + } + } else { + result = false; + break; + } + } + } + if (!result) { + if (argValue != term) { + argValue = " list is: " + argValue; + } else { + argValue = ""; + } + if (term != "") { + term = ' false term is: "' + term + '"'; + } + if (thymol.debug) { + thymol.thWindow.alert("thymol.processAssert assertion failure -" + argValue + term + "\n"); + } + } + element.removeAttribute(thUrlAttr.name); + }; + thymol.processFragment = function(element, thUrlAttr, thAttrObj) { + element.removeAttribute(thUrlAttr.name); + }; + thymol.getBoolean = function(param, element) { + if (param == null) { + return false; + } + if (typeof param === "boolean") { + return param; + } else if (typeof param === "number") { + return param != 0; + } + var initial = thymol.ThUtils.unParenthesise(param), negate = false, val, args, flag; + if (initial.charAt(0) == "!") { + negate = true; + initial = initial.substring(1, initial.length); + initial = thymol.ThUtils.unParenthesise(initial); + } + val = thymol.getThAttribute(initial, element); + if (val == null) { + args = initial.match(varExpr); + if (args) { + if (args[1].charAt(0) == "!") { + negate = !negate; + } + } + } + flag = thymol.getBooleanValue(val); + if (negate) { + flag = !flag; + } + return flag; + }; + thymol.appendToAttrList = function(func, prec, attrArray) { + var j, jLimit = attrArray.length, tha = null; + for (j = 0; j < jLimit; j++) { + tha = new thymol.ThAttr(attrArray[j], func, prec, thymol.thThymeleafPrefixList, thymol.prefix); + } + j = tha; + }; + thymol.setupAttrList = function() { + thCase = new thymol.ThAttr("case", null, 275, thymol.thThymeleafPrefixList, thymol.prefix); + thymol.addDialect({ + prefix: thymol.prefix, + attributeProcessors: [ { + name: "each", + processor: thymol.processEach, + precedence: 200 + }, { + name: "switch", + processor: thymol.processSwitch, + precedence: 250 + }, { + name: "if", + processor: thymol.processConditional, + precedence: 300 + }, { + name: "unless", + processor: thymol.processConditional, + precedence: 400 + }, { + name: "object", + processor: thymol.processObject, + precedence: 500 + }, { + name: "with", + processor: thymol.processWith, + precedence: 600 + }, { + name: "attr", + processor: thymol.processAttr, + precedence: 700 + }, { + name: "attrprepend", + processor: thymol.processAttr, + precedence: 800 + }, { + name: "attrappend", + processor: thymol.processAttr, + precedence: 900 + }, { + name: "alt-title", + processor: thymol.processPairedAttr, + precedence: 990 + }, { + name: "lang-xmllang", + processor: thymol.processPairedAttr, + precedence: 990 + }, { + name: "inline", + processor: thymol.processInline, + precedence: 1e3 + }, { + name: "classappend", + processor: thymol.processCSSAttr, + precedence: 1100 + }, { + name: "styleappend", + processor: thymol.processCSSAttr, + precedence: 1100 + }, { + name: "text", + processor: thymol.processText, + precedence: 1300 + }, { + name: "utext", + processor: thymol.processText, + precedence: 1400 + }, { + name: "fragment", + processor: thymol.processFragment, + precedence: 1500 + }, { + name: "assert", + processor: thymol.processAssert, + precedence: 1550 + }, { + name: "remove", + processor: thymol.processRemove, + precedence: 1600 + } ] + }); + thymol.appendToAttrList(thymol.processSpecAttrMod, 1e3, specAttrModList); + thymol.appendToAttrList(thymol.processSpecAttrMod, 1e3, eventAttrList); + thymol.appendToAttrList(thymol.processFixedValBoolAttr, 1e3, fixedValBoolAttrList); + }; +})(); + +thymol.objects.thHttpSessionObject = function() { + var thExpressionObjectName = "#httpSession"; + function getAttribute(name) { + var result = thymol.sessionContext[name]; + return result; + } + function getParameter(name) { + var result = thymol.sessionContext[name]; + return result; + } + function getServletContext() { + var result = thymol.applicationContext; + return result; + } + function getSessionContext() { + var result = thymol.sessionContext; + return result; + } + function getContextPath() { + var result = ""; + return result; + } + function getRequestName() { + var result = ""; + return result; + } + function getParameterValues(name) { + var result = thymol.sessionContext[name]; + return result; + } + return { + thExpressionObjectName: thExpressionObjectName, + getAttribute: getAttribute, + getParameter: getParameter, + getServletContext: getServletContext, + getSessionContext: getSessionContext, + getContextPath: getContextPath, + getRequestName: getRequestName, + getParameterValues: getParameterValues + }; +}(); + +thymol.objects.thHttpServletRequestObject = function() { + var thExpressionObjectName = "#httpServletRequest"; + function getAttribute(name) { + var result = thymol.requestContext[name][0]; + if (result instanceof thymol.ThParam) { + result = thymol.ThUtils.unQuote(result.value); + } + return result; + } + function getParameter(name) { + var result = thymol.requestContext[name]; + return result; + } + function getContextPath() { + var result = ""; + return result; + } + function getRequestName() { + var result = ""; + return result; + } + function getParameterValues(name) { + var result = thymol.requestContext[name]; + return result; + } + function getSession(create) { + return thymol.objects.thHttpSessionObject; + } + return { + thExpressionObjectName: thExpressionObjectName, + getAttribute: getAttribute, + getParameter: getParameter, + getContextPath: getContextPath, + getRequestName: getRequestName, + getParameterValues: getParameterValues, + getSession: getSession + }; +}(); + +thymol.objects.thAggregatesObject = function() { + var thExpressionObjectName = "#aggregates"; + function sum(target) { + return aggregate(target, false, "sum"); + } + function avg(target) { + return aggregate(target, true, "avg"); + } + function aggregate(target, doAvg, label) { + if (target !== null) { + var result = 0; + var count; + var tt = typeof target; + var ptc = Object.prototype.toString.call(target); + if (tt === "Array" || ptc === "[object Array]") { + count = target.length; + for (var i = 0; i < count; i++) { + if (target[i] !== null) { + result += target[i]; + } else { + throw new thymol.ThError("#aggregates." + label + " Cannot aggregate on object containing nulls"); + } + } + } else { + count = 0; + for (var k in target) { + var value = target[k]; + var process = false; + if (value !== null) { + if (target instanceof thymol.ThSet) { + process = target.isContent(k); + } else { + process = target.hasOwnProperty(k) && typeof value !== "function"; + } + } else { + throw new thymol.ThError("#aggregates." + label + " Cannot aggregate on object containing nulls"); + } + if (process) { + result += value; + count++; + } + } + } + if (doAvg) { + if (count == 0) { + throw new thymol.ThError("#aggregates." + label + " Cannot get size of object"); + } + result = result / count; + } + return result; + } + throw new thymol.ThError("#aggregates." + label + " Cannot aggregate on null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + sum: sum, + avg: avg + }; +}(); + +thymol.objects.thArraysObject = function() { + var thExpressionObjectName = "#arrays"; + function toArray(target) { + if (target !== null) { + return toTypedArray(null, target); + } + throw new thymol.ThError("#arrays.toArray Cannot convert null to array"); + } + function toStringArray(target) { + if (target !== null) { + return toTypedArray("string", target); + } + throw new thymol.ThError("#arrays.toStringArray Cannot convert null to array"); + } + function toNumberArray(target) { + if (target !== null) { + return toTypedArray("number", target); + } + throw new thymol.ThError("#arrays.toNumberArray Cannot convert null to array"); + } + function toBooleanArray(target) { + if (target !== null) { + return toTypedArray("boolean", target); + } + throw new thymol.ThError("#arrays.toBooleanArray Cannot convert null to array"); + } + function toTypedArray(componentClass, target) { + if (target instanceof Array) { + if (componentClass === null || componentClass === "undefined") { + return target; + } + var result = new Array(); + try { + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + if (componentClass === "string") { + result.push(new String(target[i]).valueOf()); + } else if (componentClass === "number") { + result.push(new Number(target[i]).valueOf()); + } else if (componentClass === "boolean") { + result.push(new Boolean(target[i]).valueOf()); + } else { + result.push(target[i]); + } + } + } + } catch (err) { + throw new IllegalArgumentException('#arrays.toArray Cannot convert object of class "' + targetComponentClass.getName() + '[]" to an array' + " of " + componentClass.getClass().getSimpleName()); + } + return result; + } else if (target instanceof Object) { + var result = new Array(); + try { + for (var k in target) { + var value = target[k]; + var process = false; + if (value !== null) { + if (target instanceof thymol.ThSet) { + process = target.isContent(k); + } else { + process = target.hasOwnProperty(k) && typeof value !== "function"; + } + } + if (process) { + if (componentClass === "string") { + result.push(new String(value).valueOf()); + } else if (componentClass === "number") { + result.push(new Number(value).valueOf()); + } else if (componentClass === "boolean") { + result.push(new Boolean(value).valueOf()); + } else { + result.push(value); + } + } + } + } catch (err) { + throw new IllegalArgumentException('#arrays.toArray Cannot convert object of class "' + targetComponentClass.getName() + '[]" to an array' + " of " + componentClass.getClass().getSimpleName()); + } + return result; + } else { + throw new thymol.ThError('#arrays.toArray Cannot convert object of type "' + typeof target + '" to an array' + (componentClass == null ? "" : " of " + componentClass)); + } + } + function length(target) { + if (target !== null) { + return target.length; + } + throw new thymol.ThError("#arrays.length Cannot get array length of null"); + } + function isEmpty(target) { + return target === null || target.length <= 0; + } + function contains(target, element) { + if (target !== null) { + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] === null) { + if (element === null) { + return true; + } + } else if (element !== null && target[i] === element) { + return true; + } + } + return false; + } + throw new thymol.ThError("#arrays.contains Cannot execute array contains: target is null"); + } + function containsAll(target, elements) { + if (target !== null) { + if (elements !== null) { + var elementsArray; + if (elements instanceof Array) { + elementsArray = [].concat(elements); + } else { + if (elements instanceof thymol.ThSet) { + elementsArray = elements.toArray(); + } else { + elementsArray = []; + for (var k in elements) { + if (elements.hasOwnProperty(k) && typeof elements[k] !== "function") { + elementsArray.push(elements[k]); + } + } + } + } + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + for (var j = 0, jLimit = elementsArray.length; j < jLimit; j++) { + if (target[i] === elementsArray[j]) { + elementsArray.splice(j, 1); + } + } + } + return elementsArray.length === 0; + } + throw new thymol.ThError("#arrays.containsAll Cannot execute array containsAll: elements is null"); + } + throw new thymol.ThError("#arrays.containsAll Cannot execute array containsAll: target is null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + toArray: toArray, + toStringArray: toStringArray, + toIntegerArray: toNumberArray, + toLongArray: toNumberArray, + toDoubleArray: toNumberArray, + toFloatArray: toNumberArray, + toBooleanArray: toBooleanArray, + length: length, + isEmpty: isEmpty, + contains: contains, + containsAll: containsAll + }; +}(); + +thymol.objects.thBoolsObject = function() { + var thExpressionObjectName = "#bools"; + function isTrue(target) { + var result = true; + var tc; + if (target == null || (tc = typeof target) === "undefined") { + result = false; + } else { + if (tc === "boolean") { + result = target; + } else if (tc === "number") { + result = target != 0; + } else if (tc === "string") { + if (target.length === 1) { + result = target.charCodeAt(0) != 0; + } else if (thymol.ThUtils.testLiteralFalse(target)) { + result = false; + } + } + } + return result; + } + function arrayIsTrue(target) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(isTrue(target[i])); + } + return result; + } + throw new thymol.ThError("#bools.arrayIsTrue Target cannot be null"); + } + function setIsTrue(target) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(isTrue(target[k])); + } + } + return result; + } + throw new thymol.ThError("#bools.setIsTrue Target cannot be null"); + } + function isFalse(target) { + return !isTrue(target); + } + function arrayIsFalse(target) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(!isTrue(target[i])); + } + return result; + } + throw new thymol.ThError("#bools.arrayIsFalse Target cannot be null"); + } + function setIsFalse(target) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(!isTrue(target[k])); + } + } + return result; + } + throw new thymol.ThError("#bools.setIsFalse Target cannot be null"); + } + function arrayAnd(target) { + if (target !== null) { + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (!isTrue(target[i])) { + return false; + } + } + return true; + } + throw new thymol.ThError("#bools.arrayAnd Target cannot be null"); + } + function setAnd(target) { + if (target !== null) { + for (var k in target) { + if (target.isContent(k)) { + if (!isTrue(target[k])) { + return false; + } + } + } + return true; + } + throw new thymol.ThError("#bools.setAnd Target cannot be null"); + } + function arrayOr(target) { + if (target !== null) { + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (isTrue(target[i])) { + return true; + } + } + return false; + } + throw new thymol.ThError("#bools.arrayOr Target cannot be null"); + } + function setOr(target) { + if (target !== null) { + for (var k in target) { + if (target.isContent(k)) { + if (isTrue(target[k])) { + return true; + } + } + } + return false; + } + throw new thymol.ThError("#bools.setOr Target cannot be null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + isTrue: isTrue, + arrayIsTrue: arrayIsTrue, + listIsTrue: arrayIsTrue, + setIsTrue: setIsTrue, + isFalse: isFalse, + arrayIsFalse: arrayIsFalse, + listIsFalse: arrayIsFalse, + setIsFalse: setIsFalse, + arrayAnd: arrayAnd, + listAnd: arrayAnd, + setAnd: setAnd, + arrayOr: arrayOr, + listOr: arrayOr, + setOr: setOr + }; +}(); + +thymol.objects.thDatesObject = function() { + var thExpressionObjectName = "#dates"; + function createProxy() { + if (arguments !== null) { + if (arguments.length > 6) { + return create(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6]); + } else if (arguments.length > 5) { + return create(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], 0); + } else if (arguments.length > 4) { + return create(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], 0, 0); + } + return create(arguments[0], arguments[1], arguments[2], 0, 0, 0, 0); + } + } + function create(year, month, day, hour, minute, second, millisecond) { + var result = new Date(); + result.setMilliseconds(millisecond); + result.setSeconds(second); + result.setMinutes(minute); + result.setHours(hour); + result.setDate(day); + result.setMonth(month - 1); + result.setFullYear(year); + return result; + } + function getDay(dateValue) { + var month = dateValue.getMonth() + 1; + var year = dateValue.getFullYear(); + var day = dateValue.getDate(); + var a = Math.floor((14 - month) / 12); + var y = year + 4800 - a; + var m = month + 12 * a - 3; + var jdn = day + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4); + if (jdn < 2331254) { + jdn = jdn - 32083; + } else { + jdn = jdn - Math.floor(y / 100) + Math.floor(y / 400) - 32045; + } + var mjdn = (jdn + 1) % 7; + return mjdn; + } + function createNow() { + return new Date(); + } + function createToday() { + var today = new Date(); + today.setHours(0, 0, 0, 0); + return today; + } + function format(dateParam, patternParam, locale) { + var pattern = ""; + var date; + if (arguments === null) { + date = new Date(); + } else { + if (arguments.length > 1) { + pattern = patternParam; + } + date = dateParam; + } + return formatDate(date, pattern, locale); + } + function formatDate(target, patternParam, locale) { + var pattern = ""; + if (arguments.length > 1) { + pattern = patternParam; + } + var result = dateFormat(target, pattern, false); + return result; + } + function arrayFormat(target, patternParam) { + var pattern = ""; + if (arguments.length > 1) { + pattern = patternParam; + } + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(dateFormat(target[i], pattern, false)); + } + return result; + } + function setFormat(target, patternParam) { + var pattern = ""; + if (arguments.length > 1) { + pattern = patternParam; + } + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(dateFormat(target[k], pattern, false)); + } + } + return result; + } + function day(target) { + return target.getDate(); + } + function arrayDay(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(target[i].getDate()); + } + return result; + } + function setDay(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].getDate()); + } + } + return result; + } + function month(target) { + return target.getMonth() + 1; + } + function arrayMonth(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(target[i].getMonth() + 1); + } + return result; + } + function setMonth(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].getMonth() + 1); + } + } + return result; + } + function monthName(target) { + return dateFormat.i18n.monthNames[target.getMonth() + 12]; + } + function arrayMonthName(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(dateFormat.i18n.monthNames[target[i].getMonth() + 12]); + } + return result; + } + function setMonthName(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(dateFormat.i18n.monthNames[target[k].getMonth() + 12]); + } + } + return result; + } + function monthNameShort(target) { + return dateFormat.i18n.monthNames[target.getMonth()]; + } + function arrayMonthNameShort(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(dateFormat.i18n.monthNames[target[i].getMonth()]); + } + return result; + } + function setMonthNameShort(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(dateFormat.i18n.monthNames[target[k].getMonth()]); + } + } + return result; + } + function year(target) { + return target.getFullYear(); + } + function arrayYear(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(target[i].getFullYear()); + } + return result; + } + function setYear(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].getFullYear()); + } + } + return result; + } + function dayOfWeek(target) { + return getDay(target) + 1; + } + function arrayDayOfWeek(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(getDay(target[i]) + 1); + } + return result; + } + function setDayOfWeek(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(getDay(target[k]) + 1); + } + } + return result; + } + function dayOfWeekName(target) { + return dateFormat.i18n.dayNames[getDay(target) + 7]; + } + function arrayDayOfWeekName(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(dateFormat.i18n.dayNames[getDay(target[i]) + 7]); + } + return result; + } + function setDayOfWeekName(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(dateFormat.i18n.dayNames[getDay(target[k]) + 7]); + } + } + return result; + } + function dayOfWeekNameShort(target) { + return dateFormat.i18n.dayNames[getDay(target)]; + } + function arrayDayOfWeekNameShort(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(dateFormat.i18n.dayNames[getDay(target[i])]); + } + return result; + } + function setDayOfWeekNameShort(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(dateFormat.i18n.dayNames[getDay(target[k])]); + } + } + return result; + } + function hour(target) { + return target.getHours(); + } + function arrayHour(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(target[i].getHours()); + } + return result; + } + function setHour(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].getHours()); + } + } + return result; + } + function minute(target) { + return target.getMinutes(); + } + function arrayMinute(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(target[i].getMinutes()); + } + return result; + } + function setMinute(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].getMinutes()); + } + } + return result; + } + function second(target) { + return target.getSeconds(); + } + function arraySecond(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(target[i].getSeconds()); + } + return result; + } + function setSecond(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].getSeconds()); + } + } + return result; + } + function millisecond(target) { + return target.getMilliseconds(); + } + function arrayMillisecond(target) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(target[i].getMilliseconds()); + } + return result; + } + function setMillisecond(target) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].getMilliseconds()); + } + } + return result; + } + var timezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g, timezoneClip = /[^-+\dA-Z]/g; + function processTZ(target) { + var toStr = String(target); + var result = toStr; + result = (result.match(timezone) || [ "" ]).pop(); + if ("" !== result) { + result = result.replace(timezoneClip, ""); + var tail = toStr.match(/[\(]((?:[GL]M|BS)T[^\)]*?)[\)]/); + if (tail) { + if (target.getFullYear() > 1916 || target.getFullYear() === 1916 && target.getMonth() > 4 || target.getFullYear() === 1916 && target.getMonth() === 4 && target.getDate() > 20) { + result = result.replace(/GMT\+\d{1,4}/, "BST"); + } else { + result = result.replace(/GMT\+\d{1,4}/, "GMT"); + } + } + } + return result; + } + var dateFormat = function() { + var token = /d{1,4}|M{1,4}|yy(?:yy)?|([HhmsTt])\1?|[LloSZ]|"[^"]*"|'[^']*'/g, pad = function(valp, lenp) { + var val = String(valp), len = lenp || 2; + while (val.length < len) val = "0" + val; + return val; + }; + return function(datep, maskp, utcp) { + var dF = dateFormat, mask = maskp, date = datep, utc = utcp; + if (arguments.length == 1 && Object.prototype.toString.call(date) == "[object String]" && !/\d/.test(date)) { + mask = date; + date = undefined; + } + date = date ? new Date(date) : new Date(); + if (isNaN(date)) throw SyntaxError("invalid date"); + mask = String(dF.masks[mask] || mask || dF.masks["default"]); + if (mask.slice(0, 4) == "UTC:") { + mask = mask.slice(4); + utc = true; + } + var _ = utc ? "getUTC" : "get", d = date[_ + "Date"](), D = getDay(date), M = date[_ + "Month"](), y = date[_ + "FullYear"](), H = date[_ + "Hours"](), m = date[_ + "Minutes"](), s = date[_ + "Seconds"](), L = date[_ + "Milliseconds"](), o = utc ? 0 : date.getTimezoneOffset(), flags = { + d: d, + dd: pad(d), + ddd: dF.i18n.dayNames[D], + dddd: dF.i18n.dayNames[D + 7], + M: M + 1, + MM: pad(M + 1), + MMM: dF.i18n.monthNames[M], + MMMM: dF.i18n.monthNames[M + 12], + yy: String(y).slice(2), + yyyy: y, + h: H % 12 || 12, + hh: pad(H % 12 || 12), + H: H, + HH: pad(H), + m: m, + mm: pad(m), + s: s, + ss: pad(s), + l: pad(L, 3), + L: pad(L > 99 ? Math.round(L / 10) : L), + t: H < 12 ? "a" : "p", + tt: H < 12 ? "am" : "pm", + T: H < 12 ? "A" : "P", + TT: H < 12 ? "AM" : "PM", + Z: utc ? "UTC" : processTZ(date), + o: (o > 0 ? "-" : "+") + pad(Math.floor(Math.abs(o) / 60) * 100 + Math.abs(o) % 60, 4), + S: [ "th", "st", "nd", "rd" ][d % 10 > 3 ? 0 : (d % 100 - d % 10 != 10) * d % 10] + }; + return mask.replace(token, function($0) { + return $0 in flags ? flags[$0] : $0.slice(1, $0.length - 1); + }); + }; + }(); + dateFormat.masks = { + "default": "dd MMMM yyyy HH:mm:ss Z", + shortDate: "M/d/yy", + mediumDate: "MMM d, yyyy", + longDate: "d MMMM yyyy", + fullDate: "dddd, MMMM d, yyyy", + shortTime: "h:mm TT", + mediumTime: "h:mm:ss TT", + longTime: "h:mm:ss TT Z", + isoDate: "yyyy-MM-dd", + isoTime: "HH:mm:ss", + isoDateTime: "yyyy-MM-dd'T'HH:mm:ss", + isoUtcDateTime: "UTC:yyyy-MM-dd'T'HH:mm:ss'Z'" + }; + dateFormat.i18n = { + dayNames: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ], + monthNames: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ] + }; + Date.prototype.format = function(mask, utc) { + return dateFormat(this, mask, utc); + }; + return { + thExpressionObjectName: thExpressionObjectName, + create: createProxy, + createNow: createNow, + createNowForTimeZone: createNow, + createToday: createToday, + createTodayForTimeZone: createToday, + format: format, + dateFormat: dateFormat, + arrayFormat: arrayFormat, + listFormat: arrayFormat, + setFormat: setFormat, + day: day, + arrayDay: arrayDay, + listDay: arrayDay, + setDay: setDay, + month: month, + arrayMonth: arrayMonth, + listMonth: arrayMonth, + setMonth: setMonth, + monthName: monthName, + arrayMonthName: arrayMonthName, + listMonthName: arrayMonthName, + setMonthName: setMonthName, + monthNameShort: monthNameShort, + arrayMonthNameShort: arrayMonthNameShort, + listMonthNameShort: arrayMonthNameShort, + setMonthNameShort: setMonthNameShort, + year: year, + arrayYear: arrayYear, + listYear: arrayYear, + setYear: setYear, + dayOfWeek: dayOfWeek, + arrayDayOfWeek: arrayDayOfWeek, + listDayOfWeek: arrayDayOfWeek, + setDayOfWeek: setDayOfWeek, + dayOfWeekName: dayOfWeekName, + arrayDayOfWeekName: arrayDayOfWeekName, + listDayOfWeekName: arrayDayOfWeekName, + setDayOfWeekName: setDayOfWeekName, + dayOfWeekNameShort: dayOfWeekNameShort, + arrayDayOfWeekNameShort: arrayDayOfWeekNameShort, + listDayOfWeekNameShort: arrayDayOfWeekNameShort, + setDayOfWeekNameShort: setDayOfWeekNameShort, + hour: hour, + arrayHour: arrayHour, + listHour: arrayHour, + setHour: setHour, + minute: minute, + arrayMinute: arrayMinute, + listMinute: arrayMinute, + setMinute: setMinute, + second: second, + arraySecond: arraySecond, + listSecond: arraySecond, + setSecond: setSecond, + millisecond: millisecond, + arrayMillisecond: arrayMillisecond, + listMillisecond: arrayMillisecond, + setMillisecond: setMillisecond + }; +}(); + +thymol.objects.thCalendarsObject = function() { + var thExpressionObjectName = "#calendars"; + return { + thExpressionObjectName: thExpressionObjectName, + create: thymol.objects.thDatesObject.create, + createNow: thymol.objects.thDatesObject.createNow, + createNowForTimeZone: thymol.objects.thDatesObject.createNow, + createToday: thymol.objects.thDatesObject.createToday, + createTodayForTimeZone: thymol.objects.thDatesObject.createToday, + format: thymol.objects.thDatesObject.format, + dateFormat: thymol.objects.thDatesObject.dateFormat, + arrayFormat: thymol.objects.thDatesObject.arrayFormat, + listFormat: thymol.objects.thDatesObject.arrayFormat, + setFormat: thymol.objects.thDatesObject.setFormat, + day: thymol.objects.thDatesObject.day, + arrayDay: thymol.objects.thDatesObject.arrayDay, + listDay: thymol.objects.thDatesObject.arrayDay, + setDay: thymol.objects.thDatesObject.setDay, + month: thymol.objects.thDatesObject.month, + arrayMonth: thymol.objects.thDatesObject.arrayMonth, + listMonth: thymol.objects.thDatesObject.arrayMonth, + setMonth: thymol.objects.thDatesObject.setMonth, + monthName: thymol.objects.thDatesObject.monthName, + arrayMonthName: thymol.objects.thDatesObject.arrayMonthName, + listMonthName: thymol.objects.thDatesObject.arrayMonthName, + setMonthName: thymol.objects.thDatesObject.setMonthName, + monthNameShort: thymol.objects.thDatesObject.monthNameShort, + arrayMonthNameShort: thymol.objects.thDatesObject.arrayMonthNameShort, + listMonthNameShort: thymol.objects.thDatesObject.arrayMonthNameShort, + setMonthNameShort: thymol.objects.thDatesObject.setMonthNameShort, + year: thymol.objects.thDatesObject.year, + arrayYear: thymol.objects.thDatesObject.arrayYear, + listYear: thymol.objects.thDatesObject.arrayYear, + setYear: thymol.objects.thDatesObject.setYear, + dayOfWeek: thymol.objects.thDatesObject.dayOfWeek, + arrayDayOfWeek: thymol.objects.thDatesObject.arrayDayOfWeek, + listDayOfWeek: thymol.objects.thDatesObject.arrayDayOfWeek, + setDayOfWeek: thymol.objects.thDatesObject.setDayOfWeek, + dayOfWeekName: thymol.objects.thDatesObject.dayOfWeekName, + arrayDayOfWeekName: thymol.objects.thDatesObject.arrayDayOfWeekName, + listDayOfWeekName: thymol.objects.thDatesObject.arrayDayOfWeekName, + setDayOfWeekName: thymol.objects.thDatesObject.setDayOfWeekName, + dayOfWeekNameShort: thymol.objects.thDatesObject.dayOfWeekNameShort, + arrayDayOfWeekNameShort: thymol.objects.thDatesObject.arrayDayOfWeekNameShort, + listDayOfWeekNameShort: thymol.objects.thDatesObject.arrayDayOfWeekNameShort, + setDayOfWeekNameShort: thymol.objects.thDatesObject.setDayOfWeekNameShort, + hour: thymol.objects.thDatesObject.hour, + arrayHour: thymol.objects.thDatesObject.arrayHour, + listHour: thymol.objects.thDatesObject.arrayHour, + setHour: thymol.objects.thDatesObject.setHour, + minute: thymol.objects.thDatesObject.minute, + arrayMinute: thymol.objects.thDatesObject.arrayMinute, + listMinute: thymol.objects.thDatesObject.arrayMinute, + setMinute: thymol.objects.thDatesObject.setMinute, + second: thymol.objects.thDatesObject.second, + arraySecond: thymol.objects.thDatesObject.arraySecond, + listSecond: thymol.objects.thDatesObject.arraySecond, + setSecond: thymol.objects.thDatesObject.setSecond, + millisecond: thymol.objects.thDatesObject.millisecond, + arrayMillisecond: thymol.objects.thDatesObject.arrayMillisecond, + listMillisecond: thymol.objects.thDatesObject.arrayMillisecond, + setMillisecond: thymol.objects.thDatesObject.setMillisecond + }; +}(); + +thymol.objects.thIdsObject = function() { + var thExpressionObjectName = "#ids"; + function seq(id) { + if (id !== null) { + var str = id.toString(); + var idCount = getLocal(str); + var result = str + idCount; + idCount++; + setLocal(str, idCount); + return result; + } + throw new thymol.ThError("#ids.seq ID Cannot be null"); + } + function next(id) { + if (id !== null) { + var str = id.toString(); + var idCount = getLocal(str); + return str + idCount; + } + throw new thymol.ThError("#ids.next ID Cannot be null"); + } + function prev(id) { + if (id !== null) { + var str = id.toString(); + var idCount = getLocal(str); + return str + (idCount - 1); + } + throw new thymol.ThError("#ids.prev ID Cannot be null"); + } + function setLocal(str, idCount) { + if (!thymol.objects.thIdsObject.thLocalVars) { + thymol.objects.thIdsObject.thLocalVars = []; + } + if (!thymol.objects.thIdsObject.thLocalVars["thIdCounts"]) { + thymol.objects.thIdsObject.thLocalVars["thIdCounts"] = []; + } + thymol.objects.thIdsObject.thLocalVars["thIdCounts"][str] = idCount; + } + function getLocal(str) { + if (!thymol.objects.thIdsObject.thLocalVars) { + thymol.objects.thIdsObject.thLocalVars = []; + } + if (!thymol.objects.thIdsObject.thLocalVars["thIdCounts"]) { + thymol.objects.thIdsObject.thLocalVars["thIdCounts"] = []; + } + if (!thymol.objects.thIdsObject.thLocalVars["thIdCounts"][str]) { + thymol.objects.thIdsObject.thLocalVars["thIdCounts"][str] = 1; + } + return thymol.objects.thIdsObject.thLocalVars["thIdCounts"][str]; + } + return { + thExpressionObjectName: thExpressionObjectName, + seq: seq, + next: next, + prev: prev + }; +}(); + +thymol.objects.thListsObject = function() { + var thExpressionObjectName = "#lists"; + function sort(list, comparator) { + if (list !== null) { + if (arguments.length > 1) { + if (comparator !== null) { + if (typeof comparator === "function") { + return list.sort(comparator); + } + throw new thymol.ThError("#lists.sort Cannot execute list sort: comparator is not a function"); + } + throw new thymol.ThError("#lists.sort Cannot execute list sort: comparator is null"); + } + return list.sort(); + } + throw new thymol.ThError("#lists.sort Cannot execute list sort: list is null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + toList: thymol.objects.thArraysObject.toArray, + size: thymol.objects.thArraysObject.length, + isEmpty: thymol.objects.thArraysObject.isEmpty, + contains: thymol.objects.thArraysObject.contains, + containsAll: thymol.objects.thArraysObject.containsAll, + sort: sort + }; +}(); + +thymol.objects.thMapsObject = function() { + var thExpressionObjectName = "#maps"; + function size(target) { + if (target !== null) { + if (target instanceof thymol.ThMap) { + return target.size(); + } + throw new thymol.ThError('#maps.size Cannot get size of non-map type "' + typeof target + '"'); + } + throw new thymol.ThError("#maps.size Cannot get size of null"); + } + function isEmpty(target) { + if (target !== null) { + if (target instanceof thymol.ThMap) { + return target.isEmpty(); + } + throw new thymol.ThError('#maps.size Cannot get isEmpty of non-map type "' + typeof target + '"'); + } + throw new thymol.ThError("#maps.size Cannot get isEmpty of null"); + } + function containsKey(target, key) { + if (target !== null) { + if (target instanceof thymol.ThMap) { + return target.containsKey(key); + } + throw new thymol.ThError('#maps.size Cannot get containsKey of non-map type "' + typeof target + '"'); + } + throw new thymol.ThError("#maps.containsKey Cannot execute map containsKey: target is null"); + } + function containsValue(target, value) { + if (target !== null) { + if (target instanceof thymol.ThMap) { + return target.containsValue(value); + } + throw new thymol.ThError('#maps.size Cannot get containsValue of non-map type "' + typeof target + '"'); + } + throw new thymol.ThError("#maps.containsKey Cannot execute map containsValue: target is null"); + } + function containsAllKeys(target, keys) { + if (target !== null) { + if (target instanceof thymol.ThMap) { + var ptc = Object.prototype.toString.call(keys); + if (keys instanceof thymol.ThSet || keys instanceof Array || ptc === "[object Array]") { + return target.containsAll(keys); + } + throw new thymol.ThError('#maps.size Cannot get containsAllKeys with non-collection type "' + ptc + '"'); + } + throw new thymol.ThError('#maps.size Cannot get containsAllKeys of non-map type "' + typeof target + '"'); + } + throw new thymol.ThError("#maps.containsKey Cannot execute map containsAllKeys: target is null"); + } + function containsAllValues(target, values) { + if (target !== null) { + if (target instanceof thymol.ThMap) { + var ptc = Object.prototype.toString.call(values); + if (values instanceof thymol.ThSet || values instanceof Array || ptc === "[object Array]") { + var vArray = values; + if (values instanceof thymol.ThSet) { + vArray = values.toArray(); + } + for (var i = 0, iLimit = vArray.length; i < iLimit; i++) { + var found = false; + for (var k in target) { + if (target.hasOwnProperty(k)) { + var value = target[k]; + if (value === vArray[i]) { + found = true; + break; + } + } + } + if (!found) { + return false; + } + } + return true; + } + throw new thymol.ThError('#maps.size Cannot get containsAllValues with non-collection type "' + ptc + '"'); + } + throw new thymol.ThError('#maps.size Cannot get containsAllValues of non-map type "' + typeof target + '"'); + } + throw new thymol.ThError("#maps.containsKey Cannot execute map containsAllValues: target is null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + size: size, + isEmpty: isEmpty, + containsKey: containsKey, + containsValue: containsValue, + containsAllKeys: containsAllKeys, + containsAllValues: containsAllValues + }; +}(); + +thymol.objects.thMessagesObject = function() { + var thExpressionObjectName = "#messages"; + function msg() { + if (arguments !== null) { + if (arguments.length > 0) { + return msgWithParams(arguments[0], Array.prototype.slice.call(arguments, 1)); + } + throw new thymol.ThError("#messages.msg Invoked with no arguments!"); + } + throw new thymol.ThError("#messages.msg Target cannot be null"); + } + function msgWithParams(target, params) { + if (target !== null) { + return thymol.getMessage(target, params, true); + } + throw new thymol.ThError("#messages.msgWithParams Target cannot be null"); + } + function msgOrNull() { + if (arguments !== null) { + if (arguments.length > 0) { + return msgOrNullWithParams(arguments[0], Array.prototype.slice.call(arguments, 1)); + } + throw new thymol.ThError("#messages.msgOrNull Invoked with no arguments!"); + } + throw new thymol.ThError("#messages.msgOrNull Target cannot be null"); + } + function msgOrNullWithParams(target, params) { + if (target !== null) { + return thymol.getMessage(target, params, false); + } + throw new thymol.ThError("#messages.msgOrNullWithParams Target cannot be null"); + } + function arrayMsg() { + if (arguments !== null) { + if (arguments.length > 0) { + return arrayMsgWithParams(arguments[0], Array.prototype.slice.call(arguments, 1)); + } + throw new thymol.ThError("#messages.arrayMsg Invoked with no arguments!"); + } + throw new thymol.ThError("#messages.arrayMsg Target cannot be null"); + } + function arrayMsgWithParams(target, params) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(msgWithParams(target[i], params)); + } + return result; + } + throw new thymol.ThError("#messages.arrayMsgWithParams Target cannot be null"); + } + function setMsg() { + if (arguments !== null) { + if (arguments.length > 0) { + return setMsgWithParams(arguments[0], Array.prototype.slice.call(arguments, 1)); + } + throw new thymol.ThError("#messages.setMsg Invoked with no arguments!"); + } + throw new thymol.ThError("#messages.setMsg Target cannot be null"); + } + function setMsgWithParams(target, params) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(msgWithParams(target[k], params)); + } + } + return result; + } + throw new thymol.ThError("#messages.setMsgWithParams Target cannot be null"); + } + function arrayMsgOrNull() { + if (arguments !== null) { + if (arguments.length > 0) { + return arrayMsgOrNullWithParams(arguments[0], Array.prototype.slice.call(arguments, 1)); + } + throw new thymol.ThError("#messages.arrayMsgOrNull Invoked with no arguments!"); + } + throw new thymol.ThError("#messages.arrayMsgOrNull Target cannot be null"); + } + function arrayMsgOrNullWithParams(target, params) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(msgOrNullWithParams(target[i], params)); + } + return result; + } + throw new thymol.ThError("#messages.arrayMsgOrNullWithParams Target cannot be null"); + } + function setMsgOrNull() { + if (arguments !== null) { + if (arguments.length > 0) { + return setMsgOrNullWithParams(arguments[0], Array.prototype.slice.call(arguments, 1)); + } + throw new thymol.ThError("#messages.setMsgOrNull Invoked with no arguments!"); + } + throw new thymol.ThError("#messages.setMsgOrNull Target cannot be null"); + } + function setMsgOrNullWithParams(target, params) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(msgOrNullWithParams(target[k], params)); + } + } + return result; + } + throw new thymol.ThError("#messages.setMsgOrNullWithParams Target cannot be null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + msg: msg, + msgWithParams: msgWithParams, + msgOrNull: msgOrNull, + msgOrNullWithParams: msgOrNullWithParams, + arrayMsg: arrayMsg, + listMsg: arrayMsg, + setMsg: setMsg, + arrayMsgWithParams: arrayMsgWithParams, + listMsgWithParams: arrayMsgWithParams, + setMsgWithParams: setMsgWithParams, + arrayMsgOrNull: arrayMsgOrNull, + listMsgOrNull: arrayMsgOrNull, + setMsgOrNull: setMsgOrNull, + arrayMsgOrNullWithParams: arrayMsgOrNullWithParams, + listMsgOrNullWithParams: arrayMsgOrNullWithParams, + setMsgOrNullWithParams: setMsgOrNullWithParams + }; +}(); + +thymol.objects.thNumbersObject = function() { + var thExpressionObjectName = "#numbers"; + var DEFAULT_THOU_PT = ","; + var DEFAULT_DECI_PT = "."; + var DEFAULT_NONE_PT = "?"; + function formatDecimalProxy() { + if (arguments !== null) { + if (arguments.length > 4) { + return formatDecimal5(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]); + } else if (arguments.length > 3) { + return formatDecimal4(arguments[0], arguments[1], arguments[2], arguments[3]); + } + return formatDecimal3(arguments[0], arguments[1], arguments[2]); + } + } + function formatIntegerProxy() { + if (arguments !== null) { + if (arguments.length > 4) { + return formatDecimal5(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]); + } else if (arguments.length > 3) { + return formatDecimal5(arguments[0], arguments[1], "NONE", arguments[2], arguments[3]); + } else if (arguments.length > 2) { + if (typeof arguments[2] === "string") { + return formatDecimal5(arguments[0], arguments[1], arguments[2], 0, "POINT"); + } + return formatDecimal5(arguments[0], arguments[1], "NONE", arguments[2], "POINT"); + } else { + return formatDecimal5(arguments[0], arguments[1], "NONE", 0, "POINT"); + } + } + } + function arrayFormatIntegerProxy() { + if (arguments !== null) { + if (arguments.length > 2) { + return arrayFormatDecimal(arguments[0], arguments[1], arguments[2], 0, "POINT"); + } + return arrayFormatDecimal(arguments[0], arguments[1], "NONE", 0, "POINT"); + } + } + function setFormatIntegerProxy() { + if (arguments !== null) { + if (arguments.length > 2) { + return setFormatDecimal(arguments[0], arguments[1], arguments[2], 0, "POINT"); + } + return setFormatDecimal(arguments[0], arguments[1], "NONE", 0, "POINT"); + } + } + function arrayFormatDecimalProxy() { + if (arguments !== null) { + if (arguments.length > 4) { + return arrayFormatDecimal(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]); + } else if (arguments.length > 3) { + return arrayFormatDecimal(arguments[0], arguments[1], "NONE", arguments[2], arguments[3]); + } + return arrayFormatDecimal(arguments[0], arguments[1], "NONE", arguments[2], "POINT"); + } + } + function setFormatDecimalProxy() { + if (arguments !== null) { + if (arguments.length > 4) { + return setFormatDecimal(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]); + } else if (arguments.length > 3) { + return setFormatDecimal(arguments[0], arguments[1], "NONE", arguments[2], arguments[3]); + } + return setFormatDecimal(arguments[0], arguments[1], "NONE", arguments[2], "POINT"); + } + } + function sequenceProxy() { + if (arguments !== null) { + if (arguments.length > 2) { + return sequence(arguments[0], arguments[1], arguments[2]); + } + return sequence(arguments[0], arguments[1], 1); + } + } + function getIntegerDigits(val) { + var s = val.toString(); + var digits = s.length; + var dp = s.indexOf("."); + if (dp > 0) { + digits = dp; + } + return digits; + } + function formatDecimal3(target, minIntegerDigits, decimalDigits) { + var result = target.toString(); + var value = new Number(target); + value = value.toFixed(decimalDigits); + if (minIntegerDigits > 0) { + result = value; + value = new Number(value); + var a = Math.abs(value); + if (a < Math.pow(10, minIntegerDigits)) { + if (target < 0) { + result = result.substring(1); + } + var p = getIntegerDigits(a); + var x = minIntegerDigits - p; + if (x > 0) { + for (var i = 0; i < x; i++) { + result = "0" + result; + } + } + if (target < 0) { + result = "-" + result; + } + } + } else { + result = value.toString(); + } + result = new String(result); + result.precision = decimalDigits; + return result; + } + function formatDecimal4(target, minIntegerDigits, decimalDigits, decimalPointType) { + var result = formatDecimal3(target, minIntegerDigits, decimalDigits); + var decimalPoint; + if ("DEFAULT" === decimalPointType) { + decimalPoint = DEFAULT_DECI_PT; + } else if ("NONE" === decimalPointType) { + decimalPoint = DEFAULT_NONE_PT; + } else { + decimalPoint = getPointType(decimalPointType); + } + if ("." !== decimalPoint) { + result = result.replace(".", decimalPoint, "g"); + } + return result; + } + function formatDecimal5(target, minIntegerDigits, thousandsPointType, decimalDigits, decimalPointType) { + var result = target.toString(); + var decimalPoint; + if ("DEFAULT" === decimalPointType) { + decimalPoint = DEFAULT_DECI_PT; + } else if ("NONE" === decimalPointType) { + decimalPoint = DEFAULT_NONE_PT; + } else { + decimalPoint = getPointType(decimalPointType); + } + if ("" !== decimalPoint) { + result = formatDecimal4(target, minIntegerDigits, decimalDigits, decimalPointType); + } else { + result = formatDecimal3(target, minIntegerDigits, decimalDigits); + } + var thousandsPoint; + if ("DEFAULT" === thousandsPointType) { + thousandsPoint = DEFAULT_THOU_PT; + } else { + thousandsPoint = getPointType(thousandsPointType); + } + if ("" !== thousandsPoint) { + result = addThousandsPointType(result.toString(), decimalPoint, thousandsPoint); + } + return result; + } + function getPointType(type) { + var result = "."; + if ("COMMA" === type) { + result = ","; + } else if ("WHITESPACE" === type) { + result = " "; + } else if ("NONE" === type) { + result = ""; + } + return result; + } + function arrayFormatDecimal(target, minIntegerDigits, thousandsPointType, decimalDigits, decimalPointType) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(formatDecimal5(target[i], minIntegerDigits, thousandsPointType, decimalDigits, decimalPointType)); + } + return result; + } + function setFormatDecimal(target, minIntegerDigits, thousandsPointType, decimalDigits, decimalPointType) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.hasOwnProperty(k) && typeof target[k] !== "function") { + result.add(formatDecimal5(target[k], minIntegerDigits, thousandsPointType, decimalDigits, decimalPointType)); + } + } + return result; + } + function addThousandsPointType(nStr, dpt, tpt) { + var x = nStr.split(dpt); + var x1 = x[0]; + var x2 = x.length > 1 ? dpt + x[1] : ""; + var rgx = /(\d+)(\d{3})/; + while (rgx.test(x1)) { + x1 = x1.replace(rgx, "$1" + tpt + "$2"); + } + return x1 + x2; + } + function sequence(start, stop, step) { + var result = []; + if (step > 0) { + var value = start; + if (start <= stop) { + do { + result.push(value); + value += step; + } while (value <= stop); + } else { + do { + result.push(value); + value -= step; + } while (value >= stop); + } + } + return result; + } + return { + thExpressionObjectName: thExpressionObjectName, + formatDecimal: formatDecimalProxy, + formatInteger: formatIntegerProxy, + arrayFormatInteger: arrayFormatIntegerProxy, + arrayFormatDecimal: arrayFormatDecimalProxy, + listFormatInteger: arrayFormatIntegerProxy, + listFormatDecimal: arrayFormatDecimalProxy, + setFormatInteger: setFormatIntegerProxy, + setFormatDecimal: setFormatDecimalProxy, + sequence: sequenceProxy + }; +}(); + +thymol.objects.thObjectsObject = function() { + var thExpressionObjectName = "#objects"; + function nullSafe(target, defaultValue) { + return target != null ? target : defaultValue; + } + function arrayNullSafe(target, defaultValue) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(nullSafe(target[i], defaultValue)); + } + return result; + } + throw new thymol.ThError("#objects.arrayNullSafe Target cannot be null"); + } + function setNullSafe(target, defaultValue) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(nullSafe(target[k], defaultValue)); + } + } + return result; + } + throw new thymol.ThError("#objects.setNullSafe Target cannot be null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + nullSafe: nullSafe, + arrayNullSafe: arrayNullSafe, + listNullSafe: arrayNullSafe, + setNullSafe: setNullSafe + }; +}(); + +thymol.objects.thSetsObject = function() { + var thExpressionObjectName = "#sets"; + function toSet(target) { + if (target !== null) { + var tt = typeof target; + var ptc = Object.prototype.toString.call(target); + var result; + if (tt === "thymol.ThSet") { + result = target; + } + if (tt === "Array" || ptc === "[object Array]") { + result = thymol.ThSet.prototype.fromArray(target); + } else if (tt === "object") { + result = new thymol.ThSet(); + for (var k in target) { + var value = target[k]; + var process = false; + if (value !== null) { + if (target instanceof thymol.ThSet) { + process = target.isContent(k); + } else { + process = target.hasOwnProperty(k) && typeof value !== "function"; + } + } + if (process) { + result.add(value); + } + } + } else { + throw new thymol.ThError('#sets.toSet Cannot convert object of type "' + tt + '" to a set'); + } + return result; + } + throw new thymol.ThError("#sets.toSet Cannot convert null to set"); + } + function size(target) { + if (target !== null) { + if (target instanceof thymol.ThSet) { + return target.size(); + } + throw new thymol.ThError('#sets.size Cannot get size of non-set type "' + typeof target + '"'); + } + throw new thymol.ThError("#sets.size Cannot get size of null"); + } + function isEmpty(target) { + if (target !== null) { + if (target instanceof thymol.ThSet) { + return target.isEmpty(); + } + throw new thymol.ThError('#sets.size Cannot get isEmpty of non-set type "' + typeof target + '"'); + } + throw new thymol.ThError("#sets.size Cannot get isEmpty of null"); + } + function contains(target, element) { + if (target !== null) { + for (var k in target) { + if (target.isContent(k)) { + if (target[k] === null) { + if (element === null) { + return true; + } + } else if (element !== null && target[k] === element) { + return true; + } + } + } + return false; + } + throw new thymol.ThError("#sets.contains Cannot execute sets contains: target is null"); + } + function containsAll(target, elements) { + if (target !== null) { + if (elements !== null) { + var elementsArray; + if (elements instanceof Array) { + elementsArray = [].concat(elements); + } else { + if (elements instanceof thymol.ThSet) { + elementsArray = elements.toArray(); + } else { + elementsArray = []; + for (var k in elements) { + if (elements.hasOwnProperty(k) && typeof elements[k] !== "function") { + elementsArray.push(elements[k]); + } + } + } + } + for (var k in target) { + if (target.isContent(k)) { + for (var j = 0, jLimit = elementsArray.length; j < jLimit; j++) { + if (target[k] === elementsArray[j]) { + elementsArray.splice(j, 1); + } + } + } + } + return elementsArray.length === 0; + } + throw new thymol.ThError("#sets.containsAll Cannot execute sets containsAll: elements is null"); + } + throw new thymol.ThError("#sets.containsAll Cannot execute sets containsAll: target is null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + toSet: toSet, + size: size, + isEmpty: isEmpty, + contains: contains, + containsAll: containsAll + }; +}(); + +thymol.objects.thStringsObject = function() { + var thExpressionObjectName = "#strings"; + function toString(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = target.toString(); + } + return result; + } + function arrayToString(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(target[i].toString()); + } else { + result.push(null); + } + } + } + return result; + } + function setToString(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(toString(target[k])); + } + } + } + return result; + } + function abbreviate(target, maxSize, source) { + if (maxSize >= 3) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = target.toString(); + if (result.length > maxSize) { + result = result.substring(0, maxSize - 3) + "..."; + } + } + return result; + } + throwAbbreviateException("abbreviate", maxSize); + } + function arrayAbbreviate(target, maxSize) { + if (maxSize >= 3) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(abbreviate(target[i], maxSize)); + } + } + return result; + } + throwAbbreviateException("arrayAbbreviate", maxSize); + } + function setAbbreviate(target, maxSize) { + if (maxSize >= 3) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(abbreviate(target[k], maxSize)); + } + } + } + return result; + } + throwAbbreviateException("setAbbreviate", maxSize); + } + function throwAbbreviateException(source, maxSize) { + throw new thymol.ThError("#strings." + source + ' Maximum size must be greater than or equal to 3 but was: "' + maxSize + '"'); + } + function equals(o1, o2) { + if (o1 === null) { + return o2 === null; + } else if (o2 !== null) { + return o1.toString() === o2.toString(); + } + return false; + } + function equalsIgnoreCase(o1, o2) { + if (o1 === null) { + return o2 === null; + } else if (o2 !== null) { + return o1.toString().toLowerCase() === o2.toString().toLowerCase(); + } + return false; + } + function contains(target, fragment) { + if (target !== null) { + if (fragment !== null) { + return target.toString().indexOf(fragment) >= 0; + } + throw new thymol.ThError("#strings.contains Fragment cannot be null"); + } + throw new thymol.ThError("#strings.contains Cannot apply contains on null"); + } + function arrayContains(target, fragment) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(contains(target[i], fragment)); + } + return result; + } + throw new thymol.ThError("#strings.arrayContains Cannot apply arrayContains on null"); + } + function setContains(target, fragment) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(contains(target[k], fragment)); + } + } + return result; + } + throw new thymol.ThError("#strings.setContains Cannot apply setContains on null"); + } + function containsIgnoreCase(target, fragment) { + if (target !== null) { + if (fragment !== null) { + return target.toString().toLowerCase().indexOf(fragment.toLowerCase()) >= 0; + } + throw new thymol.ThError("#strings.containsIgnoreCase Fragment cannot be null"); + } + throw new thymol.ThError("#strings.containsIgnoreCase Cannot apply containsIgnoreCase on null"); + } + function arrayContainsIgnoreCase(target, fragment) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(containsIgnoreCase(target[i], fragment)); + } + return result; + } + throw new thymol.ThError("#strings.arrayContainsIgnoreCase Cannot apply arrayContainsIgnoreCase on null"); + } + function setContainsIgnoreCase(target, fragment) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(containsIgnoreCase(target[k], fragment)); + } + } + return result; + } + throw new thymol.ThError("#strings.setContainsIgnoreCase Cannot apply setContainsIgnoreCase on null"); + } + function startsWith(target, prefix) { + if (target !== null) { + if (prefix !== null) { + return target.toString().indexOf(prefix) === 0; + } + throw new thymol.ThError("#strings.startsWith Prefix cannot be null"); + } + throw new thymol.ThError("#strings.startsWith Cannot apply startsWith on null"); + } + function arrayStartsWith(target, prefix) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(startsWith(target[i], prefix)); + } + return result; + } + throw new thymol.ThError("#strings.arrayStartsWith Target cannot be null"); + } + function setStartsWith(target, prefix) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(startsWith(target[k], prefix)); + } + } + return result; + } + throw new thymol.ThError("#strings.setStartsWith Target cannot be null"); + } + function endsWith(target, suffix) { + if (target !== null) { + if (suffix !== null) { + var str = target.toString(); + return str.indexOf(suffix) === str.length - suffix.length; + } + throw new thymol.ThError("#strings.startsWith Suffix cannot be null"); + } + throw new thymol.ThError("#strings.endsWith Cannot apply endsWith on null"); + } + function arrayEndsWith(target, suffix) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(endsWith(target[i], suffix)); + } + return result; + } + throw new thymol.ThError("#strings.arrayEndsWith Target cannot be null"); + } + function setEndsWith(target, suffix) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(endsWith(target[k], suffix)); + } + } + return result; + } + throw new thymol.ThError("#strings.setEndsWith Target cannot be null"); + } + function substring(target, start, end) { + if (target !== null) { + return target.toString().substring(start, end); + } + throw new thymol.ThError("#strings.substring Target cannot be null"); + } + function arraySubstring(target, start, end) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(substring(target[i], start, end)); + } + return result; + } + throw new thymol.ThError("#strings.arraySubstring Target cannot be null"); + } + function setSubstring(target, start, end) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(substring(target[k], start, end)); + } + } + return result; + } + throw new thymol.ThError("#strings.setSubstring Target cannot be null"); + } + function substringAfter(target, substr) { + if (target !== null) { + if (substr !== null) { + var str = target.toString(); + var indx = str.indexOf(substr); + if (indx < 0) { + return null; + } + return str.substring(indx + substr.length); + } + throw new thymol.ThError("#strings.substringAfter Parameter substring cannot be null"); + } + throw new thymol.ThError("#strings.substringAfter Cannot apply substringAfter on null"); + } + function arraySubstringAfter(target, substr) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(substringAfter(target[i], substr)); + } + return result; + } + throw new thymol.ThError("#strings.arraySubstringAfter Cannot apply arraySubstringAfter on null"); + } + function setSubstringAfter(target, substr) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(substringAfter(target[k], substr)); + } + } + return result; + } + throw new thymol.ThError("#strings.setSubstringAfter Cannot apply setSubstringAfter on null"); + } + function substringBefore(target, substr) { + if (target !== null) { + if (substr !== null) { + var str = target.toString(); + var indx = str.indexOf(substr); + if (indx < 0) { + return null; + } + return str.substring(0, indx); + } + throw new thymol.ThError("#strings.substringBefore Parameter substring cannot be null"); + } + throw new thymol.ThError("#strings.substringBefore Cannot apply substringBefore on null"); + } + function arraySubstringBefore(target, substr) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(substringBefore(target[i], substr)); + } + return result; + } + throw new thymol.ThError("#strings.arraySubstringBefore Cannot apply arraySubstringBefore on null"); + } + function setSubstringBefore(target, substr) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(substringBefore(target[k], substr)); + } + } + return result; + } + throw new thymol.ThError("#strings.setSubstringBefore Cannot apply setSubstringBefore on null"); + } + function prepend(target, prefix) { + if (target !== null) { + if (prefix !== null) { + return prefix.toString() + target.toString(); + } + throw new thymol.ThError("#strings.prepend Prefix cannot be null"); + } + throw new thymol.ThError("#strings.prepend Cannot apply prepend on null"); + } + function arrayPrepend(target, prefix) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(prepend(target[i], prefix)); + } + return result; + } + throw new thymol.ThError("#strings.arrayPrepend Cannot apply arrayPrepend on null"); + } + function setPrepend(target, prefix) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(prepend(target[k], prefix)); + } + } + return result; + } + throw new thymol.ThError("#strings.setPrepend Cannot apply setPrepend on null"); + } + function repeat(target, times) { + var result = ""; + for (var i = 0; i < times; i++) { + result += target.toString(); + } + return result; + } + function append(target, suffix) { + if (target !== null) { + if (suffix !== null) { + return target.toString() + suffix.toString(); + } + throw new thymol.ThError("#strings.append Suffix cannot be null"); + } + throw new thymol.ThError("#strings.append Cannot apply append on null"); + } + function concat() { + var result = ""; + for (var i = 0, iLimit = arguments.length; i < iLimit; i++) { + if (arguments[i] !== null) { + result += arguments[i]; + } + } + return result; + } + function concatReplaceNulls() { + var result = ""; + for (var i = 1, iLimit = arguments.length; i < iLimit; i++) { + if (arguments[i] === null) { + result += arguments[0]; + } else { + result += arguments[i]; + } + } + return result; + } + function arrayAppend(target, suffix) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(append(target[i], suffix)); + } + return result; + } + throw new thymol.ThError("#strings.arrayAppend Target cannot be null"); + } + function setAppend(target, suffix) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(append(target[k], suffix)); + } + } + return result; + } + throw new thymol.ThError("#strings.setAppend Target cannot be null"); + } + function indexOf(target, fragment) { + if (target !== null) { + if (fragment !== null) { + var str = target.toString(); + var indx = str.indexOf(fragment); + return indx; + } + throw new thymol.ThError("#strings.indexOf Fragment cannot be null"); + } + throw new thymol.ThError("#strings.indexOf Cannot apply indexOf on null"); + } + function arrayIndexOf(target, fragment) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(indexOf(target[i], fragment)); + } + return result; + } + throw new thymol.ThError("#strings.arrayIndexOf Cannot apply arrayIndexOf on null"); + } + function setIndexOf(target, fragment) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(indexOf(target[k], fragment)); + } + } + return result; + } + throw new thymol.ThError("#strings.setIndexOf Cannot apply setIndexOf on null"); + } + function isEmpty(target) { + if (target !== null) { + var str = target.toString(); + if (str !== null) { + str = str.replace(/(?:[\\]t)/g, " ").replace(/(?:[\\]n)/g, "\n").replace(/(?:[\\]v)/g, " ").replace(/(?:[\\]f)/g, "\f").replace(/(?:[\\]r)/g, "\r"); + str = str.trim(); + if (str.length !== 0) { + return false; + } + } + } + return true; + } + function arrayIsEmpty(target) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(isEmpty(target[i])); + } + return result; + } + throw new thymol.ThError("#strings.arrayIsEmpty Target cannot be null"); + } + function setIsEmpty(target) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(isEmpty(target[k])); + } + } + return result; + } + throw new thymol.ThError("#strings.setIsEmpty Target cannot be null"); + } + function arrayJoin(stringArray, separator) { + if (stringArray !== null) { + if (separator !== null) { + var sepStr = separator.toString(); + var result = ""; + for (var i = 0, iLimit = stringArray.length; i < iLimit; i++) { + if ("" !== result) { + result += sepStr; + } + result += stringArray[i]; + } + return result; + } + throw new thymol.ThError("#strings.arrayJoin Separator cannot be null"); + } + throw new thymol.ThError("#strings.arrayJoin Cannot apply join on null"); + } + function setJoin(stringSet, separator) { + if (stringSet !== null) { + if (separator !== null) { + var sepStr = separator.toString(); + var result = ""; + for (var k in stringSet) { + if (stringSet.isContent(k)) { + if ("" !== result) { + result += sepStr; + } + result += stringSet[k]; + } + } + return result; + } + throw new thymol.ThError("#strings.setJoin Separator cannot be null"); + } + throw new thymol.ThError("#strings.setJoin Cannot apply join on null"); + } + function doRegExpify(target, flags) { + var result = target.toString(); + result = result.replace(/[\\]/g, "\\").replace(/[\^]/g, "^").replace(/[\[]/g, "[").replace(/[\]]/g, "]").replace(/[\(]/g, "(").replace(/[\)]/g, ")"); + result = "[" + result + "]"; + return new RegExp(result, flags); + } + function doSplit(target, separator) { + var re = doRegExpify(separator); + var splits = target.split(re); + var result = []; + for (var i = 0, iLimit = splits.length; i < iLimit; i++) { + if (splits[i]) { + result.push(splits[i]); + } + } + return result; + } + function arraySplit(target, separator) { + if (target !== null) { + if (separator !== null) { + return doSplit(target, separator); + } + throw new thymol.ThError("#strings.arraySplit Separator cannot be null"); + } + throw new thymol.ThError("#strings.arraySplit Cannot apply split on null"); + } + function setSplit(target, separator) { + if (target !== null) { + if (separator !== null) { + var result = new thymol.ThSet(); + var splits = doSplit(target, separator); + for (var i = 0, iLimit = splits.length; i < iLimit; i++) { + result.add(splits[i]); + } + return result; + } + throw new thymol.ThError("#strings.setSplit Separator cannot be null"); + } + throw new thymol.ThError("#strings.setSplit Cannot apply split on null"); + } + function length(target) { + if (target !== null) { + return target.toString().length; + } + throw new thymol.ThError("#strings.length Cannot apply length on null"); + } + function arrayLength(target) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(length(target[i])); + } + return result; + } + throw new thymol.ThError("#strings.arrayLength Target cannot be null"); + } + function setLength(target) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(length(target[k])); + } + } + return result; + } + throw new thymol.ThError("#strings.setLength Target cannot be null"); + } + function getReplacer(target) { + var bfr = target.replace(/[$]/g, "[$]").replace(/[*]/g, "[*]").replace(/[\']/g, "[']").replace(/[+]/g, "[+]").replace(/[\(]/g, "[(]").replace(/[\)]/g, "[)]"); + return new RegExp(bfr, "g"); + } + function replace(target, before, after) { + if (target !== null) { + if (before !== null) { + var bfr = unescapeXml(before); + if (after !== null) { + var re = getReplacer(bfr); + var aft = unescapeXml(after); + return target.replace(re, aft); + } + throw new thymol.ThError("#strings.replace After cannot be null"); + } + throw new thymol.ThError("#strings.replace Before cannot be null"); + } + throw new thymol.ThError("#strings.replace Cannot apply replace on null"); + } + function arrayReplace(target, before, after) { + if (target !== null) { + if (before !== null) { + var bfr = unescapeXml(before); + if (after !== null) { + var re = getReplacer(bfr); + var aft = unescapeXml(after); + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(target[i].toString().replace(re, aft)); + } + return result; + } + throw new thymol.ThError("#strings.arrayReplace After cannot be null"); + } + throw new thymol.ThError("#strings.arrayReplace Before cannot be null"); + } + throw new thymol.ThError("#strings.arrayReplace Cannot apply replace on null"); + } + function setReplace(target, before, after) { + if (target !== null) { + if (before !== null) { + var bfr = unescapeXml(before); + if (after !== null) { + var re = getReplacer(bfr); + var aft = unescapeXml(after); + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].toString().replace(re, aft)); + } + } + return result; + } + throw new thymol.ThError("#strings.setReplace Array of 'after' values cannot be null"); + } + throw new thymol.ThError("#strings.setReplace Array of 'before' values cannot be null"); + } + throw new thymol.ThError("#strings.setReplace Cannot apply replace on null"); + } + function multipleReplace(target, before, after) { + if (target !== null) { + if (before !== null) { + if (Object.prototype.toString.call(before) == "[object Array]") { + if (after !== null) { + if (Object.prototype.toString.call(after) == "[object Array]") { + if (before.length === after.length) { + var result = target; + var bfr, aft; + for (var i = 0, iLimit = before.length; i < iLimit; i++) { + bfr = unescapeXml(before[i]); + var re = getReplacer(bfr); + aft = unescapeXml(after[i]); + result = result.replace(re, aft); + } + return result; + } + throw new thymol.ThError("#strings.multipleReplace Arrays of 'before' and 'after' values must have the same length"); + } + throw new thymol.ThError("#strings.multipleReplace After must be an array type"); + } + throw new thymol.ThError("#strings.multipleReplace After cannot be null"); + } + throw new thymol.ThError("#strings.multipleReplace Before must be an array type"); + } + throw new thymol.ThError("#strings.multipleReplace Before cannot be null"); + } + throw new thymol.ThError("#strings.multipleReplace Target cannot be null"); + } + function arrayMultipleReplace(target, before, after) { + if (target !== null) { + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(multipleReplace(target[i].toString(), before, after)); + } + return result; + } + throw new thymol.ThError("#strings.arrayMultipleReplace Target cannot be null"); + } + function setMultipleReplace(target, before, after) { + if (target !== null) { + var result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(multipleReplace(target[k].toString(), before, after)); + } + } + return result; + } + throw new thymol.ThError("#strings.setMultipleReplace Target cannot be null"); + } + function toUpperCase(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = target.toString().toUpperCase(); + } + return result; + } + function arrayToUpperCase(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(target[i].toString().toUpperCase()); + } else { + result.push(null); + } + } + } + return result; + } + function setToUpperCase(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].toString().toUpperCase()); + } + } + } + return result; + } + function toLowerCase(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = target.toString().toLowerCase(); + } + return result; + } + function arrayToLowerCase(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(target[i].toString().toLowerCase()); + } else { + result.push(null); + } + } + } + return result; + } + function setToLowerCase(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].toString().toLowerCase()); + } + } + } + return result; + } + function trim(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = target.toString().trim(); + } + return result; + } + function arrayTrim(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(target[i].toString().trim()); + } else { + result.push(null); + } + } + } + return result; + } + function setTrim(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(target[k].toString().trim()); + } + } + } + return result; + } + function capitalize(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = target.toString(); + if (result.length > 0) { + result = result.charAt(0).toUpperCase() + result.substr(1); + } + } + return result; + } + function arrayCapitalize(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(capitalize(target[i])); + } else { + result.push(null); + } + } + } + return result; + } + function setCapitalize(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(capitalize(target[k])); + } + } + } + return result; + } + function unCapitalize(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = target.toString(); + if (result.length > 0) { + result = result.charAt(0).toLowerCase() + result.substr(1); + } + } + return result; + } + function arrayUnCapitalize(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(unCapitalize(target[i])); + } else { + result.push(null); + } + } + } + return result; + } + function setUnCapitalize(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(unCapitalize(target[k])); + } + } + } + return result; + } + function capitalizeWords(target, delimiters) { + var splitter; + if (typeof delimiters === "undefined") { + splitter = new RegExp("[^ \r\n\f ]\\w*", "g"); + } else { + var spec = "[^ " + delimiters + "]\\w*"; + splitter = new RegExp(spec, "g"); + } + var result = null; + if (target !== null && typeof target !== "undefined") { + var str = target.toString(); + if (str.length > 0) { + result = ""; + var matched; + var indx = 0; + while ((matched = splitter.exec(str)) !== null) { + result += str.substring(indx, matched.index); + result += matched[0].charAt(0).toUpperCase() + matched[0].substr(1); + indx = splitter.lastIndex; + } + result += str.substring(indx); + } + } + return result; + } + function arrayCapitalizeWords(target, delimiters) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(capitalizeWords(target[i], delimiters)); + } else { + result.push(null); + } + } + } + return result; + } + function setCapitalizeWords(target, delimiters) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(capitalizeWords(target[k], delimiters)); + } + } + } + return result; + } + function escapeXml(target, escapeQuotesParam) { + var result = target; + if (target !== null && typeof target !== "undefined") { + var escapeQuotes = escapeQuotesParam !== null && typeof escapeQuotesParam !== "undefined" && escapeQuotesParam; + if (escapeQuotes) { + result = escapeXmlTrue(target); + } else { + result = ""; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + var c = target.charAt(i); + if (c === "&") { + if (!isEntityStart(target, i)) { + c = "&"; + } + } else if (c === "<") { + c = "&lt;"; + } else if (c === ">") { + c = "&gt;"; + } else if (c === '"') { + c = "&quot;"; + } else if (c === "'") { + c = "&#39;"; + } + result += c; + } + } + } + return result; + } + function escapeXmlTrue(target) { + var result = ""; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + var c = target.charAt(i); + if (c === "&") { + if (!isEntityStart(target, i)) { + c = "&"; + } + } else if (c === "<") { + c = "<"; + } else if (c === ">") { + c = ">"; + } else if (c === '"') { + c = """; + } else if (c === "'") { + c = "'"; + } + result += c; + } + return result; + } + function unescapeXml(target) { + var result = ""; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + var c = target.charAt(i); + if (c === "&") { + c = isEntity(target, i); + if (c !== "&") { + i += c.length; + if (c === "<") { + c = "<"; + } else if (c === ">") { + c = ">"; + } else if (c === "&") { + c = "&"; + } else if (c === """) { + c = '"'; + } else if (c === "'") { + c = "'"; + } + } else { + c = "&"; + } + } + result += c; + } + return result; + } + function isEntity(buffer, position) { + var entity = "&"; + var i = position + 1; + while (i < buffer.length) { + var c = buffer[i]; + if (!(c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c >= "0" && c <= "9" || c == ";" || c == "#")) { + return "&"; + } + entity += c; + if (c == ";") { + return entity; + } + i++; + } + return "&"; + } + function isEntityStart(buffer, position) { + var i = position + 1; + while (i < buffer.length) { + var c = buffer[i]; + if (!(c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c >= "0" && c <= "9" || c == ";" || c == "#")) { + return false; + } + if (c == ";") { + return true; + } + i++; + } + return false; + } + function arrayEscapeXml(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(escapeXml(target[i], false)); + } else { + result.push(null); + } + } + } + return result; + } + function setEscapeXml(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(escapeXml(target[k], false)); + } + } + } + return result; + } + function escapeJavaScript(target) { + var result = target; + if (target !== null && typeof target !== "undefined") { + result = escapeJavaAny(target, true); + } + return result; + } + function escapeJavaAny(target, javaScript) { + var result = ""; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + var c = target.charAt(i); + var cc = target.charCodeAt(i); + if (cc >= 32 && cc <= 127) { + switch (c) { + case "\\": + c = "\\"; + break; + + case '"': + c = '\\"'; + break; + + case "'": + if (javaScript) { + c = "\\'"; + } + break; + + case "/": + if (javaScript) { + if (i > 0 && target.charAt(i - 1) == "<") { + c = "\\/"; + } + } + break; + + case ">": + if (javaScript && i > 1) { + if (target.charAt(i - 1) == "]" && target.charAt(i - 2) == "]") { + c = "\\>"; + } + } + break; + + default: + break; + } + } else { + switch (c) { + case " ": + c = "\\t"; + break; + + case "\n": + c = "\\n"; + break; + + case "\b": + c = "\\b"; + break; + + case "\f": + c = "\\f"; + break; + + case "\r": + c = "\\r"; + break; + + default: + if (javaScript) { + c = hexEscape(cc); + } else { + c = unicodeEscape(cc); + } + break; + } + } + result += c; + } + return result; + } + function unicodeEscape(c) { + var x = c + 65536; + x = x.toString(16); + x = x.slice(1); + var output = "\\u" + x.toUpperCase(); + return output; + } + function hexEscape(c) { + var x = c + 256; + x = x.toString(16); + x = x.slice(1); + var output = "\\x" + x.toUpperCase(); + return output; + } + function arrayEscapeJavaScript(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(escapeJavaScript(target[i])); + } else { + result.push(null); + } + } + } + return result; + } + function setEscapeJavaScript(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(escapeJavaScript(target[k])); + } + } + } + return result; + } + function unescapeJavaScript(target) { + var result = target; + if (target !== null && typeof target !== "undefined") { + result = unescapeJavaAny(target); + } + return result; + } + function unescapeJavaAny(target) { + var result = ""; + var unicodeSpec = ""; + var unicodeLen = -1; + var hexSpec = ""; + var hexLen = -1; + var lastWasEscape = false; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + var c = target.charAt(i); + if (unicodeLen >= 0) { + unicodeSpec += c; + if (c >= "0" && c <= "9" || c >= "A" && c <= "F" || c >= "a" && c <= "f") { + unicodeLen++; + if (unicodeLen > 3) { + var cc = parseInt(unicodeSpec, 16); + c = String.fromCharCode(cc); + unicodeSpec = ""; + unicodeLen = -1; + result += c; + lastWasEscape = false; + } + } else { + return target; + } + } else if (hexLen >= 0) { + hexSpec += c; + if (c >= "0" && c <= "9" || c >= "A" && c <= "F" || c >= "a" && c <= "f") { + hexLen++; + if (hexLen > 1) { + var cc = parseInt(hexSpec, 16); + c = String.fromCharCode(cc); + hexSpec = ""; + hexLen = -1; + result += c; + lastWasEscape = false; + } + } else { + return target; + } + } else if (lastWasEscape) { + if (c === "u") { + unicodeLen = 0; + } else if (c === "x") { + hexLen = 0; + } else { + switch (c) { + case "t": + c = " "; + break; + + case "n": + c = "\n"; + break; + + case "b": + c = "\b"; + break; + + case "f": + c = "\f"; + break; + + case "r": + c = "\r"; + break; + + default: + break; + } + result += c; + lastWasEscape = false; + } + } else if (c == "\\") { + lastWasEscape = true; + } else { + result += c; + lastWasEscape = false; + } + } + if (unicodeLen >= 0) { + result += "\\u" + unicodeSpec; + } else if (hexLen >= 0) { + result += "\\x" + hexSpec; + } else if (lastWasEscape) { + result += "\\"; + } + return result; + } + function arrayUnescapeJavaScript(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(unescapeJavaScript(target[i])); + } else { + result.push(null); + } + } + } + return result; + } + function setUnescapeJavaScript(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(unescapeJavaScript(target[k])); + } + } + } + return result; + } + function escapeJava(target) { + var result = target; + if (target !== null && typeof target !== "undefined") { + result = escapeJavaAny(target, false); + } + return result; + } + function arrayEscapeJava(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + if (target[i] !== null) { + result.push(escapeJava(target[i])); + } else { + result.push(null); + } + } + } + return result; + } + function setEscapeJava(target) { + var result = null; + if (target !== null && typeof target !== "undefined") { + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(escapeJava(target[k])); + } + } + } + return result; + } + var ALPHA_NUMERIC = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + function randomAlphanumeric(count) { + var result = ""; + for (var i = 0; i < count; i++) { + result += ALPHA_NUMERIC.charAt(Math.floor(Math.random() * ALPHA_NUMERIC.length)); + } + return result; + } + function defaultString(target, defaultValue) { + if (defaultValue !== null && typeof defaultValue !== "undefined") { + if (target == null) { + return defaultValue.toString(); + } + var targetString = target.toString(); + if (isEmpty(targetString)) { + return defaultValue.toString(); + } + return targetString; + } + throw new thymol.ThError("#strings.defaultString defaultValue cannot be null"); + } + function doArrayDefaultString(target, defaultValue) { + if (target == null || typeof target === "undefined") { + return target; + } + var result = []; + for (var i = 0, iLimit = target.length; i < iLimit; i++) { + result.push(defaultString(target[i], defaultValue)); + } + return result; + } + function arrayDefaultString(target, defaultValue) { + if (defaultValue !== null && typeof defaultValue !== "undefined") { + return doArrayDefaultString(target, defaultValue); + } + throw new thymol.ThError("#strings.arrayDefaultString defaultValue cannot be null"); + } + function listDefaultString(target, defaultValue) { + if (defaultValue !== null && typeof defaultValue !== "undefined") { + return doArrayDefaultString(target, defaultValue); + } + throw new thymol.ThError("#strings.listDefaultString defaultValue cannot be null"); + } + function setDefaultString(target, defaultValue) { + if (defaultValue !== null && typeof defaultValue !== "undefined") { + if (target == null || typeof target === "undefined") { + return target; + } + result = new thymol.ThSet(); + for (var k in target) { + if (target.isContent(k)) { + result.add(defaultString(target[k], defaultValue)); + } + } + return result; + } + throw new thymol.ThError("#strings.setDefaultString defaultValue cannot be null"); + } + return { + thExpressionObjectName: thExpressionObjectName, + toString: toString, + arrayToString: arrayToString, + listToString: arrayToString, + setToString: setToString, + abbreviate: abbreviate, + arrayAbbreviate: arrayAbbreviate, + listAbbreviate: arrayAbbreviate, + setAbbreviate: setAbbreviate, + equals: equals, + equalsIgnoreCase: equalsIgnoreCase, + contains: contains, + arrayContains: arrayContains, + listContains: arrayContains, + setContains: setContains, + containsIgnoreCase: containsIgnoreCase, + arrayContainsIgnoreCase: arrayContainsIgnoreCase, + listContainsIgnoreCase: arrayContainsIgnoreCase, + setContainsIgnoreCase: setContainsIgnoreCase, + startsWith: startsWith, + arrayStartsWith: arrayStartsWith, + listStartsWith: arrayStartsWith, + setStartsWith: setStartsWith, + endsWith: endsWith, + arrayEndsWith: arrayEndsWith, + listEndsWith: arrayEndsWith, + setEndsWith: setEndsWith, + substring: substring, + arraySubstring: arraySubstring, + listSubstring: arraySubstring, + setSubstring: setSubstring, + substringAfter: substringAfter, + arraySubstringAfter: arraySubstringAfter, + listSubstringAfter: arraySubstringAfter, + setSubstringAfter: setSubstringAfter, + substringBefore: substringBefore, + arraySubstringBefore: arraySubstringBefore, + listSubstringBefore: arraySubstringBefore, + setSubstringBefore: setSubstringBefore, + prepend: prepend, + arrayPrepend: arrayPrepend, + listPrepend: arrayPrepend, + setPrepend: setPrepend, + repeat: repeat, + append: append, + concat: concat, + concatReplaceNulls: concatReplaceNulls, + arrayAppend: arrayAppend, + listAppend: arrayAppend, + setAppend: setAppend, + indexOf: indexOf, + arrayIndexOf: arrayIndexOf, + listIndexOf: arrayIndexOf, + setIndexOf: setIndexOf, + isEmpty: isEmpty, + arrayIsEmpty: arrayIsEmpty, + listIsEmpty: arrayIsEmpty, + setIsEmpty: setIsEmpty, + arrayJoin: arrayJoin, + listJoin: arrayJoin, + setJoin: setJoin, + arraySplit: arraySplit, + listSplit: arraySplit, + setSplit: setSplit, + length: length, + arrayLength: arrayLength, + listLength: arrayLength, + setLength: setLength, + replace: replace, + arrayReplace: arrayReplace, + listReplace: arrayReplace, + setReplace: setReplace, + multipleReplace: multipleReplace, + arrayMultipleReplace: arrayMultipleReplace, + listMultipleReplace: arrayMultipleReplace, + setMultipleReplace: setMultipleReplace, + toUpperCase: toUpperCase, + arrayToUpperCase: arrayToUpperCase, + listToUpperCase: arrayToUpperCase, + setToUpperCase: setToUpperCase, + toLowerCase: toLowerCase, + arrayToLowerCase: arrayToLowerCase, + listToLowerCase: arrayToLowerCase, + setToLowerCase: setToLowerCase, + trim: trim, + arrayTrim: arrayTrim, + listTrim: arrayTrim, + setTrim: setTrim, + capitalize: capitalize, + arrayCapitalize: arrayCapitalize, + listCapitalize: arrayCapitalize, + setCapitalize: setCapitalize, + unCapitalize: unCapitalize, + arrayUnCapitalize: arrayUnCapitalize, + listUnCapitalize: arrayUnCapitalize, + setUnCapitalize: setUnCapitalize, + capitalizeWords: capitalizeWords, + arrayCapitalizeWords: arrayCapitalizeWords, + listCapitalizeWords: arrayCapitalizeWords, + setCapitalizeWords: setCapitalizeWords, + escapeXml: escapeXml, + arrayEscapeXml: arrayEscapeXml, + listEscapeXml: arrayEscapeXml, + setEscapeXml: setEscapeXml, + escapeJavaScript: escapeJavaScript, + arrayEscapeJavaScript: arrayEscapeJavaScript, + listEscapeJavaScript: arrayEscapeJavaScript, + setEscapeJavaScript: setEscapeJavaScript, + unescapeJavaScript: unescapeJavaScript, + arrayUnescapeJavaScript: arrayUnescapeJavaScript, + listUnescapeJavaScript: arrayUnescapeJavaScript, + setUnescapeJavaScript: setUnescapeJavaScript, + escapeJava: escapeJava, + arrayEscapeJava: arrayEscapeJava, + listEscapeJava: arrayEscapeJava, + setEscapeJava: setEscapeJava, + unescapeJava: unescapeJavaScript, + arrayUnescapeJava: arrayUnescapeJavaScript, + listUnescapeJava: arrayUnescapeJavaScript, + setUnescapeJava: setUnescapeJavaScript, + randomAlphanumeric: randomAlphanumeric, + defaultString: defaultString, + arrayDefaultString: arrayDefaultString, + listDefaultString: listDefaultString, + setDefaultString: setDefaultString + }; +}(); + +thymol.thObjectsConfigureModules = function() { + thymol.addDialect({ + objects: [ thymol.objects.thAggregatesObject, thymol.objects.thArraysObject, thymol.objects.thBoolsObject, thymol.objects.thDatesObject, thymol.objects.thCalendarsObject, thymol.objects.thIdsObject, thymol.objects.thListsObject, thymol.objects.thMapsObject, thymol.objects.thMessagesObject, thymol.objects.thNumbersObject, thymol.objects.thObjectsObject, thymol.objects.thSetsObject, thymol.objects.thStringsObject ] + }); +}; + +(function() { + var DOMParser_proto = thymol.thDomParser.prototype, real_parseFromString = DOMParser_proto.parseFromString; + try { + if (new thymol.thDomParser().parseFromString("", "text/html")) { + return; + } + } catch (ignore) {} + DOMParser_proto.parseFromString = function(markup, type) { + var res, doc; + if (/^\s*text\/html\s*(?:;|$)/i.test(type)) { + doc = thymol.thDocument.implementation.createHTMLDocument(""); + if (markup.toLowerCase().indexOf(" -1) { + doc.documentElement.innerHTML = markup; + } else { + doc.body.innerHTML = markup; + } + res = doc; + } else { + res = real_parseFromString.apply(this, arguments); + } + return res; + }; +})(); + +if (!Array.indexOf) { + Array.prototype.indexOf = function(obj, start) { + for (var i = start || 0; i < this.length; i++) { + if (this[i] === obj) { + return i; + } + } + return -1; + }; +} + +$(function() { + thymol.jqSetup($); + thymol.execute(document); +}); + +$(window).unload(function() { + if (thymol.sessionContext && thymol.sessionContext.persist) { + thymol.sessionContext.persist(); + } +}); \ No newline at end of file