Get a raw node
@return {Node}
433566
function getUriRaw() {
  const startPos = pos;
  const type = NodeType.RawType;
  const token = tokens[startPos];
  const line = token.ln;
  const column = token.col;
  let content = [];
  let l;

  while (pos < tokens[startPos].uri_raw_end) {
    if (checkInterpolation(pos) || checkVariable(pos)) break;
    else if (l = checkUriRawCharacters(pos)) pos += l;
    else break;
  }

  content = joinValues(startPos, pos - 1);

  return newNode(type, content, line, column);
}
504981
function getResult(attrNode, dataSourceName, context) {
    const resultId = attrNode.dataSources[dataSourceName].resultId;
    if (typeof resultId === 'undefined') {
        const attrPath = context.attrPath.length > 0 ? context.attrPath.join('.') : '{root}';
        throw new ImplementationError(`Result for "${attrPath}" (DataSource "${dataSourceName}") missing`);
    }
    return context.rawResults[resultId];
}
611087
function () {
        let usingNode = false;
        if (typeof process === 'object') {
            if (typeof process.versions === 'object') {
                if (typeof process.versions.node !== 'undefined') {
                    usingNode = true;
                }
            }
        }

        return usingNode;
    }
956968
public org.w3c.dom.Node getMessageBody(Object rawData, boolean bReturnCopy)
    {
        if (this.getRawData() instanceof String)
        {   // Always
            String strXML = this.getXML();
            return Utility.convertXMLToDOM(strXML);
        }
        return super.getMessageBody(rawData, bReturnCopy);
    }
1101752
function raw(callSite) {
	    var tpl = _toIobject(callSite.raw);
	    var len = _toLength(tpl.length);
	    var aLen = arguments.length;
	    var res = [];
	    var i = 0;
	    while (len > i) {
	      res.push(String(tpl[i++]));
	      if (i < aLen) res.push(String(arguments[i]));
	    }return res.join('');
	  }
872368
function _getNodeText(node) {
    return node.sourceFile.text.substr(node.start, node.end - node.start);
}
220080
function (xmlNode) {

            var rawValues = this.getRawValues(xmlNode);
            if (!rawValues) {
                return null;
            }

            var len = rawValues.length;

            var bufferData = new Uint32Array(len);
            for (var i = 0; i < len; i++) {
                bufferData[i] = parseInt(rawValues[i]);
            }

            return bufferData;
        }
1236679
function(node) {
            node = Y.Dom.get(node);
            if (!node) {
                return null;
            }

            return Y.Dom.getNextSiblingBy(node);
        }
598608
function RawNode(raw, config, app) {
  utils.define(this, 'isRawNode', true);
  util.run(config, 'rawNode', raw);
  this.files = [];
  var paths = {};

  raw.options = utils.extend({}, config.options, raw.options);
  var opts = resolvePaths(raw.options);
  var filter = filterFiles(opts);

  var srcFiles = utils.arrayify(raw.src);
  if (opts.glob !== false && utils.hasGlob(raw.src)) {
    srcFiles = utils.glob.sync(raw.src, opts);
  }

  srcFiles = srcFiles.filter(filter);

  if (config.options.mapDest) {
    var len = srcFiles.length, i = -1;
    while (++i < len) {
      var node = new FilesNode(srcFiles[i], raw, config);
      app.emit('files', 'filesNode', node);
      app.emit('filesNode', node);
      var dest = node.dest;

      if (!node.src && !node.path) {
        continue;
      }

      var src = resolveArray(node.src, opts);
      if (paths[dest]) {
        paths[dest].src = paths[dest].src.concat(src);
      } else {
        node.src = utils.arrayify(src);
        this.files.push(node);
        paths[dest] = node;
      }
    }

    if (!this.files.length) {
      node = raw;
      raw.src = [];
      this.files.push(raw);
    }

  } else {
    createNode(srcFiles, raw, this.files, config);
  }
}
1181747
function(node) {
        var data = {}

        var key = null
        for (var i = 0, len = node.childNodes.length; i < len; i++) {
            var child = node.childNodes[i]
            if (child.nodeType != ELEMENT_NODE) {
                continue
            }

            // Grab the key, next noe should be the value
            if (child.tagName == 'key') {
                key = child.firstChild.nodeValue
            } else {
                // Parse the value node
                data[key] = this._parseNode(child)
            }
        }


        return data
    }
969100
function node(either) {
		var theNode = either;
		if (typeof(either) === "string") { //$NON-NLS-0$
			theNode = document.getElementById(either);
		}	
		return theNode;
	}
345165
function getPseudoClass1() {
  const type = NodeType.PseudocType;
  const token = tokens[pos];
  const line = token.ln;
  const column = token.col;
  const content = [];

  // Skip `:`.
  pos++;

  content.push(getIdent());

  {
    const type = NodeType.ArgumentsType;
    const token = tokens[pos];
    const line = token.ln;
    const column = token.col;

    // Skip `(`.
    pos++;

    const selectorContent = [].concat(
      getSC(),
      getSelectorsGroup(),
      getSC()
    );

    const end = getLastPosition(selectorContent, line, column, 1);
    const args = newNode(type, selectorContent, line, column, end);
    content.push(args);

    // Skip `)`.
    pos++;
  }

  return newNode(type, content, line, column);
}
1368824
function getChildLNode(node) {
    if (node.tNode.child) {
        var viewData = node.tNode.type === 2 /* View */ ? node.data : node.view;
        return readElementValue(viewData[node.tNode.child.index]);
    }
    return null;
}
1205560
function getParentheses() {
  const type = NodeType.ParenthesesType;
  const token = tokens[pos];
  const line = token.ln;
  const column = token.col;
  const right = token.right;
  let content = [];

  // Skip `(`.
  pos++;

  if (pos < right) {
    content = getTsets();
  }

  const end = getLastPosition(content, line, column, 1);

  // Skip `)`.
  pos++;

  return newNode(type, content, line, column, end);
}
137938
function(node) {
	var dp = DOMDataUtils.getDataParsoid(node);
	var dsr = Util.clone(dp.dsr);
	if (dp.autoInsertedStart) { dsr[2] = null; }
	if (dp.autoInsertedEnd) { dsr[3] = null; }
	return dsr;
}
421334
function(node) {
		return node && !this._suspended &&
			gui.DOMPlugin.embedded(node) &&
			node.nodeType === Node.ELEMENT_NODE;
	}
476173
function getNodeIndex(node) {
	var ret = 0;
	while (node.previousSibling) {
		ret++;
		node = node.previousSibling;
	}
	return ret;
}