The node-xcode library doesn't offer a method to get all target attributes, so we'll have to implement it ourselves.
187685
function getTargetAttributes(project, target) {
    var attributes = project.getFirstProject()['firstProject']['attributes'];
    target = target || project.getFirstTarget();

    if (attributes['TargetAttributes'] === undefined) {
        attributes['TargetAttributes'] = {};
    }

    if (attributes['TargetAttributes'][target.uuid] === undefined) {
        attributes['TargetAttributes'][target.uuid] = {};
    }

    return attributes['TargetAttributes'][target.uuid];
}
861715
function _getLinks(node) {
  var links = [];

  node.ifForEach('inEdgeIds', function (inEdge) {
    var edge = _data.edges.get(inEdge);
    edge.setProperties({
      sourceId: edge.get('inputVertexName'),
      targetId: edge.get('outputVertexName')
    });
    links.push(edge);
  });

  if(node.type === types.INPUT) {
    links.push(Ember.Object.create({
      sourceId: node.get('id'),
      targetId: node.get('vertex.id')
    }));
  }
  else if(node.type === types.OUTPUT) {
    links.push(Ember.Object.create({
      sourceId: node.get('vertex.id'),
      targetId: node.get('id')
    }));
  }

  return links;
}
1290859
def attribute_access(ast, options = {})
      options = { type: :any, ignore_calls: false }.merge!(options)
      return [] unless ast.respond_to?(:xpath)

      unless [:any, :string, :symbol, :vivified].include?(options[:type])
        raise ArgumentError, "Node type not recognised"
      end

      case options[:type]
      when :any then
        vivified_attribute_access(ast, options) +
          standard_attribute_access(ast, options)
      when :vivified then
        vivified_attribute_access(ast, options)
      else
        standard_attribute_access(ast, options)
      end
    end
613276
function build (obj, opts) {
  var XMLHDR = {
    version: '1.0',
    encoding: 'UTF-8'
  };

  var XMLDTD = {
    pubid: '-//Apple//DTD PLIST 1.0//EN',
    sysid: 'http://www.apple.com/DTDs/PropertyList-1.0.dtd'
  };

  var doc = xmlbuilder.create('plist');

  doc.dec(XMLHDR.version, XMLHDR.encoding, XMLHDR.standalone);
  doc.dtd(XMLDTD.pubid, XMLDTD.sysid);
  doc.att('version', '1.0');

  walk_obj(obj, doc);

  if (!opts) opts = {};
  // default `pretty` to `true`
  opts.pretty = opts.pretty !== false;
  return doc.end(opts);
}
1282447
function makeShimNode(main) {
	return {
		bundles: [main],
		dependencies: ["@loader"],
		deps: ["@loader"],
		load: {
			address: "",
			metadata: {
				format: "amd",
				deps: ["@loader"],
				dependencies: ["@loader"]
			},
			name: "@steal",
			source: `
				define("@steal", ["@loader"], function(atLoader) {
					var steal = {};

					steal.loader = atLoader;
					steal.done = function() {
						return Promise.resolve();
					};

					return steal;
				});
			`
		}
	};
}
963290
function buildJSXOpeningElementAttributes(attribs, file) {
    var _props = [];
    var objs = [];

    var pushProps = function pushProps() {
      if (!_props.length) return;

      objs.push(t.objectExpression(_props));
      _props = [];
    };

    while (attribs.length) {
      var prop = attribs.shift();
      if (t.isJSXSpreadAttribute(prop)) {
        pushProps();
        objs.push(prop.argument);
      } else {
        _props.push(prop);
      }
    }

    pushProps();

    if (objs.length === 1) {
      // only one object
      attribs = objs[0];
    } else {
      // looks like we have multiple objects
      if (!t.isObjectExpression(objs[0])) {
        objs.unshift(t.objectExpression([]));
      }

      // spread it
      attribs = t.callExpression(file.addHelper("extends"), objs);
    }

    return attribs;
  }
270671
function getInstructions (selectors) {
  return selectors.split(' ').reverse().map((selector, step) => {
    const discover = step === 0
    const [type, pseudo] = selector.split(':')

    var validate = null
    var instruction = null

    switch (true) {

      // child: '>'
      case />/.test(type):
        instruction = function checkParent (node) {
          return (validate) => validate(node.parent) && node.parent
        }
        break

      // class: '.'
      case /^\./.test(type):
        const names = type.substr(1).split('.')
        validate = (node) => {
          const nodeClassName = node.attribs.class
          return nodeClassName && names.every((name) => nodeClassName.indexOf(name) > -1)
        }
        instruction = function checkClass (node, root) {
          if (discover) {
            return node.getElementsByClassName(names.join(' '))
          }
          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)
        }
        break

      // attribute: '[key="value"]'
      case /^\[/.test(type):
        const [attributeKey, attributeValue] = type.replace(/\[|\]|"/g, '').split('=')
        validate = (node) => {
          const hasAttribute = Object.keys(node.attribs).indexOf(attributeKey) > -1
          if (hasAttribute) { // regard optional attributeValue
            if (!attributeValue || (node.attribs[attributeKey] === attributeValue)) {
              return true
            }
          }
          return false
        }
        instruction = function checkAttribute (node, root) {
          if (discover) {
            const NodeList = []
            traverseDescendants([node], (descendant) => {
              if (validate(descendant)) {
                NodeList.push(descendant)
              }
            })
            return NodeList
          }
          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)
        }
        break

      // id: '#'
      case /^#/.test(type):
        const id = type.substr(1)
        validate = (node) => {
          return node.attribs.id === id
        }
        instruction = function checkId (node, root) {
          if (discover) {
            const NodeList = []
            traverseDescendants([node], (descendant, done) => {
              if (validate(descendant)) {
                NodeList.push(descendant)
                done()
              }
            })
            return NodeList
          }
          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)
        }
        break

      // universal: '*'
      case /\*/.test(type):
        validate = (node) => true
        instruction = function checkUniversal (node, root) {
          if (discover) {
            const NodeList = []
            traverseDescendants([node], (descendant) => NodeList.push(descendant))
            return NodeList
          }
          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)
        }
        break

      // tag: '...'
      default:
        validate = (node) => {
          return node.name === type
        }
        instruction = function checkTag (node, root) {
          if (discover) {
            const NodeList = []
            traverseDescendants([node], (descendant) => {
              if (validate(descendant)) {
                NodeList.push(descendant)
              }
            })
            return NodeList
          }
          return (typeof node === 'function') ? node(validate) : getAncestor(node, root, validate)
        }
    }

    if (!pseudo) {
      return instruction
    }

    const rule = pseudo.match(/-(child|type)\((\d+)\)$/)
    const kind = rule[1]
    const index = parseInt(rule[2], 10) - 1

    const validatePseudo = (node) => {
      if (node) {
        var compareSet = node.parent.childTags
        if (kind === 'type') {
          compareSet = compareSet.filter(validate)
        }
        const nodeIndex = compareSet.findIndex((child) => child === node)
        if (nodeIndex === index) {
          return true
        }
      }
      return false
    }

    return function enhanceInstruction (node) {
      const match = instruction(node)
      if (discover) {
        return match.reduce((NodeList, matchedNode) => {
          if (validatePseudo(matchedNode)) {
            NodeList.push(matchedNode)
          }
          return NodeList
        }, [])
      }
      return validatePseudo(match) && match
    }
  })
}
1091122
function getNodeFromCode(code) {
    if (convert.mapFileCommentRegex.test(code)) {
        try {
            return SourceNode.fromStringWithSourceMap(
                convertCode2Script(code),
                new SourceMapConsumer(convert.fromComment(code).toObject())
            );
        } catch (error) {
            console.error('getNodeFromCode() error: ' + error);
            const node = new SourceNode();
            node.add(convertCode2Script(code));
            return node;
        }
    } else {
        const node = new SourceNode();
        node.add(convertCode2Script(code));
        return node;
    }
}
1141728
function extractAttribs( def ) {
    var key, val, attribs = { standard: {}, special: {}, implicit: [] };
    for ( key in def ) {
        val = def[ key ];
        if ( RX_INTEGER.test( key ) ) {
            attribs.implicit.push( val );
        } else if ( RX_STD_ATT.test( key ) ) {
            attribs.standard[ key ] = val;
        } else {
            attribs.special[ key ] = val;
        }
    }
    return attribs;
}
1254
function getAttributeNameValue(node, at) {
	const name = at.name;
	let atnv;

	if (name.indexOf('href') !== -1 || name.indexOf('src') !== -1) {
		let friendly = axe.utils.getFriendlyUriEnd(node.getAttribute(name));
		if (friendly) {
			let value = encodeURI(friendly);
			if (value) {
				atnv = escapeSelector(at.name) + '$="' + escapeSelector(value) + '"';
			} else {
				return;
			}
		} else {
			atnv =
				escapeSelector(at.name) +
				'="' +
				escapeSelector(node.getAttribute(name)) +
				'"';
		}
	} else {
		atnv = escapeSelector(name) + '="' + escapeSelector(at.value) + '"';
	}
	return atnv;
}
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];
}
86153
def get_xml_attributes obj, parent=true
      attribs = obj.reject { |k, _| @@ignored_attributes.include? k }
      if parent
        attribs = attribs.reject { |k, _| @@parent_ignored_attributes.include? k }
      end
      attribs = attribs.reject { |_, v| v.kind_of?(Hash) || v.kind_of?(Array) }
      attribs.each_pair do |k, v|
        if @@numeric_attributes.include?(k) || k.to_s =~ /.+_score/
          attribs[k] = v.round(@render_options[:round])
        end
      end
      attribs
    end
914102
async function getWidgetsFromXml(target) {
  const $ = await parseFile(target)
  const widgets = []
  let widget

  $('node').each((i, elem) => {
    const node = $(elem)
    widget = new Widget()
    widget.text = node.attr('text')
    widget.resourceId = node.attr('resource-id')
    widget.className = node.attr('class')
    widget.packageName = node.attr('package')
    widget.contentDesc = node.attr('content-desc')
    widget.checkable = node.attr('checkable')
    widget.checked = node.attr('checked')
    widget.clickable = node.attr('clickable')
    widget.enabled = node.attr('enabled')
    widget.focusable = node.attr('focusable')
    widget.focused = node.attr('focused')
    widget.scrollable = node.attr('scrollable')
    widget.longClickable = node.attr('long-clickable')
    widget.password = node.attr('password')
    widget.selected = node.attr('selected')
    widget.bounds = node.attr('bounds')
    widgets.push(widget)
  })

  return widgets
}
341265
function attributes(node) {
    var obj = {};
    each(function(attr) {
      obj[attr.name] = attr.value;
    }, node.attributes);
    return obj;
  }
1344617
function getAttribute(path, attrNode) {
    path.forEach(attrName => {
        if (!(attrNode.attributes && attrNode.attributes[attrName])) {
            throw new ImplementationError(`Result-Builder: Unknown attribute "${path.join('.')}"`);
        }
        attrNode = attrNode.attributes[attrName];
    });
    return attrNode;
}
956730
function () {

			var skeletons = {};
			var morphTargets = {};

			if ( 'Deformer' in fbxTree.Objects ) {

				var DeformerNodes = fbxTree.Objects.Deformer;

				for ( var nodeID in DeformerNodes ) {

					var deformerNode = DeformerNodes[ nodeID ];

					var relationships = connections.get( parseInt( nodeID ) );

					if ( deformerNode.attrType === 'Skin' ) {

						var skeleton = this.parseSkeleton( relationships, DeformerNodes );
						skeleton.ID = nodeID;

						if ( relationships.parents.length > 1 ) console.warn( 'THREE.FBXLoader: skeleton attached to more than one geometry is not supported.' );
						skeleton.geometryID = relationships.parents[ 0 ].ID;

						skeletons[ nodeID ] = skeleton;

					} else if ( deformerNode.attrType === 'BlendShape' ) {

						var morphTarget = {
							id: nodeID,
						};

						morphTarget.rawTargets = this.parseMorphTargets( relationships, DeformerNodes );
						morphTarget.id = nodeID;

						if ( relationships.parents.length > 1 ) console.warn( 'THREE.FBXLoader: morph target attached to more than one geometry is not supported.' );

						morphTargets[ nodeID ] = morphTarget;

					}

				}

			}

			return {

				skeletons: skeletons,
				morphTargets: morphTargets,

			};

		}
1351136
function getDeepRef() {
  var target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var path = arguments.length > 1 ? arguments[1] : undefined;
  var keys = getKeysFromPath(path);
  if (!keys.length) return target;
  var obj = target;

  while (obj && keys.length > 1) {
    obj = obj[keys.shift()];
  }

  var key = keys.shift();

  if (obj && obj.hasOwnProperty(key)) {
    return obj[key];
  }
}