adds a new steal and throws an error if the script doesn't load this also checks the steals map
322428
function(options){
			
			var stel = new steal.p.init(options),
				rootSrc = stel.options.rootSrc;
			
			if(stel.unique && rootSrc){
				// the .js is b/c we are not adding that automatically until
				// load because we defer 'type' determination until then
				if(!steals[rootSrc] && ! steals[rootSrc+".js"]){  //if we haven't loaded it before
					steals[rootSrc] = stel;
				} else{ // already have this steal
					stel = steals[rootSrc];
					// extend the old stolen file with any new options
					extend(stel.options, typeof options === "string" ? {} : options)
				}
			}
			
			return stel;
		}
330887
function add() {
            vm.error = undefined;
            service.add({
                description: vm.description
            }, function() {
                _fetch();
            }, function() {
                vm.error = 'An error occurred when adding a todo';
            });
            vm.description = '';
        }
722999
public function add_script($script){
		if ( \is_object($this->obj) ){
			if ( !isset($this->obj->script) ){
				$this->obj->script = '';
			}
			$this->obj->script .= $script;
		}
		return $this;
	}
1265619
public void appendDirtyObject (SceneObject scobj)
    {
        DirtyItem item = getDirtyItem();
        item.init(scobj, scobj.info.x, scobj.info.y);
        _items.add(item);
    }
280237
def _add(self, frame, strict):
        

        if not isinstance(frame, Frame):
            raise TypeError("%r not a Frame instance" % frame)

        orig_frame = frame
        frame = frame._upgrade_frame()
        if frame is None:
            if not strict:
                return
            raise TypeError(
                "Can't upgrade %r frame" % type(orig_frame).__name__)

        hash_key = frame.HashKey
        if strict or hash_key not in self:
            self[hash_key] = frame
            return

        # Try to merge frames, or change the new one. Since changing
        # the new one can lead to new conflicts, try until everything is
        # either merged or added.
        while True:
            old_frame = self[hash_key]
            new_frame = old_frame._merge_frame(frame)
            new_hash = new_frame.HashKey
            if new_hash == hash_key:
                self[hash_key] = new_frame
                break
            else:
                assert new_frame is frame
                if new_hash not in self:
                    self[new_hash] = new_frame
                    break
                hash_key = new_hash
28667
public function addScript($script) {
        $script = trim($script);
        if ($script != '') {
            if (strpos($this->script, $script) === false) {
                $this->script .= " 
				$script";
            }
        }
    }
1012810
def add_object(self, obj):
        ''''''
        state = self.state
        if not obj.layer in state.layers:
            # its a new layer
            state.layers[obj.layer] = {}
        state.layers[obj.layer][obj.key] = obj
        state.need_redraw = True
431143
def new_bundle(name, scriptmap, filemap=None):

    """"""

    #logger.debug('new bundle %s' % name)
    if name in BUNDLEMAP:
        logger.warn('overwriting bundle %s' % name)
    BUNDLEMAP[name] = Bundle(scriptmap, filemap)
39287
def add_errors(self, *errors: Union[BaseSchemaError, List[BaseSchemaError]]) -> None:
        
        self.schema_loader.add_errors(*errors)
136530
def append(object)
      if object.is_a?(BTC::Script)
        append_script(object)
      elsif object.is_a?(BTC::ScriptNumber)
        append_pushdata(object.data)
      elsif object.is_a?(Integer)
        append_opcode(object)
      elsif object.is_a?(String)
        append_pushdata(object.b)
      elsif object.is_a?(Array)
        object.each do |element|
          self << element
        end
      elsif object.is_a?(ScriptChunk)
        @chunks << object
      else
        raise ArgumentError, "Operand must be an integer, a string a BTC::Script instance or an array of any of those."
      end
      return self
    end
142433
def _add_error(self, *args, **kwargs):  # type: () -> None
        
        if kwargs.get('node', None):
            # if node specified and not none
            error = ConfigError.create_from_yaml_node(
                *args,
                **kwargs
            )
        elif self._value_node:
            # default to using the node if we have one
            error = ConfigError.create_from_yaml_node(
                node=self._value_node,
                *args,
                **kwargs
            )
        else:
            # no nodes or error_obj to attach
            error = ConfigError(*args, **kwargs)

        self._errors.append(error)
769184
public void addValueToIn(Object value, String name, Map<String, Object> map) {
        Object val = getValue(map, name);
         if (val instanceof Collection) {
             Object cleanValue = getCleanValue(value);
             ((Collection) val).add(cleanValue);
         } else if (val == null) {
             setValueForIn(value, name + "[0]", map);
         } else {
            throw new SlimFixtureException(false, "name is not a list but: " + val.getClass().getSimpleName());
         }
    }
922405
def addError(self, test, err, capt=None):
        
        self.__insert_test_result(constants.State.ERROR, test, err)
1350443
function add(data, callback) {
        var id = hat() + '.json';
        repo.contents(id).add({
            content: btoa(JSON.stringify(data)),
            branch: options.branch,
            message: '+'
        }, function(err, res) {
           callback(err, res, id);
        });
    }
1072638
def add(error)
      if @list.key? error.name
        raise DuplicateError, "An error named #{error.name} already exists"
      end
      @list[error.name] = error
    end
1235077
function(){
			var args = typeof arguments[0] == 'function' ? 
				arguments : [function(){}].concat(makeArray( arguments ) )
			return steal.apply(win, args );
		}
920323
def AddContract(self, contract):
        
        if not contract.PublicKeyHash.ToBytes() in self._keys.keys():
            raise Exception('Invalid operation - public key mismatch')

        self._contracts[contract.ScriptHash.ToBytes()] = contract
        if contract.ScriptHash in self._watch_only:
            self._watch_only.remove(contract.ScriptHash)