Software: Apache/2.4.53 (Unix) OpenSSL/1.1.1o PHP/7.4.29 mod_perl/2.0.12 Perl/v5.34.1. PHP/7.4.29 uname -a: Linux vps-2738122-x 4.15.0-213-generic #224-Ubuntu SMP Mon Jun 19 13:30:12 UTC 2023 x86_64 uid=1(daemon) gid=1(daemon) grupos=1(daemon) Safe-mode: OFF (not secure) /opt/apex_led/www/js/shindig/features/src/main/javascript/features/core.util/ drwxrwxr-x | |
| Viewing file: Select action/file-type: /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
var gadgets = gadgets || {};
/**
* @fileoverview General purpose utilities that gadgets can use.
*/
/**
* @static
* @class Provides general-purpose utility functions.
* @name gadgets.util
*/
gadgets.util = function() {
/**
* Parses URL parameters into an object.
* @return {Array.<String>} The parameters
*/
function parseUrlParams(url) {
// Get settings from url, 'hash' takes precedence over 'search' component
// don't use document.location.hash due to browser differences.
var query;
var l = url;
var queryIdx = l.indexOf("?");
var hashIdx = l.indexOf("#");
if (hashIdx === -1) {
query = l.substr(queryIdx + 1);
} else {
// essentially replaces "#" with "&"
query = [l.substr(queryIdx + 1, hashIdx - queryIdx - 1), "&",
l.substr(hashIdx + 1)].join("");
}
return query.split("&");
}
var parameters = null;
var features = {};
var services = {};
var onLoadHandlers = [];
// Maps code points to the value to replace them with.
// If the value is "false", the character is removed entirely, otherwise
// it will be replaced with an html entity.
var escapeCodePoints = {
// nul; most browsers truncate because they use c strings under the covers.
0 : false,
// new line
10 : true,
// carriage return
13 : true,
// double quote
34 : true,
// single quote
39 : true,
// less than
60 : true,
// greater than
62 : true,
// Backslash
92 : true,
// line separator
8232 : true,
// paragraph separator
8233 : true
};
/**
* Regular expression callback that returns strings from unicode code points.
*
* @param {Array} match Ignored
* @param {String} value The codepoint value to convert
* @return {String} The character corresponding to value.
*/
function unescapeEntity(match, value) {
return String.fromCharCode(value);
}
/**
* Initializes feature parameters.
*/
function init(config) {
features = config["core.util"] || {};
}
if (gadgets.config) {
gadgets.config.register("core.util", null, init);
}
return /** @scope gadgets.util */ {
/**
* Gets the URL parameters.
*
* @param {String} opt_url Optional URL whose parameters to parse.
* Defaults to window's current URL.
* @return {Object} Parameters passed into the query string
* @member gadgets.util
* @private Implementation detail.
*/
getUrlParameters : function (opt_url) {
if (parameters !== null && typeof opt_url === "undefined") {
// "parameters" is a cache of current window params only.
return parameters;
}
var parsed = {};
parameters = {};
var pairs = parseUrlParams(opt_url || document.location.href);
var unesc = window.decodeURIComponent ? decodeURIComponent : unescape;
for (var i = 0, j = pairs.length; i < j; ++i) {
var pos = pairs[i].indexOf('=');
if (pos === -1) {
continue;
}
var argName = pairs[i].substring(0, pos);
var value = pairs[i].substring(pos + 1);
// difference to IG_Prefs, is that args doesn't replace spaces in
// argname. Unclear on if it should do:
// argname = argname.replace(/\+/g, " ");
value = value.replace(/\+/g, " ");
parsed[argName] = unesc(value);
}
if (typeof opt_url === "undefined") {
// Cache current-window params in parameters var.
parameters = parsed;
}
return parsed;
},
/**
* Creates a closure that is suitable for passing as a callback.
* Any number of arguments
* may be passed to the callback;
* they will be received in the order they are passed in.
*
* @param {Object} scope The execution scope; may be null if there is no
* need to associate a specific instance of an object with this
* callback
* @param {Function} callback The callback to invoke when this is run;
* any arguments passed in will be passed after your initial arguments
* @param {Object} var_args Initial arguments to be passed to the callback
*
* @member gadgets.util
* @private Implementation detail.
*/
makeClosure : function (scope, callback, var_args) {
// arguments isn't a real array, so we copy it into one.
var baseArgs = [];
for (var i = 2, j = arguments.length; i < j; ++i) {
baseArgs.push(arguments[i]);
}
return function() {
// append new arguments.
var tmpArgs = baseArgs.slice();
for (var i = 0, j = arguments.length; i < j; ++i) {
tmpArgs.push(arguments[i]);
}
return callback.apply(scope, tmpArgs);
};
},
/**
* Utility function for generating an "enum" from an array.
*
* @param {Array.<String>} values The values to generate.
* @return {Map<String,String>} An object with member fields to handle
* the enum.
*
* @private Implementation detail.
*/
makeEnum : function (values) {
var obj = {};
for (var i = 0, v; (v = values[i]); ++i) {
obj[v] = v;
}
return obj;
},
/**
* Gets the feature parameters.
*
* @param {String} feature The feature to get parameters for
* @return {Object} The parameters for the given feature, or null
*
* @member gadgets.util
*/
getFeatureParameters : function (feature) {
return typeof features[feature] === "undefined" ? null : features[feature];
},
/**
* Returns whether the current feature is supported.
*
* @param {String} feature The feature to test for
* @return {Boolean} True if the feature is supported
*
* @member gadgets.util
*/
hasFeature : function (feature) {
return typeof features[feature] !== "undefined";
},
/**
* Returns the list of services supported by the server
* serving this gadget.
*
* @return {Object} List of Services that enumerate their methods
*
* @member gadgets.util
*/
getServices : function () {
return services;
},
/**
* Registers an onload handler.
* @param {Function} callback The handler to run
*
* @member gadgets.util
*/
registerOnLoadHandler : function (callback) {
onLoadHandlers.push(callback);
},
/**
* Runs all functions registered via registerOnLoadHandler.
* @private Only to be used by the container, not gadgets.
*/
runOnLoadHandlers : function () {
for (var i = 0, j = onLoadHandlers.length; i < j; ++i) {
onLoadHandlers[i]();
}
},
/**
* Escapes the input using html entities to make it safer.
*
* If the input is a string, uses gadgets.util.escapeString.
* If it is an array, calls escape on each of the array elements
* if it is an object, will only escape all the mapped keys and values if
* the opt_escapeObjects flag is set. This operation involves creating an
* entirely new object so only set the flag when the input is a simple
* string to string map.
* Otherwise, does not attempt to modify the input.
*
* @param {Object} input The object to escape
* @param {Boolean} opt_escapeObjects Whether to escape objects.
* @return {Object} The escaped object
* @private Only to be used by the container, not gadgets.
*/
escape : function(input, opt_escapeObjects) {
if (!input) {
return input;
} else if (typeof input === "string") {
return gadgets.util.escapeString(input);
} else if (typeof input === "array") {
for (var i = 0, j = input.length; i < j; ++i) {
input[i] = gadgets.util.escape(input[i]);
}
} else if (typeof input === "object" && opt_escapeObjects) {
var newObject = {};
for (var field in input) {
if (input.hasOwnProperty(field)) {
newObject[gadgets.util.escapeString(field)] = gadgets.util.escape(input[field], true);
}
}
return newObject;
}
return input;
},
/**
* Escapes the input using html entities to make it safer.
*
* Currently not in the spec -- future proposals may change
* how this is handled.
*
* TODO: Parsing the string would probably be more accurate and faster than
* a bunch of regular expressions.
*
* @param {String} str The string to escape
* @return {String} The escaped string
*/
escapeString : function(str) {
var out = [], ch, shouldEscape;
for (var i = 0, j = str.length; i < j; ++i) {
ch = str.charCodeAt(i);
shouldEscape = escapeCodePoints[ch];
if (shouldEscape === true) {
out.push("&#", ch, ";");
} else if (shouldEscape !== false) {
// undefined or null are OK.
out.push(str.charAt(i));
}
}
return out.join("");
},
/**
* Reverses escapeString
*
* @param {String} str The string to unescape.
*/
unescapeString : function(str) {
return str.replace(/&#([0-9]+);/g, unescapeEntity);
}
};
}();
// Initialize url parameters so that hash data is pulled in before it can be
// altered by a click.
gadgets.util.getUrlParameters();
|
:: Command execute :: | |
--[ c99shell v. 2.1 [PHP 8 Update] [02.02.2022] maintained byC99Shell Github | Generation time: 0.476 ]-- |