Server : LiteSpeed System : Linux premium84.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64 User : claqxcrl ( 523) PHP Version : 8.1.32 Disable Function : NONE Directory : /home/claqxcrl/public_html/ondjoweb/plugins/tinymce/themes/inlite/config/bolt/ |
(function (scope) {
var ephox = scope.ephox = scope.ephox || {};
var bolt = ephox.bolt = ephox.bolt || {};
var def = function (deps, factory) {
return factory.apply(null, deps);
};
var kernel = bolt.kernel = bolt.kernel || {};
kernel.api = kernel.api || {};
kernel.async = kernel.api || {};
kernel.fp = kernel.fp || {};
kernel.modulator = kernel.modulator || {};
kernel.module = kernel.module || {};
kernel.fp.array = def(
[
],
function () {
var equals = function (a1, a2) {
if (a1.length !== a2.length)
return false;
for (var i = 0; i < a1.length; ++i)
if (a1[i] !== a2[i])
return false;
return true;
};
var forall = function (a, f) {
var fn = f || function (x) {
return x === true;
};
for (var i = 0; i < a.length; ++i)
if (fn(a[i]) !== true)
return false;
return true;
};
var map = function (a, f) {
var r = [];
for (var i = 0; i < a.length; ++i)
r.push(f(a[i], i));
return r;
};
var flatten = function (a) {
var r = [];
for (var i = 0; i < a.length; ++i)
r = r.concat(a[i]);
return r;
};
var flatmap = function (a, f) {
return flatten(map(a, f));
};
var filter = function (a, f) {
var r = [];
for (var i = 0; i < a.length; ++i)
if (f(a[i]))
r.push(a[i]);
return r;
};
var each = map;
var contains = function (a, x) {
return !forall(a, function (v) {
return v !== x;
});
};
var indexof = function (a, x) {
for (var i = 0; i < a.length; ++i)
if (a[i] === x)
return i;
return -1;
};
return {
equals: equals,
forall: forall,
map: map,
flatten: flatten,
flatmap: flatmap,
filter: filter,
each: each,
contains: contains,
indexof: indexof
};
}
);
kernel.fp.object = def(
[
],
function () {
var map = function (o, f) {
var r = {};
for (var i in o)
if (o.hasOwnProperty(i))
r[i] = f(i, o[i]);
return r;
};
var each = map;
var merge = function (d, s) {
each(s, function (k, v) {
d[k] = v;
});
};
var keys = function (o) {
var r = [];
each(o, function (k) {
r.push(k);
});
return r;
};
return {
each: each,
keys: keys,
map: map,
merge: merge
};
}
);
kernel.fp.functions = def(
[
],
function () {
var curry = function (f) {
var slice = Array.prototype.slice;
var args = slice.call(arguments, 1);
return function () {
var all = args.concat(slice.call(arguments, 0));
return f.apply(null, all);
};
};
var not = function (z) {
return function () {
var slice = Array.prototype.slice;
return !z.apply(null, slice.call(arguments, 0));
};
};
var apply = function (f) {
var slice = Array.prototype.slice;
return f.apply(null, slice.call(arguments, 0));
};
return {
curry: curry,
not: not,
apply: apply
};
}
);kernel.async.map = def(
[
kernel.fp.array
],
function (ar) {
var amap = function (data, f, oncomplete) {
var total = data.length;
var count = 0;
var results = [];
ar.each(data, function (datum, i) {
f(datum, function (result) {
++count;
results[i] = result;
if (count === total)
oncomplete(results);
});
});
};
return {
amap: amap
};
}
);
/**
* This module has a dual responsibility:
* 1. Ensures that asynchronous function calls, 'f', that share the same
* 'key' are not executed in parallel.
* 2. In the case where an attempt to call in parallel is prevented,
* the 'action' callbacks are executed when the asynchronous call is
* completed.
*
* Example:
* When we async-map to remotely fetch module definition, it is
* important that only a single define is evaluated, but the
* notification that the definition has completed is propagated
* to all interested parties.
*
* 1. we require dependencies 'x' and 'y'
*
* 2. both x and y are defined in the same file (i.e. compiled together), 'a.js'.
*
* 3. we resolve x and y, to their load spec using a modulator
* x_spec = {load: function () { -- load a.js -- }, url: a.js, serial: false};
* y_spec = {load: function () { -- load a.js -- }, url: a.js, serial: false};
*
* 4. we make the piggyback call for x:
* piggybacker.piggyback(x_spec.url, x_spec.load, xdone);
*
* this will register the 'xdone' action, and actually
* trigger the load call, with a synthetic callback
* responsible for triggering all registered actions.
*
* 5. we make the piggyback call for y:
* piggybacker.piggyback(y_spec.url, y_spec.load, ydone);
*
* this will register the 'ydone' action, but NOT trigger
* the load call.
*
* 6. the load call completes, and calls the synthetic callback,
* which is responsible for triggering both 'xdone' and 'ydone'.
*
* 7. something else happens that means we have to load 'a.js' again,
* the piggybacker DOES NOT prevent this call, and will follow
* the above process.
*/
kernel.async.piggybacker = def(
[
kernel.fp.array,
kernel.fp.functions
],
function (ar, fn) {
var create = function () {
var queue = {}; // key -> [actions]
var process = function (key) {
var actions = queue[key];
delete queue[key];
ar.each(actions, fn.apply);
};
var piggyback = function (key, f, action) {
if (queue[key] === undefined) {
queue[key] = [ action ];
f(fn.curry(process, key));
} else {
queue[key].push(action);
}
};
return {
piggyback: piggyback
};
};
return {
create: create
};
}
);
kernel.modulator.globalator = def(
[
],
function () {
var create = function () {
// FIX pull out
var resolve = function (name, scope) {
var parts = name.split('.');
var r = scope;
for (var i = 0; i < parts.length && r !== undefined; ++i)
r = r[parts[i]];
return r;
};
var global = Function('return this')();
var can = function (id) {
return id.indexOf('global!') === 0;
};
var get = function (id, define, require) {
var name = id.substring('global!'.length);
var load = function (onsuccess, onfailure) {
var instance = resolve(name, global);
if (instance !== undefined) {
define(id, [], function () { return instance; });
onsuccess();
} else {
onfailure('Modulator error: could not resolve global [' + name + ']');
}
};
return {
url: id, // this just needs to be unique, no download required.
load: load,
serial: true
};
};
return {
can: can,
get: get
}
};
return {
create: create
};
}
);
kernel.modulator.bolt = def(
[
kernel.fp.functions
],
function (fn) {
var create = function (loader, pather, namespace, path, idTransformer, options) {
var can = function (id) {
return id === namespace || id.indexOf(namespace + '.') === 0 || id.indexOf(namespace + '/') === 0;
};
var get = function (id) {
var before = options !== undefined && options.absolute === true ? path : pather(path);
var after = options !== undefined && options.fresh === true ? '?cachebuster=' + new Date().getTime() : '';
var url = before + "/" + idTransformer(id) + '.js' + after;
var load = fn.curry(loader.load, url);
return {
url: url,
load: load,
serial: false
};
};
return {
can: can,
get: get
};
};
return {
create: create
};
}
);kernel.module.stratifier = def(
[
kernel.fp.array
],
function (ar) {
var stratify = function (specs) {
var parallels = ar.filter(specs, function (spec) {
return !spec.serial;
});
return parallels.length > 0 ? parallels : specs.slice(0, 1);
};
return {
stratify: stratify
};
}
);
/**
* This module performs dependency analysis of strings that depend on sets of
* strings.
*
* The input is an array of root strings to start analysis from, and an object
* that contains a mapping of each string to the strings it depends on.
*
* Performing an analysis results in either:
* 1. an empty array, indicating that all dependencies are satisfied,
* 2. an array of strings that are, at the minimum, still needed in order to
* satisfy the given dependency trees, or
* 3. an array of strings that form a dependency cycle.
*/
kernel.module.analyser = def(
[
kernel.fp.array
],
function (array) {
var collect = function (path, name) {
var i = array.indexof(path, name);
var p = path.slice(i);
return p.concat([name]);
};
/**
* @param {array} roots Contains a list of root ids
* @param {object} modules Contains dependency information in format: { id: [ 'id1', 'id2' ] }
*/
var analyse = function (roots, modules) {
var done = {};
var path = [];
var missing = [];
var cycle;
var children = function (name) {
array.each(modules[name], attempt);
};
var examine = function (name) {
if (modules[name])
children(name);
else
missing.push(name);
};
var descend = function (name) {
path.push(name);
examine(name);
path.pop();
};
var decycle = function (name) {
if (array.contains(path, name))
cycle = collect(path, name);
else
descend(name);
};
var attempt = function (name) {
if (!done[name]) {
decycle(name);
done[name] = true;
}
};
array.each(roots, attempt);
return cycle ? { cycle: cycle } : { load: missing };
};
return {
analyse: analyse
};
}
);
kernel.module.fetcher = def(
[
kernel.fp.array,
kernel.fp.functions,
kernel.async.map,
kernel.async.piggybacker,
kernel.module.stratifier
],
function (ar, fn, map, piggybacker, stratifier) {
var create = function (regulator, validator, onerror, define, require, demand) {
var piggyback = piggybacker.create();
var validate = function (onsuccess, results) {
var failed = ar.filter(results, fn.not(validator));
if (failed.length > 0)
onerror('Fetcher error: modules were not defined: ' + failed.join(', '));
else
onsuccess();
};
var mapper = function (spec, onresult) {
var action = fn.curry(onresult, spec.id);
var load = function (callback) {
spec.load(callback, onerror);
};
piggyback.piggyback(spec.url, load, action);
};
var asyncfetch = function (specs, onsuccess) {
var oncomplete = fn.curry(validate, onsuccess);
var strata = stratifier.stratify(specs);
map.amap(strata, mapper, oncomplete);
};
var fetch = function (ids, onsuccess) {
regulator.regulate(ids, define, require, demand, function (specs) {
asyncfetch(specs, onsuccess);
}, onerror);
};
return {
fetch: fetch
};
};
return {
create: create
};
}
);
kernel.module.loader = def(
[
kernel.module.analyser
],
function (analyser) {
var load = function (roots, deps, fetcher, oncontinue, onsuccess, onerror) {
var result = analyser.analyse(roots, deps);
if (result.cycle)
onerror('Dependency error: a circular module dependency exists from ' + result.cycle.join(' ~> '));
else if (result.load.length === 0)
onsuccess();
else
fetcher.fetch(result.load, oncontinue);
};
return {
load: load
};
}
);
kernel.module.manager = def(
[
kernel.fp.array,
kernel.fp.object,
kernel.module.loader,
kernel.module.fetcher
],
function (ar, obj, loader, fetcher) {
var create = function (regulator, onerror) {
var blueprints = {}; // id -> { id: string, dependencies: [ string ], definition: function }
var modules = {}; // id -> module
// Adds a module to the system.
var define = function (id, dependencies, definition) {
if (id === undefined)
onerror("Define error: module id can not be undefined");
else if (blueprints[id] !== undefined)
onerror("Define error: module '" + id + "' is already defined");
else
blueprints[id] = { id: id, dependencies: dependencies, definition: definition };
};
// Loads a set of modules asynchronously.
var require = function (ids, callback) {
var onsuccess = function () {
var instances = ar.map(ids, demand);
callback.apply(null, instances);
};
var oncontinue = function () {
var deps = obj.map(blueprints, function (k, v) {
return v.dependencies;
});
loader.load(ids, deps, fetch, oncontinue, onsuccess, onerror);
};
oncontinue();
};
// Instantiates a module and all of its dependencies.
var demand = function (id) {
if (modules[id] !== undefined)
return modules[id];
if (blueprints[id] === undefined)
throw "module '" + id + "' is not defined";
var result = instantiate(id);
if (result === undefined)
throw "module '" + id + "' returned undefined from definition function";
modules[id] = result;
return result;
};
var instantiate = function (id) {
var blueprint = blueprints[id];
var args = ar.map(blueprint.dependencies, demand); // Instantiate dependencies
return blueprint.definition.apply(null, args); // Instantiate self
};
var validator = function (id) { return blueprints[id] !== undefined; };
var fetch = fetcher.create(regulator, validator, onerror, define, require, demand);
return {
define: define,
require: require,
demand: demand
};
};
return {
create: create
};
}
);
kernel.api.sources = def(
[
kernel.fp.array,
kernel.fp.object,
kernel.modulator.globalator
],
function (ar, obj, globalator) {
var create = function (builtins, configuration) {
var data = {
'global': { instance: globalator }
};
obj.each(builtins, function (key, value) {
data[key] = { instance: value };
});
ar.each(configuration.types, function (spec) {
data[spec.type] = { id: spec.modulator };
});
var sourcespecs = configuration.sources.slice(0);
var sources = [ globalator.create() ];
var guard = function (type) {
if (data[type] === undefined)
throw 'Unknown modulator type [' + type + '].';
};
var isResolved = function (type) {
guard(type);
return data[type].instance !== undefined;
};
var idOf = function (type) {
guard(type);
return data[type].id;
};
var instanceOf = function (type) {
guard(type);
return data[type].instance;
};
var register = function (type, instance) {
guard(type);
data[type].instance = instance;
};
var find = function (id) {
for (var i = 0; i < sources.length; ++i)
if (sources[i].can(id))
return { found: sources[i] };
return { notfound: true };
};
var crank = function () {
var left = [];
ar.each(sourcespecs, function (spec) {
if (isResolved(spec.type)) {
var instance = instanceOf(spec.type);
var source = instance.create.apply(null, spec.args);
sources.push(source);
} else
left.push(spec);
});
sourcespecs = left;
};
return {
isResolved: isResolved,
idOf: idOf,
instanceOf: instanceOf,
register: register,
find: find,
crank: crank
};
};
return {
create: create
};
}
);
kernel.api.regulator = def(
[
kernel.fp.array,
kernel.fp.functions
],
function (ar, fn) {
var create = function (sources) {
/*
* 1. Resolve configuration as much as possible
* 2. Check for unresolved modulator types that are required to continue.
* a) Go ahead and resolve, if we have everything we need.
* b) Delay, requiring the modulators, then retry.
*/
var regulate = function (ids, define, require, demand, onsuccess, onerror) {
sources.crank();
var required = ar.map(ids, determinetype);
var unresolved = ar.filter(required, fn.not(sources.isResolved));
if (unresolved.length === 0)
resolve(ids, define, require, demand, onsuccess, onerror);
else
delay(unresolved, ids, define, require, demand, onsuccess, onerror);
};
var resolve = function (ids, define, require, demand, onsuccess, onerror) {
var r = [];
for (var i = 0; i < ids.length; ++i) {
var id = ids[i];
var source = sources.find(id);
if (source.notfound) {
onerror('Could not find source for module [' + id + ']');
return;
}
var spec = source.found.get(id, define, require, demand);
r[i] = build(id, spec);
}
onsuccess(r);
};
var build = function (id, spec) {
return {
id: id,
url: spec.url,
load: spec.load,
serial: spec.serial
};
};
var delay = function (types, ids, define, require, demand, onsuccess, onerror) {
var modulatorids = ar.map(types, sources.idOf);
require(modulatorids, function (/* modulators */) {
var modulators = arguments;
ar.each(types, function (type, i) {
sources.register(type, modulators[i]);
});
regulate(ids, define, require, demand, onsuccess, onerror);
});
};
var determinetype = function (id) {
var index = id.indexOf('!');
return index === -1 ? 'bolt' : id.substring(0, index);
};
return {
regulate: regulate
};
};
return {
create: create
};
}
);
kernel.api.config = def(
[
kernel.module.manager,
kernel.api.regulator,
kernel.api.sources
],
function (manager, regulator, sources) {
var configure = function (configuration, builtins, onerror) {
var s = sources.create(builtins, configuration);
var r = regulator.create(s);
var engine = manager.create(r, onerror);
return {
define: engine.define,
require: engine.require,
demand: engine.demand
};
};
return {
configure: configure
};
}
);
})(Function('return this')());
(function (scope) {
var ephox = scope.ephox = scope.ephox || {};
var bolt = ephox.bolt = ephox.bolt || {};
var def = function (deps, factory) {
return factory.apply(null, deps);
};
var loader = bolt.loader = bolt.loader || {};
loader.executor = loader.executor || {};
loader.api = loader.api || {};
loader.transporter = loader.transporter || {};
loader.tag = loader.tag || {};
loader.tag.script = def(
[
],
function () {
var guard = function (callback) {
return function (evt) {
if (evt.srcElement.readyState === "loaded" || evt.srcElement.readyState === "complete")
callback();
};
};
var ie = function (el) {
return el.attachEvent && !window.opera;
};
var onload = function (el, callback) {
if (ie(el))
el.attachEvent("onreadystatechange", guard(callback));
else
el.addEventListener("load", callback, false);
};
var createtag = function (callback) {
var el = document.createElement("script");
el.type = "text/javascript";
onload(el, callback);
return el;
};
var insert = function (decorator, callback) {
var el = createtag(callback);
decorator(el);
var head = document.getElementsByTagName("head")[0];
head.appendChild(el);
};
return {
insert: insert
};
}
);
loader.transporter.commonjs = def(
[
],
function () {
var read = function (url, success, error) {
var fs = require('fs');
fs.exists(url, function (exists) {
if (exists)
fs.readFile(url, 'UTF-8', function (err, data) {
if (err)
error('Error reading file [' + url + '], error [' + err + ']');
else
success(data);
});
else
error('File does not exist [' + url + ']');
});
};
return {
read: read
};
}
);
loader.transporter.xhr = def(
[
],
function () {
var requestObject = function () {
// Correct way to use XMLHttpRequest in IE:
// http://blogs.msdn.com/b/ie/archive/2006/01/23/516393.aspx
var factories = [
function () { return new XMLHttpRequest() },
function () { return new ActiveXObject("Microsoft.XMLHTTP") }
];
return fallback(factories);
};
var fallback = function (items) {
for (var i = 0; i < items.length; ++i) {
try {
return items[i]();
} catch (e) {
}
}
};
var handler = function (req, url, success, error) {
return function () {
if (req.readyState === 4)
done(req, url, success, error);
};
};
var done = function (req, url, success, error) {
if (req.status === 200 || req.status === 304)
success(req.responseText);
else
error('Transport error: ' + req.status + ' ' + req.statusText + ' for resource: "' + url + '"');
};
var getUrl = function (req, url, success, error) {
req.open('GET', url, true);
req.onreadystatechange = handler(req, url, success, error);
req.send();
};
var request = function (url, success, error) {
var req = requestObject();
if (req)
getUrl(req, url, success, error);
else
error('Transport error: browser does not support XMLHttpRequest.');
};
return {
request: request
};
}
);
loader.executor.evaller = def(
[
],
function () {
var execute = function (data, onsuccess, onfailure) {
try {
eval(data);
} catch(e) {
onfailure(e);
return;
}
onsuccess();
};
return {
execute: execute
};
}
);
loader.executor.injector = def(
[
loader.tag.script
],
function (script) {
var execute = function (data, onsuccess, onfailure) {
var inject = function (tag) {
tag.text = data;
};
var noop = function () {};
// Injection does not fire events, but execution happens synchronously,
// so we just make an explicit callback
script.insert(inject, noop);
onsuccess();
};
return {
execute: execute
};
}
);
loader.api.commonjsevaller = def(
[
loader.transporter.commonjs,
loader.executor.evaller
],
function (commonjs, evaller) {
var load = function (url, onsuccess, onfailure) {
var inject = function (data) {
evaller.execute(data, onsuccess, onfailure);
};
commonjs.read(url, inject, onfailure);
};
return {
load: load
};
}
);
loader.api.scripttag = def(
[
loader.tag.script
],
function (script) {
var load = function (url, onsuccess, onfailure) {
var sourcer = function (tag) {
tag.src = url;
};
script.insert(sourcer, onsuccess);
};
return {
load: load
};
}
);
loader.api.xhrevaller = def(
[
loader.transporter.xhr,
loader.executor.evaller
],
function (xhr, evaller) {
var load = function (url, onsuccess, onfailure) {
var inject = function (data) {
evaller.execute(data, onsuccess, onfailure);
};
xhr.request(url, inject, onfailure);
};
return {
load: load
};
}
);
loader.api.xhrinjector = def(
[
loader.transporter.xhr,
loader.executor.injector
],
function (xhr, injector) {
var load = function (url, onsuccess, onfailure) {
var inject = function (data) {
injector.execute(data, onsuccess);
};
xhr.request(url, inject, onfailure);
};
return {
load: load
};
}
);
})(Function('return this')());
(function (scope) {
var ephox = scope.ephox = scope.ephox || {};
var bolt = ephox.bolt = ephox.bolt || {};
var def = function (deps, factory) {
return factory.apply(null, deps);
};
var module = bolt.module = bolt.module || {};
module.bootstrap = module.bootstrap || {};
module.config = module.config || {};
module.error = module.error || {};
module.modulator = module.modulator || {};
module.reader = module.reader || {};
module.runtime = module.runtime || {};
module.util = module.util || {};
module.error.error = def(
[
],
function () {
var die = function (msg) {
throw msg || new Error('unknown error');
};
return {
die: die
};
}
);
module.config.mapper = def(
[
],
function () {
var flat = function (id) {
return id;
};
var hierarchical = function (id) {
return id.replace(/\./g, '/');
};
var constant = function (name) {
return function () {
return name;
};
};
return {
flat: flat,
hierarchical: hierarchical,
constant: constant
};
}
);
module.api = def(
[
module.runtime
],
function (runtime) {
var delegate = function (method) {
return function () {
return runtime[method].apply(null, arguments);
};
};
return {
define: delegate('define'),
require: delegate('require'),
demand: delegate('demand'),
main: delegate('main'),
load: delegate('load'),
loadscript: delegate('loadscript')
};
}
);
module.util.path = def(
[
],
function () {
var dirname = function (file) {
var normalized = file.replace(/\\/g, '/');
var end = normalized.lastIndexOf('/');
return normalized.substring(0, end);
};
var basename = function (file) {
var normalized = file.replace(/\\/g, '/');
var end = normalized.lastIndexOf('/');
return normalized.substring(end + 1);
};
return {
basename: basename,
dirname: dirname
};
}
);
module.util.locator = def(
[
],
function () {
var browser = function () {
var scripts = document.getElementsByTagName("script");
return scripts[scripts.length - 1].src;
};
var runtime = module.runtime.locate;
var locate = function () {
var f = runtime || browser;
return f();
};
return {
locate: locate
};
}
);
module.util.pather = def(
[
module.util.path
],
function (path) {
var create = function (relativeto) {
var base = path.dirname(relativeto);
return function (path) {
return base + '/' + path;
};
};
return {
create: create
};
}
);module.modulator.modulators = def(
[
ephox.bolt.kernel.fp.functions,
ephox.bolt.kernel.modulator.bolt,
ephox.bolt.loader.api.commonjsevaller,
ephox.bolt.loader.api.scripttag,
ephox.bolt.loader.api.xhrevaller,
ephox.bolt.loader.api.xhrinjector
],
function (fn, bolt, commonjsevaller, scripttag, xhrevaller, xhrinjector) {
var wrap = function (modulator, loader) {
var create = fn.curry(modulator.create, loader);
return {
create: create
}
};
return {
boltcommonjs: wrap(bolt, commonjsevaller),
boltscripttag: wrap(bolt, scripttag),
boltxhreval: wrap(bolt, xhrevaller),
boltxhrinjector: wrap(bolt, xhrinjector)
};
}
);
module.config.builtins = def(
[
ephox.bolt.module.modulator.modulators.boltscripttag,
ephox.bolt.module.modulator.modulators.boltcommonjs
],
function (boltscripttag, boltcommonjs) {
return {
// TODO: 'amd' is maintained for backwards compatibility, will be removed
// at some point.
browser: { bolt: boltscripttag, amd: boltscripttag },
commonjs: { bolt: boltcommonjs, amd: boltcommonjs }
};
}
);
module.config.specs = def(
[
module.util.pather
],
function (pather) {
var type = function (type, implementation) {
return {
type: type,
implementation: implementation,
modulator: implementation + '.Modulator',
compiler: implementation + '.Compiler'
};
};
var source = function (relativeto) {
return function (type /*, args */) {
return {
type: type,
relativeto: relativeto,
args: [ pather.create(relativeto) ].concat(Array.prototype.slice.call(arguments, 1))
};
}
};
return {
type: type,
source: source
};
}
);
module.reader.bouncing = def(
[
ephox.bolt.kernel.fp.array,
module.error.error,
module.config.specs
],
function (ar, error, specs) {
var bounce = function (done, read, acc) {
var next = acc.configs.shift();
read(next.relativeto, next.config, done, acc);
};
var tick = function (file, cfg, done, read, acc) {
var munged = ar.map(cfg.configs || [], function (config) {
return { relativeto: file, config: config };
});
var accumulated = {
sources: acc.sources.concat(cfg.sources || []),
types: acc.types.concat(cfg.types || []),
configs: munged.concat(acc.configs)
};
if (accumulated.configs.length > 0)
bounce(done, read, accumulated);
else
done({ sources: accumulated.sources, types: accumulated.types });
};
/*
* All precedence is depth-first, pre-order. Example:
*
* A
* /-\
* B C
* /| |\
* D E F G
*
* Configs are read in A, B, D, E, C, F, G.
*
* If configs mixed delegation and sources, the
* sources would be ordered the same: A, B, D, E, C, F, G.
*/
var evaluate = function (file, payload, done, read, acc) {
var result = {};
/* eval scope */
var mapper = module.config.mapper;
var type = specs.type;
var source = specs.source(file);
var configure = function (configuration) {
result = configuration;
};
try {
eval(payload);
} catch (e) {
throw 'Could not load configuration [' + file + '], with: ' + e;
}
tick(file, result, done, read, acc);
};
return {
evaluate: evaluate
};
}
);
module.reader.browser = def(
[
module.error.error,
module.reader.bouncing,
module.util.path,
ephox.bolt.loader.transporter.xhr
],
function (error, bouncing, path, xhr) {
var read = function (relativeto, file, done, acc) {
var accumulated = acc || { sources: [], types: [], configs: [] };
var base = path.dirname(relativeto);
var absolute = base + '/' + file;
xhr.request(absolute, function (payload) {
bouncing.evaluate(absolute, payload, done, read, accumulated);
}, error.die);
};
return {
read: read
};
}
);
module.reader.node = def(
[
module.reader.bouncing
],
function (bouncing, path, fs) {
var read = function (relativeto, file, done, acc) {
var fs = require('fs');
var path = require('path');
var accumulated = acc || { sources: [], types: [], configs: [] };
var base = path.dirname(relativeto);
var absolute = path.resolve(base, file);
var payload = fs.readFileSync(absolute, 'UTF-8');
bouncing.evaluate(absolute, payload, done, read, accumulated);
};
return {
read: read
};
}
);
module.reader.direct = def(
[
],
function () {
var create = function (configuration) {
return function (done) {
done({
sources: configuration.sources || [],
types: configuration.types || [],
configs: configuration.configs || []
});
};
};
return {
create: create
};
}
);
module.bootstrap.configloader = def(
[
module.util.locator,
module.reader.browser
],
function (locator, browser) {
var create = function (file) {
var script = locator.locate();
return function (done) {
browser.read(script, file, done);
};
};
return {
create: create
};
}
);module.bootstrap.deferred = def(
[
ephox.bolt.kernel.fp.array
],
function (ar) {
var deferred = [];
var require = function (ids, fn) {
var r = function (real) {
real(ids, fn);
};
deferred.push(r);
};
var configured = function (require) {
ar.each(deferred, function (action) {
action(require);
});
deferred = [];
};
return {
require: require,
configured: configured
};
}
);
module.bootstrap.main = def(
[
ephox.bolt.kernel.api.config,
module.bootstrap.deferred,
module.runtime
],
function (config, deferred, runtime) {
var main = function (id, args, configids, callback) {
runtime.require(configids || [], function () {
callback && callback.apply(null, arguments);
runtime.require([ id ], function (module) {
module.apply(null, args || []);
});
});
};
return {
main: main
};
}
);
module.bootstrap.install = def(
[
ephox.bolt.kernel.api.config,
module.bootstrap.deferred,
module.bootstrap.main,
module.runtime,
module.error.error
],
function (config, deferred, main, runtime, error) {
var notready = function () { throw 'bolt not initialised, can not call define or demand, did you mean to use require or main?'; };
var install = function (reader, builtins, load, loadscript) {
runtime.define = notready;
runtime.demand = notready;
runtime.require = deferred.require;
runtime.main = main.main;
runtime.load = load;
runtime.loadscript = loadscript;
reader(function (configuration) {
var bolt = config.configure(configuration, builtins, error.die);
runtime.define = bolt.define;
runtime.require = bolt.require;
runtime.demand = bolt.demand;
deferred.configured(runtime.require);
});
};
return {
install: install
};
}
);
})(Function('return this')());
(function (global) {
var obj = ephox.bolt.kernel.fp.object;
var api = ephox.bolt.module.api;
var builtins = ephox.bolt.module.config.builtins.browser;
var install = ephox.bolt.module.bootstrap.install;
var reader = ephox.bolt.module.bootstrap.configloader.create("prod.js");
var transport = ephox.bolt.loader.transporter.xhr.request;
var script = ephox.bolt.loader.api.scripttag.load;
install.install(reader, builtins, transport, script);
obj.merge(global, api);
})(Function("return this;")());