default consts of exedit
506946
function(setting) {
		var o = setting.treeObj;
		var c = consts.event;
		o.unbind(c.RENAME);
		o.unbind(c.DRAG);
		o.unbind(c.DRAGMOVE);
		o.unbind(c.DROP);
	}
989391
void defaults () {
		minWidth = new MinWidthValue<C, T>(layout.toolkit);
		minHeight =new MinHeightValue<C, T>(layout.toolkit);
		prefWidth = new PrefWidthValue<C, T>(layout.toolkit);
		prefHeight = new PrefHeightValue<C, T>(layout.toolkit);
		maxWidth = new MaxWidthValue<C, T>(layout.toolkit);
		maxHeight = new MaxHeightValue<C, T>(layout.toolkit);
		spaceTop = new FixedValue<C, T>(layout.toolkit,0);
		spaceLeft = new FixedValue<C, T>(layout.toolkit,0);
		spaceBottom = new FixedValue<C, T>(layout.toolkit,0);
		spaceRight = new FixedValue<C, T>(layout.toolkit,0);
		padTop = new FixedValue<C, T>(layout.toolkit,0);
		padLeft = new FixedValue<C, T>(layout.toolkit,0);
		padBottom = new FixedValue<C, T>(layout.toolkit,0);
		padRight = new FixedValue<C, T>(layout.toolkit,0);
		fillX = 0f;
		fillY = 0f;
		align = CENTER;
		expandX = 0;
		expandY = 0;
		ignore = false;
		colspan = 1;
		uniformX = null;
		uniformY = null;
	}
573287
def _format_executable(lines, element, spacer=""):
    
    rlines = []
    rlines.append(element.signature)
    _format_summary(rlines, element)

    rlines.append("")
    rlines.append("PARAMETERS")
    for p in element.ordered_parameters:
        _format_value_element(rlines, p)

    rlines.append("")
    _format_generic(rlines, element, ["summary"])

    #Subroutines can have embedded types and functions which need to be handled.
    if len(element.types) > 0:
        rlines.append("\nEMBEDDED TYPES")
        for key, value in list(element.types.items()):
            _format_type(rlines, value, "  ")

    if len(element.executables) > 0:
        rlines.append("\nEMBEDDED EXECUTABLES")
        for key, value in list(element.executables.items()):
            _format_executable(rlines, value, "  ")

    lines.extend([spacer + l for l in rlines])
115427
def setExtension(self, ext):
        
        if ext[0] != ".":
            ext = "." + ext
        self._ext = utils.asString(ext)
992874
def _ctypes_ex_assign(executable):
    
    result = []
    for p in executable.ordered_parameters:
        _ctypes_code_parameter(result, p, "assign")

    if type(executable).__name__ == "Function":
        _ctypes_code_parameter(result, executable, "assign")

    return result
1228002
function setDefault (opts, key, val) {
  if (opts.schema) {
    opts.prompts = opts.schema;
    delete opts.schema;
  }
  const prompts = opts.prompts || (opts.prompts = {});
  if (!prompts[key] || typeof prompts[key] !== 'object') {
    prompts[key] = {
      'type': 'string',
      'default': val
    };
  }
  else {
    prompts[key]['default'] = val;
  }
}
1296959
public function defaultAction($selfedit = 'false')
    {
        if ($selfedit == 'true') {
            $moufManager = MoufManager::getMoufManager();
        } else {
            $moufManager = MoufManager::getMoufManagerHiddenInstance();
        }

        $this->exludeExtentions = $moufManager->getVariable('splashexludeextentions');
        $this->exludeFolders = $moufManager->getVariable('splashexludefolders');
        if (empty($this->exludeExtentions)) {
            $this->exludeExtentions = array('js', 'ico', 'gif', 'jpg', 'png', 'css', 'woff', 'ttf', 'svg', 'eot', 'txt');
        }
        if (empty($this->exludeFolders)) {
            $this->exludeFolders = array('vendor');
        }
        $this->content->addFile(__DIR__.'/../../../../../views/admin/splashAdminApache.php', $this);
        $this->template->toHtml();
    }
62724
def raw_default(context)
      value = options.fetch(:default)
      return value unless value.is_a?(Proc)

      case value.arity
      when 1 then context.instance_exec(self, &value)
      else context.instance_exec(&value)
      end
    end
1240704
function defaultProps( target, overwrite ) 
{
	overwrite = overwrite || {};
	for( var prop in overwrite ) {
		if( target.hasOwnProperty(prop) && _isValid( overwrite[ prop ] ) ) {
			target[ prop ] = overwrite[ prop ];
		}
	}
	return target;
}
946505
function _defaultEnabled(env, addonConfig) {
  let usingInDev = env === 'development' && !addonConfig.usingProxy;
  let usingInTest = env === 'test';

  return usingInDev || usingInTest;
}
1065312
function(path, parent, defaults, ext){
    if( path === undefined ) return undefined;

    if(ext && typeof ext === 'object'){
      if(ext[path] !== undefined)  return ext[path];
    }
    
    // reject to get from computed, return undefined directly
    // like { empty.prop }, empty equals undefined
    // prop shouldn't get from computed
    if(parent === null) {
      return undefined
    }

    if(parent && typeof parent[path] !== 'undefined') {
      return parent[path]
    }

    // without parent, get from computed
    if (parent !== null) {
      var computed = this.computed,
        computedProperty = computed[path];
      if(computedProperty){
        if(computedProperty.type==='expression' && !computedProperty.get) this._touchExpr(computedProperty);
        if(computedProperty.get)  return computedProperty.get(this);
        else _.log("the computed '" + path + "' don't define the get function,  get data."+path + " altnately", "warn")
      }
    }

    if( defaults === undefined  ){
      return undefined;
    }
    return defaults[path];

  }
246551
def set_ext_param(self, ext_key, param_key, val):
        '''
        
        '''
        if not self.extensions[ext_key]:
            self.extensions[ext_key] = defaultdict(lambda: None)
        self.extensions[ext_key][param_key] = val
1218349
function(editor, syntax) {
			var propertyName = prefs.get('css.gradient.defaultProperty');
			var omitDir = prefs.get('css.gradient.omitDefaultDirection');
			
			if (!propertyName) {
				return false;
			}
			
			// assuming that gradient definition is written on new line,
			// do a simplified parsing
			var content = String(editor.getContent());
			/** @type Range */
			var lineRange = range.create(editor.getCurrentLineRange());
			
			// get line content and adjust range with padding
			var line = lineRange.substring(content)
				.replace(/^\s+/, function(pad) {
					lineRange.start += pad.length;
					return '';
				})
				.replace(/\s+$/, function(pad) {
					lineRange.end -= pad.length;
					return '';
				});

			// trick parser: make it think that we’re parsing actual CSS property
			var fakeCSS = 'a{' + propertyName + ': ' + line + ';}';
			var gradients = this.gradientsFromCSSProperty(fakeCSS, fakeCSS.length - 2);
			if (gradients) {
				var props = getPropertiesForGradient(gradients.gradients, gradients.property);
				props.push({
					name: gradients.property.name(),
					value: insertGradientsIntoCSSValue(gradients.gradients, gradients.property.value(), {
						placeholder: '${2}',
						omitDefaultDirection: omitDir
					})
				});
				
				var sep = cssResolver.getSyntaxPreference('valueSeparator', syntax);
				var end = cssResolver.getSyntaxPreference('propertyEnd', syntax);
				
				if (prefs.get('css.alignVendor')) {
					var pads = utils.getStringsPads(props.map(function(prop) {
						return prop.value.substring(0, prop.value.indexOf('('));
					}));
					props.forEach(function(prop, i) {
						prop.value = pads[i] + prop.value;
					});
				}
				
				props = props.map(function(item) {
					return item.name + sep + item.value + end;
				});
				
				editor.replaceContent(props.join('\n'), lineRange.start, lineRange.end);
				return true;
			}
			
			return false;
		}
664089
def default_arguments(cls):
        """"""
        func = cls.__init__
        args = func.__code__.co_varnames
        defaults = func.__defaults__
        index = -len(defaults)
        return {k: v for k, v in zip(args[index:], defaults)}
786932
function _configFilter ( f ) {
        var parts = f.split("."),
            ext = parts[ parts.length - 1 ],
            pre = parts[ parts.length - 2 ],
            name = parts[ parts.length - 3];

        return !!(ext === "dist" && pre === "json" &&
                    exports.__ignores.indexOf( name ) === -1 && exports.__ignores.indexOf( f ) === -1 );
    }
435732
function defaultGetCallingScript(offset = 0) {
	const stack = (new Error).stack.split(/$/m);
	const line = stack[(/^Error/).test(stack[0]) + 1 + offset];
	const parts = line.split(/@(?![^/]*?\.xpi)|\(|\s+/g);
	return parts[parts.length - 1].replace(/:\d+(?::\d+)?\)?$/, '');
}
1251298
function initConfig(conf) {
  const result = Object.assign({}, conf);
  if (conf.filename) {
    result.filepath = path.dirname(conf.filename);
  }
  return result;
}