: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
} else if (typeof exports === 'object') {
factory(require('jquery'));
// This is needed so we can catch the AMD loader configuration and use it
// The inner file should be wrapped (by `banner.start.js`) in a function that
// returns the AMD loader references.
// Restore the Select2 AMD loader so it can be used
// Needed mostly in the language files, where the loader is not inserted
if (jQuery && jQuery.fn && jQuery.fn.pumselect2 && jQuery.fn.pumselect2.amd) {
var S2 = jQuery.fn.pumselect2.amd;
var S2;(function () { if (!S2 || !S2.requirejs) {
if (!S2) { S2 = {}; } else { require = S2; }
* @license almond 0.3.1 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved.
* Available via the MIT or new BSD license.
* see: http://github.com/jrburke/almond for details
//Going sloppy to avoid 'use strict' string cost, but strict practices should
/*global setTimeout: false */
var requirejs, require, define;
var main, req, makeMap, handlers,
hasOwn = Object.prototype.hasOwnProperty,
jsSuffixRegExp = /\.js$/;
function hasProp(obj, prop) {
return hasOwn.call(obj, prop);
* Given a relative module name, like ./something, normalize it to
* a real name that can be mapped to a path.
* @param {String} name the relative name
* @param {String} baseName a real name that the name arg is relative
* @returns {String} normalized name
function normalize(name, baseName) {
var nameParts, nameSegment, mapValue, foundMap, lastIndex,
foundI, foundStarMap, starI, i, j, part,
baseParts = baseName && baseName.split("/"),
starMap = (map && map['*']) || {};
//Adjust any relative paths.
if (name && name.charAt(0) === ".") {
//If have a base name, try to normalize against it,
//otherwise, assume it is a top-level require that will
//be relative to baseUrl in the end.
lastIndex = name.length - 1;
if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
//Lop off the last part of baseParts, so that . matches the
//"directory" and not name of the baseName's module. For instance,
//baseName of "one/two/three", maps to "one/two/three.js", but we
//want the directory, "one/two" for this normalization.
name = baseParts.slice(0, baseParts.length - 1).concat(name);
for (i = 0; i < name.length; i += 1) {
} else if (part === "..") {
if (i === 1 && (name[2] === '..' || name[0] === '..')) {
//End of the line. Keep at least one non-dot
//path segment at the front so it can be mapped
//correctly to disk. Otherwise, there is likely
//no path mapping for a path starting with '..'.
//This can still fail, but catches the most reasonable
} else if (name.indexOf('./') === 0) {
// No baseName, so this is ID is resolved relative
// to baseUrl, pull off the leading dot.
name = name.substring(2);
//Apply map config if available.
if ((baseParts || starMap) && map) {
nameParts = name.split('/');
for (i = nameParts.length; i > 0; i -= 1) {
nameSegment = nameParts.slice(0, i).join("/");
//Find the longest baseName segment match in the config.
//So, do joins on the biggest to smallest lengths of baseParts.
for (j = baseParts.length; j > 0; j -= 1) {
mapValue = map[baseParts.slice(0, j).join('/')];
//baseName segment has config, find if it has one for
mapValue = mapValue[nameSegment];
//Match, update name to the new value.
//Check for a star map match, but just hold on to it,
//if there is a shorter segment match later in a matching
//config, then favor over this star map.
if (!foundStarMap && starMap && starMap[nameSegment]) {
foundStarMap = starMap[nameSegment];
if (!foundMap && foundStarMap) {
nameParts.splice(0, foundI, foundMap);
name = nameParts.join('/');
function makeRequire(relName, forceSync) {
//A version of a require function that passes a moduleName
//value for items that may need to
//look up paths relative to the moduleName
var args = aps.call(arguments, 0);
//If first arg is not require('string'), and there is only
//one arg, it is the array form without a callback. Insert
//a null so that the following concat is correct.
if (typeof args[0] !== 'string' && args.length === 1) {
return req.apply(undef, args.concat([relName, forceSync]));
function makeNormalize(relName) {
return normalize(name, relName);
function makeLoad(depName) {
return function (value) {
defined[depName] = value;
if (hasProp(waiting, name)) {
var args = waiting[name];
if (!hasProp(defined, name) && !hasProp(defining, name)) {
throw new Error('No ' + name);
//Turns a plugin!resource to [plugin, resource]
//with the plugin being undefined if the name
//did not have a plugin prefix.
function splitPrefix(name) {
index = name ? name.indexOf('!') : -1;
prefix = name.substring(0, index);
name = name.substring(index + 1, name.length);
* Makes a name map, normalizing the name, and using a plugin
* for normalization if necessary. Grabs a ref to plugin
* too, as an optimization.
makeMap = function (name, relName) {
parts = splitPrefix(name),
prefix = normalize(prefix, relName);
plugin = callDep(prefix);
if (plugin && plugin.normalize) {
name = plugin.normalize(name, makeNormalize(relName));
name = normalize(name, relName);
name = normalize(name, relName);
parts = splitPrefix(name);
plugin = callDep(prefix);
//Using ridiculous property names for space reasons
f: prefix ? prefix + '!' + name : name, //fullName
function makeConfig(name) {
return (config && config.config && config.config[name]) || {};
require: function (name) {
return makeRequire(name);
exports: function (name) {
if (typeof e !== 'undefined') {
return (defined[name] = {});
module: function (name) {
main = function (name, deps, callback, relName) {
var cjsModule, depName, ret, map, i,
callbackType = typeof callback,
relName = relName || name;
//Call the callback to define the module, if necessary.
if (callbackType === 'undefined' || callbackType === 'function') {
//Pull out the defined dependencies and pass the ordered
//values to the callback.
//Default to [require, exports, module] if no deps
deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
for (i = 0; i < deps.length; i += 1) {
map = makeMap(deps[i], relName);
//Fast path CommonJS standard dependencies.
if (depName === "require") {
args[i] = handlers.require(name);
} else if (depName === "exports") {
//CommonJS module spec 1.1
args[i] = handlers.exports(name);
} else if (depName === "module") {
//CommonJS module spec 1.1
cjsModule = args[i] = handlers.module(name);
} else if (hasProp(defined, depName) ||
hasProp(waiting, depName) ||
hasProp(defining, depName)) {
args[i] = callDep(depName);
map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
args[i] = defined[depName];
throw new Error(name + ' missing ' + depName);
ret = callback ? callback.apply(defined[name], args) : undefined;
//If setting exports via "module" is in play,
//favor that over return value and exports. After that,
//favor a non-undefined return value over exports use.
if (cjsModule && cjsModule.exports !== undef &&
cjsModule.exports !== defined[name]) {
defined[name] = cjsModule.exports;
} else if (ret !== undef || !usingExports) {
//Use the return value from the function.
//May just be an object definition for the module. Only
//worry about defining if have a module name.
defined[name] = callback;
requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
if (typeof deps === "string") {
//callback in this case is really relName
return handlers[deps](callback);
//Just return the module wanted. In this scenario, the
//deps arg is the module name, and second arg (if passed)
//Normalize module name, if it contains . or ..
return callDep(makeMap(deps, callback).f);
} else if (!deps.splice) {
//deps is a config object, not an array.
req(config.deps, config.callback);
//callback is an array, which means it is a dependency list.
//Adjust args if there are dependencies
callback = callback || function () {};
//If relName is a function, it is an errback handler,
if (typeof relName === 'function') {
//Simulate async callback;
main(undef, deps, callback, relName);
//Using a non-zero value because of concern for what old browsers
//do, and latest browsers "upgrade" to 4 if lower value is used:
//http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
//If want a value immediately, use require('id') instead -- something
//that works in almond on the global level, but not guaranteed and
//unlikely to work in other AMD implementations.
main(undef, deps, callback, relName);
* Just drops the config on the floor, but returns req in case
* the config return value is used.
req.config = function (cfg) {
* Expose module registry for debugging and tooling
requirejs._defined = defined;
define = function (name, deps, callback) {
if (typeof name !== 'string') {
throw new Error('See almond README: incorrect module build, no module name');
//This module may not have dependencies
//deps is not an array, so probably means
//an object literal or factory function for
//the value. Adjust args.
if (!hasProp(defined, name) && !hasProp(waiting, name)) {
waiting[name] = [name, deps, callback];
S2.requirejs = requirejs;S2.require = require;S2.define = define;
S2.define("almond", function(){});
/* global jQuery:false, $:false */
S2.define('jquery',[],function () {
if (_$ == null && console && console.error) {
'Select2: An instance of jQuery or a jQuery-compatible library was not ' +
'found. Make sure that you are including jQuery before Select2 on your ' +
S2.define('pumselect2/utils',[
Utils.Extend = function (ChildClass, SuperClass) {
var __hasProp = {}.hasOwnProperty;
function BaseConstructor () {
this.constructor = ChildClass;
for (var key in SuperClass) {
if (__hasProp.call(SuperClass, key)) {
ChildClass[key] = SuperClass[key];
BaseConstructor.prototype = SuperClass.prototype;
ChildClass.prototype = new BaseConstructor();
ChildClass.__super__ = SuperClass.prototype;
function getMethods (theClass) {
var proto = theClass.prototype;
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
