node_modules/ejs/lib/cjs/utils.js

/*
 * EJS Embedded JavaScript templates
 * Copyright 2112 Matthew Eernisse (mde@fleegix.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 express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
/**
 * Private utility functions
 * @module utils
 * @private
 */
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
var utils = {};
var regExpChars = /[|\\{}()[\]^$+*?.]/g;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var hasOwn = function (obj, key) { return hasOwnProperty.apply(obj, [key]); };
utils.hasOwn = hasOwn;
/**
 * Escape characters reserved in regular expressions.
 *
 * If `string` is `undefined` or `null`, the empty string is returned.
 *
 * @param {String} string Input string
 * @return {String} Escaped string
 * @static
 * @private
 */
utils.escapeRegExpChars = function (string) {
    // istanbul ignore if
    if (!string) {
        return '';
    }
    return String(string).replace(regExpChars, '\\$&');
};
var _ENCODE_HTML_RULES = {
    '&': '&',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&#34;',
    "'": '&#39;'
};
var _MATCH_HTML = /[&<>'"]/g;
function encode_char(c) {
    return _ENCODE_HTML_RULES[c] || c;
}
/**
 * Stringified version of constants used by {@link module:utils.escapeXML}.
 *
 * @readonly
 * @type {String}
 */
var escapeFuncStr = 'var _ENCODE_HTML_RULES = {\n'
    + '      "&": "&amp;"\n'
    + '    , "<": "&lt;"\n'
    + '    , ">": "&gt;"\n'
    + '    , \'"\': "&#34;"\n'
    + '    , "\'": "&#39;"\n'
    + '    }\n'
    + '  , _MATCH_HTML = /[&<>\'"]/g;\n'
    + 'function encode_char(c) {\n'
    + '  return _ENCODE_HTML_RULES[c] || c;\n'
    + '};\n';
/**
 * Escape characters reserved in XML.
 *
 * If `markup` is `undefined` or `null`, the empty string is returned.
 *
 * @implements {EscapeCallback}
 * @param {String} markup Input string
 * @return {String} Escaped string
 * @static
 * @private
 */
utils.escapeXML = function (markup) {
    return markup == undefined
        ? ''
        : String(markup)
            .replace(_MATCH_HTML, encode_char);
};
function escapeXMLToString() {
    return Function.prototype.toString.call(this) + ';\n' + escapeFuncStr;
}
try {
    if (typeof Object.defineProperty === 'function') {
        // If the Function prototype is frozen, the "toString" property is non-writable. This means that any objects which inherit this property
        // cannot have the property changed using an assignment. If using strict mode, attempting that will cause an error. If not using strict
        // mode, attempting that will be silently ignored.
        // However, we can still explicitly shadow the prototype's "toString" property by defining a new "toString" property on this object.
        Object.defineProperty(utils.escapeXML, 'toString', { value: escapeXMLToString });
    }
    else {
        // If Object.defineProperty() doesn't exist, attempt to shadow this property using the assignment operator.
        utils.escapeXML.toString = escapeXMLToString;
    }
}
catch (err) {
    console.warn('Unable to set escapeXML.toString (is the Function prototype frozen?)');
}
/**
 * Naive copy of properties from one object to another.
 * Does not recurse into non-scalar properties
 * Does not check to see if the property has a value before copying
 *
 * @param  {Object} to   Destination object
 * @param  {Object} from Source object
 * @return {Object}      Destination object
 * @static
 * @private
 */
utils.shallowCopy = function (to, from) {
    from = from || {};
    if ((to !== null) && (to !== undefined)) {
        for (var p in from) {
            if (!hasOwn(from, p)) {
                continue;
            }
            if (p === '__proto__' || p === 'constructor') {
                continue;
            }
            to[p] = from[p];
        }
    }
    return to;
};
/**
 * Naive copy of a list of key names, from one object to another.
 * Only copies property if it is actually defined
 * Does not recurse into non-scalar properties
 *
 * @param  {Object} to   Destination object
 * @param  {Object} from Source object
 * @param  {Array} list List of properties to copy
 * @return {Object}      Destination object
 * @static
 * @private
 */
utils.shallowCopyFromList = function (to, from, list) {
    list = list || [];
    from = from || {};
    if ((to !== null) && (to !== undefined)) {
        for (var i = 0; i < list.length; i++) {
            var p = list[i];
            if (typeof from[p] != 'undefined') {
                if (!hasOwn(from, p)) {
                    continue;
                }
                if (p === '__proto__' || p === 'constructor') {
                    continue;
                }
                to[p] = from[p];
            }
        }
    }
    return to;
};
/**
 * Simple in-process cache implementation. Does not implement limits of any
 * sort.
 *
 * @implements {Cache}
 * @static
 * @private
 */
utils.cache = {
    _data: {},
    set: function (key, val) {
        this._data[key] = val;
    },
    get: function (key) {
        return this._data[key];
    },
    remove: function (key) {
        delete this._data[key];
    },
    reset: function () {
        this._data = {};
    }
};
/**
 * Transforms hyphen case variable into camel case.
 *
 * @param {String} string Hyphen case string
 * @return {String} Camel case string
 * @static
 * @private
 */
utils.hyphenToCamel = function (str) {
    return str.replace(/-[a-z]/g, function (match) { return match[1].toUpperCase(); });
};
/**
 * Returns a null-prototype object in runtimes that support it
 *
 * @return {Object} Object, prototype will be set to null where possible
 * @static
 * @private
 */
utils.createNullProtoObjWherePossible = (function () {
    if (typeof Object.create == 'function') {
        return function () {
            return Object.create(null);
        };
    }
    if (!({ __proto__: null } instanceof Object)) {
        return function () {
            return { __proto__: null };
        };
    }
    // Not possible, just pass through
    return function () {
        return {};
    };
})();
/**
 * Copies own-properties from one object to a null-prototype object for basic
 * protection against prototype pollution
 *
 * @return {Object} Object with own-properties of input object
 * @static
 * @private
 */
utils.hasOwnOnlyObject = function (obj) {
    var o = utils.createNullProtoObjWherePossible();
    for (var p in obj) {
        if (hasOwn(obj, p)) {
            o[p] = obj[p];
        }
    }
    return o;
};
if (typeof exports != 'undefined') {
    module.exports = utils;
}
exports.default = utils;