FM / src

/var/www/p4ela.kz/server/delivery/node_modules/@grpc/grpc-js/node_modules/protobufjs/src/

/var/www/p4ela.kz/server/delivery/node_modules/@grpc/grpc-js/node_modules/protobufjs/src

Name	Size	Mode	Actions
rpc/	-	0755	rm
util/	-	0755	rm
common.js	9307	0644	edit dl rm
converter.js	11241	0644	edit dl rm
decoder.js	4249	0644	edit dl rm
encoder.js	3582	0644	edit dl rm
enum.js	5558	0644	edit dl rm
field.js	11667	0644	edit dl rm
index-light.js	3659	0644	edit dl rm
index-minimal.js	925	0644	edit dl rm
index.js	352	0644	edit dl rm
mapfield.js	4186	0644	edit dl rm
message.js	3800	0644	edit dl rm
method.js	5025	0644	edit dl rm
namespace.js	15044	0644	edit dl rm
object.js	6550	0644	edit dl rm
oneof.js	5771	0644	edit dl rm
parse.js	24876	0644	edit dl rm
reader.js	11263	0644	edit dl rm
reader_buffer.js	1252	0644	edit dl rm
root.js	12639	0644	edit dl rm
roots.js	454	0644	edit dl rm
rpc.js	1204	0644	edit dl rm
service.js	5122	0644	edit dl rm
tokenize.js	13163	0644	edit dl rm
type.js	20447	0644	edit dl rm
types.js	5518	0644	edit dl rm
typescript.jsdoc	275	0644	edit dl rm
util.js	6119	0644	edit dl rm
verifier.js	6043	0644	edit dl rm
wrappers.js	3368	0644	edit dl rm
writer.js	12072	0644	edit dl rm
writer_buffer.js	2356	0644	edit dl rm

Edit: /var/www/p4ela.kz/server/delivery/node_modules/@grpc/grpc-js/node_modules/protobufjs/src/object.js (6550B)

"use strict";
module.exports = ReflectionObject;

ReflectionObject.className = "ReflectionObject";

var util = require("./util");

var Root; // cyclic

/**
 * Constructs a new reflection object instance.
 * @classdesc Base class of all reflection objects.
 * @constructor
 * @param {string} name Object name
 * @param {Object.<string,*>} [options] Declared options
 * @abstract
 */
function ReflectionObject(name, options) {

if (!util.isString(name))
        throw TypeError("name must be a string");

if (options && !util.isObject(options))
        throw TypeError("options must be an object");

/**
     * Options.
     * @type {Object.<string,*>|undefined}
     */
    this.options = options; // toJSON

/**
     * Parsed Options.
     * @type {Array.<Object.<string,*>>|undefined}
     */
    this.parsedOptions = null;

/**
     * Unique name within its namespace.
     * @type {string}
     */
    this.name = name;

/**
     * Parent namespace.
     * @type {Namespace|null}
     */
    this.parent = null;

/**
     * Whether already resolved or not.
     * @type {boolean}
     */
    this.resolved = false;

/**
     * Comment text, if any.
     * @type {string|null}
     */
    this.comment = null;

/**
     * Defining file name.
     * @type {string|null}
     */
    this.filename = null;
}

Object.defineProperties(ReflectionObject.prototype, {

/**
     * Reference to the root namespace.
     * @name ReflectionObject#root
     * @type {Root}
     * @readonly
     */
    root: {
        get: function() {
            var ptr = this;
            while (ptr.parent !== null)
                ptr = ptr.parent;
            return ptr;
        }
    },

/**
     * Full name including leading dot.
     * @name ReflectionObject#fullName
     * @type {string}
     * @readonly
     */
    fullName: {
        get: function() {
            var path = [ this.name ],
                ptr = this.parent;
            while (ptr) {
                path.unshift(ptr.name);
                ptr = ptr.parent;
            }
            return path.join(".");
        }
    }
});

/**
 * Converts this reflection object to its descriptor representation.
 * @returns {Object.<string,*>} Descriptor
 * @abstract
 */
ReflectionObject.prototype.toJSON = /* istanbul ignore next */ function toJSON() {
    throw Error(); // not implemented, shouldn't happen
};

/**
 * Called when this object is added to a parent.
 * @param {ReflectionObject} parent Parent added to
 * @returns {undefined}
 */
ReflectionObject.prototype.onAdd = function onAdd(parent) {
    if (this.parent && this.parent !== parent)
        this.parent.remove(this);
    this.parent = parent;
    this.resolved = false;
    var root = parent.root;
    if (root instanceof Root)
        root._handleAdd(this);
};

/**
 * Called when this object is removed from a parent.
 * @param {ReflectionObject} parent Parent removed from
 * @returns {undefined}
 */
ReflectionObject.prototype.onRemove = function onRemove(parent) {
    var root = parent.root;
    if (root instanceof Root)
        root._handleRemove(this);
    this.parent = null;
    this.resolved = false;
};

/**
 * Resolves this objects type references.
 * @returns {ReflectionObject} `this`
 */
ReflectionObject.prototype.resolve = function resolve() {
    if (this.resolved)
        return this;
    if (this.root instanceof Root)
        this.resolved = true; // only if part of a root
    return this;
};

/**
 * Gets an option value.
 * @param {string} name Option name
 * @returns {*} Option value or `undefined` if not set
 */
ReflectionObject.prototype.getOption = function getOption(name) {
    if (this.options)
        return this.options[name];
    return undefined;
};

/**
 * Sets an option.
 * @param {string} name Option name
 * @param {*} value Option value
 * @param {boolean} [ifNotSet] Sets the option only if it isn't currently set
 * @returns {ReflectionObject} `this`
 */
ReflectionObject.prototype.setOption = function setOption(name, value, ifNotSet) {
    if (!ifNotSet || !this.options || this.options[name] === undefined)
        (this.options || (this.options = {}))[name] = value;
    return this;
};

/**
 * Sets a parsed option.
 * @param {string} name parsed Option name
 * @param {*} value Option value
 * @param {string} propName dot '.' delimited full path of property within the option to set. if undefined\empty, will add a new option with that value
 * @returns {ReflectionObject} `this`
 */
ReflectionObject.prototype.setParsedOption = function setParsedOption(name, value, propName) {
    if (!this.parsedOptions) {
        this.parsedOptions = [];
    }
    var parsedOptions = this.parsedOptions;
    if (propName) {
        // If setting a sub property of an option then try to merge it
        // with an existing option
        var opt = parsedOptions.find(function (opt) {
            return Object.prototype.hasOwnProperty.call(opt, name);
        });
        if (opt) {
            // If we found an existing option - just merge the property value
            var newValue = opt[name];
            util.setProperty(newValue, propName, value);
        } else {
            // otherwise, create a new option, set it's property and add it to the list
            opt = {};
            opt[name] = util.setProperty({}, propName, value);
            parsedOptions.push(opt);
        }
    } else {
        // Always create a new option when setting the value of the option itself
        var newOpt = {};
        newOpt[name] = value;
        parsedOptions.push(newOpt);
    }
    return this;
};

/**
 * Sets multiple options.
 * @param {Object.<string,*>} options Options to set
 * @param {boolean} [ifNotSet] Sets an option only if it isn't currently set
 * @returns {ReflectionObject} `this`
 */
ReflectionObject.prototype.setOptions = function setOptions(options, ifNotSet) {
    if (options)
        for (var keys = Object.keys(options), i = 0; i < keys.length; ++i)
            this.setOption(keys[i], options[keys[i]], ifNotSet);
    return this;
};

/**
 * Converts this instance to its string representation.
 * @returns {string} Class name[, space, full name]
 */
ReflectionObject.prototype.toString = function toString() {
    var className = this.constructor.className,
        fullName  = this.fullName;
    if (fullName.length)
        return className + " " + fullName;
    return className;
};

// Sets up cyclic dependencies (called in index-light)
ReflectionObject._configure = function(Root_) {
    Root = Root_;
};

cmd: