yonote/yjs
24
0
Fork 0
Code Pull Requests 1 Releases Activity
yjs/y.test.js
Kevin Jahns ed963dca41 v13.0.0-60 -- distribution files
2018-05-08 13:46:43 +02:00

33516 lines
1.2 MiB
Raw Permalink Blame History

(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(factory((global['y-tests'] = {})));
}(this, (function (exports) { 'use strict';
function rotate (tree, parent, newParent, n) {
if (parent === null) {
tree.root = newParent;
newParent._parent = null;
} else if (parent.left === n) {
parent.left = newParent;
} else if (parent.right === n) {
parent.right = newParent;
} else {
throw new Error('The elements are wrongly connected!')
}
}
class N {
// A created node is always red!
constructor (val) {
this.val = val;
this.color = true;
this._left = null;
this._right = null;
this._parent = null;
}
isRed () { return this.color }
isBlack () { return !this.color }
redden () { this.color = true; return this }
blacken () { this.color = false; return this }
get grandparent () {
return this.parent.parent
}
get parent () {
return this._parent
}
get sibling () {
return (this === this.parent.left)
? this.parent.right : this.parent.left
}
get left () {
return this._left
}
get right () {
return this._right
}
set left (n) {
if (n !== null) {
n._parent = this;
}
this._left = n;
}
set right (n) {
if (n !== null) {
n._parent = this;
}
this._right = n;
}
rotateLeft (tree) {
const parent = this.parent;
const newParent = this.right;
const newRight = this.right.left;
newParent.left = this;
this.right = newRight;
rotate(tree, parent, newParent, this);
}
next () {
if (this.right !== null) {
// search the most left node in the right tree
var o = this.right;
while (o.left !== null) {
o = o.left;
}
return o
} else {
var p = this;
while (p.parent !== null && p !== p.parent.left) {
p = p.parent;
}
return p.parent
}
}
prev () {
if (this.left !== null) {
// search the most right node in the left tree
var o = this.left;
while (o.right !== null) {
o = o.right;
}
return o
} else {
var p = this;
while (p.parent !== null && p !== p.parent.right) {
p = p.parent;
}
return p.parent
}
}
rotateRight (tree) {
const parent = this.parent;
const newParent = this.left;
const newLeft = this.left.right;
newParent.right = this;
this.left = newLeft;
rotate(tree, parent, newParent, this);
}
getUncle () {
// we can assume that grandparent exists when this is called!
if (this.parent === this.parent.parent.left) {
return this.parent.parent.right
} else {
return this.parent.parent.left
}
}
}
/*
* This is a Red Black Tree implementation
*/
class Tree {
constructor () {
this.root = null;
this.length = 0;
}
findNext (id) {
var nextID = id.clone();
nextID.clock += 1;
return this.findWithLowerBound(nextID)
}
findPrev (id) {
let prevID = id.clone();
prevID.clock -= 1;
return this.findWithUpperBound(prevID)
}
findNodeWithLowerBound (from) {
var o = this.root;
if (o === null) {
return null
} else {
while (true) {
if (from === null || (from.lessThan(o.val._id) && o.left !== null)) {
// o is included in the bound
// try to find an element that is closer to the bound
o = o.left;
} else if (from !== null && o.val._id.lessThan(from)) {
// o is not within the bound, maybe one of the right elements is..
if (o.right !== null) {
o = o.right;
} else {
// there is no right element. Search for the next bigger element,
// this should be within the bounds
return o.next()
}
} else {
return o
}
}
}
}
findNodeWithUpperBound (to) {
if (to === void 0) {
throw new Error('You must define from!')
}
var o = this.root;
if (o === null) {
return null
} else {
while (true) {
if ((to === null || o.val._id.lessThan(to)) && o.right !== null) {
// o is included in the bound
// try to find an element that is closer to the bound
o = o.right;
} else if (to !== null && to.lessThan(o.val._id)) {
// o is not within the bound, maybe one of the left elements is..
if (o.left !== null) {
o = o.left;
} else {
// there is no left element. Search for the prev smaller element,
// this should be within the bounds
return o.prev()
}
} else {
return o
}
}
}
}
findSmallestNode () {
var o = this.root;
while (o != null && o.left != null) {
o = o.left;
}
return o
}
findWithLowerBound (from) {
var n = this.findNodeWithLowerBound(from);
return n == null ? null : n.val
}
findWithUpperBound (to) {
var n = this.findNodeWithUpperBound(to);
return n == null ? null : n.val
}
iterate (from, to, f) {
var o;
if (from === null) {
o = this.findSmallestNode();
} else {
o = this.findNodeWithLowerBound(from);
}
while (
o !== null &&
(
to === null || // eslint-disable-line no-unmodified-loop-condition
o.val._id.lessThan(to) ||
o.val._id.equals(to)
)
) {
f(o.val);
o = o.next();
}
}
find (id) {
let n = this.findNode(id);
if (n !== null) {
return n.val
} else {
return null
}
}
findNode (id) {
var o = this.root;
if (o === null) {
return null
} else {
while (true) {
if (o === null) {
return null
}
if (id.lessThan(o.val._id)) {
o = o.left;
} else if (o.val._id.lessThan(id)) {
o = o.right;
} else {
return o
}
}
}
}
delete (id) {
var d = this.findNode(id);
if (d == null) {
// throw new Error('Element does not exist!')
return
}
this.length--;
if (d.left !== null && d.right !== null) {
// switch d with the greates element in the left subtree.
// o should have at most one child.
var o = d.left;
// find
while (o.right !== null) {
o = o.right;
}
// switch
d.val = o.val;
d = o;
}
// d has at most one child
// let n be the node that replaces d
var isFakeChild;
var child = d.left || d.right;
if (child === null) {
isFakeChild = true;
child = new N(null);
child.blacken();
d.right = child;
} else {
isFakeChild = false;
}
if (d.parent === null) {
if (!isFakeChild) {
this.root = child;
child.blacken();
child._parent = null;
} else {
this.root = null;
}
return
} else if (d.parent.left === d) {
d.parent.left = child;
} else if (d.parent.right === d) {
d.parent.right = child;
} else {
throw new Error('Impossible!')
}
if (d.isBlack()) {
if (child.isRed()) {
child.blacken();
} else {
this._fixDelete(child);
}
}
this.root.blacken();
if (isFakeChild) {
if (child.parent.left === child) {
child.parent.left = null;
} else if (child.parent.right === child) {
child.parent.right = null;
} else {
throw new Error('Impossible #3')
}
}
}
_fixDelete (n) {
function isBlack (node) {
return node !== null ? node.isBlack() : true
}
function isRed (node) {
return node !== null ? node.isRed() : false
}
if (n.parent === null) {
// this can only be called after the first iteration of fixDelete.
return
}
// d was already replaced by the child
// d is not the root
// d and child are black
var sibling = n.sibling;
if (isRed(sibling)) {
// make sibling the grandfather
n.parent.redden();
sibling.blacken();
if (n === n.parent.left) {
n.parent.rotateLeft(this);
} else if (n === n.parent.right) {
n.parent.rotateRight(this);
} else {
throw new Error('Impossible #2')
}
sibling = n.sibling;
}
// parent, sibling, and children of n are black
if (n.parent.isBlack() &&
sibling.isBlack() &&
isBlack(sibling.left) &&
isBlack(sibling.right)
) {
sibling.redden();
this._fixDelete(n.parent);
} else if (n.parent.isRed() &&
sibling.isBlack() &&
isBlack(sibling.left) &&
isBlack(sibling.right)
) {
sibling.redden();
n.parent.blacken();
} else {
if (n === n.parent.left &&
sibling.isBlack() &&
isRed(sibling.left) &&
isBlack(sibling.right)
) {
sibling.redden();
sibling.left.blacken();
sibling.rotateRight(this);
sibling = n.sibling;
} else if (n === n.parent.right &&
sibling.isBlack() &&
isRed(sibling.right) &&
isBlack(sibling.left)
) {
sibling.redden();
sibling.right.blacken();
sibling.rotateLeft(this);
sibling = n.sibling;
}
sibling.color = n.parent.color;
n.parent.blacken();
if (n === n.parent.left) {
sibling.right.blacken();
n.parent.rotateLeft(this);
} else {
sibling.left.blacken();
n.parent.rotateRight(this);
}
}
}
put (v) {
var node = new N(v);
if (this.root !== null) {
var p = this.root; // p abbrev. parent
while (true) {
if (node.val._id.lessThan(p.val._id)) {
if (p.left === null) {
p.left = node;
break
} else {
p = p.left;
}
} else if (p.val._id.lessThan(node.val._id)) {
if (p.right === null) {
p.right = node;
break
} else {
p = p.right;
}
} else {
p.val = node.val;
return p
}
}
this._fixInsert(node);
} else {
this.root = node;
}
this.length++;
this.root.blacken();
return node
}
_fixInsert (n) {
if (n.parent === null) {
n.blacken();
return
} else if (n.parent.isBlack()) {
return
}
var uncle = n.getUncle();
if (uncle !== null && uncle.isRed()) {
// Note: parent: red, uncle: red
n.parent.blacken();
uncle.blacken();
n.grandparent.redden();
this._fixInsert(n.grandparent);
} else {
// Note: parent: red, uncle: black or null
// Now we transform the tree in such a way that
// either of these holds:
// 1) grandparent.left.isRed
// and grandparent.left.left.isRed
// 2) grandparent.right.isRed
// and grandparent.right.right.isRed
if (n === n.parent.right && n.parent === n.grandparent.left) {
n.parent.rotateLeft(this);
// Since we rotated and want to use the previous
// cases, we need to set n in such a way that
// n.parent.isRed again
n = n.left;
} else if (n === n.parent.left && n.parent === n.grandparent.right) {
n.parent.rotateRight(this);
// see above
n = n.right;
}
// Case 1) or 2) hold from here on.
// Now traverse grandparent, make parent a black node
// on the highest level which holds two red nodes.
n.parent.blacken();
n.grandparent.redden();
if (n === n.parent.left) {
// Case 1
n.grandparent.rotateRight(this);
} else {
// Case 2
n.grandparent.rotateLeft(this);
}
}
}
}
class ID {
constructor (user, clock) {
this.user = user; // TODO: rename to client
this.clock = clock;
}
clone () {
return new ID(this.user, this.clock)
}
equals (id) {
return id !== null && id.user === this.user && id.clock === this.clock
}
lessThan (id) {
if (id.constructor === ID) {
return this.user < id.user || (this.user === id.user && this.clock < id.clock)
} else {
return false
}
}
}
var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function unwrapExports (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var chance_1 = createCommonjsModule(function (module, exports) {
// Chance.js 1.0.16
// http://chancejs.com
// (c) 2013 Victor Quinn
// Chance may be freely distributed or modified under the MIT license.
(function () {
// Constants
var MAX_INT = 9007199254740992;
var MIN_INT = -MAX_INT;
var NUMBERS = '0123456789';
var CHARS_LOWER = 'abcdefghijklmnopqrstuvwxyz';
var CHARS_UPPER = CHARS_LOWER.toUpperCase();
var HEX_POOL = NUMBERS + "abcdef";
// Errors
function UnsupportedError(message) {
this.name = 'UnsupportedError';
this.message = message || 'This feature is not supported on this platform';
}
UnsupportedError.prototype = new Error();
UnsupportedError.prototype.constructor = UnsupportedError;
// Cached array helpers
var slice = Array.prototype.slice;
// Constructor
function Chance (seed) {
if (!(this instanceof Chance)) {
if (!seed) { seed = null; } // handle other non-truthy seeds, as described in issue #322
return seed === null ? new Chance() : new Chance(seed);
}
// if user has provided a function, use that as the generator
if (typeof seed === 'function') {
this.random = seed;
return this;
}
if (arguments.length) {
// set a starting value of zero so we can add to it
this.seed = 0;
}
// otherwise, leave this.seed blank so that MT will receive a blank
for (var i = 0; i < arguments.length; i++) {
var seedling = 0;
if (Object.prototype.toString.call(arguments[i]) === '[object String]') {
for (var j = 0; j < arguments[i].length; j++) {
// create a numeric hash for each argument, add to seedling
var hash = 0;
for (var k = 0; k < arguments[i].length; k++) {
hash = arguments[i].charCodeAt(k) + (hash << 6) + (hash << 16) - hash;
}
seedling += hash;
}
} else {
seedling = arguments[i];
}
this.seed += (arguments.length - i) * seedling;
}
// If no generator function was provided, use our MT
this.mt = this.mersenne_twister(this.seed);
this.bimd5 = this.blueimp_md5();
this.random = function () {
return this.mt.random(this.seed);
};
return this;
}
Chance.prototype.VERSION = "1.0.16";
// Random helper functions
function initOptions(options, defaults) {
options = options || {};
if (defaults) {
for (var i in defaults) {
if (typeof options[i] === 'undefined') {
options[i] = defaults[i];
}
}
}
return options;
}
function range(size) {
return Array.apply(null, Array(size)).map(function (_, i) {return i;});
}
function testRange(test, errorMessage) {
if (test) {
throw new RangeError(errorMessage);
}
}
/**
* Encode the input string with Base64.
*/
var base64 = function() {
throw new Error('No Base64 encoder available.');
};
// Select proper Base64 encoder.
(function determineBase64Encoder() {
if (typeof btoa === 'function') {
base64 = btoa;
} else if (typeof Buffer === 'function') {
base64 = function(input) {
return new Buffer(input).toString('base64');
};
}
})();
// -- Basics --
/**
* Return a random bool, either true or false
*
* @param {Object} [options={ likelihood: 50 }] alter the likelihood of
* receiving a true or false value back.
* @throws {RangeError} if the likelihood is out of bounds
* @returns {Bool} either true or false
*/
Chance.prototype.bool = function (options) {
// likelihood of success (true)
options = initOptions(options, {likelihood : 50});
// Note, we could get some minor perf optimizations by checking range
// prior to initializing defaults, but that makes code a bit messier
// and the check more complicated as we have to check existence of
// the object then existence of the key before checking constraints.
// Since the options initialization should be minor computationally,
// decision made for code cleanliness intentionally. This is mentioned
// here as it's the first occurrence, will not be mentioned again.
testRange(
options.likelihood < 0 || options.likelihood > 100,
"Chance: Likelihood accepts values from 0 to 100."
);
return this.random() * 100 < options.likelihood;
};
Chance.prototype.animal = function (options){
//returns a random animal
options = initOptions(options);
if(typeof options.type !== 'undefined'){
//if user does not put in a valid animal type, user will get an error
testRange(
!this.get("animals")[options.type.toLowerCase()],
"Please pick from desert, ocean, grassland, forest, zoo, pets, farm."
);
//if user does put in valid animal type, will return a random animal of that type
return this.pick(this.get("animals")[options.type.toLowerCase()]);
}
//if user does not put in any animal type, will return a random animal regardless
animalTypeArray = ["desert","forest","ocean","zoo","farm","pet","grassland"];
return this.pick(this.get("animals")[this.pick(animalTypeArray)]);
};
/**
* Return a random character.
*
* @param {Object} [options={}] can specify a character pool, only alpha,
* only symbols, and casing (lower or upper)
* @returns {String} a single random character
* @throws {RangeError} Can only specify alpha or symbols, not both
*/
Chance.prototype.character = function (options) {
options = initOptions(options);
testRange(
options.alpha && options.symbols,
"Chance: Cannot specify both alpha and symbols."
);
var symbols = "!@#$%^&*()[]",
letters, pool;
if (options.casing === 'lower') {
letters = CHARS_LOWER;
} else if (options.casing === 'upper') {
letters = CHARS_UPPER;
} else {
letters = CHARS_LOWER + CHARS_UPPER;
}
if (options.pool) {
pool = options.pool;
} else if (options.alpha) {
pool = letters;
} else if (options.symbols) {
pool = symbols;
} else {
pool = letters + NUMBERS + symbols;
}
return pool.charAt(this.natural({max: (pool.length - 1)}));
};
// Note, wanted to use "float" or "double" but those are both JS reserved words.
// Note, fixed means N OR LESS digits after the decimal. This because
// It could be 14.9000 but in JavaScript, when this is cast as a number,
// the trailing zeroes are dropped. Left to the consumer if trailing zeroes are
// needed
/**
* Return a random floating point number
*
* @param {Object} [options={}] can specify a fixed precision, min, max
* @returns {Number} a single floating point number
* @throws {RangeError} Can only specify fixed or precision, not both. Also
* min cannot be greater than max
*/
Chance.prototype.floating = function (options) {
options = initOptions(options, {fixed : 4});
testRange(
options.fixed && options.precision,
"Chance: Cannot specify both fixed and precision."
);
var num;
var fixed = Math.pow(10, options.fixed);
var max = MAX_INT / fixed;
var min = -max;
testRange(
options.min && options.fixed && options.min < min,
"Chance: Min specified is out of range with fixed. Min should be, at least, " + min
);
testRange(
options.max && options.fixed && options.max > max,
"Chance: Max specified is out of range with fixed. Max should be, at most, " + max
);
options = initOptions(options, { min : min, max : max });
// Todo - Make this work!
// options.precision = (typeof options.precision !== "undefined") ? options.precision : false;
num = this.integer({min: options.min * fixed, max: options.max * fixed});
var num_fixed = (num / fixed).toFixed(options.fixed);
return parseFloat(num_fixed);
};
/**
* Return a random integer
*
* NOTE the max and min are INCLUDED in the range. So:
* chance.integer({min: 1, max: 3});
* would return either 1, 2, or 3.
*
* @param {Object} [options={}] can specify a min and/or max
* @returns {Number} a single random integer number
* @throws {RangeError} min cannot be greater than max
*/
Chance.prototype.integer = function (options) {
// 9007199254740992 (2^53) is the max integer number in JavaScript
// See: http://vq.io/132sa2j
options = initOptions(options, {min: MIN_INT, max: MAX_INT});
testRange(options.min > options.max, "Chance: Min cannot be greater than Max.");
return Math.floor(this.random() * (options.max - options.min + 1) + options.min);
};
/**
* Return a random natural
*
* NOTE the max and min are INCLUDED in the range. So:
* chance.natural({min: 1, max: 3});
* would return either 1, 2, or 3.
*
* @param {Object} [options={}] can specify a min and/or maxm or a numerals count.
* @returns {Number} a single random integer number
* @throws {RangeError} min cannot be greater than max
*/
Chance.prototype.natural = function (options) {
options = initOptions(options, {min: 0, max: MAX_INT});
if (typeof options.numerals === 'number'){
testRange(options.numerals < 1, "Chance: Numerals cannot be less than one.");
options.min = Math.pow(10, options.numerals - 1);
options.max = Math.pow(10, options.numerals) - 1;
}
testRange(options.min < 0, "Chance: Min cannot be less than zero.");
return this.integer(options);
};
/**
* Return a random hex number as string
*
* NOTE the max and min are INCLUDED in the range. So:
* chance.hex({min: '9', max: 'B'});
* would return either '9', 'A' or 'B'.
*
* @param {Object} [options={}] can specify a min and/or max and/or casing
* @returns {String} a single random string hex number
* @throws {RangeError} min cannot be greater than max
*/
Chance.prototype.hex = function (options) {
options = initOptions(options, {min: 0, max: MAX_INT, casing: 'lower'});
testRange(options.min < 0, "Chance: Min cannot be less than zero.");
var integer = this.natural({min: options.min, max: options.max});
if (options.casing === 'upper') {
return integer.toString(16).toUpperCase();
}
return integer.toString(16);
};
Chance.prototype.letter = function(options) {
options = initOptions(options, {casing: 'lower'});
var pool = "abcdefghijklmnopqrstuvwxyz";
var letter = this.character({pool: pool});
if (options.casing === 'upper') {
letter = letter.toUpperCase();
}
return letter;
};
/**
* Return a random string
*
* @param {Object} [options={}] can specify a length
* @returns {String} a string of random length
* @throws {RangeError} length cannot be less than zero
*/
Chance.prototype.string = function (options) {
options = initOptions(options, { length: this.natural({min: 5, max: 20}) });
testRange(options.length < 0, "Chance: Length cannot be less than zero.");
var length = options.length,
text = this.n(this.character, length, options);
return text.join("");
};
/**
* Return a random buffer
*
* @param {Object} [options={}] can specify a length
* @returns {Buffer} a buffer of random length
* @throws {RangeError} length cannot be less than zero
*/
Chance.prototype.buffer = function (options) {
if (typeof Buffer === 'undefined') {
throw new UnsupportedError('Sorry, the buffer() function is not supported on your platform');
}
options = initOptions(options, { length: this.natural({min: 5, max: 20}) });
testRange(options.length < 0, "Chance: Length cannot be less than zero.");
var length = options.length;
var content = this.n(this.character, length, options);
return Buffer.from(content);
};
// -- End Basics --
// -- Helpers --
Chance.prototype.capitalize = function (word) {
return word.charAt(0).toUpperCase() + word.substr(1);
};
Chance.prototype.mixin = function (obj) {
for (var func_name in obj) {
Chance.prototype[func_name] = obj[func_name];
}
return this;
};
/**
* Given a function that generates something random and a number of items to generate,
* return an array of items where none repeat.
*
* @param {Function} fn the function that generates something random
* @param {Number} num number of terms to generate
* @param {Object} options any options to pass on to the generator function
* @returns {Array} an array of length `num` with every item generated by `fn` and unique
*
* There can be more parameters after these. All additional parameters are provided to the given function
*/
Chance.prototype.unique = function(fn, num, options) {
testRange(
typeof fn !== "function",
"Chance: The first argument must be a function."
);
var comparator = function(arr, val) { return arr.indexOf(val) !== -1; };
if (options) {
comparator = options.comparator || comparator;
}
var arr = [], count = 0, result, MAX_DUPLICATES = num * 50, params = slice.call(arguments, 2);
while (arr.length < num) {
var clonedParams = JSON.parse(JSON.stringify(params));
result = fn.apply(this, clonedParams);
if (!comparator(arr, result)) {
arr.push(result);
// reset count when unique found
count = 0;
}
if (++count > MAX_DUPLICATES) {
throw new RangeError("Chance: num is likely too large for sample set");
}
}
return arr;
};
/**
* Gives an array of n random terms
*
* @param {Function} fn the function that generates something random
* @param {Number} n number of terms to generate
* @returns {Array} an array of length `n` with items generated by `fn`
*
* There can be more parameters after these. All additional parameters are provided to the given function
*/
Chance.prototype.n = function(fn, n) {
testRange(
typeof fn !== "function",
"Chance: The first argument must be a function."
);
if (typeof n === 'undefined') {
n = 1;
}
var i = n, arr = [], params = slice.call(arguments, 2);
// Providing a negative count should result in a noop.
i = Math.max( 0, i );
for (null; i--; null) {
arr.push(fn.apply(this, params));
}
return arr;
};
// H/T to SO for this one: http://vq.io/OtUrZ5
Chance.prototype.pad = function (number, width, pad) {
// Default pad to 0 if none provided
pad = pad || '0';
// Convert number to a string
number = number + '';
return number.length >= width ? number : new Array(width - number.length + 1).join(pad) + number;
};
// DEPRECATED on 2015-10-01
Chance.prototype.pick = function (arr, count) {
if (arr.length === 0) {
throw new RangeError("Chance: Cannot pick() from an empty array");
}
if (!count || count === 1) {
return arr[this.natural({max: arr.length - 1})];
} else {
return this.shuffle(arr).slice(0, count);
}
};
// Given an array, returns a single random element
Chance.prototype.pickone = function (arr) {
if (arr.length === 0) {
throw new RangeError("Chance: Cannot pickone() from an empty array");
}
return arr[this.natural({max: arr.length - 1})];
};
// Given an array, returns a random set with 'count' elements
Chance.prototype.pickset = function (arr, count) {
if (count === 0) {
return [];
}
if (arr.length === 0) {
throw new RangeError("Chance: Cannot pickset() from an empty array");
}
if (count < 0) {
throw new RangeError("Chance: Count must be a positive number");
}
if (!count || count === 1) {
return [ this.pickone(arr) ];
} else {
return this.shuffle(arr).slice(0, count);
}
};
Chance.prototype.shuffle = function (arr) {
var new_array = [],
j = 0,
length = Number(arr.length),
source_indexes = range(length),
last_source_index = length - 1,
selected_source_index;
for (var i = 0; i < length; i++) {
// Pick a random index from the array
selected_source_index = this.natural({max: last_source_index});
j = source_indexes[selected_source_index];
// Add it to the new array
new_array[i] = arr[j];
// Mark the source index as used
source_indexes[selected_source_index] = source_indexes[last_source_index];
last_source_index -= 1;
}
return new_array;
};
// Returns a single item from an array with relative weighting of odds
Chance.prototype.weighted = function (arr, weights, trim) {
if (arr.length !== weights.length) {
throw new RangeError("Chance: Length of array and weights must match");
}
// scan weights array and sum valid entries
var sum = 0;
var val;
for (var weightIndex = 0; weightIndex < weights.length; ++weightIndex) {
val = weights[weightIndex];
if (isNaN(val)) {
throw new RangeError("Chance: All weights must be numbers");
}
if (val > 0) {
sum += val;
}
}
if (sum === 0) {
throw new RangeError("Chance: No valid entries in array weights");
}
// select a value within range
var selected = this.random() * sum;
// find array entry corresponding to selected value
var total = 0;
var lastGoodIdx = -1;
var chosenIdx;
for (weightIndex = 0; weightIndex < weights.length; ++weightIndex) {
val = weights[weightIndex];
total += val;
if (val > 0) {
if (selected <= total) {
chosenIdx = weightIndex;
break;
}
lastGoodIdx = weightIndex;
}
// handle any possible rounding error comparison to ensure something is picked
if (weightIndex === (weights.length - 1)) {
chosenIdx = lastGoodIdx;
}
}
var chosen = arr[chosenIdx];
trim = (typeof trim === 'undefined') ? false : trim;
if (trim) {
arr.splice(chosenIdx, 1);
weights.splice(chosenIdx, 1);
}
return chosen;
};
// -- End Helpers --
// -- Text --
Chance.prototype.paragraph = function (options) {
options = initOptions(options);
var sentences = options.sentences || this.natural({min: 3, max: 7}),
sentence_array = this.n(this.sentence, sentences);
return sentence_array.join(' ');
};
// Could get smarter about this than generating random words and
// chaining them together. Such as: http://vq.io/1a5ceOh
Chance.prototype.sentence = function (options) {
options = initOptions(options);
var words = options.words || this.natural({min: 12, max: 18}),
punctuation = options.punctuation,
text, word_array = this.n(this.word, words);
text = word_array.join(' ');
// Capitalize first letter of sentence
text = this.capitalize(text);
// Make sure punctuation has a usable value
if (punctuation !== false && !/^[\.\?;!:]$/.test(punctuation)) {
punctuation = '.';
}
// Add punctuation mark
if (punctuation) {
text += punctuation;
}
return text;
};
Chance.prototype.syllable = function (options) {
options = initOptions(options);
var length = options.length || this.natural({min: 2, max: 3}),
consonants = 'bcdfghjklmnprstvwz', // consonants except hard to speak ones
vowels = 'aeiou', // vowels
all = consonants + vowels, // all
text = '',
chr;
// I'm sure there's a more elegant way to do this, but this works
// decently well.
for (var i = 0; i < length; i++) {
if (i === 0) {
// First character can be anything
chr = this.character({pool: all});
} else if (consonants.indexOf(chr) === -1) {
// Last character was a vowel, now we want a consonant
chr = this.character({pool: consonants});
} else {
// Last character was a consonant, now we want a vowel
chr = this.character({pool: vowels});
}
text += chr;
}
if (options.capitalize) {
text = this.capitalize(text);
}
return text;
};
Chance.prototype.word = function (options) {
options = initOptions(options);
testRange(
options.syllables && options.length,
"Chance: Cannot specify both syllables AND length."
);
var syllables = options.syllables || this.natural({min: 1, max: 3}),
text = '';
if (options.length) {
// Either bound word by length
do {
text += this.syllable();
} while (text.length < options.length);
text = text.substring(0, options.length);
} else {
// Or by number of syllables
for (var i = 0; i < syllables; i++) {
text += this.syllable();
}
}
if (options.capitalize) {
text = this.capitalize(text);
}
return text;
};
// -- End Text --
// -- Person --
Chance.prototype.age = function (options) {
options = initOptions(options);
var ageRange;
switch (options.type) {
case 'child':
ageRange = {min: 0, max: 12};
break;
case 'teen':
ageRange = {min: 13, max: 19};
break;
case 'adult':
ageRange = {min: 18, max: 65};
break;
case 'senior':
ageRange = {min: 65, max: 100};
break;
case 'all':
ageRange = {min: 0, max: 100};
break;
default:
ageRange = {min: 18, max: 65};
break;
}
return this.natural(ageRange);
};
Chance.prototype.birthday = function (options) {
var age = this.age(options);
var currentYear = new Date().getFullYear();
if (options && options.type) {
var min = new Date();
var max = new Date();
min.setFullYear(currentYear - age - 1);
max.setFullYear(currentYear - age);
options = initOptions(options, {
min: min,
max: max
});
} else {
options = initOptions(options, {
year: currentYear - age
});
}
return this.date(options);
};
// CPF; ID to identify taxpayers in Brazil
Chance.prototype.cpf = function (options) {
options = initOptions(options, {
formatted: true
});
var n = this.n(this.natural, 9, { max: 9 });
var d1 = n[8]*2+n[7]*3+n[6]*4+n[5]*5+n[4]*6+n[3]*7+n[2]*8+n[1]*9+n[0]*10;
d1 = 11 - (d1 % 11);
if (d1>=10) {
d1 = 0;
}
var d2 = d1*2+n[8]*3+n[7]*4+n[6]*5+n[5]*6+n[4]*7+n[3]*8+n[2]*9+n[1]*10+n[0]*11;
d2 = 11 - (d2 % 11);
if (d2>=10) {
d2 = 0;
}
var cpf = ''+n[0]+n[1]+n[2]+'.'+n[3]+n[4]+n[5]+'.'+n[6]+n[7]+n[8]+'-'+d1+d2;
return options.formatted ? cpf : cpf.replace(/\D/g,'');
};
// CNPJ: ID to identify companies in Brazil
Chance.prototype.cnpj = function (options) {
options = initOptions(options, {
formatted: true
});
var n = this.n(this.natural, 12, { max: 12 });
var d1 = n[11]*2+n[10]*3+n[9]*4+n[8]*5+n[7]*6+n[6]*7+n[5]*8+n[4]*9+n[3]*2+n[2]*3+n[1]*4+n[0]*5;
d1 = 11 - (d1 % 11);
if (d1<2) {
d1 = 0;
}
var d2 = d1*2+n[11]*3+n[10]*4+n[9]*5+n[8]*6+n[7]*7+n[6]*8+n[5]*9+n[4]*2+n[3]*3+n[2]*4+n[1]*5+n[0]*6;
d2 = 11 - (d2 % 11);
if (d2<2) {
d2 = 0;
}
var cnpj = ''+n[0]+n[1]+'.'+n[2]+n[3]+n[4]+'.'+n[5]+n[6]+n[7]+'/'+n[8]+n[9]+n[10]+n[11]+'-'+d1+d2;
return options.formatted ? cnpj : cnpj.replace(/\D/g,'');
};
Chance.prototype.first = function (options) {
options = initOptions(options, {gender: this.gender(), nationality: 'en'});
return this.pick(this.get("firstNames")[options.gender.toLowerCase()][options.nationality.toLowerCase()]);
};
Chance.prototype.profession = function (options) {
options = initOptions(options);
if(options.rank){
return this.pick(['Apprentice ', 'Junior ', 'Senior ', 'Lead ']) + this.pick(this.get("profession"));
} else{
return this.pick(this.get("profession"));
}
};
Chance.prototype.company = function (){
return this.pick(this.get("company"));
};
Chance.prototype.gender = function (options) {
options = initOptions(options, {extraGenders: []});
return this.pick(['Male', 'Female'].concat(options.extraGenders));
};
Chance.prototype.last = function (options) {
options = initOptions(options, {nationality: '*'});
if (options.nationality === "*") {
var allLastNames = [];
var lastNames = this.get("lastNames");
Object.keys(lastNames).forEach(function(key, i){
allLastNames = allLastNames.concat(lastNames[key]);
});
return this.pick(allLastNames)
}
else {
return this.pick(this.get("lastNames")[options.nationality.toLowerCase()]);
}
};
Chance.prototype.israelId=function(){
var x=this.string({pool: '0123456789',length:8});
var y=0;
for (var i=0;i<x.length;i++){
var thisDigit= x[i] * (i/2===parseInt(i/2) ? 1 : 2);
thisDigit=this.pad(thisDigit,2).toString();
thisDigit=parseInt(thisDigit[0]) + parseInt(thisDigit[1]);
y=y+thisDigit;
}
x=x+(10-parseInt(y.toString().slice(-1))).toString().slice(-1);
return x;
};
Chance.prototype.mrz = function (options) {
var checkDigit = function (input) {
var alpha = "<ABCDEFGHIJKLMNOPQRSTUVWXYXZ".split(''),
multipliers = [ 7, 3, 1 ],
runningTotal = 0;
if (typeof input !== 'string') {
input = input.toString();
}
input.split('').forEach(function(character, idx) {
var pos = alpha.indexOf(character);
if(pos !== -1) {
character = pos === 0 ? 0 : pos + 9;
} else {
character = parseInt(character, 10);
}
character *= multipliers[idx % multipliers.length];
runningTotal += character;
});
return runningTotal % 10;
};
var generate = function (opts) {
var pad = function (length) {
return new Array(length + 1).join('<');
};
var number = [ 'P<',
opts.issuer,
opts.last.toUpperCase(),
'<<',
opts.first.toUpperCase(),
pad(39 - (opts.last.length + opts.first.length + 2)),
opts.passportNumber,
checkDigit(opts.passportNumber),
opts.nationality,
opts.dob,
checkDigit(opts.dob),
opts.gender,
opts.expiry,
checkDigit(opts.expiry),
pad(14),
checkDigit(pad(14)) ].join('');
return number +
(checkDigit(number.substr(44, 10) +
number.substr(57, 7) +
number.substr(65, 7)));
};
var that = this;
options = initOptions(options, {
first: this.first(),
last: this.last(),
passportNumber: this.integer({min: 100000000, max: 999999999}),
dob: (function () {
var date = that.birthday({type: 'adult'});
return [date.getFullYear().toString().substr(2),
that.pad(date.getMonth() + 1, 2),
that.pad(date.getDate(), 2)].join('');
}()),
expiry: (function () {
var date = new Date();
return [(date.getFullYear() + 5).toString().substr(2),
that.pad(date.getMonth() + 1, 2),
that.pad(date.getDate(), 2)].join('');
}()),
gender: this.gender() === 'Female' ? 'F': 'M',
issuer: 'GBR',
nationality: 'GBR'
});
return generate (options);
};
Chance.prototype.name = function (options) {
options = initOptions(options);
var first = this.first(options),
last = this.last(options),
name;
if (options.middle) {
name = first + ' ' + this.first(options) + ' ' + last;
} else if (options.middle_initial) {
name = first + ' ' + this.character({alpha: true, casing: 'upper'}) + '. ' + last;
} else {
name = first + ' ' + last;
}
if (options.prefix) {
name = this.prefix(options) + ' ' + name;
}
if (options.suffix) {
name = name + ' ' + this.suffix(options);
}
return name;
};
// Return the list of available name prefixes based on supplied gender.
// @todo introduce internationalization
Chance.prototype.name_prefixes = function (gender) {
gender = gender || "all";
gender = gender.toLowerCase();
var prefixes = [
{ name: 'Doctor', abbreviation: 'Dr.' }
];
if (gender === "male" || gender === "all") {
prefixes.push({ name: 'Mister', abbreviation: 'Mr.' });
}
if (gender === "female" || gender === "all") {
prefixes.push({ name: 'Miss', abbreviation: 'Miss' });
prefixes.push({ name: 'Misses', abbreviation: 'Mrs.' });
}
return prefixes;
};
// Alias for name_prefix
Chance.prototype.prefix = function (options) {
return this.name_prefix(options);
};
Chance.prototype.name_prefix = function (options) {
options = initOptions(options, { gender: "all" });
return options.full ?
this.pick(this.name_prefixes(options.gender)).name :
this.pick(this.name_prefixes(options.gender)).abbreviation;
};
//Hungarian ID number
Chance.prototype.HIDN= function(){
//Hungarian ID nuber structure: XXXXXXYY (X=number,Y=Capital Latin letter)
var idn_pool="0123456789";
var idn_chrs="ABCDEFGHIJKLMNOPQRSTUVWXYXZ";
var idn="";
idn+=this.string({pool:idn_pool,length:6});
idn+=this.string({pool:idn_chrs,length:2});
return idn;
};
Chance.prototype.ssn = function (options) {
options = initOptions(options, {ssnFour: false, dashes: true});
var ssn_pool = "1234567890",
ssn,
dash = options.dashes ? '-' : '';
if(!options.ssnFour) {
ssn = this.string({pool: ssn_pool, length: 3}) + dash +
this.string({pool: ssn_pool, length: 2}) + dash +
this.string({pool: ssn_pool, length: 4});
} else {
ssn = this.string({pool: ssn_pool, length: 4});
}
return ssn;
};
// Aadhar is similar to ssn, used in India to uniquely identify a person
Chance.prototype.aadhar = function (options) {
options = initOptions(options, {onlyLastFour: false, separatedByWhiteSpace: true});
var aadhar_pool = "1234567890",
aadhar,
whiteSpace = options.separatedByWhiteSpace ? ' ' : '';
if(!options.onlyLastFour) {
aadhar = this.string({pool: aadhar_pool, length: 4}) + whiteSpace +
this.string({pool: aadhar_pool, length: 4}) + whiteSpace +
this.string({pool: aadhar_pool, length: 4});
} else {
aadhar = this.string({pool: aadhar_pool, length: 4});
}
return aadhar;
};
// Return the list of available name suffixes
// @todo introduce internationalization
Chance.prototype.name_suffixes = function () {
var suffixes = [
{ name: 'Doctor of Osteopathic Medicine', abbreviation: 'D.O.' },
{ name: 'Doctor of Philosophy', abbreviation: 'Ph.D.' },
{ name: 'Esquire', abbreviation: 'Esq.' },
{ name: 'Junior', abbreviation: 'Jr.' },
{ name: 'Juris Doctor', abbreviation: 'J.D.' },
{ name: 'Master of Arts', abbreviation: 'M.A.' },
{ name: 'Master of Business Administration', abbreviation: 'M.B.A.' },
{ name: 'Master of Science', abbreviation: 'M.S.' },
{ name: 'Medical Doctor', abbreviation: 'M.D.' },
{ name: 'Senior', abbreviation: 'Sr.' },
{ name: 'The Third', abbreviation: 'III' },
{ name: 'The Fourth', abbreviation: 'IV' },
{ name: 'Bachelor of Engineering', abbreviation: 'B.E' },
{ name: 'Bachelor of Technology', abbreviation: 'B.TECH' }
];
return suffixes;
};
// Alias for name_suffix
Chance.prototype.suffix = function (options) {
return this.name_suffix(options);
};
Chance.prototype.name_suffix = function (options) {
options = initOptions(options);
return options.full ?
this.pick(this.name_suffixes()).name :
this.pick(this.name_suffixes()).abbreviation;
};
Chance.prototype.nationalities = function () {
return this.get("nationalities");
};
// Generate random nationality based on json list
Chance.prototype.nationality = function () {
var nationality = this.pick(this.nationalities());
return nationality.name;
};
// -- End Person --
// -- Mobile --
// Android GCM Registration ID
Chance.prototype.android_id = function () {
return "APA91" + this.string({ pool: "0123456789abcefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_", length: 178 });
};
// Apple Push Token
Chance.prototype.apple_token = function () {
return this.string({ pool: "abcdef1234567890", length: 64 });
};
// Windows Phone 8 ANID2
Chance.prototype.wp8_anid2 = function () {
return base64( this.hash( { length : 32 } ) );
};
// Windows Phone 7 ANID
Chance.prototype.wp7_anid = function () {
return 'A=' + this.guid().replace(/-/g, '').toUpperCase() + '&E=' + this.hash({ length:3 }) + '&W=' + this.integer({ min:0, max:9 });
};
// BlackBerry Device PIN
Chance.prototype.bb_pin = function () {
return this.hash({ length: 8 });
};
// -- End Mobile --
// -- Web --
Chance.prototype.avatar = function (options) {
var url = null;
var URL_BASE = '//www.gravatar.com/avatar/';
var PROTOCOLS = {
http: 'http',
https: 'https'
};
var FILE_TYPES = {
bmp: 'bmp',
gif: 'gif',
jpg: 'jpg',
png: 'png'
};
var FALLBACKS = {
'404': '404', // Return 404 if not found
mm: 'mm', // Mystery man
identicon: 'identicon', // Geometric pattern based on hash
monsterid: 'monsterid', // A generated monster icon
wavatar: 'wavatar', // A generated face
retro: 'retro', // 8-bit icon
blank: 'blank' // A transparent png
};
var RATINGS = {
g: 'g',
pg: 'pg',
r: 'r',
x: 'x'
};
var opts = {
protocol: null,
email: null,
fileExtension: null,
size: null,
fallback: null,
rating: null
};
if (!options) {
// Set to a random email
opts.email = this.email();
options = {};
}
else if (typeof options === 'string') {
opts.email = options;
options = {};
}
else if (typeof options !== 'object') {
return null;
}
else if (options.constructor === 'Array') {
return null;
}
opts = initOptions(options, opts);
if (!opts.email) {
// Set to a random email
opts.email = this.email();
}
// Safe checking for params
opts.protocol = PROTOCOLS[opts.protocol] ? opts.protocol + ':' : '';
opts.size = parseInt(opts.size, 0) ? opts.size : '';
opts.rating = RATINGS[opts.rating] ? opts.rating : '';
opts.fallback = FALLBACKS[opts.fallback] ? opts.fallback : '';
opts.fileExtension = FILE_TYPES[opts.fileExtension] ? opts.fileExtension : '';
url =
opts.protocol +
URL_BASE +
this.bimd5.md5(opts.email) +
(opts.fileExtension ? '.' + opts.fileExtension : '') +
(opts.size || opts.rating || opts.fallback ? '?' : '') +
(opts.size ? '&s=' + opts.size.toString() : '') +
(opts.rating ? '&r=' + opts.rating : '') +
(opts.fallback ? '&d=' + opts.fallback : '')
;
return url;
};
/**
* #Description:
* ===============================================
* Generate random color value base on color type:
* -> hex
* -> rgb
* -> rgba
* -> 0x
* -> named color
*
* #Examples:
* ===============================================
* * Geerate random hex color
* chance.color() => '#79c157' / 'rgb(110,52,164)' / '0x67ae0b' / '#e2e2e2' / '#29CFA7'
*
* * Generate Hex based color value
* chance.color({format: 'hex'}) => '#d67118'
*
* * Generate simple rgb value
* chance.color({format: 'rgb'}) => 'rgb(110,52,164)'
*
* * Generate Ox based color value
* chance.color({format: '0x'}) => '0x67ae0b'
*
* * Generate graiscale based value
* chance.color({grayscale: true}) => '#e2e2e2'
*
* * Return valide color name
* chance.color({format: 'name'}) => 'red'
*
* * Make color uppercase
* chance.color({casing: 'upper'}) => '#29CFA7'
*
* * Min Max values for RGBA
* var light_red = chance.color({format: 'hex', min_red: 200, max_red: 255, max_green: 0, max_blue: 0, min_alpha: .2, max_alpha: .3});
*
* @param [object] options
* @return [string] color value
*/
Chance.prototype.color = function (options) {
function gray(value, delimiter) {
return [value, value, value].join(delimiter || '');
}
function rgb(hasAlpha) {
var rgbValue = (hasAlpha) ? 'rgba' : 'rgb';
var alphaChannel = (hasAlpha) ? (',' + this.floating({min:min_alpha, max:max_alpha})) : "";
var colorValue = (isGrayscale) ? (gray(this.natural({min: min_rgb, max: max_rgb}), ',')) : (this.natural({min: min_green, max: max_green}) + ',' + this.natural({min: min_blue, max: max_blue}) + ',' + this.natural({max: 255}));
return rgbValue + '(' + colorValue + alphaChannel + ')';
}
function hex(start, end, withHash) {
var symbol = (withHash) ? "#" : "";
var hexstring = "";
if (isGrayscale) {
hexstring = gray(this.pad(this.hex({min: min_rgb, max: max_rgb}), 2));
if (options.format === "shorthex") {
hexstring = gray(this.hex({min: 0, max: 15}));
}
}
else {
if (options.format === "shorthex") {
hexstring = this.pad(this.hex({min: Math.floor(min_red / 16), max: Math.floor(max_red / 16)}), 1) + this.pad(this.hex({min: Math.floor(min_green / 16), max: Math.floor(max_green / 16)}), 1) + this.pad(this.hex({min: Math.floor(min_blue / 16), max: Math.floor(max_blue / 16)}), 1);
}
else if (min_red !== undefined || max_red !== undefined || min_green !== undefined || max_green !== undefined || min_blue !== undefined || max_blue !== undefined) {
hexstring = this.pad(this.hex({min: min_red, max: max_red}), 2) + this.pad(this.hex({min: min_green, max: max_green}), 2) + this.pad(this.hex({min: min_blue, max: max_blue}), 2);
}
else {
hexstring = this.pad(this.hex({min: min_rgb, max: max_rgb}), 2) + this.pad(this.hex({min: min_rgb, max: max_rgb}), 2) + this.pad(this.hex({min: min_rgb, max: max_rgb}), 2);
}
}
return symbol + hexstring;
}
options = initOptions(options, {
format: this.pick(['hex', 'shorthex', 'rgb', 'rgba', '0x', 'name']),
grayscale: false,
casing: 'lower',
min: 0,
max: 255,
min_red: undefined,
max_red: undefined,
min_green: undefined,
max_green: undefined,
min_blue: undefined,
max_blue: undefined,
min_alpha: 0,
max_alpha: 1
});
var isGrayscale = options.grayscale;
var min_rgb = options.min;
var max_rgb = options.max;
var min_red = options.min_red;
var max_red = options.max_red;
var min_green = options.min_green;
var max_green = options.max_green;
var min_blue = options.min_blue;
var max_blue = options.max_blue;
var min_alpha = options.min_alpha;
var max_alpha = options.max_alpha;
if (options.min_red === undefined) { min_red = min_rgb; }
if (options.max_red === undefined) { max_red = max_rgb; }
if (options.min_green === undefined) { min_green = min_rgb; }
if (options.max_green === undefined) { max_green = max_rgb; }
if (options.min_blue === undefined) { min_blue = min_rgb; }
if (options.max_blue === undefined) { max_blue = max_rgb; }
if (options.min_alpha === undefined) { min_alpha = 0; }
if (options.max_alpha === undefined) { max_alpha = 1; }
if (isGrayscale && min_rgb === 0 && max_rgb === 255 && min_red !== undefined && max_red !== undefined) {
min_rgb = ((min_red + min_green + min_blue) / 3);
max_rgb = ((max_red + max_green + max_blue) / 3);
}
var colorValue;
if (options.format === 'hex') {
colorValue = hex.call(this, 2, 6, true);
}
else if (options.format === 'shorthex') {
colorValue = hex.call(this, 1, 3, true);
}
else if (options.format === 'rgb') {
colorValue = rgb.call(this, false);
}
else if (options.format === 'rgba') {
colorValue = rgb.call(this, true);
}
else if (options.format === '0x') {
colorValue = '0x' + hex.call(this, 2, 6);
}
else if(options.format === 'name') {
return this.pick(this.get("colorNames"));
}
else {
throw new RangeError('Invalid format provided. Please provide one of "hex", "shorthex", "rgb", "rgba", "0x" or "name".');
}
if (options.casing === 'upper' ) {
colorValue = colorValue.toUpperCase();
}
return colorValue;
};
Chance.prototype.domain = function (options) {
options = initOptions(options);
return this.word() + '.' + (options.tld || this.tld());
};
Chance.prototype.email = function (options) {
options = initOptions(options);
return this.word({length: options.length}) + '@' + (options.domain || this.domain());
};
/**
* #Description:
* ===============================================
* Generate a random Facebook id, aka fbid.
*
* NOTE: At the moment (Sep 2017), Facebook ids are
* "numeric strings" of length 16.
* However, Facebook Graph API documentation states that
* "it is extremely likely to change over time".
* @see https://developers.facebook.com/docs/graph-api/overview/
*
* #Examples:
* ===============================================
* chance.fbid() => '1000035231661304'
*
* @return [string] facebook id
*/
Chance.prototype.fbid = function () {
return '10000' + this.string({pool: "1234567890", length: 11});
};
Chance.prototype.google_analytics = function () {
var account = this.pad(this.natural({max: 999999}), 6);
var property = this.pad(this.natural({max: 99}), 2);
return 'UA-' + account + '-' + property;
};
Chance.prototype.hashtag = function () {
return '#' + this.word();
};
Chance.prototype.ip = function () {
// Todo: This could return some reserved IPs. See http://vq.io/137dgYy
// this should probably be updated to account for that rare as it may be
return this.natural({min: 1, max: 254}) + '.' +
this.natural({max: 255}) + '.' +
this.natural({max: 255}) + '.' +
this.natural({min: 1, max: 254});
};
Chance.prototype.ipv6 = function () {
var ip_addr = this.n(this.hash, 8, {length: 4});
return ip_addr.join(":");
};
Chance.prototype.klout = function () {
return this.natural({min: 1, max: 99});
};
Chance.prototype.semver = function (options) {
options = initOptions(options, { include_prerelease: true });
var range = this.pickone(["^", "~", "<", ">", "<=", ">=", "="]);
if (options.range) {
range = options.range;
}
var prerelease = "";
if (options.include_prerelease) {
prerelease = this.weighted(["", "-dev", "-beta", "-alpha"], [50, 10, 5, 1]);
}
return range + this.rpg('3d10').join('.') + prerelease;
};
Chance.prototype.tlds = function () {
return ['com', 'org', 'edu', 'gov', 'co.uk', 'net', 'io', 'ac', 'ad', 'ae', 'af', 'ag', 'ai', 'al', 'am', 'an', 'ao', 'aq', 'ar', 'as', 'at', 'au', 'aw', 'ax', 'az', 'ba', 'bb', 'bd', 'be', 'bf', 'bg', 'bh', 'bi', 'bj', 'bm', 'bn', 'bo', 'bq', 'br', 'bs', 'bt', 'bv', 'bw', 'by', 'bz', 'ca', 'cc', 'cd', 'cf', 'cg', 'ch', 'ci', 'ck', 'cl', 'cm', 'cn', 'co', 'cr', 'cu', 'cv', 'cw', 'cx', 'cy', 'cz', 'de', 'dj', 'dk', 'dm', 'do', 'dz', 'ec', 'ee', 'eg', 'eh', 'er', 'es', 'et', 'eu', 'fi', 'fj', 'fk', 'fm', 'fo', 'fr', 'ga', 'gb', 'gd', 'ge', 'gf', 'gg', 'gh', 'gi', 'gl', 'gm', 'gn', 'gp', 'gq', 'gr', 'gs', 'gt', 'gu', 'gw', 'gy', 'hk', 'hm', 'hn', 'hr', 'ht', 'hu', 'id', 'ie', 'il', 'im', 'in', 'io', 'iq', 'ir', 'is', 'it', 'je', 'jm', 'jo', 'jp', 'ke', 'kg', 'kh', 'ki', 'km', 'kn', 'kp', 'kr', 'kw', 'ky', 'kz', 'la', 'lb', 'lc', 'li', 'lk', 'lr', 'ls', 'lt', 'lu', 'lv', 'ly', 'ma', 'mc', 'md', 'me', 'mg', 'mh', 'mk', 'ml', 'mm', 'mn', 'mo', 'mp', 'mq', 'mr', 'ms', 'mt', 'mu', 'mv', 'mw', 'mx', 'my', 'mz', 'na', 'nc', 'ne', 'nf', 'ng', 'ni', 'nl', 'no', 'np', 'nr', 'nu', 'nz', 'om', 'pa', 'pe', 'pf', 'pg', 'ph', 'pk', 'pl', 'pm', 'pn', 'pr', 'ps', 'pt', 'pw', 'py', 'qa', 're', 'ro', 'rs', 'ru', 'rw', 'sa', 'sb', 'sc', 'sd', 'se', 'sg', 'sh', 'si', 'sj', 'sk', 'sl', 'sm', 'sn', 'so', 'sr', 'ss', 'st', 'su', 'sv', 'sx', 'sy', 'sz', 'tc', 'td', 'tf', 'tg', 'th', 'tj', 'tk', 'tl', 'tm', 'tn', 'to', 'tp', 'tr', 'tt', 'tv', 'tw', 'tz', 'ua', 'ug', 'uk', 'us', 'uy', 'uz', 'va', 'vc', 've', 'vg', 'vi', 'vn', 'vu', 'wf', 'ws', 'ye', 'yt', 'za', 'zm', 'zw'];
};
Chance.prototype.tld = function () {
return this.pick(this.tlds());
};
Chance.prototype.twitter = function () {
return '@' + this.word();
};
Chance.prototype.url = function (options) {
options = initOptions(options, { protocol: "http", domain: this.domain(options), domain_prefix: "", path: this.word(), extensions: []});
var extension = options.extensions.length > 0 ? "." + this.pick(options.extensions) : "";
var domain = options.domain_prefix ? options.domain_prefix + "." + options.domain : options.domain;
return options.protocol + "://" + domain + "/" + options.path + extension;
};
Chance.prototype.port = function() {
return this.integer({min: 0, max: 65535});
};
Chance.prototype.locale = function (options) {
options = initOptions(options);
if (options.region){
return this.pick(this.get("locale_regions"));
} else {
return this.pick(this.get("locale_languages"));
}
};
Chance.prototype.locales = function (options) {
options = initOptions(options);
if (options.region){
return this.get("locale_regions");
} else {
return this.get("locale_languages");
}
};
Chance.prototype.loremPicsum = function (options) {
options = initOptions(options, { width: 500, height: 500, greyscale: false, blurred: false });
var greyscale = options.greyscale ? 'g/' : '';
var query = options.blurred ? '/?blur' : '/?random';
return 'https://picsum.photos/' + greyscale + options.width + '/' + options.height + query;
};
// -- End Web --
// -- Location --
Chance.prototype.address = function (options) {
options = initOptions(options);
return this.natural({min: 5, max: 2000}) + ' ' + this.street(options);
};
Chance.prototype.altitude = function (options) {
options = initOptions(options, {fixed: 5, min: 0, max: 8848});
return this.floating({
min: options.min,
max: options.max,
fixed: options.fixed
});
};
Chance.prototype.areacode = function (options) {
options = initOptions(options, {parens : true});
// Don't want area codes to start with 1, or have a 9 as the second digit
var areacode = this.natural({min: 2, max: 9}).toString() +
this.natural({min: 0, max: 8}).toString() +
this.natural({min: 0, max: 9}).toString();
return options.parens ? '(' + areacode + ')' : areacode;
};
Chance.prototype.city = function () {
return this.capitalize(this.word({syllables: 3}));
};
Chance.prototype.coordinates = function (options) {
return this.latitude(options) + ', ' + this.longitude(options);
};
Chance.prototype.countries = function () {
return this.get("countries");
};
Chance.prototype.country = function (options) {
options = initOptions(options);
var country = this.pick(this.countries());
return options.raw ? country : options.full ? country.name : country.abbreviation;
};
Chance.prototype.depth = function (options) {
options = initOptions(options, {fixed: 5, min: -10994, max: 0});
return this.floating({
min: options.min,
max: options.max,
fixed: options.fixed
});
};
Chance.prototype.geohash = function (options) {
options = initOptions(options, { length: 7 });
return this.string({ length: options.length, pool: '0123456789bcdefghjkmnpqrstuvwxyz' });
};
Chance.prototype.geojson = function (options) {
return this.latitude(options) + ', ' + this.longitude(options) + ', ' + this.altitude(options);
};
Chance.prototype.latitude = function (options) {
options = initOptions(options, {fixed: 5, min: -90, max: 90});
return this.floating({min: options.min, max: options.max, fixed: options.fixed});
};
Chance.prototype.longitude = function (options) {
options = initOptions(options, {fixed: 5, min: -180, max: 180});
return this.floating({min: options.min, max: options.max, fixed: options.fixed});
};
Chance.prototype.phone = function (options) {
var self = this,
numPick,
ukNum = function (parts) {
var section = [];
//fills the section part of the phone number with random numbers.
parts.sections.forEach(function(n) {
section.push(self.string({ pool: '0123456789', length: n}));
});
return parts.area + section.join(' ');
};
options = initOptions(options, {
formatted: true,
country: 'us',
mobile: false
});
if (!options.formatted) {
options.parens = false;
}
var phone;
switch (options.country) {
case 'fr':
if (!options.mobile) {
numPick = this.pick([
// Valid zone and département codes.
'01' + this.pick(['30', '34', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '53', '55', '56', '58', '60', '64', '69', '70', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83']) + self.string({ pool: '0123456789', length: 6}),
'02' + this.pick(['14', '18', '22', '23', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '40', '41', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '56', '57', '61', '62', '69', '72', '76', '77', '78', '85', '90', '96', '97', '98', '99']) + self.string({ pool: '0123456789', length: 6}),
'03' + this.pick(['10', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '39', '44', '45', '51', '52', '54', '55', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90']) + self.string({ pool: '0123456789', length: 6}),
'04' + this.pick(['11', '13', '15', '20', '22', '26', '27', '30', '32', '34', '37', '42', '43', '44', '50', '56', '57', '63', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '88', '89', '90', '91', '92', '93', '94', '95', '97', '98']) + self.string({ pool: '0123456789', length: 6}),
'05' + this.pick(['08', '16', '17', '19', '24', '31', '32', '33', '34', '35', '40', '45', '46', '47', '49', '53', '55', '56', '57', '58', '59', '61', '62', '63', '64', '65', '67', '79', '81', '82', '86', '87', '90', '94']) + self.string({ pool: '0123456789', length: 6}),
'09' + self.string({ pool: '0123456789', length: 8}),
]);
phone = options.formatted ? numPick.match(/../g).join(' ') : numPick;
} else {
numPick = this.pick(['06', '07']) + self.string({ pool: '0123456789', length: 8});
phone = options.formatted ? numPick.match(/../g).join(' ') : numPick;
}
break;
case 'uk':
if (!options.mobile) {
numPick = this.pick([
//valid area codes of major cities/counties followed by random numbers in required format.
{ area: '01' + this.character({ pool: '234569' }) + '1 ', sections: [3,4] },
{ area: '020 ' + this.character({ pool: '378' }), sections: [3,4] },
{ area: '023 ' + this.character({ pool: '89' }), sections: [3,4] },
{ area: '024 7', sections: [3,4] },
{ area: '028 ' + this.pick(['25','28','37','71','82','90','92','95']), sections: [2,4] },
{ area: '012' + this.pick(['04','08','54','76','97','98']) + ' ', sections: [6] },
{ area: '013' + this.pick(['63','64','84','86']) + ' ', sections: [6] },
{ area: '014' + this.pick(['04','20','60','61','80','88']) + ' ', sections: [6] },
{ area: '015' + this.pick(['24','27','62','66']) + ' ', sections: [6] },
{ area: '016' + this.pick(['06','29','35','47','59','95']) + ' ', sections: [6] },
{ area: '017' + this.pick(['26','44','50','68']) + ' ', sections: [6] },
{ area: '018' + this.pick(['27','37','84','97']) + ' ', sections: [6] },
{ area: '019' + this.pick(['00','05','35','46','49','63','95']) + ' ', sections: [6] }
]);
phone = options.formatted ? ukNum(numPick) : ukNum(numPick).replace(' ', '', 'g');
} else {
numPick = this.pick([
{ area: '07' + this.pick(['4','5','7','8','9']), sections: [2,6] },
{ area: '07624 ', sections: [6] }
]);
phone = options.formatted ? ukNum(numPick) : ukNum(numPick).replace(' ', '');
}
break;
case 'za':
if (!options.mobile) {
numPick = this.pick([
'01' + this.pick(['0', '1', '2', '3', '4', '5', '6', '7', '8']) + self.string({ pool: '0123456789', length: 7}),
'02' + this.pick(['1', '2', '3', '4', '7', '8']) + self.string({ pool: '0123456789', length: 7}),
'03' + this.pick(['1', '2', '3', '5', '6', '9']) + self.string({ pool: '0123456789', length: 7}),
'04' + this.pick(['1', '2', '3', '4', '5','6','7', '8','9']) + self.string({ pool: '0123456789', length: 7}),
'05' + this.pick(['1', '3', '4', '6', '7', '8']) + self.string({ pool: '0123456789', length: 7}),
]);
phone = options.formatted || numPick;
} else {
numPick = this.pick([
'060' + this.pick(['3','4','5','6','7','8','9']) + self.string({ pool: '0123456789', length: 6}),
'061' + this.pick(['0','1','2','3','4','5','8']) + self.string({ pool: '0123456789', length: 6}),
'06' + self.string({ pool: '0123456789', length: 7}),
'071' + this.pick(['0','1','2','3','4','5','6','7','8','9']) + self.string({ pool: '0123456789', length: 6}),
'07' + this.pick(['2','3','4','6','7','8','9']) + self.string({ pool: '0123456789', length: 7}),
'08' + this.pick(['0','1','2','3','4','5']) + self.string({ pool: '0123456789', length: 7}),
]);
phone = options.formatted || numPick;
}
break;
case 'us':
var areacode = this.areacode(options).toString();
var exchange = this.natural({ min: 2, max: 9 }).toString() +
this.natural({ min: 0, max: 9 }).toString() +
this.natural({ min: 0, max: 9 }).toString();
var subscriber = this.natural({ min: 1000, max: 9999 }).toString(); // this could be random [0-9]{4}
phone = options.formatted ? areacode + ' ' + exchange + '-' + subscriber : areacode + exchange + subscriber;
break;
case 'br':
var areaCode = this.pick(["11", "12", "13", "14", "15", "16", "17", "18", "19", "21", "22", "24", "27", "28", "31", "32", "33", "34", "35", "37", "38", "41", "42", "43", "44", "45", "46", "47", "48", "49", "51", "53", "54", "55", "61", "62", "63", "64", "65", "66", "67", "68", "69", "71", "73", "74", "75", "77", "79", "81", "82", "83", "84", "85", "86", "87", "88", "89", "91", "92", "93", "94", "95", "96", "97", "98", "99"]);
var prefix;
if (options.mobile) {
// Brasilian official reference (mobile): http://www.anatel.gov.br/setorregulado/plano-de-numeracao-brasileiro?id=330
prefix = '9' + self.string({ pool: '0123456789', length: 4});
} else {
// Brasilian official reference: http://www.anatel.gov.br/setorregulado/plano-de-numeracao-brasileiro?id=331
prefix = this.natural({ min: 2000, max: 5999 }).toString();
}
var mcdu = self.string({ pool: '0123456789', length: 4});
phone = options.formatted ? '(' + areaCode + ') ' + prefix + '-' + mcdu : areaCode + prefix + mcdu;
break;
}
return phone;
};
Chance.prototype.postal = function () {
// Postal District
var pd = this.character({pool: "XVTSRPNKLMHJGECBA"});
// Forward Sortation Area (FSA)
var fsa = pd + this.natural({max: 9}) + this.character({alpha: true, casing: "upper"});
// Local Delivery Unut (LDU)
var ldu = this.natural({max: 9}) + this.character({alpha: true, casing: "upper"}) + this.natural({max: 9});
return fsa + " " + ldu;
};
Chance.prototype.counties = function (options) {
options = initOptions(options, { country: 'uk' });
return this.get("counties")[options.country.toLowerCase()];
};
Chance.prototype.county = function (options) {
return this.pick(this.counties(options)).name;
};
Chance.prototype.provinces = function (options) {
options = initOptions(options, { country: 'ca' });
return this.get("provinces")[options.country.toLowerCase()];
};
Chance.prototype.province = function (options) {
return (options && options.full) ?
this.pick(this.provinces(options)).name :
this.pick(this.provinces(options)).abbreviation;
};
Chance.prototype.state = function (options) {
return (options && options.full) ?
this.pick(this.states(options)).name :
this.pick(this.states(options)).abbreviation;
};
Chance.prototype.states = function (options) {
options = initOptions(options, { country: 'us', us_states_and_dc: true } );
var states;
switch (options.country.toLowerCase()) {
case 'us':
var us_states_and_dc = this.get("us_states_and_dc"),
territories = this.get("territories"),
armed_forces = this.get("armed_forces");
states = [];
if (options.us_states_and_dc) {
states = states.concat(us_states_and_dc);
}
if (options.territories) {
states = states.concat(territories);
}
if (options.armed_forces) {
states = states.concat(armed_forces);
}
break;
case 'it':
states = this.get("country_regions")[options.country.toLowerCase()];
break;
case 'uk':
states = this.get("counties")[options.country.toLowerCase()];
break;
}
return states;
};
Chance.prototype.street = function (options) {
options = initOptions(options, { country: 'us', syllables: 2 });
var street;
switch (options.country.toLowerCase()) {
case 'us':
street = this.word({ syllables: options.syllables });
street = this.capitalize(street);
street += ' ';
street += options.short_suffix ?
this.street_suffix(options).abbreviation :
this.street_suffix(options).name;
break;
case 'it':
street = this.word({ syllables: options.syllables });
street = this.capitalize(street);
street = (options.short_suffix ?
this.street_suffix(options).abbreviation :
this.street_suffix(options).name) + " " + street;
break;
}
return street;
};
Chance.prototype.street_suffix = function (options) {
options = initOptions(options, { country: 'us' });
return this.pick(this.street_suffixes(options));
};
Chance.prototype.street_suffixes = function (options) {
options = initOptions(options, { country: 'us' });
// These are the most common suffixes.
return this.get("street_suffixes")[options.country.toLowerCase()];
};
// Note: only returning US zip codes, internationalization will be a whole
// other beast to tackle at some point.
Chance.prototype.zip = function (options) {
var zip = this.n(this.natural, 5, {max: 9});
if (options && options.plusfour === true) {
zip.push('-');
zip = zip.concat(this.n(this.natural, 4, {max: 9}));
}
return zip.join("");
};
// -- End Location --
// -- Time
Chance.prototype.ampm = function () {
return this.bool() ? 'am' : 'pm';
};
Chance.prototype.date = function (options) {
var date_string, date;
// If interval is specified we ignore preset
if(options && (options.min || options.max)) {
options = initOptions(options, {
american: true,
string: false
});
var min = typeof options.min !== "undefined" ? options.min.getTime() : 1;
// 100,000,000 days measured relative to midnight at the beginning of 01 January, 1970 UTC. http://es5.github.io/#x15.9.1.1
var max = typeof options.max !== "undefined" ? options.max.getTime() : 8640000000000000;
date = new Date(this.integer({min: min, max: max}));
} else {
var m = this.month({raw: true});
var daysInMonth = m.days;
if(options && options.month) {
// Mod 12 to allow months outside range of 0-11 (not encouraged, but also not prevented).
daysInMonth = this.get('months')[((options.month % 12) + 12) % 12].days;
}
options = initOptions(options, {
year: parseInt(this.year(), 10),
// Necessary to subtract 1 because Date() 0-indexes month but not day or year
// for some reason.
month: m.numeric - 1,
day: this.natural({min: 1, max: daysInMonth}),
hour: this.hour({twentyfour: true}),
minute: this.minute(),
second: this.second(),
millisecond: this.millisecond(),
american: true,
string: false
});
date = new Date(options.year, options.month, options.day, options.hour, options.minute, options.second, options.millisecond);
}
if (options.american) {
// Adding 1 to the month is necessary because Date() 0-indexes
// months but not day for some odd reason.
date_string = (date.getMonth() + 1) + '/' + date.getDate() + '/' + date.getFullYear();
} else {
date_string = date.getDate() + '/' + (date.getMonth() + 1) + '/' + date.getFullYear();
}
return options.string ? date_string : date;
};
Chance.prototype.hammertime = function (options) {
return this.date(options).getTime();
};
Chance.prototype.hour = function (options) {
options = initOptions(options, {
min: options && options.twentyfour ? 0 : 1,
max: options && options.twentyfour ? 23 : 12
});
testRange(options.min < 0, "Chance: Min cannot be less than 0.");
testRange(options.twentyfour && options.max > 23, "Chance: Max cannot be greater than 23 for twentyfour option.");
testRange(!options.twentyfour && options.max > 12, "Chance: Max cannot be greater than 12.");
testRange(options.min > options.max, "Chance: Min cannot be greater than Max.");
return this.natural({min: options.min, max: options.max});
};
Chance.prototype.millisecond = function () {
return this.natural({max: 999});
};
Chance.prototype.minute = Chance.prototype.second = function (options) {
options = initOptions(options, {min: 0, max: 59});
testRange(options.min < 0, "Chance: Min cannot be less than 0.");
testRange(options.max > 59, "Chance: Max cannot be greater than 59.");
testRange(options.min > options.max, "Chance: Min cannot be greater than Max.");
return this.natural({min: options.min, max: options.max});
};
Chance.prototype.month = function (options) {
options = initOptions(options, {min: 1, max: 12});
testRange(options.min < 1, "Chance: Min cannot be less than 1.");
testRange(options.max > 12, "Chance: Max cannot be greater than 12.");
testRange(options.min > options.max, "Chance: Min cannot be greater than Max.");
var month = this.pick(this.months().slice(options.min - 1, options.max));
return options.raw ? month : month.name;
};
Chance.prototype.months = function () {
return this.get("months");
};
Chance.prototype.second = function () {
return this.natural({max: 59});
};
Chance.prototype.timestamp = function () {
return this.natural({min: 1, max: parseInt(new Date().getTime() / 1000, 10)});
};
Chance.prototype.weekday = function (options) {
options = initOptions(options, {weekday_only: false});
var weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"];
if (!options.weekday_only) {
weekdays.push("Saturday");
weekdays.push("Sunday");
}
return this.pickone(weekdays);
};
Chance.prototype.year = function (options) {
// Default to current year as min if none specified
options = initOptions(options, {min: new Date().getFullYear()});
// Default to one century after current year as max if none specified
options.max = (typeof options.max !== "undefined") ? options.max : options.min + 100;
return this.natural(options).toString();
};
// -- End Time
// -- Finance --
Chance.prototype.cc = function (options) {
options = initOptions(options);
var type, number, to_generate;
type = (options.type) ?
this.cc_type({ name: options.type, raw: true }) :
this.cc_type({ raw: true });
number = type.prefix.split("");
to_generate = type.length - type.prefix.length - 1;
// Generates n - 1 digits
number = number.concat(this.n(this.integer, to_generate, {min: 0, max: 9}));
// Generates the last digit according to Luhn algorithm
number.push(this.luhn_calculate(number.join("")));
return number.join("");
};
Chance.prototype.cc_types = function () {
// http://en.wikipedia.org/wiki/Bank_card_number#Issuer_identification_number_.28IIN.29
return this.get("cc_types");
};
Chance.prototype.cc_type = function (options) {
options = initOptions(options);
var types = this.cc_types(),
type = null;
if (options.name) {
for (var i = 0; i < types.length; i++) {
// Accept either name or short_name to specify card type
if (types[i].name === options.name || types[i].short_name === options.name) {
type = types[i];
break;
}
}
if (type === null) {
throw new RangeError("Chance: Credit card type '" + options.name + "' is not supported");
}
} else {
type = this.pick(types);
}
return options.raw ? type : type.name;
};
// return all world currency by ISO 4217
Chance.prototype.currency_types = function () {
return this.get("currency_types");
};
// return random world currency by ISO 4217
Chance.prototype.currency = function () {
return this.pick(this.currency_types());
};
// return all timezones available
Chance.prototype.timezones = function () {
return this.get("timezones");
};
// return random timezone
Chance.prototype.timezone = function () {
return this.pick(this.timezones());
};
//Return random correct currency exchange pair (e.g. EUR/USD) or array of currency code
Chance.prototype.currency_pair = function (returnAsString) {
var currencies = this.unique(this.currency, 2, {
comparator: function(arr, val) {
return arr.reduce(function(acc, item) {
// If a match has been found, short circuit check and just return
return acc || (item.code === val.code);
}, false);
}
});
if (returnAsString) {
return currencies[0].code + '/' + currencies[1].code;
} else {
return currencies;
}
};
Chance.prototype.dollar = function (options) {
// By default, a somewhat more sane max for dollar than all available numbers
options = initOptions(options, {max : 10000, min : 0});
var dollar = this.floating({min: options.min, max: options.max, fixed: 2}).toString(),
cents = dollar.split('.')[1];
if (cents === undefined) {
dollar += '.00';
} else if (cents.length < 2) {
dollar = dollar + '0';
}
if (dollar < 0) {
return '-$' + dollar.replace('-', '');
} else {
return '$' + dollar;
}
};
Chance.prototype.euro = function (options) {
return Number(this.dollar(options).replace("$", "")).toLocaleString() + "€";
};
Chance.prototype.exp = function (options) {
options = initOptions(options);
var exp = {};
exp.year = this.exp_year();
// If the year is this year, need to ensure month is greater than the
// current month or this expiration will not be valid
if (exp.year === (new Date().getFullYear()).toString()) {
exp.month = this.exp_month({future: true});
} else {
exp.month = this.exp_month();
}
return options.raw ? exp : exp.month + '/' + exp.year;
};
Chance.prototype.exp_month = function (options) {
options = initOptions(options);
var month, month_int,
// Date object months are 0 indexed
curMonth = new Date().getMonth() + 1;
if (options.future && (curMonth !== 12)) {
do {
month = this.month({raw: true}).numeric;
month_int = parseInt(month, 10);
} while (month_int <= curMonth);
} else {
month = this.month({raw: true}).numeric;
}
return month;
};
Chance.prototype.exp_year = function () {
var curMonth = new Date().getMonth() + 1,
curYear = new Date().getFullYear();
return this.year({min: ((curMonth === 12) ? (curYear + 1) : curYear), max: (curYear + 10)});
};
Chance.prototype.vat = function (options) {
options = initOptions(options, { country: 'it' });
switch (options.country.toLowerCase()) {
case 'it':
return this.it_vat();
}
};
/**
* Generate a string matching IBAN pattern (https://en.wikipedia.org/wiki/International_Bank_Account_Number).
* No country-specific formats support (yet)
*/
Chance.prototype.iban = function () {
var alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
var alphanum = alpha + '0123456789';
var iban =
this.string({ length: 2, pool: alpha }) +
this.pad(this.integer({ min: 0, max: 99 }), 2) +
this.string({ length: 4, pool: alphanum }) +
this.pad(this.natural(), this.natural({ min: 6, max: 26 }));
return iban;
};
// -- End Finance
// -- Regional
Chance.prototype.it_vat = function () {
var it_vat = this.natural({min: 1, max: 1800000});
it_vat = this.pad(it_vat, 7) + this.pad(this.pick(this.provinces({ country: 'it' })).code, 3);
return it_vat + this.luhn_calculate(it_vat);
};
/*
* this generator is written following the official algorithm
* all data can be passed explicitely or randomized by calling chance.cf() without options
* the code does not check that the input data is valid (it goes beyond the scope of the generator)
*
* @param [Object] options = { first: first name,
* last: last name,
* gender: female|male,
birthday: JavaScript date object,
city: string(4), 1 letter + 3 numbers
}
* @return [string] codice fiscale
*
*/
Chance.prototype.cf = function (options) {
options = options || {};
var gender = !!options.gender ? options.gender : this.gender(),
first = !!options.first ? options.first : this.first( { gender: gender, nationality: 'it'} ),
last = !!options.last ? options.last : this.last( { nationality: 'it'} ),
birthday = !!options.birthday ? options.birthday : this.birthday(),
city = !!options.city ? options.city : this.pickone(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'L', 'M', 'Z']) + this.pad(this.natural({max:999}), 3),
cf = [],
name_generator = function(name, isLast) {
var temp,
return_value = [];
if (name.length < 3) {
return_value = name.split("").concat("XXX".split("")).splice(0,3);
}
else {
temp = name.toUpperCase().split('').map(function(c){
return ("BCDFGHJKLMNPRSTVWZ".indexOf(c) !== -1) ? c : undefined;
}).join('');
if (temp.length > 3) {
if (isLast) {
temp = temp.substr(0,3);
} else {
temp = temp[0] + temp.substr(2,2);
}
}
if (temp.length < 3) {
return_value = temp;
temp = name.toUpperCase().split('').map(function(c){
return ("AEIOU".indexOf(c) !== -1) ? c : undefined;
}).join('').substr(0, 3 - return_value.length);
}
return_value = return_value + temp;
}
return return_value;
},
date_generator = function(birthday, gender, that) {
var lettermonths = ['A', 'B', 'C', 'D', 'E', 'H', 'L', 'M', 'P', 'R', 'S', 'T'];
return birthday.getFullYear().toString().substr(2) +
lettermonths[birthday.getMonth()] +
that.pad(birthday.getDate() + ((gender.toLowerCase() === "female") ? 40 : 0), 2);
},
checkdigit_generator = function(cf) {
var range1 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ",
range2 = "ABCDEFGHIJABCDEFGHIJKLMNOPQRSTUVWXYZ",
evens = "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
odds = "BAKPLCQDREVOSFTGUHMINJWZYX",
digit = 0;
for(var i = 0; i < 15; i++) {
if (i % 2 !== 0) {
digit += evens.indexOf(range2[range1.indexOf(cf[i])]);
}
else {
digit += odds.indexOf(range2[range1.indexOf(cf[i])]);
}
}
return evens[digit % 26];
};
cf = cf.concat(name_generator(last, true), name_generator(first), date_generator(birthday, gender, this), city.toUpperCase().split("")).join("");
cf += checkdigit_generator(cf.toUpperCase(), this);
return cf.toUpperCase();
};
Chance.prototype.pl_pesel = function () {
var number = this.natural({min: 1, max: 9999999999});
var arr = this.pad(number, 10).split('');
for (var i = 0; i < arr.length; i++) {
arr[i] = parseInt(arr[i]);
}
var controlNumber = (1 * arr[0] + 3 * arr[1] + 7 * arr[2] + 9 * arr[3] + 1 * arr[4] + 3 * arr[5] + 7 * arr[6] + 9 * arr[7] + 1 * arr[8] + 3 * arr[9]) % 10;
if(controlNumber !== 0) {
controlNumber = 10 - controlNumber;
}
return arr.join('') + controlNumber;
};
Chance.prototype.pl_nip = function () {
var number = this.natural({min: 1, max: 999999999});
var arr = this.pad(number, 9).split('');
for (var i = 0; i < arr.length; i++) {
arr[i] = parseInt(arr[i]);
}
var controlNumber = (6 * arr[0] + 5 * arr[1] + 7 * arr[2] + 2 * arr[3] + 3 * arr[4] + 4 * arr[5] + 5 * arr[6] + 6 * arr[7] + 7 * arr[8]) % 11;
if(controlNumber === 10) {
return this.pl_nip();
}
return arr.join('') + controlNumber;
};
Chance.prototype.pl_regon = function () {
var number = this.natural({min: 1, max: 99999999});
var arr = this.pad(number, 8).split('');
for (var i = 0; i < arr.length; i++) {
arr[i] = parseInt(arr[i]);
}
var controlNumber = (8 * arr[0] + 9 * arr[1] + 2 * arr[2] + 3 * arr[3] + 4 * arr[4] + 5 * arr[5] + 6 * arr[6] + 7 * arr[7]) % 11;
if(controlNumber === 10) {
controlNumber = 0;
}
return arr.join('') + controlNumber;
};
// -- End Regional
// -- Music --
Chance.prototype.note = function(options) {
// choices for 'notes' option:
// flatKey - chromatic scale with flat notes (default)
// sharpKey - chromatic scale with sharp notes
// flats - just flat notes
// sharps - just sharp notes
// naturals - just natural notes
// all - naturals, sharps and flats
options = initOptions(options, { notes : 'flatKey'});
var scales = {
naturals: ['C', 'D', 'E', 'F', 'G', 'A', 'B'],
flats: ['D♭', 'E♭', 'G♭', 'A♭', 'B♭'],
sharps: ['C♯', 'D♯', 'F♯', 'G♯', 'A♯']
};
scales.all = scales.naturals.concat(scales.flats.concat(scales.sharps));
scales.flatKey = scales.naturals.concat(scales.flats);
scales.sharpKey = scales.naturals.concat(scales.sharps);
return this.pickone(scales[options.notes]);
};
Chance.prototype.midi_note = function(options) {
var min = 0;
var max = 127;
options = initOptions(options, { min : min, max : max });
return this.integer({min: options.min, max: options.max});
};
Chance.prototype.chord_quality = function(options) {
options = initOptions(options, { jazz: true });
var chord_qualities = ['maj', 'min', 'aug', 'dim'];
if (options.jazz){
chord_qualities = [
'maj7',
'min7',
'7',
'sus',
'dim',
'ø'
];
}
return this.pickone(chord_qualities);
};
Chance.prototype.chord = function (options) {
options = initOptions(options);
return this.note(options) + this.chord_quality(options);
};
Chance.prototype.tempo = function (options) {
var min = 40;
var max = 320;
options = initOptions(options, {min: min, max: max});
return this.integer({min: options.min, max: options.max});
};
// -- End Music
// -- Miscellaneous --
// Coin - Flip, flip, flipadelphia
Chance.prototype.coin = function(options) {
return this.bool() ? "heads" : "tails";
};
// Dice - For all the board game geeks out there, myself included ;)
function diceFn (range) {
return function () {
return this.natural(range);
};
}
Chance.prototype.d4 = diceFn({min: 1, max: 4});
Chance.prototype.d6 = diceFn({min: 1, max: 6});
Chance.prototype.d8 = diceFn({min: 1, max: 8});
Chance.prototype.d10 = diceFn({min: 1, max: 10});
Chance.prototype.d12 = diceFn({min: 1, max: 12});
Chance.prototype.d20 = diceFn({min: 1, max: 20});
Chance.prototype.d30 = diceFn({min: 1, max: 30});
Chance.prototype.d100 = diceFn({min: 1, max: 100});
Chance.prototype.rpg = function (thrown, options) {
options = initOptions(options);
if (!thrown) {
throw new RangeError("Chance: A type of die roll must be included");
} else {
var bits = thrown.toLowerCase().split("d"),
rolls = [];
if (bits.length !== 2 || !parseInt(bits[0], 10) || !parseInt(bits[1], 10)) {
throw new Error("Chance: Invalid format provided. Please provide #d# where the first # is the number of dice to roll, the second # is the max of each die");
}
for (var i = bits[0]; i > 0; i--) {
rolls[i - 1] = this.natural({min: 1, max: bits[1]});
}
return (typeof options.sum !== 'undefined' && options.sum) ? rolls.reduce(function (p, c) { return p + c; }) : rolls;
}
};
// Guid
Chance.prototype.guid = function (options) {
options = initOptions(options, { version: 5 });
var guid_pool = "abcdef1234567890",
variant_pool = "ab89",
guid = this.string({ pool: guid_pool, length: 8 }) + '-' +
this.string({ pool: guid_pool, length: 4 }) + '-' +
// The Version
options.version +
this.string({ pool: guid_pool, length: 3 }) + '-' +
// The Variant
this.string({ pool: variant_pool, length: 1 }) +
this.string({ pool: guid_pool, length: 3 }) + '-' +
this.string({ pool: guid_pool, length: 12 });
return guid;
};
// Hash
Chance.prototype.hash = function (options) {
options = initOptions(options, {length : 40, casing: 'lower'});
var pool = options.casing === 'upper' ? HEX_POOL.toUpperCase() : HEX_POOL;
return this.string({pool: pool, length: options.length});
};
Chance.prototype.luhn_check = function (num) {
var str = num.toString();
var checkDigit = +str.substring(str.length - 1);
return checkDigit === this.luhn_calculate(+str.substring(0, str.length - 1));
};
Chance.prototype.luhn_calculate = function (num) {
var digits = num.toString().split("").reverse();
var sum = 0;
var digit;
for (var i = 0, l = digits.length; l > i; ++i) {
digit = +digits[i];
if (i % 2 === 0) {
digit *= 2;
if (digit > 9) {
digit -= 9;
}
}
sum += digit;
}
return (sum * 9) % 10;
};
// MD5 Hash
Chance.prototype.md5 = function(options) {
var opts = { str: '', key: null, raw: false };
if (!options) {
opts.str = this.string();
options = {};
}
else if (typeof options === 'string') {
opts.str = options;
options = {};
}
else if (typeof options !== 'object') {
return null;
}
else if(options.constructor === 'Array') {
return null;
}
opts = initOptions(options, opts);
if(!opts.str){
throw new Error('A parameter is required to return an md5 hash.');
}
return this.bimd5.md5(opts.str, opts.key, opts.raw);
};
/**
* #Description:
* =====================================================
* Generate random file name with extension
*
* The argument provide extension type
* -> raster
* -> vector
* -> 3d
* -> document
*
* If nothing is provided the function return random file name with random
* extension type of any kind
*
* The user can validate the file name length range
* If nothing provided the generated file name is random
*
* #Extension Pool :
* * Currently the supported extensions are
* -> some of the most popular raster image extensions
* -> some of the most popular vector image extensions
* -> some of the most popular 3d image extensions
* -> some of the most popular document extensions
*
* #Examples :
* =====================================================
*
* Return random file name with random extension. The file extension
* is provided by a predefined collection of extensions. More about the extension
* pool can be found in #Extension Pool section
*
* chance.file()
* => dsfsdhjf.xml
*
* In order to generate a file name with specific length, specify the
* length property and integer value. The extension is going to be random
*
* chance.file({length : 10})
* => asrtineqos.pdf
*
* In order to generate file with extension from some of the predefined groups
* of the extension pool just specify the extension pool category in fileType property
*
* chance.file({fileType : 'raster'})
* => dshgssds.psd
*
* You can provide specific extension for your files
* chance.file({extension : 'html'})
* => djfsd.html
*
* Or you could pass custom collection of extensions by array or by object
* chance.file({extensions : [...]})
* => dhgsdsd.psd
*
* chance.file({extensions : { key : [...], key : [...]}})
* => djsfksdjsd.xml
*
* @param [collection] options
* @return [string]
*
*/
Chance.prototype.file = function(options) {
var fileOptions = options || {};
var poolCollectionKey = "fileExtension";
var typeRange = Object.keys(this.get("fileExtension"));//['raster', 'vector', '3d', 'document'];
var fileName;
var fileExtension;
// Generate random file name
fileName = this.word({length : fileOptions.length});
// Generate file by specific extension provided by the user
if(fileOptions.extension) {
fileExtension = fileOptions.extension;
return (fileName + '.' + fileExtension);
}
// Generate file by specific extension collection
if(fileOptions.extensions) {
if(Array.isArray(fileOptions.extensions)) {
fileExtension = this.pickone(fileOptions.extensions);
return (fileName + '.' + fileExtension);
}
else if(fileOptions.extensions.constructor === Object) {
var extensionObjectCollection = fileOptions.extensions;
var keys = Object.keys(extensionObjectCollection);
fileExtension = this.pickone(extensionObjectCollection[this.pickone(keys)]);
return (fileName + '.' + fileExtension);
}
throw new Error("Chance: Extensions must be an Array or Object");
}
// Generate file extension based on specific file type
if(fileOptions.fileType) {
var fileType = fileOptions.fileType;
if(typeRange.indexOf(fileType) !== -1) {
fileExtension = this.pickone(this.get(poolCollectionKey)[fileType]);
return (fileName + '.' + fileExtension);
}
throw new RangeError("Chance: Expect file type value to be 'raster', 'vector', '3d' or 'document'");
}
// Generate random file name if no extension options are passed
fileExtension = this.pickone(this.get(poolCollectionKey)[this.pickone(typeRange)]);
return (fileName + '.' + fileExtension);
};
var data = {
firstNames: {
"male": {
"en": ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph", "Charles", "Thomas", "Christopher", "Daniel", "Matthew", "George", "Donald", "Anthony", "Paul", "Mark", "Edward", "Steven", "Kenneth", "Andrew", "Brian", "Joshua", "Kevin", "Ronald", "Timothy", "Jason", "Jeffrey", "Frank", "Gary", "Ryan", "Nicholas", "Eric", "Stephen", "Jacob", "Larry", "Jonathan", "Scott", "Raymond", "Justin", "Brandon", "Gregory", "Samuel", "Benjamin", "Patrick", "Jack", "Henry", "Walter", "Dennis", "Jerry", "Alexander", "Peter", "Tyler", "Douglas", "Harold", "Aaron", "Jose", "Adam", "Arthur", "Zachary", "Carl", "Nathan", "Albert", "Kyle", "Lawrence", "Joe", "Willie", "Gerald", "Roger", "Keith", "Jeremy", "Terry", "Harry", "Ralph", "Sean", "Jesse", "Roy", "Louis", "Billy", "Austin", "Bruce", "Eugene", "Christian", "Bryan", "Wayne", "Russell", "Howard", "Fred", "Ethan", "Jordan", "Philip", "Alan", "Juan", "Randy", "Vincent", "Bobby", "Dylan", "Johnny", "Phillip", "Victor", "Clarence", "Ernest", "Martin", "Craig", "Stanley", "Shawn", "Travis", "Bradley", "Leonard", "Earl", "Gabriel", "Jimmy", "Francis", "Todd", "Noah", "Danny", "Dale", "Cody", "Carlos", "Allen", "Frederick", "Logan", "Curtis", "Alex", "Joel", "Luis", "Norman", "Marvin", "Glenn", "Tony", "Nathaniel", "Rodney", "Melvin", "Alfred", "Steve", "Cameron", "Chad", "Edwin", "Caleb", "Evan", "Antonio", "Lee", "Herbert", "Jeffery", "Isaac", "Derek", "Ricky", "Marcus", "Theodore", "Elijah", "Luke", "Jesus", "Eddie", "Troy", "Mike", "Dustin", "Ray", "Adrian", "Bernard", "Leroy", "Angel", "Randall", "Wesley", "Ian", "Jared", "Mason", "Hunter", "Calvin", "Oscar", "Clifford", "Jay", "Shane", "Ronnie", "Barry", "Lucas", "Corey", "Manuel", "Leo", "Tommy", "Warren", "Jackson", "Isaiah", "Connor", "Don", "Dean", "Jon", "Julian", "Miguel", "Bill", "Lloyd", "Charlie", "Mitchell", "Leon", "Jerome", "Darrell", "Jeremiah", "Alvin", "Brett", "Seth", "Floyd", "Jim", "Blake", "Micheal", "Gordon", "Trevor", "Lewis", "Erik", "Edgar", "Vernon", "Devin", "Gavin", "Jayden", "Chris", "Clyde", "Tom", "Derrick", "Mario", "Brent", "Marc", "Herman", "Chase", "Dominic", "Ricardo", "Franklin", "Maurice", "Max", "Aiden", "Owen", "Lester", "Gilbert", "Elmer", "Gene", "Francisco", "Glen", "Cory", "Garrett", "Clayton", "Sam", "Jorge", "Chester", "Alejandro", "Jeff", "Harvey", "Milton", "Cole", "Ivan", "Andre", "Duane", "Landon"],
// Data taken from http://www.dati.gov.it/dataset/comune-di-firenze_0163
"it": ["Adolfo", "Alberto", "Aldo", "Alessandro", "Alessio", "Alfredo", "Alvaro", "Andrea", "Angelo", "Angiolo", "Antonino", "Antonio", "Attilio", "Benito", "Bernardo", "Bruno", "Carlo", "Cesare", "Christian", "Claudio", "Corrado", "Cosimo", "Cristian", "Cristiano", "Daniele", "Dario", "David", "Davide", "Diego", "Dino", "Domenico", "Duccio", "Edoardo", "Elia", "Elio", "Emanuele", "Emiliano", "Emilio", "Enrico", "Enzo", "Ettore", "Fabio", "Fabrizio", "Federico", "Ferdinando", "Fernando", "Filippo", "Francesco", "Franco", "Gabriele", "Giacomo", "Giampaolo", "Giampiero", "Giancarlo", "Gianfranco", "Gianluca", "Gianmarco", "Gianni", "Gino", "Giorgio", "Giovanni", "Giuliano", "Giulio", "Giuseppe", "Graziano", "Gregorio", "Guido", "Iacopo", "Jacopo", "Lapo", "Leonardo", "Lorenzo", "Luca", "Luciano", "Luigi", "Manuel", "Marcello", "Marco", "Marino", "Mario", "Massimiliano", "Massimo", "Matteo", "Mattia", "Maurizio", "Mauro", "Michele", "Mirko", "Mohamed", "Nello", "Neri", "Niccolò", "Nicola", "Osvaldo", "Otello", "Paolo", "Pier Luigi", "Piero", "Pietro", "Raffaele", "Remo", "Renato", "Renzo", "Riccardo", "Roberto", "Rolando", "Romano", "Salvatore", "Samuele", "Sandro", "Sergio", "Silvano", "Simone", "Stefano", "Thomas", "Tommaso", "Ubaldo", "Ugo", "Umberto", "Valerio", "Valter", "Vasco", "Vincenzo", "Vittorio"],
// Data taken from http://www.svbkindernamen.nl/int/nl/kindernamen/index.html
"nl": ["Aaron","Abel","Adam","Adriaan","Albert","Alexander","Ali","Arjen","Arno","Bart","Bas","Bastiaan","Benjamin","Bob", "Boris","Bram","Brent","Cas","Casper","Chris","Christiaan","Cornelis","Daan","Daley","Damian","Dani","Daniel","Daniël","David","Dean","Dirk","Dylan","Egbert","Elijah","Erik","Erwin","Evert","Ezra","Fabian","Fedde","Finn","Florian","Floris","Frank","Frans","Frederik","Freek","Geert","Gerard","Gerben","Gerrit","Gijs","Guus","Hans","Hendrik","Henk","Herman","Hidde","Hugo","Jaap","Jan Jaap","Jan-Willem","Jack","Jacob","Jan","Jason","Jasper","Jayden","Jelle","Jelte","Jens","Jeroen","Jesse","Jim","Job","Joep","Johannes","John","Jonathan","Joris","Joshua","Joël","Julian","Kees","Kevin","Koen","Lars","Laurens","Leendert","Lennard","Lodewijk","Luc","Luca","Lucas","Lukas","Luuk","Maarten","Marcus","Martijn","Martin","Matthijs","Maurits","Max","Mees","Melle","Mick","Mika","Milan","Mohamed","Mohammed","Morris","Muhammed","Nathan","Nick","Nico","Niek","Niels","Noah","Noud","Olivier","Oscar","Owen","Paul","Pepijn","Peter","Pieter","Pim","Quinten","Reinier","Rens","Robin","Ruben","Sam","Samuel","Sander","Sebastiaan","Sem","Sep","Sepp","Siem","Simon","Stan","Stef","Steven","Stijn","Sven","Teun","Thijmen","Thijs","Thomas","Tijn","Tim","Timo","Tobias","Tom","Victor","Vince","Willem","Wim","Wouter","Yusuf"],
// Data taken from https://fr.wikipedia.org/wiki/Liste_de_pr%C3%A9noms_fran%C3%A7ais_et_de_la_francophonie
"fr": ["Aaron","Abdon","Abel","Abélard","Abelin","Abondance","Abraham","Absalon","Acace","Achaire","Achille","Adalard","Adalbald","Adalbéron","Adalbert","Adalric","Adam","Adegrin","Adel","Adelin","Andelin","Adelphe","Adam","Adéodat","Adhémar","Adjutor","Adolphe","Adonis","Adon","Adrien","Agapet","Agathange","Agathon","Agilbert","Agénor","Agnan","Aignan","Agrippin","Aimable","Aimé","Alain","Alban","Albin","Aubin","Albéric","Albert","Albertet","Alcibiade","Alcide","Alcée","Alcime","Aldonce","Aldric","Aldéric","Aleaume","Alexandre","Alexis","Alix","Alliaume","Aleaume","Almine","Almire","Aloïs","Alphée","Alphonse","Alpinien","Alverède","Amalric","Amaury","Amandin","Amant","Ambroise","Amédée","Amélien","Amiel","Amour","Anaël","Anastase","Anatole","Ancelin","Andéol","Andoche","André","Andoche","Ange","Angelin","Angilbe","Anglebert","Angoustan","Anicet","Anne","Annibal","Ansbert","Anselme","Anthelme","Antheaume","Anthime","Antide","Antoine","Antonius","Antonin","Apollinaire","Apollon","Aquilin","Arcade","Archambaud","Archambeau","Archange","Archibald","Arian","Ariel","Ariste","Aristide","Armand","Armel","Armin","Arnould","Arnaud","Arolde","Arsène","Arsinoé","Arthaud","Arthème","Arthur","Ascelin","Athanase","Aubry","Audebert","Audouin","Audran","Audric","Auguste","Augustin","Aurèle","Aurélien","Aurian","Auxence","Axel","Aymard","Aymeric","Aymon","Aymond","Balthazar","Baptiste","Barnabé","Barthélemy","Bartimée","Basile","Bastien","Baudouin","Bénigne","Benjamin","Benoît","Bérenger","Bérard","Bernard","Bertrand","Blaise","Bon","Boniface","Bouchard","Brice","Brieuc","Bruno","Brunon","Calixte","Calliste","Camélien","Camille","Camillien","Candide","Caribert","Carloman","Cassandre","Cassien","Cédric","Céleste","Célestin","Célien","Césaire","César","Charles","Charlemagne","Childebert","Chilpéric","Chrétien","Christian","Christodule","Christophe","Chrysostome","Clarence","Claude","Claudien","Cléandre","Clément","Clotaire","Côme","Constance","Constant","Constantin","Corentin","Cyprien","Cyriaque","Cyrille","Cyril","Damien","Daniel","David","Delphin","Denis","Désiré","Didier","Dieudonné","Dimitri","Dominique","Dorian","Dorothée","Edgard","Edmond","Édouard","Éleuthère","Élie","Élisée","Émeric","Émile","Émilien","Emmanuel","Enguerrand","Épiphane","Éric","Esprit","Ernest","Étienne","Eubert","Eudes","Eudoxe","Eugène","Eusèbe","Eustache","Évariste","Évrard","Fabien","Fabrice","Falba","Félicité","Félix","Ferdinand","Fiacre","Fidèle","Firmin","Flavien","Flodoard","Florent","Florentin","Florestan","Florian","Fortuné","Foulques","Francisque","François","Français","Franciscus","Francs","Frédéric","Fulbert","Fulcran","Fulgence","Gabin","Gabriel","Gaël","Garnier","Gaston","Gaspard","Gatien","Gaud","Gautier","Gédéon","Geoffroy","Georges","Géraud","Gérard","Gerbert","Germain","Gervais","Ghislain","Gilbert","Gilles","Girart","Gislebert","Gondebaud","Gonthier","Gontran","Gonzague","Grégoire","Guérin","Gui","Guillaume","Gustave","Guy","Guyot","Hardouin","Hector","Hédelin","Hélier","Henri","Herbert","Herluin","Hervé","Hilaire","Hildebert","Hincmar","Hippolyte","Honoré","Hubert","Hugues","Innocent","Isabeau","Isidore","Jacques","Japhet","Jason","Jean","Jeannel","Jeannot","Jérémie","Jérôme","Joachim","Joanny","Job","Jocelyn","Joël","Johan","Jonas","Jonathan","Joseph","Josse","Josselin","Jourdain","Jude","Judicaël","Jules","Julien","Juste","Justin","Lambert","Landry","Laurent","Lazare","Léandre","Léon","Léonard","Léopold","Leu","Loup","Leufroy","Libère","Liétald","Lionel","Loïc","Longin","Lorrain","Lorraine","Lothaire","Louis","Loup","Luc","Lucas","Lucien","Ludolphe","Ludovic","Macaire","Malo","Mamert","Manassé","Marc","Marceau","Marcel","Marcelin","Marius","Marseille","Martial","Martin","Mathurin","Matthias","Mathias","Matthieu","Maugis","Maurice","Mauricet","Maxence","Maxime","Maximilien","Mayeul","Médéric","Melchior","Mence","Merlin","Mérovée","Michaël","Michel","Moïse","Morgan","Nathan","Nathanaël","Narcisse","Néhémie","Nestor","Nestor","Nicéphore","Nicolas","Noé","Noël","Norbert","Normand","Normands","Octave","Odilon","Odon","Oger","Olivier","Oury","Pacôme","Palémon","Parfait","Pascal","Paterne","Patrice","Paul","Pépin","Perceval","Philémon","Philibert","Philippe","Philothée","Pie","Pierre","Pierrick","Prosper","Quentin","Raoul","Raphaël","Raymond","Régis","Réjean","Rémi","Renaud","René","Reybaud","Richard","Robert","Roch","Rodolphe","Rodrigue","Roger","Roland","Romain","Romuald","Roméo","Rome","Ronan","Roselin","Salomon","Samuel","Savin","Savinien","Scholastique","Sébastien","Séraphin","Serge","Séverin","Sidoine","Sigebert","Sigismond","Silvère","Simon","Siméon","Sixte","Stanislas","Stéphane","Stephan","Sylvain","Sylvestre","Tancrède","Tanguy","Taurin","Théodore","Théodose","Théophile","Théophraste","Thibault","Thibert","Thierry","Thomas","Timoléon","Timothée","Titien","Tonnin","Toussaint","Trajan","Tristan","Turold","Tim","Ulysse","Urbain","Valentin","Valère","Valéry","Venance","Venant","Venceslas","Vianney","Victor","Victorien","Victorin","Vigile","Vincent","Vital","Vitalien","Vivien","Waleran","Wandrille","Xavier","Xénophon","Yves","Zacharie","Zaché","Zéphirin"]
},
"female": {
"en": ["Mary", "Emma", "Elizabeth", "Minnie", "Margaret", "Ida", "Alice", "Bertha", "Sarah", "Annie", "Clara", "Ella", "Florence", "Cora", "Martha", "Laura", "Nellie", "Grace", "Carrie", "Maude", "Mabel", "Bessie", "Jennie", "Gertrude", "Julia", "Hattie", "Edith", "Mattie", "Rose", "Catherine", "Lillian", "Ada", "Lillie", "Helen", "Jessie", "Louise", "Ethel", "Lula", "Myrtle", "Eva", "Frances", "Lena", "Lucy", "Edna", "Maggie", "Pearl", "Daisy", "Fannie", "Josephine", "Dora", "Rosa", "Katherine", "Agnes", "Marie", "Nora", "May", "Mamie", "Blanche", "Stella", "Ellen", "Nancy", "Effie", "Sallie", "Nettie", "Della", "Lizzie", "Flora", "Susie", "Maud", "Mae", "Etta", "Harriet", "Sadie", "Caroline", "Katie", "Lydia", "Elsie", "Kate", "Susan", "Mollie", "Alma", "Addie", "Georgia", "Eliza", "Lulu", "Nannie", "Lottie", "Amanda", "Belle", "Charlotte", "Rebecca", "Ruth", "Viola", "Olive", "Amelia", "Hannah", "Jane", "Virginia", "Emily", "Matilda", "Irene", "Kathryn", "Esther", "Willie", "Henrietta", "Ollie", "Amy", "Rachel", "Sara", "Estella", "Theresa", "Augusta", "Ora", "Pauline", "Josie", "Lola", "Sophia", "Leona", "Anne", "Mildred", "Ann", "Beulah", "Callie", "Lou", "Delia", "Eleanor", "Barbara", "Iva", "Louisa", "Maria", "Mayme", "Evelyn", "Estelle", "Nina", "Betty", "Marion", "Bettie", "Dorothy", "Luella", "Inez", "Lela", "Rosie", "Allie", "Millie", "Janie", "Cornelia", "Victoria", "Ruby", "Winifred", "Alta", "Celia", "Christine", "Beatrice", "Birdie", "Harriett", "Mable", "Myra", "Sophie", "Tillie", "Isabel", "Sylvia", "Carolyn", "Isabelle", "Leila", "Sally", "Ina", "Essie", "Bertie", "Nell", "Alberta", "Katharine", "Lora", "Rena", "Mina", "Rhoda", "Mathilda", "Abbie", "Eula", "Dollie", "Hettie", "Eunice", "Fanny", "Ola", "Lenora", "Adelaide", "Christina", "Lelia", "Nelle", "Sue", "Johanna", "Lilly", "Lucinda", "Minerva", "Lettie", "Roxie", "Cynthia", "Helena", "Hilda", "Hulda", "Bernice", "Genevieve", "Jean", "Cordelia", "Marian", "Francis", "Jeanette", "Adeline", "Gussie", "Leah", "Lois", "Lura", "Mittie", "Hallie", "Isabella", "Olga", "Phoebe", "Teresa", "Hester", "Lida", "Lina", "Winnie", "Claudia", "Marguerite", "Vera", "Cecelia", "Bess", "Emilie", "Rosetta", "Verna", "Myrtie", "Cecilia", "Elva", "Olivia", "Ophelia", "Georgie", "Elnora", "Violet", "Adele", "Lily", "Linnie", "Loretta", "Madge", "Polly", "Virgie", "Eugenia", "Lucile", "Lucille", "Mabelle", "Rosalie"],
// Data taken from http://www.dati.gov.it/dataset/comune-di-firenze_0162
"it": ["Ada", "Adriana", "Alessandra", "Alessia", "Alice", "Angela", "Anna", "Anna Maria", "Annalisa", "Annita", "Annunziata", "Antonella", "Arianna", "Asia", "Assunta", "Aurora", "Barbara", "Beatrice", "Benedetta", "Bianca", "Bruna", "Camilla", "Carla", "Carlotta", "Carmela", "Carolina", "Caterina", "Catia", "Cecilia", "Chiara", "Cinzia", "Clara", "Claudia", "Costanza", "Cristina", "Daniela", "Debora", "Diletta", "Dina", "Donatella", "Elena", "Eleonora", "Elisa", "Elisabetta", "Emanuela", "Emma", "Eva", "Federica", "Fernanda", "Fiorella", "Fiorenza", "Flora", "Franca", "Francesca", "Gabriella", "Gaia", "Gemma", "Giada", "Gianna", "Gina", "Ginevra", "Giorgia", "Giovanna", "Giulia", "Giuliana", "Giuseppa", "Giuseppina", "Grazia", "Graziella", "Greta", "Ida", "Ilaria", "Ines", "Iolanda", "Irene", "Irma", "Isabella", "Jessica", "Laura", "Lea", "Letizia", "Licia", "Lidia", "Liliana", "Lina", "Linda", "Lisa", "Livia", "Loretta", "Luana", "Lucia", "Luciana", "Lucrezia", "Luisa", "Manuela", "Mara", "Marcella", "Margherita", "Maria", "Maria Cristina", "Maria Grazia", "Maria Luisa", "Maria Pia", "Maria Teresa", "Marina", "Marisa", "Marta", "Martina", "Marzia", "Matilde", "Melissa", "Michela", "Milena", "Mirella", "Monica", "Natalina", "Nella", "Nicoletta", "Noemi", "Olga", "Paola", "Patrizia", "Piera", "Pierina", "Raffaella", "Rebecca", "Renata", "Rina", "Rita", "Roberta", "Rosa", "Rosanna", "Rossana", "Rossella", "Sabrina", "Sandra", "Sara", "Serena", "Silvana", "Silvia", "Simona", "Simonetta", "Sofia", "Sonia", "Stefania", "Susanna", "Teresa", "Tina", "Tiziana", "Tosca", "Valentina", "Valeria", "Vanda", "Vanessa", "Vanna", "Vera", "Veronica", "Vilma", "Viola", "Virginia", "Vittoria"],
// Data taken from http://www.svbkindernamen.nl/int/nl/kindernamen/index.html
"nl": ["Ada", "Arianne", "Afke", "Amanda", "Amber", "Amy", "Aniek", "Anita", "Anja", "Anna", "Anne", "Annelies", "Annemarie", "Annette", "Anouk", "Astrid", "Aukje", "Barbara", "Bianca", "Carla", "Carlijn", "Carolien", "Chantal", "Charlotte", "Claudia", "Daniëlle", "Debora", "Diane", "Dora", "Eline", "Elise", "Ella", "Ellen", "Emma", "Esmee", "Evelien", "Esther", "Erica", "Eva", "Femke", "Fleur", "Floor", "Froukje", "Gea", "Gerda", "Hanna", "Hanneke", "Heleen", "Hilde", "Ilona", "Ina", "Inge", "Ingrid", "Iris", "Isabel", "Isabelle", "Janneke", "Jasmijn", "Jeanine", "Jennifer", "Jessica", "Johanna", "Joke", "Julia", "Julie", "Karen", "Karin", "Katja", "Kim", "Lara", "Laura", "Lena", "Lianne", "Lieke", "Lilian", "Linda", "Lisa", "Lisanne", "Lotte", "Louise", "Maaike", "Manon", "Marga", "Maria", "Marissa", "Marit", "Marjolein", "Martine", "Marleen", "Melissa", "Merel", "Miranda", "Michelle", "Mirjam", "Mirthe", "Naomi", "Natalie", 'Nienke', "Nina", "Noortje", "Olivia", "Patricia", "Paula", "Paulien", "Ramona", "Ria", "Rianne", "Roos", "Rosanne", "Ruth", "Sabrina", "Sandra", "Sanne", "Sara", "Saskia", "Silvia", "Sofia", "Sophie", "Sonja", "Suzanne", "Tamara", "Tess", "Tessa", "Tineke", "Valerie", "Vanessa", "Veerle", "Vera", "Victoria", "Wendy", "Willeke", "Yvonne", "Zoë"],
// Data taken from https://fr.wikipedia.org/wiki/Liste_de_pr%C3%A9noms_fran%C3%A7ais_et_de_la_francophonie
"fr": ["Abdon","Abel","Abigaëlle","Abigaïl","Acacius","Acanthe","Adalbert","Adalsinde","Adegrine","Adélaïde","Adèle","Adélie","Adeline","Adeltrude","Adolphe","Adonis","Adrastée","Adrehilde","Adrienne","Agathe","Agilbert","Aglaé","Aignan","Agneflète","Agnès","Agrippine","Aimé","Alaine","Alaïs","Albane","Albérade","Alberte","Alcide","Alcine","Alcyone","Aldegonde","Aleth","Alexandrine","Alexine","Alice","Aliénor","Aliette","Aline","Alix","Alizé","Aloïse","Aloyse","Alphonsine","Althée","Amaliane","Amalthée","Amande","Amandine","Amant","Amarande","Amaranthe","Amaryllis","Ambre","Ambroisie","Amélie","Améthyste","Aminte","Anaël","Anaïs","Anastasie","Anatole","Ancelin","Andrée","Anémone","Angadrême","Angèle","Angeline","Angélique","Angilbert","Anicet","Annabelle","Anne","Annette","Annick","Annie","Annonciade","Ansbert","Anstrudie","Anthelme","Antigone","Antoinette","Antonine","Aphélie","Apolline","Apollonie","Aquiline","Arabelle","Arcadie","Archange","Argine","Ariane","Aricie","Ariel","Arielle","Arlette","Armance","Armande","Armandine","Armelle","Armide","Armelle","Armin","Arnaud","Arsène","Arsinoé","Artémis","Arthur","Ascelin","Ascension","Assomption","Astarté","Astérie","Astrée","Astrid","Athalie","Athanasie","Athina","Aube","Albert","Aude","Audrey","Augustine","Aure","Aurélie","Aurélien","Aurèle","Aurore","Auxence","Aveline","Abigaëlle","Avoye","Axelle","Aymard","Azalée","Adèle","Adeline","Barbe","Basilisse","Bathilde","Béatrice","Béatrix","Bénédicte","Bérengère","Bernadette","Berthe","Bertille","Beuve","Blanche","Blanc","Blandine","Brigitte","Brune","Brunehilde","Callista","Camille","Capucine","Carine","Caroline","Cassandre","Catherine","Cécile","Céleste","Célestine","Céline","Chantal","Charlène","Charline","Charlotte","Chloé","Christelle","Christiane","Christine","Claire","Clara","Claude","Claudine","Clarisse","Clémence","Clémentine","Cléo","Clio","Clotilde","Coline","Conception","Constance","Coralie","Coraline","Corentine","Corinne","Cyrielle","Daniel","Daniel","Daphné","Débora","Delphine","Denise","Diane","Dieudonné","Dominique","Doriane","Dorothée","Douce","Édith","Edmée","Éléonore","Éliane","Élia","Éliette","Élisabeth","Élise","Ella","Élodie","Éloïse","Elsa","Émeline","Émérance","Émérentienne","Émérencie","Émilie","Emma","Emmanuelle","Emmelie","Ernestine","Esther","Estelle","Eudoxie","Eugénie","Eulalie","Euphrasie","Eusébie","Évangéline","Eva","Ève","Évelyne","Fanny","Fantine","Faustine","Félicie","Fernande","Flavie","Fleur","Flore","Florence","Florie","Fortuné","France","Francia","Françoise","Francine","Gabrielle","Gaëlle","Garance","Geneviève","Georgette","Gerberge","Germaine","Gertrude","Gisèle","Guenièvre","Guilhemine","Guillemette","Gustave","Gwenael","Hélène","Héloïse","Henriette","Hermine","Hermione","Hippolyte","Honorine","Hortense","Huguette","Ines","Irène","Irina","Iris","Isabeau","Isabelle","Iseult","Isolde","Ismérie","Jacinthe","Jacqueline","Jade","Janine","Jeanne","Jocelyne","Joëlle","Joséphine","Judith","Julia","Julie","Jules","Juliette","Justine","Katy","Kathy","Katie","Laura","Laure","Laureline","Laurence","Laurene","Lauriane","Laurianne","Laurine","Léa","Léna","Léonie","Léon","Léontine","Lorraine","Lucie","Lucienne","Lucille","Ludivine","Lydie","Lydie","Megane","Madeleine","Magali","Maguelone","Mallaury","Manon","Marceline","Margot","Marguerite","Marianne","Marie","Myriam","Marie","Marine","Marion","Marlène","Marthe","Martine","Mathilde","Maud","Maureen","Mauricette","Maxime","Mélanie","Melissa","Mélissandre","Mélisande","Mélodie","Michel","Micheline","Mireille","Miriam","Moïse","Monique","Morgane","Muriel","Mylène","Nadège","Nadine","Nathalie","Nicole","Nicolette","Nine","Noël","Noémie","Océane","Odette","Odile","Olive","Olivia","Olympe","Ombline","Ombeline","Ophélie","Oriande","Oriane","Ozanne","Pascale","Pascaline","Paule","Paulette","Pauline","Priscille","Prisca","Prisque","Pécine","Pélagie","Pénélope","Perrine","Pétronille","Philippine","Philomène","Philothée","Primerose","Prudence","Pulchérie","Quentine","Quiéta","Quintia","Quintilla","Rachel","Raphaëlle","Raymonde","Rebecca","Régine","Réjeanne","René","Rita","Rita","Rolande","Romane","Rosalie","Rose","Roseline","Sabine","Salomé","Sandra","Sandrine","Sarah","Ségolène","Séverine","Sibylle","Simone","Sixt","Solange","Soline","Solène","Sophie","Stéphanie","Suzanne","Sylvain","Sylvie","Tatiana","Thaïs","Théodora","Thérèse","Tiphaine","Ursule","Valentine","Valérie","Véronique","Victoire","Victorine","Vinciane","Violette","Virginie","Viviane","Xavière","Yolande","Ysaline","Yvette","Yvonne","Zélie","Zita","Zoé"]
}
},
lastNames: {
"en": ['Smith', 'Johnson', 'Williams', 'Jones', 'Brown', 'Davis', 'Miller', 'Wilson', 'Moore', 'Taylor', 'Anderson', 'Thomas', 'Jackson', 'White', 'Harris', 'Martin', 'Thompson', 'Garcia', 'Martinez', 'Robinson', 'Clark', 'Rodriguez', 'Lewis', 'Lee', 'Walker', 'Hall', 'Allen', 'Young', 'Hernandez', 'King', 'Wright', 'Lopez', 'Hill', 'Scott', 'Green', 'Adams', 'Baker', 'Gonzalez', 'Nelson', 'Carter', 'Mitchell', 'Perez', 'Roberts', 'Turner', 'Phillips', 'Campbell', 'Parker', 'Evans', 'Edwards', 'Collins', 'Stewart', 'Sanchez', 'Morris', 'Rogers', 'Reed', 'Cook', 'Morgan', 'Bell', 'Murphy', 'Bailey', 'Rivera', 'Cooper', 'Richardson', 'Cox', 'Howard', 'Ward', 'Torres', 'Peterson', 'Gray', 'Ramirez', 'James', 'Watson', 'Brooks', 'Kelly', 'Sanders', 'Price', 'Bennett', 'Wood', 'Barnes', 'Ross', 'Henderson', 'Coleman', 'Jenkins', 'Perry', 'Powell', 'Long', 'Patterson', 'Hughes', 'Flores', 'Washington', 'Butler', 'Simmons', 'Foster', 'Gonzales', 'Bryant', 'Alexander', 'Russell', 'Griffin', 'Diaz', 'Hayes', 'Myers', 'Ford', 'Hamilton', 'Graham', 'Sullivan', 'Wallace', 'Woods', 'Cole', 'West', 'Jordan', 'Owens', 'Reynolds', 'Fisher', 'Ellis', 'Harrison', 'Gibson', 'McDonald', 'Cruz', 'Marshall', 'Ortiz', 'Gomez', 'Murray', 'Freeman', 'Wells', 'Webb', 'Simpson', 'Stevens', 'Tucker', 'Porter', 'Hunter', 'Hicks', 'Crawford', 'Henry', 'Boyd', 'Mason', 'Morales', 'Kennedy', 'Warren', 'Dixon', 'Ramos', 'Reyes', 'Burns', 'Gordon', 'Shaw', 'Holmes', 'Rice', 'Robertson', 'Hunt', 'Black', 'Daniels', 'Palmer', 'Mills', 'Nichols', 'Grant', 'Knight', 'Ferguson', 'Rose', 'Stone', 'Hawkins', 'Dunn', 'Perkins', 'Hudson', 'Spencer', 'Gardner', 'Stephens', 'Payne', 'Pierce', 'Berry', 'Matthews', 'Arnold', 'Wagner', 'Willis', 'Ray', 'Watkins', 'Olson', 'Carroll', 'Duncan', 'Snyder', 'Hart', 'Cunningham', 'Bradley', 'Lane', 'Andrews', 'Ruiz', 'Harper', 'Fox', 'Riley', 'Armstrong', 'Carpenter', 'Weaver', 'Greene', 'Lawrence', 'Elliott', 'Chavez', 'Sims', 'Austin', 'Peters', 'Kelley', 'Franklin', 'Lawson', 'Fields', 'Gutierrez', 'Ryan', 'Schmidt', 'Carr', 'Vasquez', 'Castillo', 'Wheeler', 'Chapman', 'Oliver', 'Montgomery', 'Richards', 'Williamson', 'Johnston', 'Banks', 'Meyer', 'Bishop', 'McCoy', 'Howell', 'Alvarez', 'Morrison', 'Hansen', 'Fernandez', 'Garza', 'Harvey', 'Little', 'Burton', 'Stanley', 'Nguyen', 'George', 'Jacobs', 'Reid', 'Kim', 'Fuller', 'Lynch', 'Dean', 'Gilbert', 'Garrett', 'Romero', 'Welch', 'Larson', 'Frazier', 'Burke', 'Hanson', 'Day', 'Mendoza', 'Moreno', 'Bowman', 'Medina', 'Fowler', 'Brewer', 'Hoffman', 'Carlson', 'Silva', 'Pearson', 'Holland', 'Douglas', 'Fleming', 'Jensen', 'Vargas', 'Byrd', 'Davidson', 'Hopkins', 'May', 'Terry', 'Herrera', 'Wade', 'Soto', 'Walters', 'Curtis', 'Neal', 'Caldwell', 'Lowe', 'Jennings', 'Barnett', 'Graves', 'Jimenez', 'Horton', 'Shelton', 'Barrett', 'Obrien', 'Castro', 'Sutton', 'Gregory', 'McKinney', 'Lucas', 'Miles', 'Craig', 'Rodriquez', 'Chambers', 'Holt', 'Lambert', 'Fletcher', 'Watts', 'Bates', 'Hale', 'Rhodes', 'Pena', 'Beck', 'Newman', 'Haynes', 'McDaniel', 'Mendez', 'Bush', 'Vaughn', 'Parks', 'Dawson', 'Santiago', 'Norris', 'Hardy', 'Love', 'Steele', 'Curry', 'Powers', 'Schultz', 'Barker', 'Guzman', 'Page', 'Munoz', 'Ball', 'Keller', 'Chandler', 'Weber', 'Leonard', 'Walsh', 'Lyons', 'Ramsey', 'Wolfe', 'Schneider', 'Mullins', 'Benson', 'Sharp', 'Bowen', 'Daniel', 'Barber', 'Cummings', 'Hines', 'Baldwin', 'Griffith', 'Valdez', 'Hubbard', 'Salazar', 'Reeves', 'Warner', 'Stevenson', 'Burgess', 'Santos', 'Tate', 'Cross', 'Garner', 'Mann', 'Mack', 'Moss', 'Thornton', 'Dennis', 'McGee', 'Farmer', 'Delgado', 'Aguilar', 'Vega', 'Glover', 'Manning', 'Cohen', 'Harmon', 'Rodgers', 'Robbins', 'Newton', 'Todd', 'Blair', 'Higgins', 'Ingram', 'Reese', 'Cannon', 'Strickland', 'Townsend', 'Potter', 'Goodwin', 'Walton', 'Rowe', 'Hampton', 'Ortega', 'Patton', 'Swanson', 'Joseph', 'Francis', 'Goodman', 'Maldonado', 'Yates', 'Becker', 'Erickson', 'Hodges', 'Rios', 'Conner', 'Adkins', 'Webster', 'Norman', 'Malone', 'Hammond', 'Flowers', 'Cobb', 'Moody', 'Quinn', 'Blake', 'Maxwell', 'Pope', 'Floyd', 'Osborne', 'Paul', 'McCarthy', 'Guerrero', 'Lindsey', 'Estrada', 'Sandoval', 'Gibbs', 'Tyler', 'Gross', 'Fitzgerald', 'Stokes', 'Doyle', 'Sherman', 'Saunders', 'Wise', 'Colon', 'Gill', 'Alvarado', 'Greer', 'Padilla', 'Simon', 'Waters', 'Nunez', 'Ballard', 'Schwartz', 'McBride', 'Houston', 'Christensen', 'Klein', 'Pratt', 'Briggs', 'Parsons', 'McLaughlin', 'Zimmerman', 'French', 'Buchanan', 'Moran', 'Copeland', 'Roy', 'Pittman', 'Brady', 'McCormick', 'Holloway', 'Brock', 'Poole', 'Frank', 'Logan', 'Owen', 'Bass', 'Marsh', 'Drake', 'Wong', 'Jefferson', 'Park', 'Morton', 'Abbott', 'Sparks', 'Patrick', 'Norton', 'Huff', 'Clayton', 'Massey', 'Lloyd', 'Figueroa', 'Carson', 'Bowers', 'Roberson', 'Barton', 'Tran', 'Lamb', 'Harrington', 'Casey', 'Boone', 'Cortez', 'Clarke', 'Mathis', 'Singleton', 'Wilkins', 'Cain', 'Bryan', 'Underwood', 'Hogan', 'McKenzie', 'Collier', 'Luna', 'Phelps', 'McGuire', 'Allison', 'Bridges', 'Wilkerson', 'Nash', 'Summers', 'Atkins'],
// Data taken from http://www.dati.gov.it/dataset/comune-di-firenze_0164 (first 1000)
"it": ["Acciai", "Aglietti", "Agostini", "Agresti", "Ahmed", "Aiazzi", "Albanese", "Alberti", "Alessi", "Alfani", "Alinari", "Alterini", "Amato", "Ammannati", "Ancillotti", "Andrei", "Andreini", "Andreoni", "Angeli", "Anichini", "Antonelli", "Antonini", "Arena", "Ariani", "Arnetoli", "Arrighi", "Baccani", "Baccetti", "Bacci", "Bacherini", "Badii", "Baggiani", "Baglioni", "Bagni", "Bagnoli", "Baldassini", "Baldi", "Baldini", "Ballerini", "Balli", "Ballini", "Balloni", "Bambi", "Banchi", "Bandinelli", "Bandini", "Bani", "Barbetti", "Barbieri", "Barchielli", "Bardazzi", "Bardelli", "Bardi", "Barducci", "Bargellini", "Bargiacchi", "Barni", "Baroncelli", "Baroncini", "Barone", "Baroni", "Baronti", "Bartalesi", "Bartoletti", "Bartoli", "Bartolini", "Bartoloni", "Bartolozzi", "Basagni", "Basile", "Bassi", "Batacchi", "Battaglia", "Battaglini", "Bausi", "Becagli", "Becattini", "Becchi", "Becucci", "Bellandi", "Bellesi", "Belli", "Bellini", "Bellucci", "Bencini", "Benedetti", "Benelli", "Beni", "Benini", "Bensi", "Benucci", "Benvenuti", "Berlincioni", "Bernacchioni", "Bernardi", "Bernardini", "Berni", "Bernini", "Bertelli", "Berti", "Bertini", "Bessi", "Betti", "Bettini", "Biagi", "Biagini", "Biagioni", "Biagiotti", "Biancalani", "Bianchi", "Bianchini", "Bianco", "Biffoli", "Bigazzi", "Bigi", "Biliotti", "Billi", "Binazzi", "Bindi", "Bini", "Biondi", "Bizzarri", "Bocci", "Bogani", "Bolognesi", "Bonaiuti", "Bonanni", "Bonciani", "Boncinelli", "Bondi", "Bonechi", "Bongini", "Boni", "Bonini", "Borchi", "Boretti", "Borghi", "Borghini", "Borgioli", "Borri", "Borselli", "Boschi", "Bottai", "Bracci", "Braccini", "Brandi", "Braschi", "Bravi", "Brazzini", "Breschi", "Brilli", "Brizzi", "Brogelli", "Brogi", "Brogioni", "Brunelli", "Brunetti", "Bruni", "Bruno", "Brunori", "Bruschi", "Bucci", "Bucciarelli", "Buccioni", "Bucelli", "Bulli", "Burberi", "Burchi", "Burgassi", "Burroni", "Bussotti", "Buti", "Caciolli", "Caiani", "Calabrese", "Calamai", "Calamandrei", "Caldini", "Calo'", "Calonaci", "Calosi", "Calvelli", "Cambi", "Camiciottoli", "Cammelli", "Cammilli", "Campolmi", "Cantini", "Capanni", "Capecchi", "Caponi", "Cappelletti", "Cappelli", "Cappellini", "Cappugi", "Capretti", "Caputo", "Carbone", "Carboni", "Cardini", "Carlesi", "Carletti", "Carli", "Caroti", "Carotti", "Carrai", "Carraresi", "Carta", "Caruso", "Casalini", "Casati", "Caselli", "Casini", "Castagnoli", "Castellani", "Castelli", "Castellucci", "Catalano", "Catarzi", "Catelani", "Cavaciocchi", "Cavallaro", "Cavallini", "Cavicchi", "Cavini", "Ceccarelli", "Ceccatelli", "Ceccherelli", "Ceccherini", "Cecchi", "Cecchini", "Cecconi", "Cei", "Cellai", "Celli", "Cellini", "Cencetti", "Ceni", "Cenni", "Cerbai", "Cesari", "Ceseri", "Checcacci", "Checchi", "Checcucci", "Cheli", "Chellini", "Chen", "Cheng", "Cherici", "Cherubini", "Chiaramonti", "Chiarantini", "Chiarelli", "Chiari", "Chiarini", "Chiarugi", "Chiavacci", "Chiesi", "Chimenti", "Chini", "Chirici", "Chiti", "Ciabatti", "Ciampi", "Cianchi", "Cianfanelli", "Cianferoni", "Ciani", "Ciapetti", "Ciappi", "Ciardi", "Ciatti", "Cicali", "Ciccone", "Cinelli", "Cini", "Ciobanu", "Ciolli", "Cioni", "Cipriani", "Cirillo", "Cirri", "Ciucchi", "Ciuffi", "Ciulli", "Ciullini", "Clemente", "Cocchi", "Cognome", "Coli", "Collini", "Colombo", "Colzi", "Comparini", "Conforti", "Consigli", "Conte", "Conti", "Contini", "Coppini", "Coppola", "Corsi", "Corsini", "Corti", "Cortini", "Cosi", "Costa", "Costantini", "Costantino", "Cozzi", "Cresci", "Crescioli", "Cresti", "Crini", "Curradi", "D'Agostino", "D'Alessandro", "D'Amico", "D'Angelo", "Daddi", "Dainelli", "Dallai", "Danti", "Davitti", "De Angelis", "De Luca", "De Marco", "De Rosa", "De Santis", "De Simone", "De Vita", "Degl'Innocenti", "Degli Innocenti", "Dei", "Del Lungo", "Del Re", "Di Marco", "Di Stefano", "Dini", "Diop", "Dobre", "Dolfi", "Donati", "Dondoli", "Dong", "Donnini", "Ducci", "Dumitru", "Ermini", "Esposito", "Evangelisti", "Fabbri", "Fabbrini", "Fabbrizzi", "Fabbroni", "Fabbrucci", "Fabiani", "Facchini", "Faggi", "Fagioli", "Failli", "Faini", "Falciani", "Falcini", "Falcone", "Fallani", "Falorni", "Falsini", "Falugiani", "Fancelli", "Fanelli", "Fanetti", "Fanfani", "Fani", "Fantappie'", "Fantechi", "Fanti", "Fantini", "Fantoni", "Farina", "Fattori", "Favilli", "Fedi", "Fei", "Ferrante", "Ferrara", "Ferrari", "Ferraro", "Ferretti", "Ferri", "Ferrini", "Ferroni", "Fiaschi", "Fibbi", "Fiesoli", "Filippi", "Filippini", "Fini", "Fioravanti", "Fiore", "Fiorentini", "Fiorini", "Fissi", "Focardi", "Foggi", "Fontana", "Fontanelli", "Fontani", "Forconi", "Formigli", "Forte", "Forti", "Fortini", "Fossati", "Fossi", "Francalanci", "Franceschi", "Franceschini", "Franchi", "Franchini", "Franci", "Francini", "Francioni", "Franco", "Frassineti", "Frati", "Fratini", "Frilli", "Frizzi", "Frosali", "Frosini", "Frullini", "Fusco", "Fusi", "Gabbrielli", "Gabellini", "Gagliardi", "Galanti", "Galardi", "Galeotti", "Galletti", "Galli", "Gallo", "Gallori", "Gambacciani", "Gargani", "Garofalo", "Garuglieri", "Gashi", "Gasperini", "Gatti", "Gelli", "Gensini", "Gentile", "Gentili", "Geri", "Gerini", "Gheri", "Ghini", "Giachetti", "Giachi", "Giacomelli", "Gianassi", "Giani", "Giannelli", "Giannetti", "Gianni", "Giannini", "Giannoni", "Giannotti", "Giannozzi", "Gigli", "Giordano", "Giorgetti", "Giorgi", "Giovacchini", "Giovannelli", "Giovannetti", "Giovannini", "Giovannoni", "Giuliani", "Giunti", "Giuntini", "Giusti", "Gonnelli", "Goretti", "Gori", "Gradi", "Gramigni", "Grassi", "Grasso", "Graziani", "Grazzini", "Greco", "Grifoni", "Grillo", "Grimaldi", "Grossi", "Gualtieri", "Guarducci", "Guarino", "Guarnieri", "Guasti", "Guerra", "Guerri", "Guerrini", "Guidi", "Guidotti", "He", "Hoxha", "Hu", "Huang", "Iandelli", "Ignesti", "Innocenti", "Jin", "La Rosa", "Lai", "Landi", "Landini", "Lanini", "Lapi", "Lapini", "Lari", "Lascialfari", "Lastrucci", "Latini", "Lazzeri", "Lazzerini", "Lelli", "Lenzi", "Leonardi", "Leoncini", "Leone", "Leoni", "Lepri", "Li", "Liao", "Lin", "Linari", "Lippi", "Lisi", "Livi", "Lombardi", "Lombardini", "Lombardo", "Longo", "Lopez", "Lorenzi", "Lorenzini", "Lorini", "Lotti", "Lu", "Lucchesi", "Lucherini", "Lunghi", "Lupi", "Madiai", "Maestrini", "Maffei", "Maggi", "Maggini", "Magherini", "Magini", "Magnani", "Magnelli", "Magni", "Magnolfi", "Magrini", "Malavolti", "Malevolti", "Manca", "Mancini", "Manetti", "Manfredi", "Mangani", "Mannelli", "Manni", "Mannini", "Mannucci", "Manuelli", "Manzini", "Marcelli", "Marchese", "Marchetti", "Marchi", "Marchiani", "Marchionni", "Marconi", "Marcucci", "Margheri", "Mari", "Mariani", "Marilli", "Marinai", "Marinari", "Marinelli", "Marini", "Marino", "Mariotti", "Marsili", "Martelli", "Martinelli", "Martini", "Martino", "Marzi", "Masi", "Masini", "Masoni", "Massai", "Materassi", "Mattei", "Matteini", "Matteucci", "Matteuzzi", "Mattioli", "Mattolini", "Matucci", "Mauro", "Mazzanti", "Mazzei", "Mazzetti", "Mazzi", "Mazzini", "Mazzocchi", "Mazzoli", "Mazzoni", "Mazzuoli", "Meacci", "Mecocci", "Meini", "Melani", "Mele", "Meli", "Mengoni", "Menichetti", "Meoni", "Merlini", "Messeri", "Messina", "Meucci", "Miccinesi", "Miceli", "Micheli", "Michelini", "Michelozzi", "Migliori", "Migliorini", "Milani", "Miniati", "Misuri", "Monaco", "Montagnani", "Montagni", "Montanari", "Montelatici", "Monti", "Montigiani", "Montini", "Morandi", "Morandini", "Morelli", "Moretti", "Morganti", "Mori", "Morini", "Moroni", "Morozzi", "Mugnai", "Mugnaini", "Mustafa", "Naldi", "Naldini", "Nannelli", "Nanni", "Nannini", "Nannucci", "Nardi", "Nardini", "Nardoni", "Natali", "Ndiaye", "Nencetti", "Nencini", "Nencioni", "Neri", "Nesi", "Nesti", "Niccolai", "Niccoli", "Niccolini", "Nigi", "Nistri", "Nocentini", "Noferini", "Novelli", "Nucci", "Nuti", "Nutini", "Oliva", "Olivieri", "Olmi", "Orlandi", "Orlandini", "Orlando", "Orsini", "Ortolani", "Ottanelli", "Pacciani", "Pace", "Paci", "Pacini", "Pagani", "Pagano", "Paggetti", "Pagliai", "Pagni", "Pagnini", "Paladini", "Palagi", "Palchetti", "Palloni", "Palmieri", "Palumbo", "Pampaloni", "Pancani", "Pandolfi", "Pandolfini", "Panerai", "Panichi", "Paoletti", "Paoli", "Paolini", "Papi", "Papini", "Papucci", "Parenti", "Parigi", "Parisi", "Parri", "Parrini", "Pasquini", "Passeri", "Pecchioli", "Pecorini", "Pellegrini", "Pepi", "Perini", "Perrone", "Peruzzi", "Pesci", "Pestelli", "Petri", "Petrini", "Petrucci", "Pettini", "Pezzati", "Pezzatini", "Piani", "Piazza", "Piazzesi", "Piazzini", "Piccardi", "Picchi", "Piccini", "Piccioli", "Pieraccini", "Pieraccioni", "Pieralli", "Pierattini", "Pieri", "Pierini", "Pieroni", "Pietrini", "Pini", "Pinna", "Pinto", "Pinzani", "Pinzauti", "Piras", "Pisani", "Pistolesi", "Poggesi", "Poggi", "Poggiali", "Poggiolini", "Poli", "Pollastri", "Porciani", "Pozzi", "Pratellesi", "Pratesi", "Prosperi", "Pruneti", "Pucci", "Puccini", "Puccioni", "Pugi", "Pugliese", "Puliti", "Querci", "Quercioli", "Raddi", "Radu", "Raffaelli", "Ragazzini", "Ranfagni", "Ranieri", "Rastrelli", "Raugei", "Raveggi", "Renai", "Renzi", "Rettori", "Ricci", "Ricciardi", "Ridi", "Ridolfi", "Rigacci", "Righi", "Righini", "Rinaldi", "Risaliti", "Ristori", "Rizzo", "Rocchi", "Rocchini", "Rogai", "Romagnoli", "Romanelli", "Romani", "Romano", "Romei", "Romeo", "Romiti", "Romoli", "Romolini", "Rontini", "Rosati", "Roselli", "Rosi", "Rossetti", "Rossi", "Rossini", "Rovai", "Ruggeri", "Ruggiero", "Russo", "Sabatini", "Saccardi", "Sacchetti", "Sacchi", "Sacco", "Salerno", "Salimbeni", "Salucci", "Salvadori", "Salvestrini", "Salvi", "Salvini", "Sanesi", "Sani", "Sanna", "Santi", "Santini", "Santoni", "Santoro", "Santucci", "Sardi", "Sarri", "Sarti", "Sassi", "Sbolci", "Scali", "Scarpelli", "Scarselli", "Scopetani", "Secci", "Selvi", "Senatori", "Senesi", "Serafini", "Sereni", "Serra", "Sestini", "Sguanci", "Sieni", "Signorini", "Silvestri", "Simoncini", "Simonetti", "Simoni", "Singh", "Sodi", "Soldi", "Somigli", "Sorbi", "Sorelli", "Sorrentino", "Sottili", "Spina", "Spinelli", "Staccioli", "Staderini", "Stefanelli", "Stefani", "Stefanini", "Stella", "Susini", "Tacchi", "Tacconi", "Taddei", "Tagliaferri", "Tamburini", "Tanganelli", "Tani", "Tanini", "Tapinassi", "Tarchi", "Tarchiani", "Targioni", "Tassi", "Tassini", "Tempesti", "Terzani", "Tesi", "Testa", "Testi", "Tilli", "Tinti", "Tirinnanzi", "Toccafondi", "Tofanari", "Tofani", "Tognaccini", "Tonelli", "Tonini", "Torelli", "Torrini", "Tosi", "Toti", "Tozzi", "Trambusti", "Trapani", "Tucci", "Turchi", "Ugolini", "Ulivi", "Valente", "Valenti", "Valentini", "Vangelisti", "Vanni", "Vannini", "Vannoni", "Vannozzi", "Vannucchi", "Vannucci", "Ventura", "Venturi", "Venturini", "Vestri", "Vettori", "Vichi", "Viciani", "Vieri", "Vigiani", "Vignoli", "Vignolini", "Vignozzi", "Villani", "Vinci", "Visani", "Vitale", "Vitali", "Viti", "Viviani", "Vivoli", "Volpe", "Volpi", "Wang", "Wu", "Xu", "Yang", "Ye", "Zagli", "Zani", "Zanieri", "Zanobini", "Zecchi", "Zetti", "Zhang", "Zheng", "Zhou", "Zhu", "Zingoni", "Zini", "Zoppi"],
// http://www.voornamelijk.nl/meest-voorkomende-achternamen-in-nederland-en-amsterdam/
"nl":["Albers", "Alblas", "Appelman", "Baars", "Baas", "Bakker", "Blank", "Bleeker", "Blok", "Blom", "Boer", "Boers", "Boldewijn", "Boon", "Boot", "Bos", "Bosch", "Bosma", "Bosman", "Bouma", "Bouman", "Bouwman", "Brands", "Brouwer", "Burger", "Buijs", "Buitenhuis", "Ceder", "Cohen", "Dekker", "Dekkers", "Dijkman", "Dijkstra", "Driessen", "Drost", "Engel", "Evers", "Faber", "Franke", "Gerritsen", "Goedhart", "Goossens", "Groen", "Groenenberg", "Groot", "Haan", "Hart", "Heemskerk", "Hendriks", "Hermans", "Hoekstra", "Hofman", "Hopman", "Huisman", "Jacobs", "Jansen", "Janssen", "Jonker", "Jaspers", "Keijzer", "Klaassen", "Klein", "Koek", "Koenders", "Kok", "Kool", "Koopman", "Koopmans", "Koning", "Koster", "Kramer", "Kroon", "Kuijpers", "Kuiper", "Kuipers", "Kurt", "Koster", "Kwakman", "Los", "Lubbers", "Maas", "Markus", "Martens", "Meijer", "Mol", "Molenaar", "Mulder", "Nieuwenhuis", "Peeters", "Peters", "Pengel", "Pieters", "Pool", "Post", "Postma", "Prins", "Pronk", "Reijnders", "Rietveld", "Roest", "Roos", "Sanders", "Schaap", "Scheffer", "Schenk", "Schilder", "Schipper", "Schmidt", "Scholten", "Schouten", "Schut", "Schutte", "Schuurman", "Simons", "Smeets", "Smit", "Smits", "Snel", "Swinkels", "Tas", "Terpstra", "Timmermans", "Tol", "Tromp", "Troost", "Valk", "Veenstra", "Veldkamp", "Verbeek", "Verheul", "Verhoeven", "Vermeer", "Vermeulen", "Verweij", "Vink", "Visser", "Voorn", "Vos", "Wagenaar", "Wiersema", "Willems", "Willemsen", "Witteveen", "Wolff", "Wolters", "Zijlstra", "Zwart", "de Beer", "de Boer", "de Bruijn", "de Bruin", "de Graaf", "de Groot", "de Haan", "de Haas", "de Jager", "de Jong", "de Jonge", "de Koning", "de Lange", "de Leeuw", "de Ridder", "de Rooij", "de Ruiter", "de Vos", "de Vries", "de Waal", "de Wit", "de Zwart", "van Beek", "van Boven", "van Dam", "van Dijk", "van Dongen", "van Doorn", "van Egmond", "van Eijk", "van Es", "van Gelder", "van Gelderen", "van Houten", "van Hulst", "van Kempen", "van Kesteren", "van Leeuwen", "van Loon", "van Mill", "van Noord", "van Ommen", "van Ommeren", "van Oosten", "van Oostveen", "van Rijn", "van Schaik", "van Veen", "van Vliet", "van Wijk", "van Wijngaarden", "van den Poel", "van de Pol", "van den Ploeg", "van de Ven", "van den Berg", "van den Bosch", "van den Brink", "van den Broek", "van den Heuvel", "van der Heijden", "van der Horst", "van der Hulst", "van der Kroon", "van der Laan", "van der Linden", "van der Meer", "van der Meij", "van der Meulen", "van der Molen", "van der Sluis", "van der Spek", "van der Veen", "van der Velde", "van der Velden", "van der Vliet", "van der Wal"],
// https://surnames.behindthename.com/top/lists/england-wales/1991
"uk":["Smith","Jones","Williams","Taylor","Brown","Davies","Evans","Wilson","Thomas","Johnson","Roberts","Robinson","Thompson","Wright","Walker","White","Edwards","Hughes","Green","Hall","Lewis","Harris","Clarke","Patel","Jackson","Wood","Turner","Martin","Cooper","Hill","Ward","Morris","Moore","Clark","Lee","King","Baker","Harrison","Morgan","Allen","James","Scott","Phillips","Watson","Davis","Parker","Price","Bennett","Young","Griffiths","Mitchell","Kelly","Cook","Carter","Richardson","Bailey","Collins","Bell","Shaw","Murphy","Miller","Cox","Richards","Khan","Marshall","Anderson","Simpson","Ellis","Adams","Singh","Begum","Wilkinson","Foster","Chapman","Powell","Webb","Rogers","Gray","Mason","Ali","Hunt","Hussain","Campbell","Matthews","Owen","Palmer","Holmes","Mills","Barnes","Knight","Lloyd","Butler","Russell","Barker","Fisher","Stevens","Jenkins","Murray","Dixon","Harvey","Graham","Pearson","Ahmed","Fletcher","Walsh","Kaur","Gibson","Howard","Andrews","Stewart","Elliott","Reynolds","Saunders","Payne","Fox","Ford","Pearce","Day","Brooks","West","Lawrence","Cole","Atkinson","Bradley","Spencer","Gill","Dawson","Ball","Burton","O'brien","Watts","Rose","Booth","Perry","Ryan","Grant","Wells","Armstrong","Francis","Rees","Hayes","Hart","Hudson","Newman","Barrett","Webster","Hunter","Gregory","Carr","Lowe","Page","Marsh","Riley","Dunn","Woods","Parsons","Berry","Stone","Reid","Holland","Hawkins","Harding","Porter","Robertson","Newton","Oliver","Reed","Kennedy","Williamson","Bird","Gardner","Shah","Dean","Lane","Cooke","Bates","Henderson","Parry","Burgess","Bishop","Walton","Burns","Nicholson","Shepherd","Ross","Cross","Long","Freeman","Warren","Nicholls","Hamilton","Byrne","Sutton","Mcdonald","Yates","Hodgson","Robson","Curtis","Hopkins","O'connor","Harper","Coleman","Watkins","Moss","Mccarthy","Chambers","O'neill","Griffin","Sharp","Hardy","Wheeler","Potter","Osborne","Johnston","Gordon","Doyle","Wallace","George","Jordan","Hutchinson","Rowe","Burke","May","Pritchard","Gilbert","Willis","Higgins","Read","Miles","Stevenson","Stephenson","Hammond","Arnold","Buckley","Walters","Hewitt","Barber","Nelson","Slater","Austin","Sullivan","Whitehead","Mann","Frost","Lambert","Stephens","Blake","Akhtar","Lynch","Goodwin","Barton","Woodward","Thomson","Cunningham","Quinn","Barnett","Baxter","Bibi","Clayton","Nash","Greenwood","Jennings","Holt","Kemp","Poole","Gallagher","Bond","Stokes","Tucker","Davidson","Fowler","Heath","Norman","Middleton","Lawson","Banks","French","Stanley","Jarvis","Gibbs","Ferguson","Hayward","Carroll","Douglas","Dickinson","Todd","Barlow","Peters","Lucas","Knowles","Hartley","Miah","Simmons","Morton","Alexander","Field","Morrison","Norris","Townsend","Preston","Hancock","Thornton","Baldwin","Burrows","Briggs","Parkinson","Reeves","Macdonald","Lamb","Black","Abbott","Sanders","Thorpe","Holden","Tomlinson","Perkins","Ashton","Rhodes","Fuller","Howe","Bryant","Vaughan","Dale","Davey","Weston","Bartlett","Whittaker","Davison","Kent","Skinner","Birch","Morley","Daniels","Glover","Howell","Cartwright","Pugh","Humphreys","Goddard","Brennan","Wall","Kirby","Bowen","Savage","Bull","Wong","Dobson","Smart","Wilkins","Kirk","Fraser","Duffy","Hicks","Patterson","Bradshaw","Little","Archer","Warner","Waters","O'sullivan","Farrell","Brookes","Atkins","Kay","Dodd","Bentley","Flynn","John","Schofield","Short","Haynes","Wade","Butcher","Henry","Sanderson","Crawford","Sheppard","Bolton","Coates","Giles","Gould","Houghton","Gibbons","Pratt","Manning","Law","Hooper","Noble","Dyer","Rahman","Clements","Moran","Sykes","Chan","Doherty","Connolly","Joyce","Franklin","Hobbs","Coles","Herbert","Steele","Kerr","Leach","Winter","Owens","Duncan","Naylor","Fleming","Horton","Finch","Fitzgerald","Randall","Carpenter","Marsden","Browne","Garner","Pickering","Hale","Dennis","Vincent","Chadwick","Chandler","Sharpe","Nolan","Lyons","Hurst","Collier","Peacock","Howarth","Faulkner","Rice","Pollard","Welch","Norton","Gough","Sinclair","Blackburn","Bryan","Conway","Power","Cameron","Daly","Allan","Hanson","Gardiner","Boyle","Myers","Turnbull","Wallis","Mahmood","Sims","Swift","Iqbal","Pope","Brady","Chamberlain","Rowley","Tyler","Farmer","Metcalfe","Hilton","Godfrey","Holloway","Parkin","Bray","Talbot","Donnelly","Nixon","Charlton","Benson","Whitehouse","Barry","Hope","Lord","North","Storey","Connor","Potts","Bevan","Hargreaves","Mclean","Mistry","Bruce","Howells","Hyde","Parkes","Wyatt","Fry","Lees","O'donnell","Craig","Forster","Mckenzie","Humphries","Mellor","Carey","Ingram","Summers","Leonard"],
// https://surnames.behindthename.com/top/lists/germany/2017
"de": ["Müller","Schmidt","Schneider","Fischer","Weber","Meyer","Wagner","Becker","Schulz","Hoffmann","Schäfer","Koch","Bauer","Richter","Klein","Wolf","Schröder","Neumann","Schwarz","Zimmermann","Braun","Krüger","Hofmann","Hartmann","Lange","Schmitt","Werner","Schmitz","Krause","Meier","Lehmann","Schmid","Schulze","Maier","Köhler","Herrmann","König","Walter","Mayer","Huber","Kaiser","Fuchs","Peters","Lang","Scholz","Möller","Weiß","Jung","Hahn","Schubert","Vogel","Friedrich","Keller","Günther","Frank","Berger","Winkler","Roth","Beck","Lorenz","Baumann","Franke","Albrecht","Schuster","Simon","Ludwig","Böhm","Winter","Kraus","Martin","Schumacher","Krämer","Vogt","Stein","Jäger","Otto","Sommer","Groß","Seidel","Heinrich","Brandt","Haas","Schreiber","Graf","Schulte","Dietrich","Ziegler","Kuhn","Kühn","Pohl","Engel","Horn","Busch","Bergmann","Thomas","Voigt","Sauer","Arnold","Wolff","Pfeiffer"],
// http://www.japantimes.co.jp/life/2009/10/11/lifestyle/japans-top-100-most-common-family-names/
"jp": ["Sato","Suzuki","Takahashi","Tanaka","Watanabe","Ito","Yamamoto","Nakamura","Kobayashi","Kato","Yoshida","Yamada","Sasaki","Yamaguchi","Saito","Matsumoto","Inoue","Kimura","Hayashi","Shimizu","Yamazaki","Mori","Abe","Ikeda","Hashimoto","Yamashita","Ishikawa","Nakajima","Maeda","Fujita","Ogawa","Goto","Okada","Hasegawa","Murakami","Kondo","Ishii","Saito","Sakamoto","Endo","Aoki","Fujii","Nishimura","Fukuda","Ota","Miura","Fujiwara","Okamoto","Matsuda","Nakagawa","Nakano","Harada","Ono","Tamura","Takeuchi","Kaneko","Wada","Nakayama","Ishida","Ueda","Morita","Hara","Shibata","Sakai","Kudo","Yokoyama","Miyazaki","Miyamoto","Uchida","Takagi","Ando","Taniguchi","Ohno","Maruyama","Imai","Takada","Fujimoto","Takeda","Murata","Ueno","Sugiyama","Masuda","Sugawara","Hirano","Kojima","Otsuka","Chiba","Kubo","Matsui","Iwasaki","Sakurai","Kinoshita","Noguchi","Matsuo","Nomura","Kikuchi","Sano","Onishi","Sugimoto","Arai"],
// http://www.lowchensaustralia.com/names/popular-spanish-names.htm
"es": ["Garcia","Fernandez","Lopez","Martinez","Gonzalez","Rodriguez","Sanchez","Perez","Martin","Gomez","Ruiz","Diaz","Hernandez","Alvarez","Jimenez","Moreno","Munoz","Alonso","Romero","Navarro","Gutierrez","Torres","Dominguez","Gil","Vazquez","Blanco","Serrano","Ramos","Castro","Suarez","Sanz","Rubio","Ortega","Molina","Delgado","Ortiz","Morales","Ramirez","Marin","Iglesias","Santos","Castillo","Garrido","Calvo","Pena","Cruz","Cano","Nunez","Prieto","Diez","Lozano","Vidal","Pascual","Ferrer","Medina","Vega","Leon","Herrero","Vicente","Mendez","Guerrero","Fuentes","Campos","Nieto","Cortes","Caballero","Ibanez","Lorenzo","Pastor","Gimenez","Saez","Soler","Marquez","Carrasco","Herrera","Montero","Arias","Crespo","Flores","Andres","Aguilar","Hidalgo","Cabrera","Mora","Duran","Velasco","Rey","Pardo","Roman","Vila","Bravo","Merino","Moya","Soto","Izquierdo","Reyes","Redondo","Marcos","Carmona","Menendez"],
// Data taken from https://fr.wikipedia.org/wiki/Liste_des_noms_de_famille_les_plus_courants_en_France
"fr": ["Martin","Bernard","Thomas","Petit","Robert","Richard","Durand","Dubois","Moreau","Laurent","Simon","Michel","Lefèvre","Leroy","Roux","David","Bertrand","Morel","Fournier","Girard","Bonnet","Dupont","Lambert","Fontaine","Rousseau","Vincent","Müller","Lefèvre","Faure","André","Mercier","Blanc","Guérin","Boyer","Garnier","Chevalier","François","Legrand","Gauthier","Garcia","Perrin","Robin","Clément","Morin","Nicolas","Henry","Roussel","Matthieu","Gautier","Masson","Marchand","Duval","Denis","Dumont","Marie","Lemaire","Noël","Meyer","Dufour","Meunier","Brun","Blanchard","Giraud","Joly","Rivière","Lucas","Brunet","Gaillard","Barbier","Arnaud","Martínez","Gérard","Roche","Renard","Schmitt","Roy","Leroux","Colin","Vidal","Caron","Picard","Roger","Fabre","Aubert","Lemoine","Renaud","Dumas","Lacroix","Olivier","Philippe","Bourgeois","Pierre","Benoît","Rey","Leclerc","Payet","Rolland","Leclercq","Guillaume","Lecomte","López","Jean","Dupuy","Guillot","Hubert","Berger","Carpentier","Sánchez","Dupuis","Moulin","Louis","Deschamps","Huet","Vasseur","Perez","Boucher","Fleury","Royer","Klein","Jacquet","Adam","Paris","Poirier","Marty","Aubry","Guyot","Carré","Charles","Renault","Charpentier","Ménard","Maillard","Baron","Bertin","Bailly","Hervé","Schneider","Fernández","Le GallGall","Collet","Léger","Bouvier","Julien","Prévost","Millet","Perrot","Daniel","Le RouxRoux","Cousin","Germain","Breton","Besson","Langlois","Rémi","Le GoffGoff","Pelletier","Lévêque","Perrier","Leblanc","Barré","Lebrun","Marchal","Weber","Mallet","Hamon","Boulanger","Jacob","Monnier","Michaud","Rodríguez","Guichard","Gillet","Étienne","Grondin","Poulain","Tessier","Chevallier","Collin","Chauvin","Da SilvaSilva","Bouchet","Gay","Lemaître","Bénard","Maréchal","Humbert","Reynaud","Antoine","Hoarau","Perret","Barthélemy","Cordier","Pichon","Lejeune","Gilbert","Lamy","Delaunay","Pasquier","Carlier","LaporteLaporte"]
},
// Data taken from https://github.com/umpirsky/country-list/blob/master/data/en_US/country.json
countries: [{"name":"Afghanistan","abbreviation":"AF"},{"name":"Åland Islands","abbreviation":"AX"},{"name":"Albania","abbreviation":"AL"},{"name":"Algeria","abbreviation":"DZ"},{"name":"American Samoa","abbreviation":"AS"},{"name":"Andorra","abbreviation":"AD"},{"name":"Angola","abbreviation":"AO"},{"name":"Anguilla","abbreviation":"AI"},{"name":"Antarctica","abbreviation":"AQ"},{"name":"Antigua & Barbuda","abbreviation":"AG"},{"name":"Argentina","abbreviation":"AR"},{"name":"Armenia","abbreviation":"AM"},{"name":"Aruba","abbreviation":"AW"},{"name":"Ascension Island","abbreviation":"AC"},{"name":"Australia","abbreviation":"AU"},{"name":"Austria","abbreviation":"AT"},{"name":"Azerbaijan","abbreviation":"AZ"},{"name":"Bahamas","abbreviation":"BS"},{"name":"Bahrain","abbreviation":"BH"},{"name":"Bangladesh","abbreviation":"BD"},{"name":"Barbados","abbreviation":"BB"},{"name":"Belarus","abbreviation":"BY"},{"name":"Belgium","abbreviation":"BE"},{"name":"Belize","abbreviation":"BZ"},{"name":"Benin","abbreviation":"BJ"},{"name":"Bermuda","abbreviation":"BM"},{"name":"Bhutan","abbreviation":"BT"},{"name":"Bolivia","abbreviation":"BO"},{"name":"Bosnia & Herzegovina","abbreviation":"BA"},{"name":"Botswana","abbreviation":"BW"},{"name":"Brazil","abbreviation":"BR"},{"name":"British Indian Ocean Territory","abbreviation":"IO"},{"name":"British Virgin Islands","abbreviation":"VG"},{"name":"Brunei","abbreviation":"BN"},{"name":"Bulgaria","abbreviation":"BG"},{"name":"Burkina Faso","abbreviation":"BF"},{"name":"Burundi","abbreviation":"BI"},{"name":"Cambodia","abbreviation":"KH"},{"name":"Cameroon","abbreviation":"CM"},{"name":"Canada","abbreviation":"CA"},{"name":"Canary Islands","abbreviation":"IC"},{"name":"Cape Verde","abbreviation":"CV"},{"name":"Caribbean Netherlands","abbreviation":"BQ"},{"name":"Cayman Islands","abbreviation":"KY"},{"name":"Central African Republic","abbreviation":"CF"},{"name":"Ceuta & Melilla","abbreviation":"EA"},{"name":"Chad","abbreviation":"TD"},{"name":"Chile","abbreviation":"CL"},{"name":"China","abbreviation":"CN"},{"name":"Christmas Island","abbreviation":"CX"},{"name":"Cocos (Keeling) Islands","abbreviation":"CC"},{"name":"Colombia","abbreviation":"CO"},{"name":"Comoros","abbreviation":"KM"},{"name":"Congo - Brazzaville","abbreviation":"CG"},{"name":"Congo - Kinshasa","abbreviation":"CD"},{"name":"Cook Islands","abbreviation":"CK"},{"name":"Costa Rica","abbreviation":"CR"},{"name":"Côte d'Ivoire","abbreviation":"CI"},{"name":"Croatia","abbreviation":"HR"},{"name":"Cuba","abbreviation":"CU"},{"name":"Curaçao","abbreviation":"CW"},{"name":"Cyprus","abbreviation":"CY"},{"name":"Czech Republic","abbreviation":"CZ"},{"name":"Denmark","abbreviation":"DK"},{"name":"Diego Garcia","abbreviation":"DG"},{"name":"Djibouti","abbreviation":"DJ"},{"name":"Dominica","abbreviation":"DM"},{"name":"Dominican Republic","abbreviation":"DO"},{"name":"Ecuador","abbreviation":"EC"},{"name":"Egypt","abbreviation":"EG"},{"name":"El Salvador","abbreviation":"SV"},{"name":"Equatorial Guinea","abbreviation":"GQ"},{"name":"Eritrea","abbreviation":"ER"},{"name":"Estonia","abbreviation":"EE"},{"name":"Ethiopia","abbreviation":"ET"},{"name":"Falkland Islands","abbreviation":"FK"},{"name":"Faroe Islands","abbreviation":"FO"},{"name":"Fiji","abbreviation":"FJ"},{"name":"Finland","abbreviation":"FI"},{"name":"France","abbreviation":"FR"},{"name":"French Guiana","abbreviation":"GF"},{"name":"French Polynesia","abbreviation":"PF"},{"name":"French Southern Territories","abbreviation":"TF"},{"name":"Gabon","abbreviation":"GA"},{"name":"Gambia","abbreviation":"GM"},{"name":"Georgia","abbreviation":"GE"},{"name":"Germany","abbreviation":"DE"},{"name":"Ghana","abbreviation":"GH"},{"name":"Gibraltar","abbreviation":"GI"},{"name":"Greece","abbreviation":"GR"},{"name":"Greenland","abbreviation":"GL"},{"name":"Grenada","abbreviation":"GD"},{"name":"Guadeloupe","abbreviation":"GP"},{"name":"Guam","abbreviation":"GU"},{"name":"Guatemala","abbreviation":"GT"},{"name":"Guernsey","abbreviation":"GG"},{"name":"Guinea","abbreviation":"GN"},{"name":"Guinea-Bissau","abbreviation":"GW"},{"name":"Guyana","abbreviation":"GY"},{"name":"Haiti","abbreviation":"HT"},{"name":"Honduras","abbreviation":"HN"},{"name":"Hong Kong SAR China","abbreviation":"HK"},{"name":"Hungary","abbreviation":"HU"},{"name":"Iceland","abbreviation":"IS"},{"name":"India","abbreviation":"IN"},{"name":"Indonesia","abbreviation":"ID"},{"name":"Iran","abbreviation":"IR"},{"name":"Iraq","abbreviation":"IQ"},{"name":"Ireland","abbreviation":"IE"},{"name":"Isle of Man","abbreviation":"IM"},{"name":"Israel","abbreviation":"IL"},{"name":"Italy","abbreviation":"IT"},{"name":"Jamaica","abbreviation":"JM"},{"name":"Japan","abbreviation":"JP"},{"name":"Jersey","abbreviation":"JE"},{"name":"Jordan","abbreviation":"JO"},{"name":"Kazakhstan","abbreviation":"KZ"},{"name":"Kenya","abbreviation":"KE"},{"name":"Kiribati","abbreviation":"KI"},{"name":"Kosovo","abbreviation":"XK"},{"name":"Kuwait","abbreviation":"KW"},{"name":"Kyrgyzstan","abbreviation":"KG"},{"name":"Laos","abbreviation":"LA"},{"name":"Latvia","abbreviation":"LV"},{"name":"Lebanon","abbreviation":"LB"},{"name":"Lesotho","abbreviation":"LS"},{"name":"Liberia","abbreviation":"LR"},{"name":"Libya","abbreviation":"LY"},{"name":"Liechtenstein","abbreviation":"LI"},{"name":"Lithuania","abbreviation":"LT"},{"name":"Luxembourg","abbreviation":"LU"},{"name":"Macau SAR China","abbreviation":"MO"},{"name":"Macedonia","abbreviation":"MK"},{"name":"Madagascar","abbreviation":"MG"},{"name":"Malawi","abbreviation":"MW"},{"name":"Malaysia","abbreviation":"MY"},{"name":"Maldives","abbreviation":"MV"},{"name":"Mali","abbreviation":"ML"},{"name":"Malta","abbreviation":"MT"},{"name":"Marshall Islands","abbreviation":"MH"},{"name":"Martinique","abbreviation":"MQ"},{"name":"Mauritania","abbreviation":"MR"},{"name":"Mauritius","abbreviation":"MU"},{"name":"Mayotte","abbreviation":"YT"},{"name":"Mexico","abbreviation":"MX"},{"name":"Micronesia","abbreviation":"FM"},{"name":"Moldova","abbreviation":"MD"},{"name":"Monaco","abbreviation":"MC"},{"name":"Mongolia","abbreviation":"MN"},{"name":"Montenegro","abbreviation":"ME"},{"name":"Montserrat","abbreviation":"MS"},{"name":"Morocco","abbreviation":"MA"},{"name":"Mozambique","abbreviation":"MZ"},{"name":"Myanmar (Burma)","abbreviation":"MM"},{"name":"Namibia","abbreviation":"NA"},{"name":"Nauru","abbreviation":"NR"},{"name":"Nepal","abbreviation":"NP"},{"name":"Netherlands","abbreviation":"NL"},{"name":"New Caledonia","abbreviation":"NC"},{"name":"New Zealand","abbreviation":"NZ"},{"name":"Nicaragua","abbreviation":"NI"},{"name":"Niger","abbreviation":"NE"},{"name":"Nigeria","abbreviation":"NG"},{"name":"Niue","abbreviation":"NU"},{"name":"Norfolk Island","abbreviation":"NF"},{"name":"North Korea","abbreviation":"KP"},{"name":"Northern Mariana Islands","abbreviation":"MP"},{"name":"Norway","abbreviation":"NO"},{"name":"Oman","abbreviation":"OM"},{"name":"Pakistan","abbreviation":"PK"},{"name":"Palau","abbreviation":"PW"},{"name":"Palestinian Territories","abbreviation":"PS"},{"name":"Panama","abbreviation":"PA"},{"name":"Papua New Guinea","abbreviation":"PG"},{"name":"Paraguay","abbreviation":"PY"},{"name":"Peru","abbreviation":"PE"},{"name":"Philippines","abbreviation":"PH"},{"name":"Pitcairn Islands","abbreviation":"PN"},{"name":"Poland","abbreviation":"PL"},{"name":"Portugal","abbreviation":"PT"},{"name":"Puerto Rico","abbreviation":"PR"},{"name":"Qatar","abbreviation":"QA"},{"name":"Réunion","abbreviation":"RE"},{"name":"Romania","abbreviation":"RO"},{"name":"Russia","abbreviation":"RU"},{"name":"Rwanda","abbreviation":"RW"},{"name":"Samoa","abbreviation":"WS"},{"name":"San Marino","abbreviation":"SM"},{"name":"São Tomé and Príncipe","abbreviation":"ST"},{"name":"Saudi Arabia","abbreviation":"SA"},{"name":"Senegal","abbreviation":"SN"},{"name":"Serbia","abbreviation":"RS"},{"name":"Seychelles","abbreviation":"SC"},{"name":"Sierra Leone","abbreviation":"SL"},{"name":"Singapore","abbreviation":"SG"},{"name":"Sint Maarten","abbreviation":"SX"},{"name":"Slovakia","abbreviation":"SK"},{"name":"Slovenia","abbreviation":"SI"},{"name":"Solomon Islands","abbreviation":"SB"},{"name":"Somalia","abbreviation":"SO"},{"name":"South Africa","abbreviation":"ZA"},{"name":"South Georgia & South Sandwich Islands","abbreviation":"GS"},{"name":"South Korea","abbreviation":"KR"},{"name":"South Sudan","abbreviation":"SS"},{"name":"Spain","abbreviation":"ES"},{"name":"Sri Lanka","abbreviation":"LK"},{"name":"St. Barthélemy","abbreviation":"BL"},{"name":"St. Helena","abbreviation":"SH"},{"name":"St. Kitts & Nevis","abbreviation":"KN"},{"name":"St. Lucia","abbreviation":"LC"},{"name":"St. Martin","abbreviation":"MF"},{"name":"St. Pierre & Miquelon","abbreviation":"PM"},{"name":"St. Vincent & Grenadines","abbreviation":"VC"},{"name":"Sudan","abbreviation":"SD"},{"name":"Suriname","abbreviation":"SR"},{"name":"Svalbard & Jan Mayen","abbreviation":"SJ"},{"name":"Swaziland","abbreviation":"SZ"},{"name":"Sweden","abbreviation":"SE"},{"name":"Switzerland","abbreviation":"CH"},{"name":"Syria","abbreviation":"SY"},{"name":"Taiwan","abbreviation":"TW"},{"name":"Tajikistan","abbreviation":"TJ"},{"name":"Tanzania","abbreviation":"TZ"},{"name":"Thailand","abbreviation":"TH"},{"name":"Timor-Leste","abbreviation":"TL"},{"name":"Togo","abbreviation":"TG"},{"name":"Tokelau","abbreviation":"TK"},{"name":"Tonga","abbreviation":"TO"},{"name":"Trinidad & Tobago","abbreviation":"TT"},{"name":"Tristan da Cunha","abbreviation":"TA"},{"name":"Tunisia","abbreviation":"TN"},{"name":"Turkey","abbreviation":"TR"},{"name":"Turkmenistan","abbreviation":"TM"},{"name":"Turks & Caicos Islands","abbreviation":"TC"},{"name":"Tuvalu","abbreviation":"TV"},{"name":"U.S. Outlying Islands","abbreviation":"UM"},{"name":"U.S. Virgin Islands","abbreviation":"VI"},{"name":"Uganda","abbreviation":"UG"},{"name":"Ukraine","abbreviation":"UA"},{"name":"United Arab Emirates","abbreviation":"AE"},{"name":"United Kingdom","abbreviation":"GB"},{"name":"United States","abbreviation":"US"},{"name":"Uruguay","abbreviation":"UY"},{"name":"Uzbekistan","abbreviation":"UZ"},{"name":"Vanuatu","abbreviation":"VU"},{"name":"Vatican City","abbreviation":"VA"},{"name":"Venezuela","abbreviation":"VE"},{"name":"Vietnam","abbreviation":"VN"},{"name":"Wallis & Futuna","abbreviation":"WF"},{"name":"Western Sahara","abbreviation":"EH"},{"name":"Yemen","abbreviation":"YE"},{"name":"Zambia","abbreviation":"ZM"},{"name":"Zimbabwe","abbreviation":"ZW"}],
counties: {
// Data taken from http://www.downloadexcelfiles.com/gb_en/download-excel-file-list-counties-uk
"uk": [
{name: 'Bath and North East Somerset'},
{name: 'Aberdeenshire'},
{name: 'Anglesey'},
{name: 'Angus'},
{name: 'Bedford'},
{name: 'Blackburn with Darwen'},
{name: 'Blackpool'},
{name: 'Bournemouth'},
{name: 'Bracknell Forest'},
{name: 'Brighton & Hove'},
{name: 'Bristol'},
{name: 'Buckinghamshire'},
{name: 'Cambridgeshire'},
{name: 'Carmarthenshire'},
{name: 'Central Bedfordshire'},
{name: 'Ceredigion'},
{name: 'Cheshire East'},
{name: 'Cheshire West and Chester'},
{name: 'Clackmannanshire'},
{name: 'Conwy'},
{name: 'Cornwall'},
{name: 'County Antrim'},
{name: 'County Armagh'},
{name: 'County Down'},
{name: 'County Durham'},
{name: 'County Fermanagh'},
{name: 'County Londonderry'},
{name: 'County Tyrone'},
{name: 'Cumbria'},
{name: 'Darlington'},
{name: 'Denbighshire'},
{name: 'Derby'},
{name: 'Derbyshire'},
{name: 'Devon'},
{name: 'Dorset'},
{name: 'Dumfries and Galloway'},
{name: 'Dundee'},
{name: 'East Lothian'},
{name: 'East Riding of Yorkshire'},
{name: 'East Sussex'},
{name: 'Edinburgh?'},
{name: 'Essex'},
{name: 'Falkirk'},
{name: 'Fife'},
{name: 'Flintshire'},
{name: 'Gloucestershire'},
{name: 'Greater London'},
{name: 'Greater Manchester'},
{name: 'Gwent'},
{name: 'Gwynedd'},
{name: 'Halton'},
{name: 'Hampshire'},
{name: 'Hartlepool'},
{name: 'Herefordshire'},
{name: 'Hertfordshire'},
{name: 'Highlands'},
{name: 'Hull'},
{name: 'Isle of Wight'},
{name: 'Isles of Scilly'},
{name: 'Kent'},
{name: 'Lancashire'},
{name: 'Leicester'},
{name: 'Leicestershire'},
{name: 'Lincolnshire'},
{name: 'Lothian'},
{name: 'Luton'},
{name: 'Medway'},
{name: 'Merseyside'},
{name: 'Mid Glamorgan'},
{name: 'Middlesbrough'},
{name: 'Milton Keynes'},
{name: 'Monmouthshire'},
{name: 'Moray'},
{name: 'Norfolk'},
{name: 'North East Lincolnshire'},
{name: 'North Lincolnshire'},
{name: 'North Somerset'},
{name: 'North Yorkshire'},
{name: 'Northamptonshire'},
{name: 'Northumberland'},
{name: 'Nottingham'},
{name: 'Nottinghamshire'},
{name: 'Oxfordshire'},
{name: 'Pembrokeshire'},
{name: 'Perth and Kinross'},
{name: 'Peterborough'},
{name: 'Plymouth'},
{name: 'Poole'},
{name: 'Portsmouth'},
{name: 'Powys'},
{name: 'Reading'},
{name: 'Redcar and Cleveland'},
{name: 'Rutland'},
{name: 'Scottish Borders'},
{name: 'Shropshire'},
{name: 'Slough'},
{name: 'Somerset'},
{name: 'South Glamorgan'},
{name: 'South Gloucestershire'},
{name: 'South Yorkshire'},
{name: 'Southampton'},
{name: 'Southend-on-Sea'},
{name: 'Staffordshire'},
{name: 'Stirlingshire'},
{name: 'Stockton-on-Tees'},
{name: 'Stoke-on-Trent'},
{name: 'Strathclyde'},
{name: 'Suffolk'},
{name: 'Surrey'},
{name: 'Swindon'},
{name: 'Telford and Wrekin'},
{name: 'Thurrock'},
{name: 'Torbay'},
{name: 'Tyne and Wear'},
{name: 'Warrington'},
{name: 'Warwickshire'},
{name: 'West Berkshire'},
{name: 'West Glamorgan'},
{name: 'West Lothian'},
{name: 'West Midlands'},
{name: 'West Sussex'},
{name: 'West Yorkshire'},
{name: 'Western Isles'},
{name: 'Wiltshire'},
{name: 'Windsor and Maidenhead'},
{name: 'Wokingham'},
{name: 'Worcestershire'},
{name: 'Wrexham'},
{name: 'York'}]
},
provinces: {
"ca": [
{name: 'Alberta', abbreviation: 'AB'},
{name: 'British Columbia', abbreviation: 'BC'},
{name: 'Manitoba', abbreviation: 'MB'},
{name: 'New Brunswick', abbreviation: 'NB'},
{name: 'Newfoundland and Labrador', abbreviation: 'NL'},
{name: 'Nova Scotia', abbreviation: 'NS'},
{name: 'Ontario', abbreviation: 'ON'},
{name: 'Prince Edward Island', abbreviation: 'PE'},
{name: 'Quebec', abbreviation: 'QC'},
{name: 'Saskatchewan', abbreviation: 'SK'},
// The case could be made that the following are not actually provinces
// since they are technically considered "territories" however they all
// look the same on an envelope!
{name: 'Northwest Territories', abbreviation: 'NT'},
{name: 'Nunavut', abbreviation: 'NU'},
{name: 'Yukon', abbreviation: 'YT'}
],
"it": [
{ name: "Agrigento", abbreviation: "AG", code: 84 },
{ name: "Alessandria", abbreviation: "AL", code: 6 },
{ name: "Ancona", abbreviation: "AN", code: 42 },
{ name: "Aosta", abbreviation: "AO", code: 7 },
{ name: "L'Aquila", abbreviation: "AQ", code: 66 },
{ name: "Arezzo", abbreviation: "AR", code: 51 },
{ name: "Ascoli-Piceno", abbreviation: "AP", code: 44 },
{ name: "Asti", abbreviation: "AT", code: 5 },
{ name: "Avellino", abbreviation: "AV", code: 64 },
{ name: "Bari", abbreviation: "BA", code: 72 },
{ name: "Barletta-Andria-Trani", abbreviation: "BT", code: 72 },
{ name: "Belluno", abbreviation: "BL", code: 25 },
{ name: "Benevento", abbreviation: "BN", code: 62 },
{ name: "Bergamo", abbreviation: "BG", code: 16 },
{ name: "Biella", abbreviation: "BI", code: 96 },
{ name: "Bologna", abbreviation: "BO", code: 37 },
{ name: "Bolzano", abbreviation: "BZ", code: 21 },
{ name: "Brescia", abbreviation: "BS", code: 17 },
{ name: "Brindisi", abbreviation: "BR", code: 74 },
{ name: "Cagliari", abbreviation: "CA", code: 92 },
{ name: "Caltanissetta", abbreviation: "CL", code: 85 },
{ name: "Campobasso", abbreviation: "CB", code: 70 },
{ name: "Carbonia Iglesias", abbreviation: "CI", code: 70 },
{ name: "Caserta", abbreviation: "CE", code: 61 },
{ name: "Catania", abbreviation: "CT", code: 87 },
{ name: "Catanzaro", abbreviation: "CZ", code: 79 },
{ name: "Chieti", abbreviation: "CH", code: 69 },
{ name: "Como", abbreviation: "CO", code: 13 },
{ name: "Cosenza", abbreviation: "CS", code: 78 },
{ name: "Cremona", abbreviation: "CR", code: 19 },
{ name: "Crotone", abbreviation: "KR", code: 101 },
{ name: "Cuneo", abbreviation: "CN", code: 4 },
{ name: "Enna", abbreviation: "EN", code: 86 },
{ name: "Fermo", abbreviation: "FM", code: 86 },
{ name: "Ferrara", abbreviation: "FE", code: 38 },
{ name: "Firenze", abbreviation: "FI", code: 48 },
{ name: "Foggia", abbreviation: "FG", code: 71 },
{ name: "Forli-Cesena", abbreviation: "FC", code: 71 },
{ name: "Frosinone", abbreviation: "FR", code: 60 },
{ name: "Genova", abbreviation: "GE", code: 10 },
{ name: "Gorizia", abbreviation: "GO", code: 31 },
{ name: "Grosseto", abbreviation: "GR", code: 53 },
{ name: "Imperia", abbreviation: "IM", code: 8 },
{ name: "Isernia", abbreviation: "IS", code: 94 },
{ name: "La-Spezia", abbreviation: "SP", code: 66 },
{ name: "Latina", abbreviation: "LT", code: 59 },
{ name: "Lecce", abbreviation: "LE", code: 75 },
{ name: "Lecco", abbreviation: "LC", code: 97 },
{ name: "Livorno", abbreviation: "LI", code: 49 },
{ name: "Lodi", abbreviation: "LO", code: 98 },
{ name: "Lucca", abbreviation: "LU", code: 46 },
{ name: "Macerata", abbreviation: "MC", code: 43 },
{ name: "Mantova", abbreviation: "MN", code: 20 },
{ name: "Massa-Carrara", abbreviation: "MS", code: 45 },
{ name: "Matera", abbreviation: "MT", code: 77 },
{ name: "Medio Campidano", abbreviation: "VS", code: 77 },
{ name: "Messina", abbreviation: "ME", code: 83 },
{ name: "Milano", abbreviation: "MI", code: 15 },
{ name: "Modena", abbreviation: "MO", code: 36 },
{ name: "Monza-Brianza", abbreviation: "MB", code: 36 },
{ name: "Napoli", abbreviation: "NA", code: 63 },
{ name: "Novara", abbreviation: "NO", code: 3 },
{ name: "Nuoro", abbreviation: "NU", code: 91 },
{ name: "Ogliastra", abbreviation: "OG", code: 91 },
{ name: "Olbia Tempio", abbreviation: "OT", code: 91 },
{ name: "Oristano", abbreviation: "OR", code: 95 },
{ name: "Padova", abbreviation: "PD", code: 28 },
{ name: "Palermo", abbreviation: "PA", code: 82 },
{ name: "Parma", abbreviation: "PR", code: 34 },
{ name: "Pavia", abbreviation: "PV", code: 18 },
{ name: "Perugia", abbreviation: "PG", code: 54 },
{ name: "Pesaro-Urbino", abbreviation: "PU", code: 41 },
{ name: "Pescara", abbreviation: "PE", code: 68 },
{ name: "Piacenza", abbreviation: "PC", code: 33 },
{ name: "Pisa", abbreviation: "PI", code: 50 },
{ name: "Pistoia", abbreviation: "PT", code: 47 },
{ name: "Pordenone", abbreviation: "PN", code: 93 },
{ name: "Potenza", abbreviation: "PZ", code: 76 },
{ name: "Prato", abbreviation: "PO", code: 100 },
{ name: "Ragusa", abbreviation: "RG", code: 88 },
{ name: "Ravenna", abbreviation: "RA", code: 39 },
{ name: "Reggio-Calabria", abbreviation: "RC", code: 35 },
{ name: "Reggio-Emilia", abbreviation: "RE", code: 35 },
{ name: "Rieti", abbreviation: "RI", code: 57 },
{ name: "Rimini", abbreviation: "RN", code: 99 },
{ name: "Roma", abbreviation: "Roma", code: 58 },
{ name: "Rovigo", abbreviation: "RO", code: 29 },
{ name: "Salerno", abbreviation: "SA", code: 65 },
{ name: "Sassari", abbreviation: "SS", code: 90 },
{ name: "Savona", abbreviation: "SV", code: 9 },
{ name: "Siena", abbreviation: "SI", code: 52 },
{ name: "Siracusa", abbreviation: "SR", code: 89 },
{ name: "Sondrio", abbreviation: "SO", code: 14 },
{ name: "Taranto", abbreviation: "TA", code: 73 },
{ name: "Teramo", abbreviation: "TE", code: 67 },
{ name: "Terni", abbreviation: "TR", code: 55 },
{ name: "Torino", abbreviation: "TO", code: 1 },
{ name: "Trapani", abbreviation: "TP", code: 81 },
{ name: "Trento", abbreviation: "TN", code: 22 },
{ name: "Treviso", abbreviation: "TV", code: 26 },
{ name: "Trieste", abbreviation: "TS", code: 32 },
{ name: "Udine", abbreviation: "UD", code: 30 },
{ name: "Varese", abbreviation: "VA", code: 12 },
{ name: "Venezia", abbreviation: "VE", code: 27 },
{ name: "Verbania", abbreviation: "VB", code: 27 },
{ name: "Vercelli", abbreviation: "VC", code: 2 },
{ name: "Verona", abbreviation: "VR", code: 23 },
{ name: "Vibo-Valentia", abbreviation: "VV", code: 102 },
{ name: "Vicenza", abbreviation: "VI", code: 24 },
{ name: "Viterbo", abbreviation: "VT", code: 56 }
]
},
// from: https://github.com/samsargent/Useful-Autocomplete-Data/blob/master/data/nationalities.json
nationalities: [
{name: 'Afghan'},
{name: 'Albanian'},
{name: 'Algerian'},
{name: 'American'},
{name: 'Andorran'},
{name: 'Angolan'},
{name: 'Antiguans'},
{name: 'Argentinean'},
{name: 'Armenian'},
{name: 'Australian'},
{name: 'Austrian'},
{name: 'Azerbaijani'},
{name: 'Bahami'},
{name: 'Bahraini'},
{name: 'Bangladeshi'},
{name: 'Barbadian'},
{name: 'Barbudans'},
{name: 'Batswana'},
{name: 'Belarusian'},
{name: 'Belgian'},
{name: 'Belizean'},
{name: 'Beninese'},
{name: 'Bhutanese'},
{name: 'Bolivian'},
{name: 'Bosnian'},
{name: 'Brazilian'},
{name: 'British'},
{name: 'Bruneian'},
{name: 'Bulgarian'},
{name: 'Burkinabe'},
{name: 'Burmese'},
{name: 'Burundian'},
{name: 'Cambodian'},
{name: 'Cameroonian'},
{name: 'Canadian'},
{name: 'Cape Verdean'},
{name: 'Central African'},
{name: 'Chadian'},
{name: 'Chilean'},
{name: 'Chinese'},
{name: 'Colombian'},
{name: 'Comoran'},
{name: 'Congolese'},
{name: 'Costa Rican'},
{name: 'Croatian'},
{name: 'Cuban'},
{name: 'Cypriot'},
{name: 'Czech'},
{name: 'Danish'},
{name: 'Djibouti'},
{name: 'Dominican'},
{name: 'Dutch'},
{name: 'East Timorese'},
{name: 'Ecuadorean'},
{name: 'Egyptian'},
{name: 'Emirian'},
{name: 'Equatorial Guinean'},
{name: 'Eritrean'},
{name: 'Estonian'},
{name: 'Ethiopian'},
{name: 'Fijian'},
{name: 'Filipino'},
{name: 'Finnish'},
{name: 'French'},
{name: 'Gabonese'},
{name: 'Gambian'},
{name: 'Georgian'},
{name: 'German'},
{name: 'Ghanaian'},
{name: 'Greek'},
{name: 'Grenadian'},
{name: 'Guatemalan'},
{name: 'Guinea-Bissauan'},
{name: 'Guinean'},
{name: 'Guyanese'},
{name: 'Haitian'},
{name: 'Herzegovinian'},
{name: 'Honduran'},
{name: 'Hungarian'},
{name: 'I-Kiribati'},
{name: 'Icelander'},
{name: 'Indian'},
{name: 'Indonesian'},
{name: 'Iranian'},
{name: 'Iraqi'},
{name: 'Irish'},
{name: 'Israeli'},
{name: 'Italian'},
{name: 'Ivorian'},
{name: 'Jamaican'},
{name: 'Japanese'},
{name: 'Jordanian'},
{name: 'Kazakhstani'},
{name: 'Kenyan'},
{name: 'Kittian and Nevisian'},
{name: 'Kuwaiti'},
{name: 'Kyrgyz'},
{name: 'Laotian'},
{name: 'Latvian'},
{name: 'Lebanese'},
{name: 'Liberian'},
{name: 'Libyan'},
{name: 'Liechtensteiner'},
{name: 'Lithuanian'},
{name: 'Luxembourger'},
{name: 'Macedonian'},
{name: 'Malagasy'},
{name: 'Malawian'},
{name: 'Malaysian'},
{name: 'Maldivan'},
{name: 'Malian'},
{name: 'Maltese'},
{name: 'Marshallese'},
{name: 'Mauritanian'},
{name: 'Mauritian'},
{name: 'Mexican'},
{name: 'Micronesian'},
{name: 'Moldovan'},
{name: 'Monacan'},
{name: 'Mongolian'},
{name: 'Moroccan'},
{name: 'Mosotho'},
{name: 'Motswana'},
{name: 'Mozambican'},
{name: 'Namibian'},
{name: 'Nauruan'},
{name: 'Nepalese'},
{name: 'New Zealander'},
{name: 'Nicaraguan'},
{name: 'Nigerian'},
{name: 'Nigerien'},
{name: 'North Korean'},
{name: 'Northern Irish'},
{name: 'Norwegian'},
{name: 'Omani'},
{name: 'Pakistani'},
{name: 'Palauan'},
{name: 'Panamanian'},
{name: 'Papua New Guinean'},
{name: 'Paraguayan'},
{name: 'Peruvian'},
{name: 'Polish'},
{name: 'Portuguese'},
{name: 'Qatari'},
{name: 'Romani'},
{name: 'Russian'},
{name: 'Rwandan'},
{name: 'Saint Lucian'},
{name: 'Salvadoran'},
{name: 'Samoan'},
{name: 'San Marinese'},
{name: 'Sao Tomean'},
{name: 'Saudi'},
{name: 'Scottish'},
{name: 'Senegalese'},
{name: 'Serbian'},
{name: 'Seychellois'},
{name: 'Sierra Leonean'},
{name: 'Singaporean'},
{name: 'Slovakian'},
{name: 'Slovenian'},
{name: 'Solomon Islander'},
{name: 'Somali'},
{name: 'South African'},
{name: 'South Korean'},
{name: 'Spanish'},
{name: 'Sri Lankan'},
{name: 'Sudanese'},
{name: 'Surinamer'},
{name: 'Swazi'},
{name: 'Swedish'},
{name: 'Swiss'},
{name: 'Syrian'},
{name: 'Taiwanese'},
{name: 'Tajik'},
{name: 'Tanzanian'},
{name: 'Thai'},
{name: 'Togolese'},
{name: 'Tongan'},
{name: 'Trinidadian or Tobagonian'},
{name: 'Tunisian'},
{name: 'Turkish'},
{name: 'Tuvaluan'},
{name: 'Ugandan'},
{name: 'Ukrainian'},
{name: 'Uruguaya'},
{name: 'Uzbekistani'},
{name: 'Venezuela'},
{name: 'Vietnamese'},
{name: 'Wels'},
{name: 'Yemenit'},
{name: 'Zambia'},
{name: 'Zimbabwe'},
],
// http://www.loc.gov/standards/iso639-2/php/code_list.php (ISO-639-1 codes)
locale_languages: [
"aa",
"ab",
"ae",
"af",
"ak",
"am",
"an",
"ar",
"as",
"av",
"ay",
"az",
"ba",
"be",
"bg",
"bh",
"bi",
"bm",
"bn",
"bo",
"br",
"bs",
"ca",
"ce",
"ch",
"co",
"cr",
"cs",
"cu",
"cv",
"cy",
"da",
"de",
"dv",
"dz",
"ee",
"el",
"en",
"eo",
"es",
"et",
"eu",
"fa",
"ff",
"fi",
"fj",
"fo",
"fr",
"fy",
"ga",
"gd",
"gl",
"gn",
"gu",
"gv",
"ha",
"he",
"hi",
"ho",
"hr",
"ht",
"hu",
"hy",
"hz",
"ia",
"id",
"ie",
"ig",
"ii",
"ik",
"io",
"is",
"it",
"iu",
"ja",
"jv",
"ka",
"kg",
"ki",
"kj",
"kk",
"kl",
"km",
"kn",
"ko",
"kr",
"ks",
"ku",
"kv",
"kw",
"ky",
"la",
"lb",
"lg",
"li",
"ln",
"lo",
"lt",
"lu",
"lv",
"mg",
"mh",
"mi",
"mk",
"ml",
"mn",
"mr",
"ms",
"mt",
"my",
"na",
"nb",
"nd",
"ne",
"ng",
"nl",
"nn",
"no",
"nr",
"nv",
"ny",
"oc",
"oj",
"om",
"or",
"os",
"pa",
"pi",
"pl",
"ps",
"pt",
"qu",
"rm",
"rn",
"ro",
"ru",
"rw",
"sa",
"sc",
"sd",
"se",
"sg",
"si",
"sk",
"sl",
"sm",
"sn",
"so",
"sq",
"sr",
"ss",
"st",
"su",
"sv",
"sw",
"ta",
"te",
"tg",
"th",
"ti",
"tk",
"tl",
"tn",
"to",
"tr",
"ts",
"tt",
"tw",
"ty",
"ug",
"uk",
"ur",
"uz",
"ve",
"vi",
"vo",
"wa",
"wo",
"xh",
"yi",
"yo",
"za",
"zh",
"zu"
],
// From http://data.okfn.org/data/core/language-codes#resource-language-codes-full (IETF language tags)
locale_regions: [
"agq-CM",
"asa-TZ",
"ast-ES",
"bas-CM",
"bem-ZM",
"bez-TZ",
"brx-IN",
"cgg-UG",
"chr-US",
"dav-KE",
"dje-NE",
"dsb-DE",
"dua-CM",
"dyo-SN",
"ebu-KE",
"ewo-CM",
"fil-PH",
"fur-IT",
"gsw-CH",
"gsw-FR",
"gsw-LI",
"guz-KE",
"haw-US",
"hsb-DE",
"jgo-CM",
"jmc-TZ",
"kab-DZ",
"kam-KE",
"kde-TZ",
"kea-CV",
"khq-ML",
"kkj-CM",
"kln-KE",
"kok-IN",
"ksb-TZ",
"ksf-CM",
"ksh-DE",
"lag-TZ",
"lkt-US",
"luo-KE",
"luy-KE",
"mas-KE",
"mas-TZ",
"mer-KE",
"mfe-MU",
"mgh-MZ",
"mgo-CM",
"mua-CM",
"naq-NA",
"nmg-CM",
"nnh-CM",
"nus-SD",
"nyn-UG",
"rof-TZ",
"rwk-TZ",
"sah-RU",
"saq-KE",
"sbp-TZ",
"seh-MZ",
"ses-ML",
"shi-Latn",
"shi-Latn-MA",
"shi-Tfng",
"shi-Tfng-MA",
"smn-FI",
"teo-KE",
"teo-UG",
"twq-NE",
"tzm-Latn",
"tzm-Latn-MA",
"vai-Latn",
"vai-Latn-LR",
"vai-Vaii",
"vai-Vaii-LR",
"vun-TZ",
"wae-CH",
"xog-UG",
"yav-CM",
"zgh-MA",
"af-NA",
"af-ZA",
"ak-GH",
"am-ET",
"ar-001",
"ar-AE",
"ar-BH",
"ar-DJ",
"ar-DZ",
"ar-EG",
"ar-EH",
"ar-ER",
"ar-IL",
"ar-IQ",
"ar-JO",
"ar-KM",
"ar-KW",
"ar-LB",
"ar-LY",
"ar-MA",
"ar-MR",
"ar-OM",
"ar-PS",
"ar-QA",
"ar-SA",
"ar-SD",
"ar-SO",
"ar-SS",
"ar-SY",
"ar-TD",
"ar-TN",
"ar-YE",
"as-IN",
"az-Cyrl",
"az-Cyrl-AZ",
"az-Latn",
"az-Latn-AZ",
"be-BY",
"bg-BG",
"bm-Latn",
"bm-Latn-ML",
"bn-BD",
"bn-IN",
"bo-CN",
"bo-IN",
"br-FR",
"bs-Cyrl",
"bs-Cyrl-BA",
"bs-Latn",
"bs-Latn-BA",
"ca-AD",
"ca-ES",
"ca-ES-VALENCIA",
"ca-FR",
"ca-IT",
"cs-CZ",
"cy-GB",
"da-DK",
"da-GL",
"de-AT",
"de-BE",
"de-CH",
"de-DE",
"de-LI",
"de-LU",
"dz-BT",
"ee-GH",
"ee-TG",
"el-CY",
"el-GR",
"en-001",
"en-150",
"en-AG",
"en-AI",
"en-AS",
"en-AU",
"en-BB",
"en-BE",
"en-BM",
"en-BS",
"en-BW",
"en-BZ",
"en-CA",
"en-CC",
"en-CK",
"en-CM",
"en-CX",
"en-DG",
"en-DM",
"en-ER",
"en-FJ",
"en-FK",
"en-FM",
"en-GB",
"en-GD",
"en-GG",
"en-GH",
"en-GI",
"en-GM",
"en-GU",
"en-GY",
"en-HK",
"en-IE",
"en-IM",
"en-IN",
"en-IO",
"en-JE",
"en-JM",
"en-KE",
"en-KI",
"en-KN",
"en-KY",
"en-LC",
"en-LR",
"en-LS",
"en-MG",
"en-MH",
"en-MO",
"en-MP",
"en-MS",
"en-MT",
"en-MU",
"en-MW",
"en-MY",
"en-NA",
"en-NF",
"en-NG",
"en-NR",
"en-NU",
"en-NZ",
"en-PG",
"en-PH",
"en-PK",
"en-PN",
"en-PR",
"en-PW",
"en-RW",
"en-SB",
"en-SC",
"en-SD",
"en-SG",
"en-SH",
"en-SL",
"en-SS",
"en-SX",
"en-SZ",
"en-TC",
"en-TK",
"en-TO",
"en-TT",
"en-TV",
"en-TZ",
"en-UG",
"en-UM",
"en-US",
"en-US-POSIX",
"en-VC",
"en-VG",
"en-VI",
"en-VU",
"en-WS",
"en-ZA",
"en-ZM",
"en-ZW",
"eo-001",
"es-419",
"es-AR",
"es-BO",
"es-CL",
"es-CO",
"es-CR",
"es-CU",
"es-DO",
"es-EA",
"es-EC",
"es-ES",
"es-GQ",
"es-GT",
"es-HN",
"es-IC",
"es-MX",
"es-NI",
"es-PA",
"es-PE",
"es-PH",
"es-PR",
"es-PY",
"es-SV",
"es-US",
"es-UY",
"es-VE",
"et-EE",
"eu-ES",
"fa-AF",
"fa-IR",
"ff-CM",
"ff-GN",
"ff-MR",
"ff-SN",
"fi-FI",
"fo-FO",
"fr-BE",
"fr-BF",
"fr-BI",
"fr-BJ",
"fr-BL",
"fr-CA",
"fr-CD",
"fr-CF",
"fr-CG",
"fr-CH",
"fr-CI",
"fr-CM",
"fr-DJ",
"fr-DZ",
"fr-FR",
"fr-GA",
"fr-GF",
"fr-GN",
"fr-GP",
"fr-GQ",
"fr-HT",
"fr-KM",
"fr-LU",
"fr-MA",
"fr-MC",
"fr-MF",
"fr-MG",
"fr-ML",
"fr-MQ",
"fr-MR",
"fr-MU",
"fr-NC",
"fr-NE",
"fr-PF",
"fr-PM",
"fr-RE",
"fr-RW",
"fr-SC",
"fr-SN",
"fr-SY",
"fr-TD",
"fr-TG",
"fr-TN",
"fr-VU",
"fr-WF",
"fr-YT",
"fy-NL",
"ga-IE",
"gd-GB",
"gl-ES",
"gu-IN",
"gv-IM",
"ha-Latn",
"ha-Latn-GH",
"ha-Latn-NE",
"ha-Latn-NG",
"he-IL",
"hi-IN",
"hr-BA",
"hr-HR",
"hu-HU",
"hy-AM",
"id-ID",
"ig-NG",
"ii-CN",
"is-IS",
"it-CH",
"it-IT",
"it-SM",
"ja-JP",
"ka-GE",
"ki-KE",
"kk-Cyrl",
"kk-Cyrl-KZ",
"kl-GL",
"km-KH",
"kn-IN",
"ko-KP",
"ko-KR",
"ks-Arab",
"ks-Arab-IN",
"kw-GB",
"ky-Cyrl",
"ky-Cyrl-KG",
"lb-LU",
"lg-UG",
"ln-AO",
"ln-CD",
"ln-CF",
"ln-CG",
"lo-LA",
"lt-LT",
"lu-CD",
"lv-LV",
"mg-MG",
"mk-MK",
"ml-IN",
"mn-Cyrl",
"mn-Cyrl-MN",
"mr-IN",
"ms-Latn",
"ms-Latn-BN",
"ms-Latn-MY",
"ms-Latn-SG",
"mt-MT",
"my-MM",
"nb-NO",
"nb-SJ",
"nd-ZW",
"ne-IN",
"ne-NP",
"nl-AW",
"nl-BE",
"nl-BQ",
"nl-CW",
"nl-NL",
"nl-SR",
"nl-SX",
"nn-NO",
"om-ET",
"om-KE",
"or-IN",
"os-GE",
"os-RU",
"pa-Arab",
"pa-Arab-PK",
"pa-Guru",
"pa-Guru-IN",
"pl-PL",
"ps-AF",
"pt-AO",
"pt-BR",
"pt-CV",
"pt-GW",
"pt-MO",
"pt-MZ",
"pt-PT",
"pt-ST",
"pt-TL",
"qu-BO",
"qu-EC",
"qu-PE",
"rm-CH",
"rn-BI",
"ro-MD",
"ro-RO",
"ru-BY",
"ru-KG",
"ru-KZ",
"ru-MD",
"ru-RU",
"ru-UA",
"rw-RW",
"se-FI",
"se-NO",
"se-SE",
"sg-CF",
"si-LK",
"sk-SK",
"sl-SI",
"sn-ZW",
"so-DJ",
"so-ET",
"so-KE",
"so-SO",
"sq-AL",
"sq-MK",
"sq-XK",
"sr-Cyrl",
"sr-Cyrl-BA",
"sr-Cyrl-ME",
"sr-Cyrl-RS",
"sr-Cyrl-XK",
"sr-Latn",
"sr-Latn-BA",
"sr-Latn-ME",
"sr-Latn-RS",
"sr-Latn-XK",
"sv-AX",
"sv-FI",
"sv-SE",
"sw-CD",
"sw-KE",
"sw-TZ",
"sw-UG",
"ta-IN",
"ta-LK",
"ta-MY",
"ta-SG",
"te-IN",
"th-TH",
"ti-ER",
"ti-ET",
"to-TO",
"tr-CY",
"tr-TR",
"ug-Arab",
"ug-Arab-CN",
"uk-UA",
"ur-IN",
"ur-PK",
"uz-Arab",
"uz-Arab-AF",
"uz-Cyrl",
"uz-Cyrl-UZ",
"uz-Latn",
"uz-Latn-UZ",
"vi-VN",
"yi-001",
"yo-BJ",
"yo-NG",
"zh-Hans",
"zh-Hans-CN",
"zh-Hans-HK",
"zh-Hans-MO",
"zh-Hans-SG",
"zh-Hant",
"zh-Hant-HK",
"zh-Hant-MO",
"zh-Hant-TW",
"zu-ZA"
],
us_states_and_dc: [
{name: 'Alabama', abbreviation: 'AL'},
{name: 'Alaska', abbreviation: 'AK'},
{name: 'Arizona', abbreviation: 'AZ'},
{name: 'Arkansas', abbreviation: 'AR'},
{name: 'California', abbreviation: 'CA'},
{name: 'Colorado', abbreviation: 'CO'},
{name: 'Connecticut', abbreviation: 'CT'},
{name: 'Delaware', abbreviation: 'DE'},
{name: 'District of Columbia', abbreviation: 'DC'},
{name: 'Florida', abbreviation: 'FL'},
{name: 'Georgia', abbreviation: 'GA'},
{name: 'Hawaii', abbreviation: 'HI'},
{name: 'Idaho', abbreviation: 'ID'},
{name: 'Illinois', abbreviation: 'IL'},
{name: 'Indiana', abbreviation: 'IN'},
{name: 'Iowa', abbreviation: 'IA'},
{name: 'Kansas', abbreviation: 'KS'},
{name: 'Kentucky', abbreviation: 'KY'},
{name: 'Louisiana', abbreviation: 'LA'},
{name: 'Maine', abbreviation: 'ME'},
{name: 'Maryland', abbreviation: 'MD'},
{name: 'Massachusetts', abbreviation: 'MA'},
{name: 'Michigan', abbreviation: 'MI'},
{name: 'Minnesota', abbreviation: 'MN'},
{name: 'Mississippi', abbreviation: 'MS'},
{name: 'Missouri', abbreviation: 'MO'},
{name: 'Montana', abbreviation: 'MT'},
{name: 'Nebraska', abbreviation: 'NE'},
{name: 'Nevada', abbreviation: 'NV'},
{name: 'New Hampshire', abbreviation: 'NH'},
{name: 'New Jersey', abbreviation: 'NJ'},
{name: 'New Mexico', abbreviation: 'NM'},
{name: 'New York', abbreviation: 'NY'},
{name: 'North Carolina', abbreviation: 'NC'},
{name: 'North Dakota', abbreviation: 'ND'},
{name: 'Ohio', abbreviation: 'OH'},
{name: 'Oklahoma', abbreviation: 'OK'},
{name: 'Oregon', abbreviation: 'OR'},
{name: 'Pennsylvania', abbreviation: 'PA'},
{name: 'Rhode Island', abbreviation: 'RI'},
{name: 'South Carolina', abbreviation: 'SC'},
{name: 'South Dakota', abbreviation: 'SD'},
{name: 'Tennessee', abbreviation: 'TN'},
{name: 'Texas', abbreviation: 'TX'},
{name: 'Utah', abbreviation: 'UT'},
{name: 'Vermont', abbreviation: 'VT'},
{name: 'Virginia', abbreviation: 'VA'},
{name: 'Washington', abbreviation: 'WA'},
{name: 'West Virginia', abbreviation: 'WV'},
{name: 'Wisconsin', abbreviation: 'WI'},
{name: 'Wyoming', abbreviation: 'WY'}
],
territories: [
{name: 'American Samoa', abbreviation: 'AS'},
{name: 'Federated States of Micronesia', abbreviation: 'FM'},
{name: 'Guam', abbreviation: 'GU'},
{name: 'Marshall Islands', abbreviation: 'MH'},
{name: 'Northern Mariana Islands', abbreviation: 'MP'},
{name: 'Puerto Rico', abbreviation: 'PR'},
{name: 'Virgin Islands, U.S.', abbreviation: 'VI'}
],
armed_forces: [
{name: 'Armed Forces Europe', abbreviation: 'AE'},
{name: 'Armed Forces Pacific', abbreviation: 'AP'},
{name: 'Armed Forces the Americas', abbreviation: 'AA'}
],
country_regions: {
it: [
{ name: "Valle d'Aosta", abbreviation: "VDA" },
{ name: "Piemonte", abbreviation: "PIE" },
{ name: "Lombardia", abbreviation: "LOM" },
{ name: "Veneto", abbreviation: "VEN" },
{ name: "Trentino Alto Adige", abbreviation: "TAA" },
{ name: "Friuli Venezia Giulia", abbreviation: "FVG" },
{ name: "Liguria", abbreviation: "LIG" },
{ name: "Emilia Romagna", abbreviation: "EMR" },
{ name: "Toscana", abbreviation: "TOS" },
{ name: "Umbria", abbreviation: "UMB" },
{ name: "Marche", abbreviation: "MAR" },
{ name: "Abruzzo", abbreviation: "ABR" },
{ name: "Lazio", abbreviation: "LAZ" },
{ name: "Campania", abbreviation: "CAM" },
{ name: "Puglia", abbreviation: "PUG" },
{ name: "Basilicata", abbreviation: "BAS" },
{ name: "Molise", abbreviation: "MOL" },
{ name: "Calabria", abbreviation: "CAL" },
{ name: "Sicilia", abbreviation: "SIC" },
{ name: "Sardegna", abbreviation: "SAR" }
]
},
street_suffixes: {
'us': [
{name: 'Avenue', abbreviation: 'Ave'},
{name: 'Boulevard', abbreviation: 'Blvd'},
{name: 'Center', abbreviation: 'Ctr'},
{name: 'Circle', abbreviation: 'Cir'},
{name: 'Court', abbreviation: 'Ct'},
{name: 'Drive', abbreviation: 'Dr'},
{name: 'Extension', abbreviation: 'Ext'},
{name: 'Glen', abbreviation: 'Gln'},
{name: 'Grove', abbreviation: 'Grv'},
{name: 'Heights', abbreviation: 'Hts'},
{name: 'Highway', abbreviation: 'Hwy'},
{name: 'Junction', abbreviation: 'Jct'},
{name: 'Key', abbreviation: 'Key'},
{name: 'Lane', abbreviation: 'Ln'},
{name: 'Loop', abbreviation: 'Loop'},
{name: 'Manor', abbreviation: 'Mnr'},
{name: 'Mill', abbreviation: 'Mill'},
{name: 'Park', abbreviation: 'Park'},
{name: 'Parkway', abbreviation: 'Pkwy'},
{name: 'Pass', abbreviation: 'Pass'},
{name: 'Path', abbreviation: 'Path'},
{name: 'Pike', abbreviation: 'Pike'},
{name: 'Place', abbreviation: 'Pl'},
{name: 'Plaza', abbreviation: 'Plz'},
{name: 'Point', abbreviation: 'Pt'},
{name: 'Ridge', abbreviation: 'Rdg'},
{name: 'River', abbreviation: 'Riv'},
{name: 'Road', abbreviation: 'Rd'},
{name: 'Square', abbreviation: 'Sq'},
{name: 'Street', abbreviation: 'St'},
{name: 'Terrace', abbreviation: 'Ter'},
{name: 'Trail', abbreviation: 'Trl'},
{name: 'Turnpike', abbreviation: 'Tpke'},
{name: 'View', abbreviation: 'Vw'},
{name: 'Way', abbreviation: 'Way'}
],
'it': [
{ name: 'Accesso', abbreviation: 'Acc.' },
{ name: 'Alzaia', abbreviation: 'Alz.' },
{ name: 'Arco', abbreviation: 'Arco' },
{ name: 'Archivolto', abbreviation: 'Acv.' },
{ name: 'Arena', abbreviation: 'Arena' },
{ name: 'Argine', abbreviation: 'Argine' },
{ name: 'Bacino', abbreviation: 'Bacino' },
{ name: 'Banchi', abbreviation: 'Banchi' },
{ name: 'Banchina', abbreviation: 'Ban.' },
{ name: 'Bastioni', abbreviation: 'Bas.' },
{ name: 'Belvedere', abbreviation: 'Belv.' },
{ name: 'Borgata', abbreviation: 'B.ta' },
{ name: 'Borgo', abbreviation: 'B.go' },
{ name: 'Calata', abbreviation: 'Cal.' },
{ name: 'Calle', abbreviation: 'Calle' },
{ name: 'Campiello', abbreviation: 'Cam.' },
{ name: 'Campo', abbreviation: 'Cam.' },
{ name: 'Canale', abbreviation: 'Can.' },
{ name: 'Carraia', abbreviation: 'Carr.' },
{ name: 'Cascina', abbreviation: 'Cascina' },
{ name: 'Case sparse', abbreviation: 'c.s.' },
{ name: 'Cavalcavia', abbreviation: 'Cv.' },
{ name: 'Circonvallazione', abbreviation: 'Cv.' },
{ name: 'Complanare', abbreviation: 'C.re' },
{ name: 'Contrada', abbreviation: 'C.da' },
{ name: 'Corso', abbreviation: 'C.so' },
{ name: 'Corte', abbreviation: 'C.te' },
{ name: 'Cortile', abbreviation: 'C.le' },
{ name: 'Diramazione', abbreviation: 'Dir.' },
{ name: 'Fondaco', abbreviation: 'F.co' },
{ name: 'Fondamenta', abbreviation: 'F.ta' },
{ name: 'Fondo', abbreviation: 'F.do' },
{ name: 'Frazione', abbreviation: 'Fr.' },
{ name: 'Isola', abbreviation: 'Is.' },
{ name: 'Largo', abbreviation: 'L.go' },
{ name: 'Litoranea', abbreviation: 'Lit.' },
{ name: 'Lungolago', abbreviation: 'L.go lago' },
{ name: 'Lungo Po', abbreviation: 'l.go Po' },
{ name: 'Molo', abbreviation: 'Molo' },
{ name: 'Mura', abbreviation: 'Mura' },
{ name: 'Passaggio privato', abbreviation: 'pass. priv.' },
{ name: 'Passeggiata', abbreviation: 'Pass.' },
{ name: 'Piazza', abbreviation: 'P.zza' },
{ name: 'Piazzale', abbreviation: 'P.le' },
{ name: 'Ponte', abbreviation: 'P.te' },
{ name: 'Portico', abbreviation: 'P.co' },
{ name: 'Rampa', abbreviation: 'Rampa' },
{ name: 'Regione', abbreviation: 'Reg.' },
{ name: 'Rione', abbreviation: 'R.ne' },
{ name: 'Rio', abbreviation: 'Rio' },
{ name: 'Ripa', abbreviation: 'Ripa' },
{ name: 'Riva', abbreviation: 'Riva' },
{ name: 'Rondò', abbreviation: 'Rondò' },
{ name: 'Rotonda', abbreviation: 'Rot.' },
{ name: 'Sagrato', abbreviation: 'Sagr.' },
{ name: 'Salita', abbreviation: 'Sal.' },
{ name: 'Scalinata', abbreviation: 'Scal.' },
{ name: 'Scalone', abbreviation: 'Scal.' },
{ name: 'Slargo', abbreviation: 'Sl.' },
{ name: 'Sottoportico', abbreviation: 'Sott.' },
{ name: 'Strada', abbreviation: 'Str.' },
{ name: 'Stradale', abbreviation: 'Str.le' },
{ name: 'Strettoia', abbreviation: 'Strett.' },
{ name: 'Traversa', abbreviation: 'Trav.' },
{ name: 'Via', abbreviation: 'V.' },
{ name: 'Viale', abbreviation: 'V.le' },
{ name: 'Vicinale', abbreviation: 'Vic.le' },
{ name: 'Vicolo', abbreviation: 'Vic.' }
],
'uk' : [
{name: 'Avenue', abbreviation: 'Ave'},
{name: 'Close', abbreviation: 'Cl'},
{name: 'Court', abbreviation: 'Ct'},
{name: 'Crescent', abbreviation: 'Cr'},
{name: 'Drive', abbreviation: 'Dr'},
{name: 'Garden', abbreviation: 'Gdn'},
{name: 'Gardens', abbreviation: 'Gdns'},
{name: 'Green', abbreviation: 'Gn'},
{name: 'Grove', abbreviation: 'Gr'},
{name: 'Lane', abbreviation: 'Ln'},
{name: 'Mount', abbreviation: 'Mt'},
{name: 'Place', abbreviation: 'Pl'},
{name: 'Park', abbreviation: 'Pk'},
{name: 'Ridge', abbreviation: 'Rdg'},
{name: 'Road', abbreviation: 'Rd'},
{name: 'Square', abbreviation: 'Sq'},
{name: 'Street', abbreviation: 'St'},
{name: 'Terrace', abbreviation: 'Ter'},
{name: 'Valley', abbreviation: 'Val'}
]
},
months: [
{name: 'January', short_name: 'Jan', numeric: '01', days: 31},
// Not messing with leap years...
{name: 'February', short_name: 'Feb', numeric: '02', days: 28},
{name: 'March', short_name: 'Mar', numeric: '03', days: 31},
{name: 'April', short_name: 'Apr', numeric: '04', days: 30},
{name: 'May', short_name: 'May', numeric: '05', days: 31},
{name: 'June', short_name: 'Jun', numeric: '06', days: 30},
{name: 'July', short_name: 'Jul', numeric: '07', days: 31},
{name: 'August', short_name: 'Aug', numeric: '08', days: 31},
{name: 'September', short_name: 'Sep', numeric: '09', days: 30},
{name: 'October', short_name: 'Oct', numeric: '10', days: 31},
{name: 'November', short_name: 'Nov', numeric: '11', days: 30},
{name: 'December', short_name: 'Dec', numeric: '12', days: 31}
],
// http://en.wikipedia.org/wiki/Bank_card_number#Issuer_identification_number_.28IIN.29
cc_types: [
{name: "American Express", short_name: 'amex', prefix: '34', length: 15},
{name: "Bankcard", short_name: 'bankcard', prefix: '5610', length: 16},
{name: "China UnionPay", short_name: 'chinaunion', prefix: '62', length: 16},
{name: "Diners Club Carte Blanche", short_name: 'dccarte', prefix: '300', length: 14},
{name: "Diners Club enRoute", short_name: 'dcenroute', prefix: '2014', length: 15},
{name: "Diners Club International", short_name: 'dcintl', prefix: '36', length: 14},
{name: "Diners Club United States & Canada", short_name: 'dcusc', prefix: '54', length: 16},
{name: "Discover Card", short_name: 'discover', prefix: '6011', length: 16},
{name: "InstaPayment", short_name: 'instapay', prefix: '637', length: 16},
{name: "JCB", short_name: 'jcb', prefix: '3528', length: 16},
{name: "Laser", short_name: 'laser', prefix: '6304', length: 16},
{name: "Maestro", short_name: 'maestro', prefix: '5018', length: 16},
{name: "Mastercard", short_name: 'mc', prefix: '51', length: 16},
{name: "Solo", short_name: 'solo', prefix: '6334', length: 16},
{name: "Switch", short_name: 'switch', prefix: '4903', length: 16},
{name: "Visa", short_name: 'visa', prefix: '4', length: 16},
{name: "Visa Electron", short_name: 'electron', prefix: '4026', length: 16}
],
//return all world currency by ISO 4217
currency_types: [
{'code' : 'AED', 'name' : 'United Arab Emirates Dirham'},
{'code' : 'AFN', 'name' : 'Afghanistan Afghani'},
{'code' : 'ALL', 'name' : 'Albania Lek'},
{'code' : 'AMD', 'name' : 'Armenia Dram'},
{'code' : 'ANG', 'name' : 'Netherlands Antilles Guilder'},
{'code' : 'AOA', 'name' : 'Angola Kwanza'},
{'code' : 'ARS', 'name' : 'Argentina Peso'},
{'code' : 'AUD', 'name' : 'Australia Dollar'},
{'code' : 'AWG', 'name' : 'Aruba Guilder'},
{'code' : 'AZN', 'name' : 'Azerbaijan New Manat'},
{'code' : 'BAM', 'name' : 'Bosnia and Herzegovina Convertible Marka'},
{'code' : 'BBD', 'name' : 'Barbados Dollar'},
{'code' : 'BDT', 'name' : 'Bangladesh Taka'},
{'code' : 'BGN', 'name' : 'Bulgaria Lev'},
{'code' : 'BHD', 'name' : 'Bahrain Dinar'},
{'code' : 'BIF', 'name' : 'Burundi Franc'},
{'code' : 'BMD', 'name' : 'Bermuda Dollar'},
{'code' : 'BND', 'name' : 'Brunei Darussalam Dollar'},
{'code' : 'BOB', 'name' : 'Bolivia Boliviano'},
{'code' : 'BRL', 'name' : 'Brazil Real'},
{'code' : 'BSD', 'name' : 'Bahamas Dollar'},
{'code' : 'BTN', 'name' : 'Bhutan Ngultrum'},
{'code' : 'BWP', 'name' : 'Botswana Pula'},
{'code' : 'BYR', 'name' : 'Belarus Ruble'},
{'code' : 'BZD', 'name' : 'Belize Dollar'},
{'code' : 'CAD', 'name' : 'Canada Dollar'},
{'code' : 'CDF', 'name' : 'Congo/Kinshasa Franc'},
{'code' : 'CHF', 'name' : 'Switzerland Franc'},
{'code' : 'CLP', 'name' : 'Chile Peso'},
{'code' : 'CNY', 'name' : 'China Yuan Renminbi'},
{'code' : 'COP', 'name' : 'Colombia Peso'},
{'code' : 'CRC', 'name' : 'Costa Rica Colon'},
{'code' : 'CUC', 'name' : 'Cuba Convertible Peso'},
{'code' : 'CUP', 'name' : 'Cuba Peso'},
{'code' : 'CVE', 'name' : 'Cape Verde Escudo'},
{'code' : 'CZK', 'name' : 'Czech Republic Koruna'},
{'code' : 'DJF', 'name' : 'Djibouti Franc'},
{'code' : 'DKK', 'name' : 'Denmark Krone'},
{'code' : 'DOP', 'name' : 'Dominican Republic Peso'},
{'code' : 'DZD', 'name' : 'Algeria Dinar'},
{'code' : 'EGP', 'name' : 'Egypt Pound'},
{'code' : 'ERN', 'name' : 'Eritrea Nakfa'},
{'code' : 'ETB', 'name' : 'Ethiopia Birr'},
{'code' : 'EUR', 'name' : 'Euro Member Countries'},
{'code' : 'FJD', 'name' : 'Fiji Dollar'},
{'code' : 'FKP', 'name' : 'Falkland Islands (Malvinas) Pound'},
{'code' : 'GBP', 'name' : 'United Kingdom Pound'},
{'code' : 'GEL', 'name' : 'Georgia Lari'},
{'code' : 'GGP', 'name' : 'Guernsey Pound'},
{'code' : 'GHS', 'name' : 'Ghana Cedi'},
{'code' : 'GIP', 'name' : 'Gibraltar Pound'},
{'code' : 'GMD', 'name' : 'Gambia Dalasi'},
{'code' : 'GNF', 'name' : 'Guinea Franc'},
{'code' : 'GTQ', 'name' : 'Guatemala Quetzal'},
{'code' : 'GYD', 'name' : 'Guyana Dollar'},
{'code' : 'HKD', 'name' : 'Hong Kong Dollar'},
{'code' : 'HNL', 'name' : 'Honduras Lempira'},
{'code' : 'HRK', 'name' : 'Croatia Kuna'},
{'code' : 'HTG', 'name' : 'Haiti Gourde'},
{'code' : 'HUF', 'name' : 'Hungary Forint'},
{'code' : 'IDR', 'name' : 'Indonesia Rupiah'},
{'code' : 'ILS', 'name' : 'Israel Shekel'},
{'code' : 'IMP', 'name' : 'Isle of Man Pound'},
{'code' : 'INR', 'name' : 'India Rupee'},
{'code' : 'IQD', 'name' : 'Iraq Dinar'},
{'code' : 'IRR', 'name' : 'Iran Rial'},
{'code' : 'ISK', 'name' : 'Iceland Krona'},
{'code' : 'JEP', 'name' : 'Jersey Pound'},
{'code' : 'JMD', 'name' : 'Jamaica Dollar'},
{'code' : 'JOD', 'name' : 'Jordan Dinar'},
{'code' : 'JPY', 'name' : 'Japan Yen'},
{'code' : 'KES', 'name' : 'Kenya Shilling'},
{'code' : 'KGS', 'name' : 'Kyrgyzstan Som'},
{'code' : 'KHR', 'name' : 'Cambodia Riel'},
{'code' : 'KMF', 'name' : 'Comoros Franc'},
{'code' : 'KPW', 'name' : 'Korea (North) Won'},
{'code' : 'KRW', 'name' : 'Korea (South) Won'},
{'code' : 'KWD', 'name' : 'Kuwait Dinar'},
{'code' : 'KYD', 'name' : 'Cayman Islands Dollar'},
{'code' : 'KZT', 'name' : 'Kazakhstan Tenge'},
{'code' : 'LAK', 'name' : 'Laos Kip'},
{'code' : 'LBP', 'name' : 'Lebanon Pound'},
{'code' : 'LKR', 'name' : 'Sri Lanka Rupee'},
{'code' : 'LRD', 'name' : 'Liberia Dollar'},
{'code' : 'LSL', 'name' : 'Lesotho Loti'},
{'code' : 'LTL', 'name' : 'Lithuania Litas'},
{'code' : 'LYD', 'name' : 'Libya Dinar'},
{'code' : 'MAD', 'name' : 'Morocco Dirham'},
{'code' : 'MDL', 'name' : 'Moldova Leu'},
{'code' : 'MGA', 'name' : 'Madagascar Ariary'},
{'code' : 'MKD', 'name' : 'Macedonia Denar'},
{'code' : 'MMK', 'name' : 'Myanmar (Burma) Kyat'},
{'code' : 'MNT', 'name' : 'Mongolia Tughrik'},
{'code' : 'MOP', 'name' : 'Macau Pataca'},
{'code' : 'MRO', 'name' : 'Mauritania Ouguiya'},
{'code' : 'MUR', 'name' : 'Mauritius Rupee'},
{'code' : 'MVR', 'name' : 'Maldives (Maldive Islands) Rufiyaa'},
{'code' : 'MWK', 'name' : 'Malawi Kwacha'},
{'code' : 'MXN', 'name' : 'Mexico Peso'},
{'code' : 'MYR', 'name' : 'Malaysia Ringgit'},
{'code' : 'MZN', 'name' : 'Mozambique Metical'},
{'code' : 'NAD', 'name' : 'Namibia Dollar'},
{'code' : 'NGN', 'name' : 'Nigeria Naira'},
{'code' : 'NIO', 'name' : 'Nicaragua Cordoba'},
{'code' : 'NOK', 'name' : 'Norway Krone'},
{'code' : 'NPR', 'name' : 'Nepal Rupee'},
{'code' : 'NZD', 'name' : 'New Zealand Dollar'},
{'code' : 'OMR', 'name' : 'Oman Rial'},
{'code' : 'PAB', 'name' : 'Panama Balboa'},
{'code' : 'PEN', 'name' : 'Peru Nuevo Sol'},
{'code' : 'PGK', 'name' : 'Papua New Guinea Kina'},
{'code' : 'PHP', 'name' : 'Philippines Peso'},
{'code' : 'PKR', 'name' : 'Pakistan Rupee'},
{'code' : 'PLN', 'name' : 'Poland Zloty'},
{'code' : 'PYG', 'name' : 'Paraguay Guarani'},
{'code' : 'QAR', 'name' : 'Qatar Riyal'},
{'code' : 'RON', 'name' : 'Romania New Leu'},
{'code' : 'RSD', 'name' : 'Serbia Dinar'},
{'code' : 'RUB', 'name' : 'Russia Ruble'},
{'code' : 'RWF', 'name' : 'Rwanda Franc'},
{'code' : 'SAR', 'name' : 'Saudi Arabia Riyal'},
{'code' : 'SBD', 'name' : 'Solomon Islands Dollar'},
{'code' : 'SCR', 'name' : 'Seychelles Rupee'},
{'code' : 'SDG', 'name' : 'Sudan Pound'},
{'code' : 'SEK', 'name' : 'Sweden Krona'},
{'code' : 'SGD', 'name' : 'Singapore Dollar'},
{'code' : 'SHP', 'name' : 'Saint Helena Pound'},
{'code' : 'SLL', 'name' : 'Sierra Leone Leone'},
{'code' : 'SOS', 'name' : 'Somalia Shilling'},
{'code' : 'SPL', 'name' : 'Seborga Luigino'},
{'code' : 'SRD', 'name' : 'Suriname Dollar'},
{'code' : 'STD', 'name' : 'São Tomé and Príncipe Dobra'},
{'code' : 'SVC', 'name' : 'El Salvador Colon'},
{'code' : 'SYP', 'name' : 'Syria Pound'},
{'code' : 'SZL', 'name' : 'Swaziland Lilangeni'},
{'code' : 'THB', 'name' : 'Thailand Baht'},
{'code' : 'TJS', 'name' : 'Tajikistan Somoni'},
{'code' : 'TMT', 'name' : 'Turkmenistan Manat'},
{'code' : 'TND', 'name' : 'Tunisia Dinar'},
{'code' : 'TOP', 'name' : 'Tonga Pa\'anga'},
{'code' : 'TRY', 'name' : 'Turkey Lira'},
{'code' : 'TTD', 'name' : 'Trinidad and Tobago Dollar'},
{'code' : 'TVD', 'name' : 'Tuvalu Dollar'},
{'code' : 'TWD', 'name' : 'Taiwan New Dollar'},
{'code' : 'TZS', 'name' : 'Tanzania Shilling'},
{'code' : 'UAH', 'name' : 'Ukraine Hryvnia'},
{'code' : 'UGX', 'name' : 'Uganda Shilling'},
{'code' : 'USD', 'name' : 'United States Dollar'},
{'code' : 'UYU', 'name' : 'Uruguay Peso'},
{'code' : 'UZS', 'name' : 'Uzbekistan Som'},
{'code' : 'VEF', 'name' : 'Venezuela Bolivar'},
{'code' : 'VND', 'name' : 'Viet Nam Dong'},
{'code' : 'VUV', 'name' : 'Vanuatu Vatu'},
{'code' : 'WST', 'name' : 'Samoa Tala'},
{'code' : 'XAF', 'name' : 'Communauté Financière Africaine (BEAC) CFA Franc BEAC'},
{'code' : 'XCD', 'name' : 'East Caribbean Dollar'},
{'code' : 'XDR', 'name' : 'International Monetary Fund (IMF) Special Drawing Rights'},
{'code' : 'XOF', 'name' : 'Communauté Financière Africaine (BCEAO) Franc'},
{'code' : 'XPF', 'name' : 'Comptoirs Français du Pacifique (CFP) Franc'},
{'code' : 'YER', 'name' : 'Yemen Rial'},
{'code' : 'ZAR', 'name' : 'South Africa Rand'},
{'code' : 'ZMW', 'name' : 'Zambia Kwacha'},
{'code' : 'ZWD', 'name' : 'Zimbabwe Dollar'}
],
// return the names of all valide colors
colorNames : [ "AliceBlue", "Black", "Navy", "DarkBlue", "MediumBlue", "Blue", "DarkGreen", "Green", "Teal", "DarkCyan", "DeepSkyBlue", "DarkTurquoise", "MediumSpringGreen", "Lime", "SpringGreen",
"Aqua", "Cyan", "MidnightBlue", "DodgerBlue", "LightSeaGreen", "ForestGreen", "SeaGreen", "DarkSlateGray", "LimeGreen", "MediumSeaGreen", "Turquoise", "RoyalBlue", "SteelBlue", "DarkSlateBlue", "MediumTurquoise",
"Indigo", "DarkOliveGreen", "CadetBlue", "CornflowerBlue", "RebeccaPurple", "MediumAquaMarine", "DimGray", "SlateBlue", "OliveDrab", "SlateGray", "LightSlateGray", "MediumSlateBlue", "LawnGreen", "Chartreuse",
"Aquamarine", "Maroon", "Purple", "Olive", "Gray", "SkyBlue", "LightSkyBlue", "BlueViolet", "DarkRed", "DarkMagenta", "SaddleBrown", "Ivory", "White",
"DarkSeaGreen", "LightGreen", "MediumPurple", "DarkViolet", "PaleGreen", "DarkOrchid", "YellowGreen", "Sienna", "Brown", "DarkGray", "LightBlue", "GreenYellow", "PaleTurquoise", "LightSteelBlue", "PowderBlue",
"FireBrick", "DarkGoldenRod", "MediumOrchid", "RosyBrown", "DarkKhaki", "Silver", "MediumVioletRed", "IndianRed", "Peru", "Chocolate", "Tan", "LightGray", "Thistle", "Orchid", "GoldenRod", "PaleVioletRed",
"Crimson", "Gainsboro", "Plum", "BurlyWood", "LightCyan", "Lavender", "DarkSalmon", "Violet", "PaleGoldenRod", "LightCoral", "Khaki", "AliceBlue", "HoneyDew", "Azure", "SandyBrown", "Wheat", "Beige", "WhiteSmoke",
"MintCream", "GhostWhite", "Salmon", "AntiqueWhite", "Linen", "LightGoldenRodYellow", "OldLace", "Red", "Fuchsia", "Magenta", "DeepPink", "OrangeRed", "Tomato", "HotPink", "Coral", "DarkOrange", "LightSalmon", "Orange",
"LightPink", "Pink", "Gold", "PeachPuff", "NavajoWhite", "Moccasin", "Bisque", "MistyRose", "BlanchedAlmond", "PapayaWhip", "LavenderBlush", "SeaShell", "Cornsilk", "LemonChiffon", "FloralWhite", "Snow", "Yellow", "LightYellow"
],
// Data taken from https://www.sec.gov/rules/other/4-460list.htm
company: [ "3Com Corp",
"3M Company",
"A.G. Edwards Inc.",
"Abbott Laboratories",
"Abercrombie & Fitch Co.",
"ABM Industries Incorporated",
"Ace Hardware Corporation",
"ACT Manufacturing Inc.",
"Acterna Corp.",
"Adams Resources & Energy, Inc.",
"ADC Telecommunications, Inc.",
"Adelphia Communications Corporation",
"Administaff, Inc.",
"Adobe Systems Incorporated",
"Adolph Coors Company",
"Advance Auto Parts, Inc.",
"Advanced Micro Devices, Inc.",
"AdvancePCS, Inc.",
"Advantica Restaurant Group, Inc.",
"The AES Corporation",
"Aetna Inc.",
"Affiliated Computer Services, Inc.",
"AFLAC Incorporated",
"AGCO Corporation",
"Agilent Technologies, Inc.",
"Agway Inc.",
"Apartment Investment and Management Company",
"Air Products and Chemicals, Inc.",
"Airborne, Inc.",
"Airgas, Inc.",
"AK Steel Holding Corporation",
"Alaska Air Group, Inc.",
"Alberto-Culver Company",
"Albertson's, Inc.",
"Alcoa Inc.",
"Alleghany Corporation",
"Allegheny Energy, Inc.",
"Allegheny Technologies Incorporated",
"Allergan, Inc.",
"ALLETE, Inc.",
"Alliant Energy Corporation",
"Allied Waste Industries, Inc.",
"Allmerica Financial Corporation",
"The Allstate Corporation",
"ALLTEL Corporation",
"The Alpine Group, Inc.",
"Amazon.com, Inc.",
"AMC Entertainment Inc.",
"American Power Conversion Corporation",
"Amerada Hess Corporation",
"AMERCO",
"Ameren Corporation",
"America West Holdings Corporation",
"American Axle & Manufacturing Holdings, Inc.",
"American Eagle Outfitters, Inc.",
"American Electric Power Company, Inc.",
"American Express Company",
"American Financial Group, Inc.",
"American Greetings Corporation",
"American International Group, Inc.",
"American Standard Companies Inc.",
"American Water Works Company, Inc.",
"AmerisourceBergen Corporation",
"Ames Department Stores, Inc.",
"Amgen Inc.",
"Amkor Technology, Inc.",
"AMR Corporation",
"AmSouth Bancorp.",
"Amtran, Inc.",
"Anadarko Petroleum Corporation",
"Analog Devices, Inc.",
"Anheuser-Busch Companies, Inc.",
"Anixter International Inc.",
"AnnTaylor Inc.",
"Anthem, Inc.",
"AOL Time Warner Inc.",
"Aon Corporation",
"Apache Corporation",
"Apple Computer, Inc.",
"Applera Corporation",
"Applied Industrial Technologies, Inc.",
"Applied Materials, Inc.",
"Aquila, Inc.",
"ARAMARK Corporation",
"Arch Coal, Inc.",
"Archer Daniels Midland Company",
"Arkansas Best Corporation",
"Armstrong Holdings, Inc.",
"Arrow Electronics, Inc.",
"ArvinMeritor, Inc.",
"Ashland Inc.",
"Astoria Financial Corporation",
"AT&T Corp.",
"Atmel Corporation",
"Atmos Energy Corporation",
"Audiovox Corporation",
"Autoliv, Inc.",
"Automatic Data Processing, Inc.",
"AutoNation, Inc.",
"AutoZone, Inc.",
"Avaya Inc.",
"Avery Dennison Corporation",
"Avista Corporation",
"Avnet, Inc.",
"Avon Products, Inc.",
"Baker Hughes Incorporated",
"Ball Corporation",
"Bank of America Corporation",
"The Bank of New York Company, Inc.",
"Bank One Corporation",
"Banknorth Group, Inc.",
"Banta Corporation",
"Barnes & Noble, Inc.",
"Bausch & Lomb Incorporated",
"Baxter International Inc.",
"BB&T Corporation",
"The Bear Stearns Companies Inc.",
"Beazer Homes USA, Inc.",
"Beckman Coulter, Inc.",
"Becton, Dickinson and Company",
"Bed Bath & Beyond Inc.",
"Belk, Inc.",
"Bell Microproducts Inc.",
"BellSouth Corporation",
"Belo Corp.",
"Bemis Company, Inc.",
"Benchmark Electronics, Inc.",
"Berkshire Hathaway Inc.",
"Best Buy Co., Inc.",
"Bethlehem Steel Corporation",
"Beverly Enterprises, Inc.",
"Big Lots, Inc.",
"BJ Services Company",
"BJ's Wholesale Club, Inc.",
"The Black & Decker Corporation",
"Black Hills Corporation",
"BMC Software, Inc.",
"The Boeing Company",
"Boise Cascade Corporation",
"Borders Group, Inc.",
"BorgWarner Inc.",
"Boston Scientific Corporation",
"Bowater Incorporated",
"Briggs & Stratton Corporation",
"Brightpoint, Inc.",
"Brinker International, Inc.",
"Bristol-Myers Squibb Company",
"Broadwing, Inc.",
"Brown Shoe Company, Inc.",
"Brown-Forman Corporation",
"Brunswick Corporation",
"Budget Group, Inc.",
"Burlington Coat Factory Warehouse Corporation",
"Burlington Industries, Inc.",
"Burlington Northern Santa Fe Corporation",
"Burlington Resources Inc.",
"C. H. Robinson Worldwide Inc.",
"Cablevision Systems Corp",
"Cabot Corp",
"Cadence Design Systems, Inc.",
"Calpine Corp.",
"Campbell Soup Co.",
"Capital One Financial Corp.",
"Cardinal Health Inc.",
"Caremark Rx Inc.",
"Carlisle Cos. Inc.",
"Carpenter Technology Corp.",
"Casey's General Stores Inc.",
"Caterpillar Inc.",
"CBRL Group Inc.",
"CDI Corp.",
"CDW Computer Centers Inc.",
"CellStar Corp.",
"Cendant Corp",
"Cenex Harvest States Cooperatives",
"Centex Corp.",
"CenturyTel Inc.",
"Ceridian Corp.",
"CH2M Hill Cos. Ltd.",
"Champion Enterprises Inc.",
"Charles Schwab Corp.",
"Charming Shoppes Inc.",
"Charter Communications Inc.",
"Charter One Financial Inc.",
"ChevronTexaco Corp.",
"Chiquita Brands International Inc.",
"Chubb Corp",
"Ciena Corp.",
"Cigna Corp",
"Cincinnati Financial Corp.",
"Cinergy Corp.",
"Cintas Corp.",
"Circuit City Stores Inc.",
"Cisco Systems Inc.",
"Citigroup, Inc",
"Citizens Communications Co.",
"CKE Restaurants Inc.",
"Clear Channel Communications Inc.",
"The Clorox Co.",
"CMGI Inc.",
"CMS Energy Corp.",
"CNF Inc.",
"Coca-Cola Co.",
"Coca-Cola Enterprises Inc.",
"Colgate-Palmolive Co.",
"Collins & Aikman Corp.",
"Comcast Corp.",
"Comdisco Inc.",
"Comerica Inc.",
"Comfort Systems USA Inc.",
"Commercial Metals Co.",
"Community Health Systems Inc.",
"Compass Bancshares Inc",
"Computer Associates International Inc.",
"Computer Sciences Corp.",
"Compuware Corp.",
"Comverse Technology Inc.",
"ConAgra Foods Inc.",
"Concord EFS Inc.",
"Conectiv, Inc",
"Conoco Inc",
"Conseco Inc.",
"Consolidated Freightways Corp.",
"Consolidated Edison Inc.",
"Constellation Brands Inc.",
"Constellation Emergy Group Inc.",
"Continental Airlines Inc.",
"Convergys Corp.",
"Cooper Cameron Corp.",
"Cooper Industries Ltd.",
"Cooper Tire & Rubber Co.",
"Corn Products International Inc.",
"Corning Inc.",
"Costco Wholesale Corp.",
"Countrywide Credit Industries Inc.",
"Coventry Health Care Inc.",
"Cox Communications Inc.",
"Crane Co.",
"Crompton Corp.",
"Crown Cork & Seal Co. Inc.",
"CSK Auto Corp.",
"CSX Corp.",
"Cummins Inc.",
"CVS Corp.",
"Cytec Industries Inc.",
"D&K Healthcare Resources, Inc.",
"D.R. Horton Inc.",
"Dana Corporation",
"Danaher Corporation",
"Darden Restaurants Inc.",
"DaVita Inc.",
"Dean Foods Company",
"Deere & Company",
"Del Monte Foods Co",
"Dell Computer Corporation",
"Delphi Corp.",
"Delta Air Lines Inc.",
"Deluxe Corporation",
"Devon Energy Corporation",
"Di Giorgio Corporation",
"Dial Corporation",
"Diebold Incorporated",
"Dillard's Inc.",
"DIMON Incorporated",
"Dole Food Company, Inc.",
"Dollar General Corporation",
"Dollar Tree Stores, Inc.",
"Dominion Resources, Inc.",
"Domino's Pizza LLC",
"Dover Corporation, Inc.",
"Dow Chemical Company",
"Dow Jones & Company, Inc.",
"DPL Inc.",
"DQE Inc.",
"Dreyer's Grand Ice Cream, Inc.",
"DST Systems, Inc.",
"DTE Energy Co.",
"E.I. Du Pont de Nemours and Company",
"Duke Energy Corp",
"Dun & Bradstreet Inc.",
"DURA Automotive Systems Inc.",
"DynCorp",
"Dynegy Inc.",
"E*Trade Group, Inc.",
"E.W. Scripps Company",
"Earthlink, Inc.",
"Eastman Chemical Company",
"Eastman Kodak Company",
"Eaton Corporation",
"Echostar Communications Corporation",
"Ecolab Inc.",
"Edison International",
"EGL Inc.",
"El Paso Corporation",
"Electronic Arts Inc.",
"Electronic Data Systems Corp.",
"Eli Lilly and Company",
"EMC Corporation",
"Emcor Group Inc.",
"Emerson Electric Co.",
"Encompass Services Corporation",
"Energizer Holdings Inc.",
"Energy East Corporation",
"Engelhard Corporation",
"Enron Corp.",
"Entergy Corporation",
"Enterprise Products Partners L.P.",
"EOG Resources, Inc.",
"Equifax Inc.",
"Equitable Resources Inc.",
"Equity Office Properties Trust",
"Equity Residential Properties Trust",
"Estee Lauder Companies Inc.",
"Exelon Corporation",
"Exide Technologies",
"Expeditors International of Washington Inc.",
"Express Scripts Inc.",
"ExxonMobil Corporation",
"Fairchild Semiconductor International Inc.",
"Family Dollar Stores Inc.",
"Farmland Industries Inc.",
"Federal Mogul Corp.",
"Federated Department Stores Inc.",
"Federal Express Corp.",
"Felcor Lodging Trust Inc.",
"Ferro Corp.",
"Fidelity National Financial Inc.",
"Fifth Third Bancorp",
"First American Financial Corp.",
"First Data Corp.",
"First National of Nebraska Inc.",
"First Tennessee National Corp.",
"FirstEnergy Corp.",
"Fiserv Inc.",
"Fisher Scientific International Inc.",
"FleetBoston Financial Co.",
"Fleetwood Enterprises Inc.",
"Fleming Companies Inc.",
"Flowers Foods Inc.",
"Flowserv Corp",
"Fluor Corp",
"FMC Corp",
"Foamex International Inc",
"Foot Locker Inc",
"Footstar Inc.",
"Ford Motor Co",
"Forest Laboratories Inc.",
"Fortune Brands Inc.",
"Foster Wheeler Ltd.",
"FPL Group Inc.",
"Franklin Resources Inc.",
"Freeport McMoran Copper & Gold Inc.",
"Frontier Oil Corp",
"Furniture Brands International Inc.",
"Gannett Co., Inc.",
"Gap Inc.",
"Gateway Inc.",
"GATX Corporation",
"Gemstar-TV Guide International Inc.",
"GenCorp Inc.",
"General Cable Corporation",
"General Dynamics Corporation",
"General Electric Company",
"General Mills Inc",
"General Motors Corporation",
"Genesis Health Ventures Inc.",
"Gentek Inc.",
"Gentiva Health Services Inc.",
"Genuine Parts Company",
"Genuity Inc.",
"Genzyme Corporation",
"Georgia Gulf Corporation",
"Georgia-Pacific Corporation",
"Gillette Company",
"Gold Kist Inc.",
"Golden State Bancorp Inc.",
"Golden West Financial Corporation",
"Goldman Sachs Group Inc.",
"Goodrich Corporation",
"The Goodyear Tire & Rubber Company",
"Granite Construction Incorporated",
"Graybar Electric Company Inc.",
"Great Lakes Chemical Corporation",
"Great Plains Energy Inc.",
"GreenPoint Financial Corp.",
"Greif Bros. Corporation",
"Grey Global Group Inc.",
"Group 1 Automotive Inc.",
"Guidant Corporation",
"H&R Block Inc.",
"H.B. Fuller Company",
"H.J. Heinz Company",
"Halliburton Co.",
"Harley-Davidson Inc.",
"Harman International Industries Inc.",
"Harrah's Entertainment Inc.",
"Harris Corp.",
"Harsco Corp.",
"Hartford Financial Services Group Inc.",
"Hasbro Inc.",
"Hawaiian Electric Industries Inc.",
"HCA Inc.",
"Health Management Associates Inc.",
"Health Net Inc.",
"Healthsouth Corp",
"Henry Schein Inc.",
"Hercules Inc.",
"Herman Miller Inc.",
"Hershey Foods Corp.",
"Hewlett-Packard Company",
"Hibernia Corp.",
"Hillenbrand Industries Inc.",
"Hilton Hotels Corp.",
"Hollywood Entertainment Corp.",
"Home Depot Inc.",
"Hon Industries Inc.",
"Honeywell International Inc.",
"Hormel Foods Corp.",
"Host Marriott Corp.",
"Household International Corp.",
"Hovnanian Enterprises Inc.",
"Hub Group Inc.",
"Hubbell Inc.",
"Hughes Supply Inc.",
"Humana Inc.",
"Huntington Bancshares Inc.",
"Idacorp Inc.",
"IDT Corporation",
"IKON Office Solutions Inc.",
"Illinois Tool Works Inc.",
"IMC Global Inc.",
"Imperial Sugar Company",
"IMS Health Inc.",
"Ingles Market Inc",
"Ingram Micro Inc.",
"Insight Enterprises Inc.",
"Integrated Electrical Services Inc.",
"Intel Corporation",
"International Paper Co.",
"Interpublic Group of Companies Inc.",
"Interstate Bakeries Corporation",
"International Business Machines Corp.",
"International Flavors & Fragrances Inc.",
"International Multifoods Corporation",
"Intuit Inc.",
"IT Group Inc.",
"ITT Industries Inc.",
"Ivax Corp.",
"J.B. Hunt Transport Services Inc.",
"J.C. Penny Co.",
"J.P. Morgan Chase & Co.",
"Jabil Circuit Inc.",
"Jack In The Box Inc.",
"Jacobs Engineering Group Inc.",
"JDS Uniphase Corp.",
"Jefferson-Pilot Co.",
"John Hancock Financial Services Inc.",
"Johnson & Johnson",
"Johnson Controls Inc.",
"Jones Apparel Group Inc.",
"KB Home",
"Kellogg Company",
"Kellwood Company",
"Kelly Services Inc.",
"Kemet Corp.",
"Kennametal Inc.",
"Kerr-McGee Corporation",
"KeyCorp",
"KeySpan Corp.",
"Kimball International Inc.",
"Kimberly-Clark Corporation",
"Kindred Healthcare Inc.",
"KLA-Tencor Corporation",
"K-Mart Corp.",
"Knight-Ridder Inc.",
"Kohl's Corp.",
"KPMG Consulting Inc.",
"Kroger Co.",
"L-3 Communications Holdings Inc.",
"Laboratory Corporation of America Holdings",
"Lam Research Corporation",
"LandAmerica Financial Group Inc.",
"Lands' End Inc.",
"Landstar System Inc.",
"La-Z-Boy Inc.",
"Lear Corporation",
"Legg Mason Inc.",
"Leggett & Platt Inc.",
"Lehman Brothers Holdings Inc.",
"Lennar Corporation",
"Lennox International Inc.",
"Level 3 Communications Inc.",
"Levi Strauss & Co.",
"Lexmark International Inc.",
"Limited Inc.",
"Lincoln National Corporation",
"Linens 'n Things Inc.",
"Lithia Motors Inc.",
"Liz Claiborne Inc.",
"Lockheed Martin Corporation",
"Loews Corporation",
"Longs Drug Stores Corporation",
"Louisiana-Pacific Corporation",
"Lowe's Companies Inc.",
"LSI Logic Corporation",
"The LTV Corporation",
"The Lubrizol Corporation",
"Lucent Technologies Inc.",
"Lyondell Chemical Company",
"M & T Bank Corporation",
"Magellan Health Services Inc.",
"Mail-Well Inc.",
"Mandalay Resort Group",
"Manor Care Inc.",
"Manpower Inc.",
"Marathon Oil Corporation",
"Mariner Health Care Inc.",
"Markel Corporation",
"Marriott International Inc.",
"Marsh & McLennan Companies Inc.",
"Marsh Supermarkets Inc.",
"Marshall & Ilsley Corporation",
"Martin Marietta Materials Inc.",
"Masco Corporation",
"Massey Energy Company",
"MasTec Inc.",
"Mattel Inc.",
"Maxim Integrated Products Inc.",
"Maxtor Corporation",
"Maxxam Inc.",
"The May Department Stores Company",
"Maytag Corporation",
"MBNA Corporation",
"McCormick & Company Incorporated",
"McDonald's Corporation",
"The McGraw-Hill Companies Inc.",
"McKesson Corporation",
"McLeodUSA Incorporated",
"M.D.C. Holdings Inc.",
"MDU Resources Group Inc.",
"MeadWestvaco Corporation",
"Medtronic Inc.",
"Mellon Financial Corporation",
"The Men's Wearhouse Inc.",
"Merck & Co., Inc.",
"Mercury General Corporation",
"Merrill Lynch & Co. Inc.",
"Metaldyne Corporation",
"Metals USA Inc.",
"MetLife Inc.",
"Metris Companies Inc",
"MGIC Investment Corporation",
"MGM Mirage",
"Michaels Stores Inc.",
"Micron Technology Inc.",
"Microsoft Corporation",
"Milacron Inc.",
"Millennium Chemicals Inc.",
"Mirant Corporation",
"Mohawk Industries Inc.",
"Molex Incorporated",
"The MONY Group Inc.",
"Morgan Stanley Dean Witter & Co.",
"Motorola Inc.",
"MPS Group Inc.",
"Murphy Oil Corporation",
"Nabors Industries Inc",
"Nacco Industries Inc",
"Nash Finch Company",
"National City Corp.",
"National Commerce Financial Corporation",
"National Fuel Gas Company",
"National Oilwell Inc",
"National Rural Utilities Cooperative Finance Corporation",
"National Semiconductor Corporation",
"National Service Industries Inc",
"Navistar International Corporation",
"NCR Corporation",
"The Neiman Marcus Group Inc.",
"New Jersey Resources Corporation",
"New York Times Company",
"Newell Rubbermaid Inc",
"Newmont Mining Corporation",
"Nextel Communications Inc",
"Nicor Inc",
"Nike Inc",
"NiSource Inc",
"Noble Energy Inc",
"Nordstrom Inc",
"Norfolk Southern Corporation",
"Nortek Inc",
"North Fork Bancorporation Inc",
"Northeast Utilities System",
"Northern Trust Corporation",
"Northrop Grumman Corporation",
"NorthWestern Corporation",
"Novellus Systems Inc",
"NSTAR",
"NTL Incorporated",
"Nucor Corp",
"Nvidia Corp",
"NVR Inc",
"Northwest Airlines Corp",
"Occidental Petroleum Corp",
"Ocean Energy Inc",
"Office Depot Inc.",
"OfficeMax Inc",
"OGE Energy Corp",
"Oglethorpe Power Corp.",
"Ohio Casualty Corp.",
"Old Republic International Corp.",
"Olin Corp.",
"OM Group Inc",
"Omnicare Inc",
"Omnicom Group",
"On Semiconductor Corp",
"ONEOK Inc",
"Oracle Corp",
"Oshkosh Truck Corp",
"Outback Steakhouse Inc.",
"Owens & Minor Inc.",
"Owens Corning",
"Owens-Illinois Inc",
"Oxford Health Plans Inc",
"Paccar Inc",
"PacifiCare Health Systems Inc",
"Packaging Corp. of America",
"Pactiv Corp",
"Pall Corp",
"Pantry Inc",
"Park Place Entertainment Corp",
"Parker Hannifin Corp.",
"Pathmark Stores Inc.",
"Paychex Inc",
"Payless Shoesource Inc",
"Penn Traffic Co.",
"Pennzoil-Quaker State Company",
"Pentair Inc",
"Peoples Energy Corp.",
"PeopleSoft Inc",
"Pep Boys Manny, Moe & Jack",
"Potomac Electric Power Co.",
"Pepsi Bottling Group Inc.",
"PepsiAmericas Inc.",
"PepsiCo Inc.",
"Performance Food Group Co.",
"Perini Corp",
"PerkinElmer Inc",
"Perot Systems Corp",
"Petco Animal Supplies Inc.",
"Peter Kiewit Sons', Inc.",
"PETsMART Inc",
"Pfizer Inc",
"Pacific Gas & Electric Corp.",
"Pharmacia Corp",
"Phar Mor Inc.",
"Phelps Dodge Corp.",
"Philip Morris Companies Inc.",
"Phillips Petroleum Co",
"Phillips Van Heusen Corp.",
"Phoenix Companies Inc",
"Pier 1 Imports Inc.",
"Pilgrim's Pride Corporation",
"Pinnacle West Capital Corp",
"Pioneer-Standard Electronics Inc.",
"Pitney Bowes Inc.",
"Pittston Brinks Group",
"Plains All American Pipeline LP",
"PNC Financial Services Group Inc.",
"PNM Resources Inc",
"Polaris Industries Inc.",
"Polo Ralph Lauren Corp",
"PolyOne Corp",
"Popular Inc",
"Potlatch Corp",
"PPG Industries Inc",
"PPL Corp",
"Praxair Inc",
"Precision Castparts Corp",
"Premcor Inc.",
"Pride International Inc",
"Primedia Inc",
"Principal Financial Group Inc.",
"Procter & Gamble Co.",
"Pro-Fac Cooperative Inc.",
"Progress Energy Inc",
"Progressive Corporation",
"Protective Life Corp",
"Provident Financial Group",
"Providian Financial Corp.",
"Prudential Financial Inc.",
"PSS World Medical Inc",
"Public Service Enterprise Group Inc.",
"Publix Super Markets Inc.",
"Puget Energy Inc.",
"Pulte Homes Inc",
"Qualcomm Inc",
"Quanta Services Inc.",
"Quantum Corp",
"Quest Diagnostics Inc.",
"Questar Corp",
"Quintiles Transnational",
"Qwest Communications Intl Inc",
"R.J. Reynolds Tobacco Company",
"R.R. Donnelley & Sons Company",
"Radio Shack Corporation",
"Raymond James Financial Inc.",
"Raytheon Company",
"Reader's Digest Association Inc.",
"Reebok International Ltd.",
"Regions Financial Corp.",
"Regis Corporation",
"Reliance Steel & Aluminum Co.",
"Reliant Energy Inc.",
"Rent A Center Inc",
"Republic Services Inc",
"Revlon Inc",
"RGS Energy Group Inc",
"Rite Aid Corp",
"Riverwood Holding Inc.",
"RoadwayCorp",
"Robert Half International Inc.",
"Rock-Tenn Co",
"Rockwell Automation Inc",
"Rockwell Collins Inc",
"Rohm & Haas Co.",
"Ross Stores Inc",
"RPM Inc.",
"Ruddick Corp",
"Ryder System Inc",
"Ryerson Tull Inc",
"Ryland Group Inc.",
"Sabre Holdings Corp",
"Safeco Corp",
"Safeguard Scientifics Inc.",
"Safeway Inc",
"Saks Inc",
"Sanmina-SCI Inc",
"Sara Lee Corp",
"SBC Communications Inc",
"Scana Corp.",
"Schering-Plough Corp",
"Scholastic Corp",
"SCI Systems Onc.",
"Science Applications Intl. Inc.",
"Scientific-Atlanta Inc",
"Scotts Company",
"Seaboard Corp",
"Sealed Air Corp",
"Sears Roebuck & Co",
"Sempra Energy",
"Sequa Corp",
"Service Corp. International",
"ServiceMaster Co",
"Shaw Group Inc",
"Sherwin-Williams Company",
"Shopko Stores Inc",
"Siebel Systems Inc",
"Sierra Health Services Inc",
"Sierra Pacific Resources",
"Silgan Holdings Inc.",
"Silicon Graphics Inc",
"Simon Property Group Inc",
"SLM Corporation",
"Smith International Inc",
"Smithfield Foods Inc",
"Smurfit-Stone Container Corp",
"Snap-On Inc",
"Solectron Corp",
"Solutia Inc",
"Sonic Automotive Inc.",
"Sonoco Products Co.",
"Southern Company",
"Southern Union Company",
"SouthTrust Corp.",
"Southwest Airlines Co",
"Southwest Gas Corp",
"Sovereign Bancorp Inc.",
"Spartan Stores Inc",
"Spherion Corp",
"Sports Authority Inc",
"Sprint Corp.",
"SPX Corp",
"St. Jude Medical Inc",
"St. Paul Cos.",
"Staff Leasing Inc.",
"StanCorp Financial Group Inc",
"Standard Pacific Corp.",
"Stanley Works",
"Staples Inc",
"Starbucks Corp",
"Starwood Hotels & Resorts Worldwide Inc",
"State Street Corp.",
"Stater Bros. Holdings Inc.",
"Steelcase Inc",
"Stein Mart Inc",
"Stewart & Stevenson Services Inc",
"Stewart Information Services Corp",
"Stilwell Financial Inc",
"Storage Technology Corporation",
"Stryker Corp",
"Sun Healthcare Group Inc.",
"Sun Microsystems Inc.",
"SunGard Data Systems Inc.",
"Sunoco Inc.",
"SunTrust Banks Inc",
"Supervalu Inc",
"Swift Transportation, Co., Inc",
"Symbol Technologies Inc",
"Synovus Financial Corp.",
"Sysco Corp",
"Systemax Inc.",
"Target Corp.",
"Tech Data Corporation",
"TECO Energy Inc",
"Tecumseh Products Company",
"Tektronix Inc",
"Teleflex Incorporated",
"Telephone & Data Systems Inc",
"Tellabs Inc.",
"Temple-Inland Inc",
"Tenet Healthcare Corporation",
"Tenneco Automotive Inc.",
"Teradyne Inc",
"Terex Corp",
"Tesoro Petroleum Corp.",
"Texas Industries Inc.",
"Texas Instruments Incorporated",
"Textron Inc",
"Thermo Electron Corporation",
"Thomas & Betts Corporation",
"Tiffany & Co",
"Timken Company",
"TJX Companies Inc",
"TMP Worldwide Inc",
"Toll Brothers Inc",
"Torchmark Corporation",
"Toro Company",
"Tower Automotive Inc.",
"Toys 'R' Us Inc",
"Trans World Entertainment Corp.",
"TransMontaigne Inc",
"Transocean Inc",
"TravelCenters of America Inc.",
"Triad Hospitals Inc",
"Tribune Company",
"Trigon Healthcare Inc.",
"Trinity Industries Inc",
"Trump Hotels & Casino Resorts Inc.",
"TruServ Corporation",
"TRW Inc",
"TXU Corp",
"Tyson Foods Inc",
"U.S. Bancorp",
"U.S. Industries Inc.",
"UAL Corporation",
"UGI Corporation",
"Unified Western Grocers Inc",
"Union Pacific Corporation",
"Union Planters Corp",
"Unisource Energy Corp",
"Unisys Corporation",
"United Auto Group Inc",
"United Defense Industries Inc.",
"United Parcel Service Inc",
"United Rentals Inc",
"United Stationers Inc",
"United Technologies Corporation",
"UnitedHealth Group Incorporated",
"Unitrin Inc",
"Universal Corporation",
"Universal Forest Products Inc",
"Universal Health Services Inc",
"Unocal Corporation",
"Unova Inc",
"UnumProvident Corporation",
"URS Corporation",
"US Airways Group Inc",
"US Oncology Inc",
"USA Interactive",
"USFreighways Corporation",
"USG Corporation",
"UST Inc",
"Valero Energy Corporation",
"Valspar Corporation",
"Value City Department Stores Inc",
"Varco International Inc",
"Vectren Corporation",
"Veritas Software Corporation",
"Verizon Communications Inc",
"VF Corporation",
"Viacom Inc",
"Viad Corp",
"Viasystems Group Inc",
"Vishay Intertechnology Inc",
"Visteon Corporation",
"Volt Information Sciences Inc",
"Vulcan Materials Company",
"W.R. Berkley Corporation",
"W.R. Grace & Co",
"W.W. Grainger Inc",
"Wachovia Corporation",
"Wakenhut Corporation",
"Walgreen Co",
"Wallace Computer Services Inc",
"Wal-Mart Stores Inc",
"Walt Disney Co",
"Walter Industries Inc",
"Washington Mutual Inc",
"Washington Post Co.",
"Waste Management Inc",
"Watsco Inc",
"Weatherford International Inc",
"Weis Markets Inc.",
"Wellpoint Health Networks Inc",
"Wells Fargo & Company",
"Wendy's International Inc",
"Werner Enterprises Inc",
"WESCO International Inc",
"Western Digital Inc",
"Western Gas Resources Inc",
"WestPoint Stevens Inc",
"Weyerhauser Company",
"WGL Holdings Inc",
"Whirlpool Corporation",
"Whole Foods Market Inc",
"Willamette Industries Inc.",
"Williams Companies Inc",
"Williams Sonoma Inc",
"Winn Dixie Stores Inc",
"Wisconsin Energy Corporation",
"Wm Wrigley Jr Company",
"World Fuel Services Corporation",
"WorldCom Inc",
"Worthington Industries Inc",
"WPS Resources Corporation",
"Wyeth",
"Wyndham International Inc",
"Xcel Energy Inc",
"Xerox Corp",
"Xilinx Inc",
"XO Communications Inc",
"Yellow Corporation",
"York International Corp",
"Yum Brands Inc.",
"Zale Corporation",
"Zions Bancorporation"
],
fileExtension : {
"raster" : ["bmp", "gif", "gpl", "ico", "jpeg", "psd", "png", "psp", "raw", "tiff"],
"vector" : ["3dv", "amf", "awg", "ai", "cgm", "cdr", "cmx", "dxf", "e2d", "egt", "eps", "fs", "odg", "svg", "xar"],
"3d" : ["3dmf", "3dm", "3mf", "3ds", "an8", "aoi", "blend", "cal3d", "cob", "ctm", "iob", "jas", "max", "mb", "mdx", "obj", "x", "x3d"],
"document" : ["doc", "docx", "dot", "html", "xml", "odt", "odm", "ott", "csv", "rtf", "tex", "xhtml", "xps"]
},
// Data taken from https://github.com/dmfilipenko/timezones.json/blob/master/timezones.json
timezones: [
{
"name": "Dateline Standard Time",
"abbr": "DST",
"offset": -12,
"isdst": false,
"text": "(UTC-12:00) International Date Line West",
"utc": [
"Etc/GMT+12"
]
},
{
"name": "UTC-11",
"abbr": "U",
"offset": -11,
"isdst": false,
"text": "(UTC-11:00) Coordinated Universal Time-11",
"utc": [
"Etc/GMT+11",
"Pacific/Midway",
"Pacific/Niue",
"Pacific/Pago_Pago"
]
},
{
"name": "Hawaiian Standard Time",
"abbr": "HST",
"offset": -10,
"isdst": false,
"text": "(UTC-10:00) Hawaii",
"utc": [
"Etc/GMT+10",
"Pacific/Honolulu",
"Pacific/Johnston",
"Pacific/Rarotonga",
"Pacific/Tahiti"
]
},
{
"name": "Alaskan Standard Time",
"abbr": "AKDT",
"offset": -8,
"isdst": true,
"text": "(UTC-09:00) Alaska",
"utc": [
"America/Anchorage",
"America/Juneau",
"America/Nome",
"America/Sitka",
"America/Yakutat"
]
},
{
"name": "Pacific Standard Time (Mexico)",
"abbr": "PDT",
"offset": -7,
"isdst": true,
"text": "(UTC-08:00) Baja California",
"utc": [
"America/Santa_Isabel"
]
},
{
"name": "Pacific Standard Time",
"abbr": "PDT",
"offset": -7,
"isdst": true,
"text": "(UTC-08:00) Pacific Time (US & Canada)",
"utc": [
"America/Dawson",
"America/Los_Angeles",
"America/Tijuana",
"America/Vancouver",
"America/Whitehorse",
"PST8PDT"
]
},
{
"name": "US Mountain Standard Time",
"abbr": "UMST",
"offset": -7,
"isdst": false,
"text": "(UTC-07:00) Arizona",
"utc": [
"America/Creston",
"America/Dawson_Creek",
"America/Hermosillo",
"America/Phoenix",
"Etc/GMT+7"
]
},
{
"name": "Mountain Standard Time (Mexico)",
"abbr": "MDT",
"offset": -6,
"isdst": true,
"text": "(UTC-07:00) Chihuahua, La Paz, Mazatlan",
"utc": [
"America/Chihuahua",
"America/Mazatlan"
]
},
{
"name": "Mountain Standard Time",
"abbr": "MDT",
"offset": -6,
"isdst": true,
"text": "(UTC-07:00) Mountain Time (US & Canada)",
"utc": [
"America/Boise",
"America/Cambridge_Bay",
"America/Denver",
"America/Edmonton",
"America/Inuvik",
"America/Ojinaga",
"America/Yellowknife",
"MST7MDT"
]
},
{
"name": "Central America Standard Time",
"abbr": "CAST",
"offset": -6,
"isdst": false,
"text": "(UTC-06:00) Central America",
"utc": [
"America/Belize",
"America/Costa_Rica",
"America/El_Salvador",
"America/Guatemala",
"America/Managua",
"America/Tegucigalpa",
"Etc/GMT+6",
"Pacific/Galapagos"
]
},
{
"name": "Central Standard Time",
"abbr": "CDT",
"offset": -5,
"isdst": true,
"text": "(UTC-06:00) Central Time (US & Canada)",
"utc": [
"America/Chicago",
"America/Indiana/Knox",
"America/Indiana/Tell_City",
"America/Matamoros",
"America/Menominee",
"America/North_Dakota/Beulah",
"America/North_Dakota/Center",
"America/North_Dakota/New_Salem",
"America/Rainy_River",
"America/Rankin_Inlet",
"America/Resolute",
"America/Winnipeg",
"CST6CDT"
]
},
{
"name": "Central Standard Time (Mexico)",
"abbr": "CDT",
"offset": -5,
"isdst": true,
"text": "(UTC-06:00) Guadalajara, Mexico City, Monterrey",
"utc": [
"America/Bahia_Banderas",
"America/Cancun",
"America/Merida",
"America/Mexico_City",
"America/Monterrey"
]
},
{
"name": "Canada Central Standard Time",
"abbr": "CCST",
"offset": -6,
"isdst": false,
"text": "(UTC-06:00) Saskatchewan",
"utc": [
"America/Regina",
"America/Swift_Current"
]
},
{
"name": "SA Pacific Standard Time",
"abbr": "SPST",
"offset": -5,
"isdst": false,
"text": "(UTC-05:00) Bogota, Lima, Quito",
"utc": [
"America/Bogota",
"America/Cayman",
"America/Coral_Harbour",
"America/Eirunepe",
"America/Guayaquil",
"America/Jamaica",
"America/Lima",
"America/Panama",
"America/Rio_Branco",
"Etc/GMT+5"
]
},
{
"name": "Eastern Standard Time",
"abbr": "EDT",
"offset": -4,
"isdst": true,
"text": "(UTC-05:00) Eastern Time (US & Canada)",
"utc": [
"America/Detroit",
"America/Havana",
"America/Indiana/Petersburg",
"America/Indiana/Vincennes",
"America/Indiana/Winamac",
"America/Iqaluit",
"America/Kentucky/Monticello",
"America/Louisville",
"America/Montreal",
"America/Nassau",
"America/New_York",
"America/Nipigon",
"America/Pangnirtung",
"America/Port-au-Prince",
"America/Thunder_Bay",
"America/Toronto",
"EST5EDT"
]
},
{
"name": "US Eastern Standard Time",
"abbr": "UEDT",
"offset": -4,
"isdst": true,
"text": "(UTC-05:00) Indiana (East)",
"utc": [
"America/Indiana/Marengo",
"America/Indiana/Vevay",
"America/Indianapolis"
]
},
{
"name": "Venezuela Standard Time",
"abbr": "VST",
"offset": -4.5,
"isdst": false,
"text": "(UTC-04:30) Caracas",
"utc": [
"America/Caracas"
]
},
{
"name": "Paraguay Standard Time",
"abbr": "PST",
"offset": -4,
"isdst": false,
"text": "(UTC-04:00) Asuncion",
"utc": [
"America/Asuncion"
]
},
{
"name": "Atlantic Standard Time",
"abbr": "ADT",
"offset": -3,
"isdst": true,
"text": "(UTC-04:00) Atlantic Time (Canada)",
"utc": [
"America/Glace_Bay",
"America/Goose_Bay",
"America/Halifax",
"America/Moncton",
"America/Thule",
"Atlantic/Bermuda"
]
},
{
"name": "Central Brazilian Standard Time",
"abbr": "CBST",
"offset": -4,
"isdst": false,
"text": "(UTC-04:00) Cuiaba",
"utc": [
"America/Campo_Grande",
"America/Cuiaba"
]
},
{
"name": "SA Western Standard Time",
"abbr": "SWST",
"offset": -4,
"isdst": false,
"text": "(UTC-04:00) Georgetown, La Paz, Manaus, San Juan",
"utc": [
"America/Anguilla",
"America/Antigua",
"America/Aruba",
"America/Barbados",
"America/Blanc-Sablon",
"America/Boa_Vista",
"America/Curacao",
"America/Dominica",
"America/Grand_Turk",
"America/Grenada",
"America/Guadeloupe",
"America/Guyana",
"America/Kralendijk",
"America/La_Paz",
"America/Lower_Princes",
"America/Manaus",
"America/Marigot",
"America/Martinique",
"America/Montserrat",
"America/Port_of_Spain",
"America/Porto_Velho",
"America/Puerto_Rico",
"America/Santo_Domingo",
"America/St_Barthelemy",
"America/St_Kitts",
"America/St_Lucia",
"America/St_Thomas",
"America/St_Vincent",
"America/Tortola",
"Etc/GMT+4"
]
},
{
"name": "Pacific SA Standard Time",
"abbr": "PSST",
"offset": -4,
"isdst": false,
"text": "(UTC-04:00) Santiago",
"utc": [
"America/Santiago",
"Antarctica/Palmer"
]
},
{
"name": "Newfoundland Standard Time",
"abbr": "NDT",
"offset": -2.5,
"isdst": true,
"text": "(UTC-03:30) Newfoundland",
"utc": [
"America/St_Johns"
]
},
{
"name": "E. South America Standard Time",
"abbr": "ESAST",
"offset": -3,
"isdst": false,
"text": "(UTC-03:00) Brasilia",
"utc": [
"America/Sao_Paulo"
]
},
{
"name": "Argentina Standard Time",
"abbr": "AST",
"offset": -3,
"isdst": false,
"text": "(UTC-03:00) Buenos Aires",
"utc": [
"America/Argentina/La_Rioja",
"America/Argentina/Rio_Gallegos",
"America/Argentina/Salta",
"America/Argentina/San_Juan",
"America/Argentina/San_Luis",
"America/Argentina/Tucuman",
"America/Argentina/Ushuaia",
"America/Buenos_Aires",
"America/Catamarca",
"America/Cordoba",
"America/Jujuy",
"America/Mendoza"
]
},
{
"name": "SA Eastern Standard Time",
"abbr": "SEST",
"offset": -3,
"isdst": false,
"text": "(UTC-03:00) Cayenne, Fortaleza",
"utc": [
"America/Araguaina",
"America/Belem",
"America/Cayenne",
"America/Fortaleza",
"America/Maceio",
"America/Paramaribo",
"America/Recife",
"America/Santarem",
"Antarctica/Rothera",
"Atlantic/Stanley",
"Etc/GMT+3"
]
},
{
"name": "Greenland Standard Time",
"abbr": "GDT",
"offset": -2,
"isdst": true,
"text": "(UTC-03:00) Greenland",
"utc": [
"America/Godthab"
]
},
{
"name": "Montevideo Standard Time",
"abbr": "MST",
"offset": -3,
"isdst": false,
"text": "(UTC-03:00) Montevideo",
"utc": [
"America/Montevideo"
]
},
{
"name": "Bahia Standard Time",
"abbr": "BST",
"offset": -3,
"isdst": false,
"text": "(UTC-03:00) Salvador",
"utc": [
"America/Bahia"
]
},
{
"name": "UTC-02",
"abbr": "U",
"offset": -2,
"isdst": false,
"text": "(UTC-02:00) Coordinated Universal Time-02",
"utc": [
"America/Noronha",
"Atlantic/South_Georgia",
"Etc/GMT+2"
]
},
{
"name": "Mid-Atlantic Standard Time",
"abbr": "MDT",
"offset": -1,
"isdst": true,
"text": "(UTC-02:00) Mid-Atlantic - Old"
},
{
"name": "Azores Standard Time",
"abbr": "ADT",
"offset": 0,
"isdst": true,
"text": "(UTC-01:00) Azores",
"utc": [
"America/Scoresbysund",
"Atlantic/Azores"
]
},
{
"name": "Cape Verde Standard Time",
"abbr": "CVST",
"offset": -1,
"isdst": false,
"text": "(UTC-01:00) Cape Verde Is.",
"utc": [
"Atlantic/Cape_Verde",
"Etc/GMT+1"
]
},
{
"name": "Morocco Standard Time",
"abbr": "MDT",
"offset": 1,
"isdst": true,
"text": "(UTC) Casablanca",
"utc": [
"Africa/Casablanca",
"Africa/El_Aaiun"
]
},
{
"name": "UTC",
"abbr": "CUT",
"offset": 0,
"isdst": false,
"text": "(UTC) Coordinated Universal Time",
"utc": [
"America/Danmarkshavn",
"Etc/GMT"
]
},
{
"name": "GMT Standard Time",
"abbr": "GDT",
"offset": 1,
"isdst": true,
"text": "(UTC) Dublin, Edinburgh, Lisbon, London",
"utc": [
"Atlantic/Canary",
"Atlantic/Faeroe",
"Atlantic/Madeira",
"Europe/Dublin",
"Europe/Guernsey",
"Europe/Isle_of_Man",
"Europe/Jersey",
"Europe/Lisbon",
"Europe/London"
]
},
{
"name": "Greenwich Standard Time",
"abbr": "GST",
"offset": 0,
"isdst": false,
"text": "(UTC) Monrovia, Reykjavik",
"utc": [
"Africa/Abidjan",
"Africa/Accra",
"Africa/Bamako",
"Africa/Banjul",
"Africa/Bissau",
"Africa/Conakry",
"Africa/Dakar",
"Africa/Freetown",
"Africa/Lome",
"Africa/Monrovia",
"Africa/Nouakchott",
"Africa/Ouagadougou",
"Africa/Sao_Tome",
"Atlantic/Reykjavik",
"Atlantic/St_Helena"
]
},
{
"name": "W. Europe Standard Time",
"abbr": "WEDT",
"offset": 2,
"isdst": true,
"text": "(UTC+01:00) Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna",
"utc": [
"Arctic/Longyearbyen",
"Europe/Amsterdam",
"Europe/Andorra",
"Europe/Berlin",
"Europe/Busingen",
"Europe/Gibraltar",
"Europe/Luxembourg",
"Europe/Malta",
"Europe/Monaco",
"Europe/Oslo",
"Europe/Rome",
"Europe/San_Marino",
"Europe/Stockholm",
"Europe/Vaduz",
"Europe/Vatican",
"Europe/Vienna",
"Europe/Zurich"
]
},
{
"name": "Central Europe Standard Time",
"abbr": "CEDT",
"offset": 2,
"isdst": true,
"text": "(UTC+01:00) Belgrade, Bratislava, Budapest, Ljubljana, Prague",
"utc": [
"Europe/Belgrade",
"Europe/Bratislava",
"Europe/Budapest",
"Europe/Ljubljana",
"Europe/Podgorica",
"Europe/Prague",
"Europe/Tirane"
]
},
{
"name": "Romance Standard Time",
"abbr": "RDT",
"offset": 2,
"isdst": true,
"text": "(UTC+01:00) Brussels, Copenhagen, Madrid, Paris",
"utc": [
"Africa/Ceuta",
"Europe/Brussels",
"Europe/Copenhagen",
"Europe/Madrid",
"Europe/Paris"
]
},
{
"name": "Central European Standard Time",
"abbr": "CEDT",
"offset": 2,
"isdst": true,
"text": "(UTC+01:00) Sarajevo, Skopje, Warsaw, Zagreb",
"utc": [
"Europe/Sarajevo",
"Europe/Skopje",
"Europe/Warsaw",
"Europe/Zagreb"
]
},
{
"name": "W. Central Africa Standard Time",
"abbr": "WCAST",
"offset": 1,
"isdst": false,
"text": "(UTC+01:00) West Central Africa",
"utc": [
"Africa/Algiers",
"Africa/Bangui",
"Africa/Brazzaville",
"Africa/Douala",
"Africa/Kinshasa",
"Africa/Lagos",
"Africa/Libreville",
"Africa/Luanda",
"Africa/Malabo",
"Africa/Ndjamena",
"Africa/Niamey",
"Africa/Porto-Novo",
"Africa/Tunis",
"Etc/GMT-1"
]
},
{
"name": "Namibia Standard Time",
"abbr": "NST",
"offset": 1,
"isdst": false,
"text": "(UTC+01:00) Windhoek",
"utc": [
"Africa/Windhoek"
]
},
{
"name": "GTB Standard Time",
"abbr": "GDT",
"offset": 3,
"isdst": true,
"text": "(UTC+02:00) Athens, Bucharest",
"utc": [
"Asia/Nicosia",
"Europe/Athens",
"Europe/Bucharest",
"Europe/Chisinau"
]
},
{
"name": "Middle East Standard Time",
"abbr": "MEDT",
"offset": 3,
"isdst": true,
"text": "(UTC+02:00) Beirut",
"utc": [
"Asia/Beirut"
]
},
{
"name": "Egypt Standard Time",
"abbr": "EST",
"offset": 2,
"isdst": false,
"text": "(UTC+02:00) Cairo",
"utc": [
"Africa/Cairo"
]
},
{
"name": "Syria Standard Time",
"abbr": "SDT",
"offset": 3,
"isdst": true,
"text": "(UTC+02:00) Damascus",
"utc": [
"Asia/Damascus"
]
},
{
"name": "E. Europe Standard Time",
"abbr": "EEDT",
"offset": 3,
"isdst": true,
"text": "(UTC+02:00) E. Europe"
},
{
"name": "South Africa Standard Time",
"abbr": "SAST",
"offset": 2,
"isdst": false,
"text": "(UTC+02:00) Harare, Pretoria",
"utc": [
"Africa/Blantyre",
"Africa/Bujumbura",
"Africa/Gaborone",
"Africa/Harare",
"Africa/Johannesburg",
"Africa/Kigali",
"Africa/Lubumbashi",
"Africa/Lusaka",
"Africa/Maputo",
"Africa/Maseru",
"Africa/Mbabane",
"Etc/GMT-2"
]
},
{
"name": "FLE Standard Time",
"abbr": "FDT",
"offset": 3,
"isdst": true,
"text": "(UTC+02:00) Helsinki, Kyiv, Riga, Sofia, Tallinn, Vilnius",
"utc": [
"Europe/Helsinki",
"Europe/Kiev",
"Europe/Mariehamn",
"Europe/Riga",
"Europe/Sofia",
"Europe/Tallinn",
"Europe/Uzhgorod",
"Europe/Vilnius",
"Europe/Zaporozhye"
]
},
{
"name": "Turkey Standard Time",
"abbr": "TDT",
"offset": 3,
"isdst": true,
"text": "(UTC+02:00) Istanbul",
"utc": [
"Europe/Istanbul"
]
},
{
"name": "Israel Standard Time",
"abbr": "JDT",
"offset": 3,
"isdst": true,
"text": "(UTC+02:00) Jerusalem",
"utc": [
"Asia/Jerusalem"
]
},
{
"name": "Libya Standard Time",
"abbr": "LST",
"offset": 2,
"isdst": false,
"text": "(UTC+02:00) Tripoli",
"utc": [
"Africa/Tripoli"
]
},
{
"name": "Jordan Standard Time",
"abbr": "JST",
"offset": 3,
"isdst": false,
"text": "(UTC+03:00) Amman",
"utc": [
"Asia/Amman"
]
},
{
"name": "Arabic Standard Time",
"abbr": "AST",
"offset": 3,
"isdst": false,
"text": "(UTC+03:00) Baghdad",
"utc": [
"Asia/Baghdad"
]
},
{
"name": "Kaliningrad Standard Time",
"abbr": "KST",
"offset": 3,
"isdst": false,
"text": "(UTC+03:00) Kaliningrad, Minsk",
"utc": [
"Europe/Kaliningrad",
"Europe/Minsk"
]
},
{
"name": "Arab Standard Time",
"abbr": "AST",
"offset": 3,
"isdst": false,
"text": "(UTC+03:00) Kuwait, Riyadh",
"utc": [
"Asia/Aden",
"Asia/Bahrain",
"Asia/Kuwait",
"Asia/Qatar",
"Asia/Riyadh"
]
},
{
"name": "E. Africa Standard Time",
"abbr": "EAST",
"offset": 3,
"isdst": false,
"text": "(UTC+03:00) Nairobi",
"utc": [
"Africa/Addis_Ababa",
"Africa/Asmera",
"Africa/Dar_es_Salaam",
"Africa/Djibouti",
"Africa/Juba",
"Africa/Kampala",
"Africa/Khartoum",
"Africa/Mogadishu",
"Africa/Nairobi",
"Antarctica/Syowa",
"Etc/GMT-3",
"Indian/Antananarivo",
"Indian/Comoro",
"Indian/Mayotte"
]
},
{
"name": "Iran Standard Time",
"abbr": "IDT",
"offset": 4.5,
"isdst": true,
"text": "(UTC+03:30) Tehran",
"utc": [
"Asia/Tehran"
]
},
{
"name": "Arabian Standard Time",
"abbr": "AST",
"offset": 4,
"isdst": false,
"text": "(UTC+04:00) Abu Dhabi, Muscat",
"utc": [
"Asia/Dubai",
"Asia/Muscat",
"Etc/GMT-4"
]
},
{
"name": "Azerbaijan Standard Time",
"abbr": "ADT",
"offset": 5,
"isdst": true,
"text": "(UTC+04:00) Baku",
"utc": [
"Asia/Baku"
]
},
{
"name": "Russian Standard Time",
"abbr": "RST",
"offset": 4,
"isdst": false,
"text": "(UTC+04:00) Moscow, St. Petersburg, Volgograd",
"utc": [
"Europe/Moscow",
"Europe/Samara",
"Europe/Simferopol",
"Europe/Volgograd"
]
},
{
"name": "Mauritius Standard Time",
"abbr": "MST",
"offset": 4,
"isdst": false,
"text": "(UTC+04:00) Port Louis",
"utc": [
"Indian/Mahe",
"Indian/Mauritius",
"Indian/Reunion"
]
},
{
"name": "Georgian Standard Time",
"abbr": "GST",
"offset": 4,
"isdst": false,
"text": "(UTC+04:00) Tbilisi",
"utc": [
"Asia/Tbilisi"
]
},
{
"name": "Caucasus Standard Time",
"abbr": "CST",
"offset": 4,
"isdst": false,
"text": "(UTC+04:00) Yerevan",
"utc": [
"Asia/Yerevan"
]
},
{
"name": "Afghanistan Standard Time",
"abbr": "AST",
"offset": 4.5,
"isdst": false,
"text": "(UTC+04:30) Kabul",
"utc": [
"Asia/Kabul"
]
},
{
"name": "West Asia Standard Time",
"abbr": "WAST",
"offset": 5,
"isdst": false,
"text": "(UTC+05:00) Ashgabat, Tashkent",
"utc": [
"Antarctica/Mawson",
"Asia/Aqtau",
"Asia/Aqtobe",
"Asia/Ashgabat",
"Asia/Dushanbe",
"Asia/Oral",
"Asia/Samarkand",
"Asia/Tashkent",
"Etc/GMT-5",
"Indian/Kerguelen",
"Indian/Maldives"
]
},
{
"name": "Pakistan Standard Time",
"abbr": "PST",
"offset": 5,
"isdst": false,
"text": "(UTC+05:00) Islamabad, Karachi",
"utc": [
"Asia/Karachi"
]
},
{
"name": "India Standard Time",
"abbr": "IST",
"offset": 5.5,
"isdst": false,
"text": "(UTC+05:30) Chennai, Kolkata, Mumbai, New Delhi",
"utc": [
"Asia/Calcutta"
]
},
{
"name": "Sri Lanka Standard Time",
"abbr": "SLST",
"offset": 5.5,
"isdst": false,
"text": "(UTC+05:30) Sri Jayawardenepura",
"utc": [
"Asia/Colombo"
]
},
{
"name": "Nepal Standard Time",
"abbr": "NST",
"offset": 5.75,
"isdst": false,
"text": "(UTC+05:45) Kathmandu",
"utc": [
"Asia/Katmandu"
]
},
{
"name": "Central Asia Standard Time",
"abbr": "CAST",
"offset": 6,
"isdst": false,
"text": "(UTC+06:00) Astana",
"utc": [
"Antarctica/Vostok",
"Asia/Almaty",
"Asia/Bishkek",
"Asia/Qyzylorda",
"Asia/Urumqi",
"Etc/GMT-6",
"Indian/Chagos"
]
},
{
"name": "Bangladesh Standard Time",
"abbr": "BST",
"offset": 6,
"isdst": false,
"text": "(UTC+06:00) Dhaka",
"utc": [
"Asia/Dhaka",
"Asia/Thimphu"
]
},
{
"name": "Ekaterinburg Standard Time",
"abbr": "EST",
"offset": 6,
"isdst": false,
"text": "(UTC+06:00) Ekaterinburg",
"utc": [
"Asia/Yekaterinburg"
]
},
{
"name": "Myanmar Standard Time",
"abbr": "MST",
"offset": 6.5,
"isdst": false,
"text": "(UTC+06:30) Yangon (Rangoon)",
"utc": [
"Asia/Rangoon",
"Indian/Cocos"
]
},
{
"name": "SE Asia Standard Time",
"abbr": "SAST",
"offset": 7,
"isdst": false,
"text": "(UTC+07:00) Bangkok, Hanoi, Jakarta",
"utc": [
"Antarctica/Davis",
"Asia/Bangkok",
"Asia/Hovd",
"Asia/Jakarta",
"Asia/Phnom_Penh",
"Asia/Pontianak",
"Asia/Saigon",
"Asia/Vientiane",
"Etc/GMT-7",
"Indian/Christmas"
]
},
{
"name": "N. Central Asia Standard Time",
"abbr": "NCAST",
"offset": 7,
"isdst": false,
"text": "(UTC+07:00) Novosibirsk",
"utc": [
"Asia/Novokuznetsk",
"Asia/Novosibirsk",
"Asia/Omsk"
]
},
{
"name": "China Standard Time",
"abbr": "CST",
"offset": 8,
"isdst": false,
"text": "(UTC+08:00) Beijing, Chongqing, Hong Kong, Urumqi",
"utc": [
"Asia/Hong_Kong",
"Asia/Macau",
"Asia/Shanghai"
]
},
{
"name": "North Asia Standard Time",
"abbr": "NAST",
"offset": 8,
"isdst": false,
"text": "(UTC+08:00) Krasnoyarsk",
"utc": [
"Asia/Krasnoyarsk"
]
},
{
"name": "Singapore Standard Time",
"abbr": "MPST",
"offset": 8,
"isdst": false,
"text": "(UTC+08:00) Kuala Lumpur, Singapore",
"utc": [
"Asia/Brunei",
"Asia/Kuala_Lumpur",
"Asia/Kuching",
"Asia/Makassar",
"Asia/Manila",
"Asia/Singapore",
"Etc/GMT-8"
]
},
{
"name": "W. Australia Standard Time",
"abbr": "WAST",
"offset": 8,
"isdst": false,
"text": "(UTC+08:00) Perth",
"utc": [
"Antarctica/Casey",
"Australia/Perth"
]
},
{
"name": "Taipei Standard Time",
"abbr": "TST",
"offset": 8,
"isdst": false,
"text": "(UTC+08:00) Taipei",
"utc": [
"Asia/Taipei"
]
},
{
"name": "Ulaanbaatar Standard Time",
"abbr": "UST",
"offset": 8,
"isdst": false,
"text": "(UTC+08:00) Ulaanbaatar",
"utc": [
"Asia/Choibalsan",
"Asia/Ulaanbaatar"
]
},
{
"name": "North Asia East Standard Time",
"abbr": "NAEST",
"offset": 9,
"isdst": false,
"text": "(UTC+09:00) Irkutsk",
"utc": [
"Asia/Irkutsk"
]
},
{
"name": "Tokyo Standard Time",
"abbr": "TST",
"offset": 9,
"isdst": false,
"text": "(UTC+09:00) Osaka, Sapporo, Tokyo",
"utc": [
"Asia/Dili",
"Asia/Jayapura",
"Asia/Tokyo",
"Etc/GMT-9",
"Pacific/Palau"
]
},
{
"name": "Korea Standard Time",
"abbr": "KST",
"offset": 9,
"isdst": false,
"text": "(UTC+09:00) Seoul",
"utc": [
"Asia/Pyongyang",
"Asia/Seoul"
]
},
{
"name": "Cen. Australia Standard Time",
"abbr": "CAST",
"offset": 9.5,
"isdst": false,
"text": "(UTC+09:30) Adelaide",
"utc": [
"Australia/Adelaide",
"Australia/Broken_Hill"
]
},
{
"name": "AUS Central Standard Time",
"abbr": "ACST",
"offset": 9.5,
"isdst": false,
"text": "(UTC+09:30) Darwin",
"utc": [
"Australia/Darwin"
]
},
{
"name": "E. Australia Standard Time",
"abbr": "EAST",
"offset": 10,
"isdst": false,
"text": "(UTC+10:00) Brisbane",
"utc": [
"Australia/Brisbane",
"Australia/Lindeman"
]
},
{
"name": "AUS Eastern Standard Time",
"abbr": "AEST",
"offset": 10,
"isdst": false,
"text": "(UTC+10:00) Canberra, Melbourne, Sydney",
"utc": [
"Australia/Melbourne",
"Australia/Sydney"
]
},
{
"name": "West Pacific Standard Time",
"abbr": "WPST",
"offset": 10,
"isdst": false,
"text": "(UTC+10:00) Guam, Port Moresby",
"utc": [
"Antarctica/DumontDUrville",
"Etc/GMT-10",
"Pacific/Guam",
"Pacific/Port_Moresby",
"Pacific/Saipan",
"Pacific/Truk"
]
},
{
"name": "Tasmania Standard Time",
"abbr": "TST",
"offset": 10,
"isdst": false,
"text": "(UTC+10:00) Hobart",
"utc": [
"Australia/Currie",
"Australia/Hobart"
]
},
{
"name": "Yakutsk Standard Time",
"abbr": "YST",
"offset": 10,
"isdst": false,
"text": "(UTC+10:00) Yakutsk",
"utc": [
"Asia/Chita",
"Asia/Khandyga",
"Asia/Yakutsk"
]
},
{
"name": "Central Pacific Standard Time",
"abbr": "CPST",
"offset": 11,
"isdst": false,
"text": "(UTC+11:00) Solomon Is., New Caledonia",
"utc": [
"Antarctica/Macquarie",
"Etc/GMT-11",
"Pacific/Efate",
"Pacific/Guadalcanal",
"Pacific/Kosrae",
"Pacific/Noumea",
"Pacific/Ponape"
]
},
{
"name": "Vladivostok Standard Time",
"abbr": "VST",
"offset": 11,
"isdst": false,
"text": "(UTC+11:00) Vladivostok",
"utc": [
"Asia/Sakhalin",
"Asia/Ust-Nera",
"Asia/Vladivostok"
]
},
{
"name": "New Zealand Standard Time",
"abbr": "NZST",
"offset": 12,
"isdst": false,
"text": "(UTC+12:00) Auckland, Wellington",
"utc": [
"Antarctica/McMurdo",
"Pacific/Auckland"
]
},
{
"name": "UTC+12",
"abbr": "U",
"offset": 12,
"isdst": false,
"text": "(UTC+12:00) Coordinated Universal Time+12",
"utc": [
"Etc/GMT-12",
"Pacific/Funafuti",
"Pacific/Kwajalein",
"Pacific/Majuro",
"Pacific/Nauru",
"Pacific/Tarawa",
"Pacific/Wake",
"Pacific/Wallis"
]
},
{
"name": "Fiji Standard Time",
"abbr": "FST",
"offset": 12,
"isdst": false,
"text": "(UTC+12:00) Fiji",
"utc": [
"Pacific/Fiji"
]
},
{
"name": "Magadan Standard Time",
"abbr": "MST",
"offset": 12,
"isdst": false,
"text": "(UTC+12:00) Magadan",
"utc": [
"Asia/Anadyr",
"Asia/Kamchatka",
"Asia/Magadan",
"Asia/Srednekolymsk"
]
},
{
"name": "Kamchatka Standard Time",
"abbr": "KDT",
"offset": 13,
"isdst": true,
"text": "(UTC+12:00) Petropavlovsk-Kamchatsky - Old"
},
{
"name": "Tonga Standard Time",
"abbr": "TST",
"offset": 13,
"isdst": false,
"text": "(UTC+13:00) Nuku'alofa",
"utc": [
"Etc/GMT-13",
"Pacific/Enderbury",
"Pacific/Fakaofo",
"Pacific/Tongatapu"
]
},
{
"name": "Samoa Standard Time",
"abbr": "SST",
"offset": 13,
"isdst": false,
"text": "(UTC+13:00) Samoa",
"utc": [
"Pacific/Apia"
]
}
],
//List source: http://answers.google.com/answers/threadview/id/589312.html
profession: [
"Airline Pilot",
"Academic Team",
"Accountant",
"Account Executive",
"Actor",
"Actuary",
"Acquisition Analyst",
"Administrative Asst.",
"Administrative Analyst",
"Administrator",
"Advertising Director",
"Aerospace Engineer",
"Agent",
"Agricultural Inspector",
"Agricultural Scientist",
"Air Traffic Controller",
"Animal Trainer",
"Anthropologist",
"Appraiser",
"Architect",
"Art Director",
"Artist",
"Astronomer",
"Athletic Coach",
"Auditor",
"Author",
"Baker",
"Banker",
"Bankruptcy Attorney",
"Benefits Manager",
"Biologist",
"Bio-feedback Specialist",
"Biomedical Engineer",
"Biotechnical Researcher",
"Broadcaster",
"Broker",
"Building Manager",
"Building Contractor",
"Building Inspector",
"Business Analyst",
"Business Planner",
"Business Manager",
"Buyer",
"Call Center Manager",
"Career Counselor",
"Cash Manager",
"Ceramic Engineer",
"Chief Executive Officer",
"Chief Operation Officer",
"Chef",
"Chemical Engineer",
"Chemist",
"Child Care Manager",
"Chief Medical Officer",
"Chiropractor",
"Cinematographer",
"City Housing Manager",
"City Manager",
"Civil Engineer",
"Claims Manager",
"Clinical Research Assistant",
"Collections Manager.",
"Compliance Manager",
"Comptroller",
"Computer Manager",
"Commercial Artist",
"Communications Affairs Director",
"Communications Director",
"Communications Engineer",
"Compensation Analyst",
"Computer Programmer",
"Computer Ops. Manager",
"Computer Engineer",
"Computer Operator",
"Computer Graphics Specialist",
"Construction Engineer",
"Construction Manager",
"Consultant",
"Consumer Relations Manager",
"Contract Administrator",
"Copyright Attorney",
"Copywriter",
"Corporate Planner",
"Corrections Officer",
"Cosmetologist",
"Credit Analyst",
"Cruise Director",
"Chief Information Officer",
"Chief Technology Officer",
"Customer Service Manager",
"Cryptologist",
"Dancer",
"Data Security Manager",
"Database Manager",
"Day Care Instructor",
"Dentist",
"Designer",
"Design Engineer",
"Desktop Publisher",
"Developer",
"Development Officer",
"Diamond Merchant",
"Dietitian",
"Direct Marketer",
"Director",
"Distribution Manager",
"Diversity Manager",
"Economist",
"EEO Compliance Manager",
"Editor",
"Education Adminator",
"Electrical Engineer",
"Electro Optical Engineer",
"Electronics Engineer",
"Embassy Management",
"Employment Agent",
"Engineer Technician",
"Entrepreneur",
"Environmental Analyst",
"Environmental Attorney",
"Environmental Engineer",
"Environmental Specialist",
"Escrow Officer",
"Estimator",
"Executive Assistant",
"Executive Director",
"Executive Recruiter",
"Facilities Manager",
"Family Counselor",
"Fashion Events Manager",
"Fashion Merchandiser",
"Fast Food Manager",
"Film Producer",
"Film Production Assistant",
"Financial Analyst",
"Financial Planner",
"Financier",
"Fine Artist",
"Wildlife Specialist",
"Fitness Consultant",
"Flight Attendant",
"Flight Engineer",
"Floral Designer",
"Food & Beverage Director",
"Food Service Manager",
"Forestry Technician",
"Franchise Management",
"Franchise Sales",
"Fraud Investigator",
"Freelance Writer",
"Fund Raiser",
"General Manager",
"Geologist",
"General Counsel",
"Geriatric Specialist",
"Gerontologist",
"Glamour Photographer",
"Golf Club Manager",
"Gourmet Chef",
"Graphic Designer",
"Grounds Keeper",
"Hazardous Waste Manager",
"Health Care Manager",
"Health Therapist",
"Health Service Administrator",
"Hearing Officer",
"Home Economist",
"Horticulturist",
"Hospital Administrator",
"Hotel Manager",
"Human Resources Manager",
"Importer",
"Industrial Designer",
"Industrial Engineer",
"Information Director",
"Inside Sales",
"Insurance Adjuster",
"Interior Decorator",
"Internal Controls Director",
"International Acct.",
"International Courier",
"International Lawyer",
"Interpreter",
"Investigator",
"Investment Banker",
"Investment Manager",
"IT Architect",
"IT Project Manager",
"IT Systems Analyst",
"Jeweler",
"Joint Venture Manager",
"Journalist",
"Labor Negotiator",
"Labor Organizer",
"Labor Relations Manager",
"Lab Services Director",
"Lab Technician",
"Land Developer",
"Landscape Architect",
"Law Enforcement Officer",
"Lawyer",
"Lead Software Engineer",
"Lead Software Test Engineer",
"Leasing Manager",
"Legal Secretary",
"Library Manager",
"Litigation Attorney",
"Loan Officer",
"Lobbyist",
"Logistics Manager",
"Maintenance Manager",
"Management Consultant",
"Managed Care Director",
"Managing Partner",
"Manufacturing Director",
"Manpower Planner",
"Marine Biologist",
"Market Res. Analyst",
"Marketing Director",
"Materials Manager",
"Mathematician",
"Membership Chairman",
"Mechanic",
"Mechanical Engineer",
"Media Buyer",
"Medical Investor",
"Medical Secretary",
"Medical Technician",
"Mental Health Counselor",
"Merchandiser",
"Metallurgical Engineering",
"Meteorologist",
"Microbiologist",
"MIS Manager",
"Motion Picture Director",
"Multimedia Director",
"Musician",
"Network Administrator",
"Network Specialist",
"Network Operator",
"New Product Manager",
"Novelist",
"Nuclear Engineer",
"Nuclear Specialist",
"Nutritionist",
"Nursing Administrator",
"Occupational Therapist",
"Oceanographer",
"Office Manager",
"Operations Manager",
"Operations Research Director",
"Optical Technician",
"Optometrist",
"Organizational Development Manager",
"Outplacement Specialist",
"Paralegal",
"Park Ranger",
"Patent Attorney",
"Payroll Specialist",
"Personnel Specialist",
"Petroleum Engineer",
"Pharmacist",
"Photographer",
"Physical Therapist",
"Physician",
"Physician Assistant",
"Physicist",
"Planning Director",
"Podiatrist",
"Political Analyst",
"Political Scientist",
"Politician",
"Portfolio Manager",
"Preschool Management",
"Preschool Teacher",
"Principal",
"Private Banker",
"Private Investigator",
"Probation Officer",
"Process Engineer",
"Producer",
"Product Manager",
"Product Engineer",
"Production Engineer",
"Production Planner",
"Professional Athlete",
"Professional Coach",
"Professor",
"Project Engineer",
"Project Manager",
"Program Manager",
"Property Manager",
"Public Administrator",
"Public Safety Director",
"PR Specialist",
"Publisher",
"Purchasing Agent",
"Publishing Director",
"Quality Assurance Specialist",
"Quality Control Engineer",
"Quality Control Inspector",
"Radiology Manager",
"Railroad Engineer",
"Real Estate Broker",
"Recreational Director",
"Recruiter",
"Redevelopment Specialist",
"Regulatory Affairs Manager",
"Registered Nurse",
"Rehabilitation Counselor",
"Relocation Manager",
"Reporter",
"Research Specialist",
"Restaurant Manager",
"Retail Store Manager",
"Risk Analyst",
"Safety Engineer",
"Sales Engineer",
"Sales Trainer",
"Sales Promotion Manager",
"Sales Representative",
"Sales Manager",
"Service Manager",
"Sanitation Engineer",
"Scientific Programmer",
"Scientific Writer",
"Securities Analyst",
"Security Consultant",
"Security Director",
"Seminar Presenter",
"Ship's Officer",
"Singer",
"Social Director",
"Social Program Planner",
"Social Research",
"Social Scientist",
"Social Worker",
"Sociologist",
"Software Developer",
"Software Engineer",
"Software Test Engineer",
"Soil Scientist",
"Special Events Manager",
"Special Education Teacher",
"Special Projects Director",
"Speech Pathologist",
"Speech Writer",
"Sports Event Manager",
"Statistician",
"Store Manager",
"Strategic Alliance Director",
"Strategic Planning Director",
"Stress Reduction Specialist",
"Stockbroker",
"Surveyor",
"Structural Engineer",
"Superintendent",
"Supply Chain Director",
"System Engineer",
"Systems Analyst",
"Systems Programmer",
"System Administrator",
"Tax Specialist",
"Teacher",
"Technical Support Specialist",
"Technical Illustrator",
"Technical Writer",
"Technology Director",
"Telecom Analyst",
"Telemarketer",
"Theatrical Director",
"Title Examiner",
"Tour Escort",
"Tour Guide Director",
"Traffic Manager",
"Trainer Translator",
"Transportation Manager",
"Travel Agent",
"Treasurer",
"TV Programmer",
"Underwriter",
"Union Representative",
"University Administrator",
"University Dean",
"Urban Planner",
"Veterinarian",
"Vendor Relations Director",
"Viticulturist",
"Warehouse Manager"
],
animals : {
//list of ocean animals comes from https://owlcation.com/stem/list-of-ocean-animals
"ocean" : ["Acantharea","Anemone","Angelfish King","Ahi Tuna","Albacore","American Oyster","Anchovy","Armored Snail","Arctic Char","Atlantic Bluefin Tuna","Atlantic Cod","Atlantic Goliath Grouper","Atlantic Trumpetfish","Atlantic Wolffish","Baleen Whale","Banded Butterflyfish","Banded Coral Shrimp","Banded Sea Krait","Barnacle","Barndoor Skate","Barracuda","Basking Shark","Bass","Beluga Whale","Bluebanded Goby","Bluehead Wrasse","Bluefish","Bluestreak Cleaner-Wrasse","Blue Marlin","Blue Shark","Blue Spiny Lobster","Blue Tang","Blue Whale","Broadclub Cuttlefish","Bull Shark","Chambered Nautilus","Chilean Basket Star","Chilean Jack Mackerel","Chinook Salmon","Christmas Tree Worm","Clam","Clown Anemonefish","Clown Triggerfish","Cod","Coelacanth","Cockscomb Cup Coral","Common Fangtooth","Conch","Cookiecutter Shark","Copepod","Coral","Corydoras","Cownose Ray","Crab","Crown-of-Thorns Starfish","Cushion Star","Cuttlefish","California Sea Otters","Dolphin","Dolphinfish","Dory","Devil Fish","Dugong","Dumbo Octopus","Dungeness Crab","Eccentric Sand Dollar","Edible Sea Cucumber","Eel","Elephant Seal","Elkhorn Coral","Emperor Shrimp","Estuarine Crocodile","Fathead Sculpin","Fiddler Crab","Fin Whale","Flameback","Flamingo Tongue Snail","Flashlight Fish","Flatback Turtle","Flatfish","Flying Fish","Flounder","Fluke","French Angelfish","Frilled Shark","Fugu (also called Pufferfish)","Gar","Geoduck","Giant Barrel Sponge","Giant Caribbean Sea Anemone","Giant Clam","Giant Isopod","Giant Kingfish","Giant Oarfish","Giant Pacific Octopus","Giant Pyrosome","Giant Sea Star","Giant Squid","Glowing Sucker Octopus","Giant Tube Worm","Goblin Shark","Goosefish","Great White Shark","Greenland Shark","Grey Atlantic Seal","Grouper","Grunion","Guineafowl Puffer","Haddock","Hake","Halibut","Hammerhead Shark","Hapuka","Harbor Porpoise","Harbor Seal","Hatchetfish","Hawaiian Monk Seal","Hawksbill Turtle","Hector's Dolphin","Hermit Crab","Herring","Hoki","Horn Shark","Horseshoe Crab","Humpback Anglerfish","Humpback Whale","Icefish","Imperator Angelfish","Irukandji Jellyfish","Isopod","Ivory Bush Coral","Japanese Spider Crab","Jellyfish","John Dory","Juan Fernandez Fur Seal","Killer Whale","Kiwa Hirsuta","Krill","Lagoon Triggerfish","Lamprey","Leafy Seadragon","Leopard Seal","Limpet","Ling","Lionfish","Lions Mane Jellyfish","Lobe Coral","Lobster","Loggerhead Turtle","Longnose Sawshark","Longsnout Seahorse","Lophelia Coral","Marrus Orthocanna","Manatee","Manta Ray","Marlin","Megamouth Shark","Mexican Lookdown","Mimic Octopus","Moon Jelly","Mollusk","Monkfish","Moray Eel","Mullet","Mussel","Megaladon","Napoleon Wrasse","Nassau Grouper","Narwhal","Nautilus","Needlefish","Northern Seahorse","North Atlantic Right Whale","Northern Red Snapper","Norway Lobster","Nudibranch","Nurse Shark","Oarfish","Ocean Sunfish","Oceanic Whitetip Shark","Octopus","Olive Sea Snake","Orange Roughy","Ostracod","Otter","Oyster","Pacific Angelshark","Pacific Blackdragon","Pacific Halibut","Pacific Sardine","Pacific Sea Nettle Jellyfish","Pacific White Sided Dolphin","Pantropical Spotted Dolphin","Patagonian Toothfish","Peacock Mantis Shrimp","Pelagic Thresher Shark","Penguin","Peruvian Anchoveta","Pilchard","Pink Salmon","Pinniped","Plankton","Porpoise","Polar Bear","Portuguese Man o' War","Pycnogonid Sea Spider","Quahog","Queen Angelfish","Queen Conch","Queen Parrotfish","Queensland Grouper","Ragfish","Ratfish","Rattail Fish","Ray","Red Drum","Red King Crab","Ringed Seal","Risso's Dolphin","Ross Seals","Sablefish","Salmon","Sand Dollar","Sandbar Shark","Sawfish","Sarcastic Fringehead","Scalloped Hammerhead Shark","Seahorse","Sea Cucumber","Sea Lion","Sea Urchin","Seal","Shark","Shortfin Mako Shark","Shovelnose Guitarfish","Shrimp","Silverside Fish","Skipjack Tuna","Slender Snipe Eel","Smalltooth Sawfish","Smelts","Sockeye Salmon","Southern Stingray","Sponge","Spotted Porcupinefish","Spotted Dolphin","Spotted Eagle Ray","Spotted Moray","Squid","Squidworm","Starfish","Stickleback","Stonefish","Stoplight Loosejaw","Sturgeon","Swordfish","Tan Bristlemouth","Tasseled Wobbegong","Terrible Claw Lobster","Threespot Damselfish","Tiger Prawn","Tiger Shark","Tilefish","Toadfish","Tropical Two-Wing Flyfish","Tuna","Umbrella Squid","Velvet Crab","Venus Flytrap Sea Anemone","Vigtorniella Worm","Viperfish","Vampire Squid","Vaquita","Wahoo","Walrus","West Indian Manatee","Whale","Whale Shark","Whiptail Gulper","White-Beaked Dolphin","White-Ring Garden Eel","White Shrimp","Wobbegong","Wrasse","Wreckfish","Xiphosura","Yellowtail Damselfish","Yelloweye Rockfish","Yellow Cup Black Coral","Yellow Tube Sponge","Yellowfin Tuna","Zebrashark","Zooplankton"],
//list of desert, grassland, and forest animals comes from http://www.skyenimals.com/
"desert" : ["Aardwolf","Addax","African Wild Ass","Ant","Antelope","Armadillo","Baboon","Badger","Bat","Bearded Dragon","Beetle","Bird","Black-footed Cat","Boa","Brown Bear","Bustard","Butterfly","Camel","Caracal","Caracara","Caterpillar","Centipede","Cheetah","Chipmunk","Chuckwalla","Climbing Mouse","Coati","Cobra","Cotton Rat","Cougar","Courser","Crane Fly","Crow","Dassie Rat","Dove","Dunnart","Eagle","Echidna","Elephant","Emu","Falcon","Fly","Fox","Frogmouth","Gecko","Geoffroy's Cat","Gerbil","Grasshopper","Guanaco","Gundi","Hamster","Hawk","Hedgehog","Hyena","Hyrax","Jackal","Kangaroo","Kangaroo Rat","Kestrel","Kowari","Kultarr","Leopard","Lion","Macaw","Meerkat","Mouse","Oryx","Ostrich","Owl","Pronghorn","Python","Rabbit","Raccoon","Rattlesnake","Rhinoceros","Sand Cat","Spectacled Bear","Spiny Mouse","Starling","Stick Bug","Tarantula","Tit","Toad","Tortoise","Tyrant Flycatcher","Viper","Vulture","Waxwing","Xerus","Zebra"],
"grassland" : ["Aardvark","Aardwolf","Accentor","African Buffalo","African Wild Dog","Alpaca","Anaconda","Ant","Anteater","Antelope","Armadillo","Baboon","Badger","Bandicoot","Barbet","Bat","Bee","Bee-eater","Beetle","Bird","Bison","Black-footed Cat","Black-footed Ferret","Bluebird","Boa","Bowerbird","Brown Bear","Bush Dog","Bushshrike","Bustard","Butterfly","Buzzard","Caracal","Caracara","Cardinal","Caterpillar","Cheetah","Chipmunk","Civet","Climbing Mouse","Clouded Leopard","Coati","Cobra","Cockatoo","Cockroach","Common Genet","Cotton Rat","Cougar","Courser","Coyote","Crane","Crane Fly","Cricket","Crow","Culpeo","Death Adder","Deer","Deer Mouse","Dingo","Dinosaur","Dove","Drongo","Duck","Duiker","Dunnart","Eagle","Echidna","Elephant","Elk","Emu","Falcon","Finch","Flea","Fly","Flying Frog","Fox","Frog","Frogmouth","Garter Snake","Gazelle","Gecko","Geoffroy's Cat","Gerbil","Giant Tortoise","Giraffe","Grasshopper","Grison","Groundhog","Grouse","Guanaco","Guinea Pig","Hamster","Harrier","Hartebeest","Hawk","Hedgehog","Helmetshrike","Hippopotamus","Hornbill","Hyena","Hyrax","Impala","Jackal","Jaguar","Jaguarundi","Kangaroo","Kangaroo Rat","Kestrel","Kultarr","Ladybug","Leopard","Lion","Macaw","Meerkat","Mouse","Newt","Oryx","Ostrich","Owl","Pangolin","Pheasant","Prairie Dog","Pronghorn","Przewalski's Horse","Python","Quoll","Rabbit","Raven","Rhinoceros","Shelduck","Sloth Bear","Spectacled Bear","Squirrel","Starling","Stick Bug","Tamandua","Tasmanian Devil","Thornbill","Thrush","Toad","Tortoise"],
"forest" : ["Agouti","Anaconda","Anoa","Ant","Anteater","Antelope","Armadillo","Asian Black Bear","Aye-aye","Babirusa","Baboon","Badger","Bandicoot","Banteng","Barbet","Basilisk","Bat","Bearded Dragon","Bee","Bee-eater","Beetle","Bettong","Binturong","Bird-of-paradise","Bongo","Bowerbird","Bulbul","Bush Dog","Bushbaby","Bushshrike","Butterfly","Buzzard","Caecilian","Cardinal","Cassowary","Caterpillar","Centipede","Chameleon","Chimpanzee","Cicada","Civet","Clouded Leopard","Coati","Cobra","Cockatoo","Cockroach","Colugo","Cotinga","Cotton Rat","Cougar","Crane Fly","Cricket","Crocodile","Crow","Cuckoo","Cuscus","Death Adder","Deer","Dhole","Dingo","Dinosaur","Drongo","Duck","Duiker","Eagle","Echidna","Elephant","Finch","Flat-headed Cat","Flea","Flowerpecker","Fly","Flying Frog","Fossa","Frog","Frogmouth","Gaur","Gecko","Gorilla","Grison","Hawaiian Honeycreeper","Hawk","Hedgehog","Helmetshrike","Hornbill","Hyrax","Iguana","Jackal","Jaguar","Jaguarundi","Kestrel","Ladybug","Lemur","Leopard","Lion","Macaw","Mandrill","Margay","Monkey","Mouse","Mouse Deer","Newt","Okapi","Old World Flycatcher","Orangutan","Owl","Pangolin","Peafowl","Pheasant","Possum","Python","Quokka","Rabbit","Raccoon","Red Panda","Red River Hog","Rhinoceros","Sloth Bear","Spectacled Bear","Squirrel","Starling","Stick Bug","Sun Bear","Tamandua","Tamarin","Tapir","Tarantula","Thrush","Tiger","Tit","Toad","Tortoise","Toucan","Trogon","Trumpeter","Turaco","Turtle","Tyrant Flycatcher","Viper","Vulture","Wallaby","Warbler","Wasp","Waxwing","Weaver","Weaver-finch","Whistler","White-eye","Whydah","Woodswallow","Worm","Wren","Xenops","Yellowjacket","Accentor","African Buffalo","American Black Bear","Anole","Bird","Bison","Boa","Brown Bear","Chipmunk","Common Genet","Copperhead","Coyote","Deer Mouse","Dormouse","Elk","Emu","Fisher","Fox","Garter Snake","Giant Panda","Giant Tortoise","Groundhog","Grouse","Guanaco","Himalayan Tahr","Kangaroo","Koala","Numbat","Quoll","Raccoon dog","Tasmanian Devil","Thornbill","Turkey","Vole","Weasel","Wildcat","Wolf","Wombat","Woodchuck","Woodpecker"],
//list of farm animals comes from https://www.buzzle.com/articles/farm-animals-list.html
"farm" : ["Alpaca","Buffalo","Banteng","Cow","Cat","Chicken","Carp","Camel","Donkey","Dog","Duck","Emu","Goat","Gayal","Guinea","Goose","Horse","Honey","Llama","Pig","Pigeon","Rhea","Rabbit","Sheep","Silkworm","Turkey","Yak","Zebu"],
//list of pet animals comes from https://www.dogbreedinfo.com/pets/pet.htm
"pet" : ["Bearded Dragon","Birds","Burro","Cats","Chameleons","Chickens","Chinchillas","Chinese Water Dragon","Cows","Dogs","Donkey","Ducks","Ferrets","Fish","Geckos","Geese","Gerbils","Goats","Guinea Fowl","Guinea Pigs","Hamsters","Hedgehogs","Horses","Iguanas","Llamas","Lizards","Mice","Mule","Peafowl","Pigs and Hogs","Pigeons","Ponies","Pot Bellied Pig","Rabbits","Rats","Sheep","Skinks","Snakes","Stick Insects","Sugar Gliders","Tarantula","Turkeys","Turtles"],
//list of zoo animals comes from https://bronxzoo.com/animals
"zoo" : ["Aardvark","African Wild Dog","Aldabra Tortoise","American Alligator","American Bison","Amur Tiger","Anaconda","Andean Condor","Asian Elephant","Baby Doll Sheep","Bald Eagle","Barred Owl","Blue Iguana","Boer Goat","California Sea Lion","Caribbean Flamingo","Chinchilla","Collared Lemur","Coquerel's Sifaka","Cuban Amazon Parrot","Ebony Langur","Fennec Fox","Fossa","Gelada","Giant Anteater","Giraffe","Gorilla","Grizzly Bear","Henkel's Leaf-tailed Gecko","Indian Gharial","Indian Rhinoceros","King Cobra","King Vulture","Komodo Dragon","Linne's Two-toed Sloth","Lion","Little Penguin","Madagascar Tree Boa","Magellanic Penguin","Malayan Tapir","Malayan Tiger","Matschies Tree Kangaroo","Mini Donkey","Monarch Butterfly","Nile crocodile","North American Porcupine","Nubian Ibex","Okapi","Poison Dart Frog","Polar Bear","Pygmy Marmoset","Radiated Tortoise","Red Panda","Red Ruffed Lemur","Ring-tailed Lemur","Ring-tailed Mongoose","Rock Hyrax","Small Clawed Asian Otter","Snow Leopard","Snowy Owl","Southern White-faced Owl","Southern White Rhinocerous","Squirrel Monkey","Tufted Puffin","White Cheeked Gibbon","White-throated Bee Eater","Zebra"]
}
};
var o_hasOwnProperty = Object.prototype.hasOwnProperty;
var o_keys = (Object.keys || function(obj) {
var result = [];
for (var key in obj) {
if (o_hasOwnProperty.call(obj, key)) {
result.push(key);
}
}
return result;
});
function _copyObject(source, target) {
var keys = o_keys(source);
var key;
for (var i = 0, l = keys.length; i < l; i++) {
key = keys[i];
target[key] = source[key] || target[key];
}
}
function _copyArray(source, target) {
for (var i = 0, l = source.length; i < l; i++) {
target[i] = source[i];
}
}
function copyObject(source, _target) {
var isArray = Array.isArray(source);
var target = _target || (isArray ? new Array(source.length) : {});
if (isArray) {
_copyArray(source, target);
} else {
_copyObject(source, target);
}
return target;
}
/** Get the data based on key**/
Chance.prototype.get = function (name) {
return copyObject(data[name]);
};
// Mac Address
Chance.prototype.mac_address = function(options){
// typically mac addresses are separated by ":"
// however they can also be separated by "-"
// the network variant uses a dot every fourth byte
options = initOptions(options);
if(!options.separator) {
options.separator = options.networkVersion ? "." : ":";
}
var mac_pool="ABCDEF1234567890",
mac = "";
if(!options.networkVersion) {
mac = this.n(this.string, 6, { pool: mac_pool, length:2 }).join(options.separator);
} else {
mac = this.n(this.string, 3, { pool: mac_pool, length:4 }).join(options.separator);
}
return mac;
};
Chance.prototype.normal = function (options) {
options = initOptions(options, {mean : 0, dev : 1, pool : []});
testRange(
options.pool.constructor !== Array,
"Chance: The pool option must be a valid array."
);
testRange(
typeof options.mean !== 'number',
"Chance: Mean (mean) must be a number"
);
testRange(
typeof options.dev !== 'number',
"Chance: Standard deviation (dev) must be a number"
);
// If a pool has been passed, then we are returning an item from that pool,
// using the normal distribution settings that were passed in
if (options.pool.length > 0) {
return this.normal_pool(options);
}
// The Marsaglia Polar method
var s, u, v, norm,
mean = options.mean,
dev = options.dev;
do {
// U and V are from the uniform distribution on (-1, 1)
u = this.random() * 2 - 1;
v = this.random() * 2 - 1;
s = u * u + v * v;
} while (s >= 1);
// Compute the standard normal variate
norm = u * Math.sqrt(-2 * Math.log(s) / s);
// Shape and scale
return dev * norm + mean;
};
Chance.prototype.normal_pool = function(options) {
var performanceCounter = 0;
do {
var idx = Math.round(this.normal({ mean: options.mean, dev: options.dev }));
if (idx < options.pool.length && idx >= 0) {
return options.pool[idx];
} else {
performanceCounter++;
}
} while(performanceCounter < 100);
throw new RangeError("Chance: Your pool is too small for the given mean and standard deviation. Please adjust.");
};
Chance.prototype.radio = function (options) {
// Initial Letter (Typically Designated by Side of Mississippi River)
options = initOptions(options, {side : "?"});
var fl = "";
switch (options.side.toLowerCase()) {
case "east":
case "e":
fl = "W";
break;
case "west":
case "w":
fl = "K";
break;
default:
fl = this.character({pool: "KW"});
break;
}
return fl + this.character({alpha: true, casing: "upper"}) +
this.character({alpha: true, casing: "upper"}) +
this.character({alpha: true, casing: "upper"});
};
// Set the data as key and data or the data map
Chance.prototype.set = function (name, values) {
if (typeof name === "string") {
data[name] = values;
} else {
data = copyObject(name, data);
}
};
Chance.prototype.tv = function (options) {
return this.radio(options);
};
// ID number for Brazil companies
Chance.prototype.cnpj = function () {
var n = this.n(this.natural, 8, { max: 9 });
var d1 = 2+n[7]*6+n[6]*7+n[5]*8+n[4]*9+n[3]*2+n[2]*3+n[1]*4+n[0]*5;
d1 = 11 - (d1 % 11);
if (d1>=10){
d1 = 0;
}
var d2 = d1*2+3+n[7]*7+n[6]*8+n[5]*9+n[4]*2+n[3]*3+n[2]*4+n[1]*5+n[0]*6;
d2 = 11 - (d2 % 11);
if (d2>=10){
d2 = 0;
}
return ''+n[0]+n[1]+'.'+n[2]+n[3]+n[4]+'.'+n[5]+n[6]+n[7]+'/0001-'+d1+d2;
};
// -- End Miscellaneous --
Chance.prototype.mersenne_twister = function (seed) {
return new MersenneTwister(seed);
};
Chance.prototype.blueimp_md5 = function () {
return new BlueImpMD5();
};
// Mersenne Twister from https://gist.github.com/banksean/300494
/*
A C-program for MT19937, with initialization improved 2002/1/26.
Coded by Takuji Nishimura and Makoto Matsumoto.
Before using, initialize the state by using init_genrand(seed)
or init_by_array(init_key, key_length).
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Any feedback is very welcome.
http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
*/
var MersenneTwister = function (seed) {
if (seed === undefined) {
// kept random number same size as time used previously to ensure no unexpected results downstream
seed = Math.floor(Math.random()*Math.pow(10,13));
}
/* Period parameters */
this.N = 624;
this.M = 397;
this.MATRIX_A = 0x9908b0df; /* constant vector a */
this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
this.mt = new Array(this.N); /* the array for the state vector */
this.mti = this.N + 1; /* mti==N + 1 means mt[N] is not initialized */
this.init_genrand(seed);
};
/* initializes mt[N] with a seed */
MersenneTwister.prototype.init_genrand = function (s) {
this.mt[0] = s >>> 0;
for (this.mti = 1; this.mti < this.N; this.mti++) {
s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253) + this.mti;
/* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
/* In the previous versions, MSBs of the seed affect */
/* only MSBs of the array mt[]. */
/* 2002/01/09 modified by Makoto Matsumoto */
this.mt[this.mti] >>>= 0;
/* for >32 bit machines */
}
};
/* initialize by an array with array-length */
/* init_key is the array for initializing keys */
/* key_length is its length */
/* slight change for C++, 2004/2/26 */
MersenneTwister.prototype.init_by_array = function (init_key, key_length) {
var i = 1, j = 0, k, s;
this.init_genrand(19650218);
k = (this.N > key_length ? this.N : key_length);
for (; k; k--) {
s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525))) + init_key[j] + j; /* non linear */
this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
i++;
j++;
if (i >= this.N) { this.mt[0] = this.mt[this.N - 1]; i = 1; }
if (j >= key_length) { j = 0; }
}
for (k = this.N - 1; k; k--) {
s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941)) - i; /* non linear */
this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
i++;
if (i >= this.N) { this.mt[0] = this.mt[this.N - 1]; i = 1; }
}
this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
};
/* generates a random number on [0,0xffffffff]-interval */
MersenneTwister.prototype.genrand_int32 = function () {
var y;
var mag01 = new Array(0x0, this.MATRIX_A);
/* mag01[x] = x * MATRIX_A for x=0,1 */
if (this.mti >= this.N) { /* generate N words at one time */
var kk;
if (this.mti === this.N + 1) { /* if init_genrand() has not been called, */
this.init_genrand(5489); /* a default initial seed is used */
}
for (kk = 0; kk < this.N - this.M; kk++) {
y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk + 1]&this.LOWER_MASK);
this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
}
for (;kk < this.N - 1; kk++) {
y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk + 1]&this.LOWER_MASK);
this.mt[kk] = this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
}
y = (this.mt[this.N - 1]&this.UPPER_MASK)|(this.mt[0]&this.LOWER_MASK);
this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
this.mti = 0;
}
y = this.mt[this.mti++];
/* Tempering */
y ^= (y >>> 11);
y ^= (y << 7) & 0x9d2c5680;
y ^= (y << 15) & 0xefc60000;
y ^= (y >>> 18);
return y >>> 0;
};
/* generates a random number on [0,0x7fffffff]-interval */
MersenneTwister.prototype.genrand_int31 = function () {
return (this.genrand_int32() >>> 1);
};
/* generates a random number on [0,1]-real-interval */
MersenneTwister.prototype.genrand_real1 = function () {
return this.genrand_int32() * (1.0 / 4294967295.0);
/* divided by 2^32-1 */
};
/* generates a random number on [0,1)-real-interval */
MersenneTwister.prototype.random = function () {
return this.genrand_int32() * (1.0 / 4294967296.0);
/* divided by 2^32 */
};
/* generates a random number on (0,1)-real-interval */
MersenneTwister.prototype.genrand_real3 = function () {
return (this.genrand_int32() + 0.5) * (1.0 / 4294967296.0);
/* divided by 2^32 */
};
/* generates a random number on [0,1) with 53-bit resolution*/
MersenneTwister.prototype.genrand_res53 = function () {
var a = this.genrand_int32()>>>5, b = this.genrand_int32()>>>6;
return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
};
// BlueImp MD5 hashing algorithm from https://github.com/blueimp/JavaScript-MD5
var BlueImpMD5 = function () {};
BlueImpMD5.prototype.VERSION = '1.0.1';
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
BlueImpMD5.prototype.safe_add = function safe_add(x, y) {
var lsw = (x & 0xFFFF) + (y & 0xFFFF),
msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) | (lsw & 0xFFFF);
};
/*
* Bitwise rotate a 32-bit number to the left.
*/
BlueImpMD5.prototype.bit_roll = function (num, cnt) {
return (num << cnt) | (num >>> (32 - cnt));
};
/*
* These functions implement the five basic operations the algorithm uses.
*/
BlueImpMD5.prototype.md5_cmn = function (q, a, b, x, s, t) {
return this.safe_add(this.bit_roll(this.safe_add(this.safe_add(a, q), this.safe_add(x, t)), s), b);
};
BlueImpMD5.prototype.md5_ff = function (a, b, c, d, x, s, t) {
return this.md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
};
BlueImpMD5.prototype.md5_gg = function (a, b, c, d, x, s, t) {
return this.md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
};
BlueImpMD5.prototype.md5_hh = function (a, b, c, d, x, s, t) {
return this.md5_cmn(b ^ c ^ d, a, b, x, s, t);
};
BlueImpMD5.prototype.md5_ii = function (a, b, c, d, x, s, t) {
return this.md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
};
/*
* Calculate the MD5 of an array of little-endian words, and a bit length.
*/
BlueImpMD5.prototype.binl_md5 = function (x, len) {
/* append padding */
x[len >> 5] |= 0x80 << (len % 32);
x[(((len + 64) >>> 9) << 4) + 14] = len;
var i, olda, oldb, oldc, oldd,
a = 1732584193,
b = -271733879,
c = -1732584194,
d = 271733878;
for (i = 0; i < x.length; i += 16) {
olda = a;
oldb = b;
oldc = c;
oldd = d;
a = this.md5_ff(a, b, c, d, x[i], 7, -680876936);
d = this.md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
c = this.md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
b = this.md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
a = this.md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
d = this.md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
c = this.md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
b = this.md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
a = this.md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
d = this.md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
c = this.md5_ff(c, d, a, b, x[i + 10], 17, -42063);
b = this.md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
a = this.md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
d = this.md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
c = this.md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
b = this.md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);
a = this.md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
d = this.md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
c = this.md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
b = this.md5_gg(b, c, d, a, x[i], 20, -373897302);
a = this.md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
d = this.md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
c = this.md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
b = this.md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
a = this.md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
d = this.md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
c = this.md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
b = this.md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
a = this.md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
d = this.md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
c = this.md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
b = this.md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);
a = this.md5_hh(a, b, c, d, x[i + 5], 4, -378558);
d = this.md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
c = this.md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
b = this.md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
a = this.md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
d = this.md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
c = this.md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
b = this.md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
a = this.md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
d = this.md5_hh(d, a, b, c, x[i], 11, -358537222);
c = this.md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
b = this.md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
a = this.md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
d = this.md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
c = this.md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
b = this.md5_hh(b, c, d, a, x[i + 2], 23, -995338651);
a = this.md5_ii(a, b, c, d, x[i], 6, -198630844);
d = this.md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
c = this.md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
b = this.md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
a = this.md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
d = this.md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
c = this.md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
b = this.md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
a = this.md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
d = this.md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
c = this.md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
b = this.md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
a = this.md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
d = this.md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
c = this.md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
b = this.md5_ii(b, c, d, a, x[i + 9], 21, -343485551);
a = this.safe_add(a, olda);
b = this.safe_add(b, oldb);
c = this.safe_add(c, oldc);
d = this.safe_add(d, oldd);
}
return [a, b, c, d];
};
/*
* Convert an array of little-endian words to a string
*/
BlueImpMD5.prototype.binl2rstr = function (input) {
var i,
output = '';
for (i = 0; i < input.length * 32; i += 8) {
output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xFF);
}
return output;
};
/*
* Convert a raw string to an array of little-endian words
* Characters >255 have their high-byte silently ignored.
*/
BlueImpMD5.prototype.rstr2binl = function (input) {
var i,
output = [];
output[(input.length >> 2) - 1] = undefined;
for (i = 0; i < output.length; i += 1) {
output[i] = 0;
}
for (i = 0; i < input.length * 8; i += 8) {
output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << (i % 32);
}
return output;
};
/*
* Calculate the MD5 of a raw string
*/
BlueImpMD5.prototype.rstr_md5 = function (s) {
return this.binl2rstr(this.binl_md5(this.rstr2binl(s), s.length * 8));
};
/*
* Calculate the HMAC-MD5, of a key and some data (raw strings)
*/
BlueImpMD5.prototype.rstr_hmac_md5 = function (key, data) {
var i,
bkey = this.rstr2binl(key),
ipad = [],
opad = [],
hash;
ipad[15] = opad[15] = undefined;
if (bkey.length > 16) {
bkey = this.binl_md5(bkey, key.length * 8);
}
for (i = 0; i < 16; i += 1) {
ipad[i] = bkey[i] ^ 0x36363636;
opad[i] = bkey[i] ^ 0x5C5C5C5C;
}
hash = this.binl_md5(ipad.concat(this.rstr2binl(data)), 512 + data.length * 8);
return this.binl2rstr(this.binl_md5(opad.concat(hash), 512 + 128));
};
/*
* Convert a raw string to a hex string
*/
BlueImpMD5.prototype.rstr2hex = function (input) {
var hex_tab = '0123456789abcdef',
output = '',
x,
i;
for (i = 0; i < input.length; i += 1) {
x = input.charCodeAt(i);
output += hex_tab.charAt((x >>> 4) & 0x0F) +
hex_tab.charAt(x & 0x0F);
}
return output;
};
/*
* Encode a string as utf-8
*/
BlueImpMD5.prototype.str2rstr_utf8 = function (input) {
return unescape(encodeURIComponent(input));
};
/*
* Take string arguments and return either raw or hex encoded strings
*/
BlueImpMD5.prototype.raw_md5 = function (s) {
return this.rstr_md5(this.str2rstr_utf8(s));
};
BlueImpMD5.prototype.hex_md5 = function (s) {
return this.rstr2hex(this.raw_md5(s));
};
BlueImpMD5.prototype.raw_hmac_md5 = function (k, d) {
return this.rstr_hmac_md5(this.str2rstr_utf8(k), this.str2rstr_utf8(d));
};
BlueImpMD5.prototype.hex_hmac_md5 = function (k, d) {
return this.rstr2hex(this.raw_hmac_md5(k, d));
};
BlueImpMD5.prototype.md5 = function (string, key, raw) {
if (!key) {
if (!raw) {
return this.hex_md5(string);
}
return this.raw_md5(string);
}
if (!raw) {
return this.hex_hmac_md5(key, string);
}
return this.raw_hmac_md5(key, string);
};
// CommonJS module
{
if ('object' !== 'undefined' && module.exports) {
exports = module.exports = Chance;
}
exports.Chance = Chance;
}
// Register as an anonymous AMD module
if (typeof undefined === 'function' && undefined.amd) {
undefined([], function () {
return Chance;
});
}
// if there is a importsScrips object define chance for worker
// allows worker to use full Chance functionality with seed
if (typeof importScripts !== 'undefined') {
chance = new Chance();
self.Chance = Chance;
}
// If there is a window object, that at least has a document property,
// instantiate and define chance on the window
if (typeof window === "object" && typeof window.document === "object") {
window.Chance = Chance;
window.chance = new Chance();
}
})();
});
var chance_2 = chance_1.Chance;
var index$1 = function (str) {
return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
return '%' + c.charCodeAt(0).toString(16).toUpperCase();
});
};
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
if (val === null || val === undefined) {
throw new TypeError('Object.assign cannot be called with null or undefined');
}
return Object(val);
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false;
}
// Detect buggy property enumeration order in older V8 versions.
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
test1[5] = 'de';
if (Object.getOwnPropertyNames(test1)[0] === '5') {
return false;
}
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test2 = {};
for (var i = 0; i < 10; i++) {
test2['_' + String.fromCharCode(i)] = i;
}
var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
return test2[n];
});
if (order2.join('') !== '0123456789') {
return false;
}
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test3 = {};
'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
test3[letter] = letter;
});
if (Object.keys(Object.assign({}, test3)).join('') !==
'abcdefghijklmnopqrst') {
return false;
}
return true;
} catch (err) {
// We don't expect any of the above to throw, but better to be safe.
return false;
}
}
var index$3 = shouldUseNative() ? Object.assign : function (target, source) {
var from;
var to = toObject(target);
var symbols;
for (var s = 1; s < arguments.length; s++) {
from = Object(arguments[s]);
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
if (getOwnPropertySymbols) {
symbols = getOwnPropertySymbols(from);
for (var i = 0; i < symbols.length; i++) {
if (propIsEnumerable.call(from, symbols[i])) {
to[symbols[i]] = from[symbols[i]];
}
}
}
}
return to;
};
function encoderForArrayFormat(opts) {
switch (opts.arrayFormat) {
case 'index':
return function (key, value, index) {
return value === null ? [
encode(key, opts),
'[',
index,
']'
].join('') : [
encode(key, opts),
'[',
encode(index, opts),
']=',
encode(value, opts)
].join('');
};
case 'bracket':
return function (key, value) {
return value === null ? encode(key, opts) : [
encode(key, opts),
'[]=',
encode(value, opts)
].join('');
};
default:
return function (key, value) {
return value === null ? encode(key, opts) : [
encode(key, opts),
'=',
encode(value, opts)
].join('');
};
}
}
function parserForArrayFormat(opts) {
var result;
switch (opts.arrayFormat) {
case 'index':
return function (key, value, accumulator) {
result = /\[(\d*)\]$/.exec(key);
key = key.replace(/\[\d*\]$/, '');
if (!result) {
accumulator[key] = value;
return;
}
if (accumulator[key] === undefined) {
accumulator[key] = {};
}
accumulator[key][result[1]] = value;
};
case 'bracket':
return function (key, value, accumulator) {
result = /(\[\])$/.exec(key);
key = key.replace(/\[\]$/, '');
if (!result) {
accumulator[key] = value;
return;
} else if (accumulator[key] === undefined) {
accumulator[key] = [value];
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
default:
return function (key, value, accumulator) {
if (accumulator[key] === undefined) {
accumulator[key] = value;
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
}
}
function encode(value, opts) {
if (opts.encode) {
return opts.strict ? index$1(value) : encodeURIComponent(value);
}
return value;
}
function keysSorter(input) {
if (Array.isArray(input)) {
return input.sort();
} else if (typeof input === 'object') {
return keysSorter(Object.keys(input)).sort(function (a, b) {
return Number(a) - Number(b);
}).map(function (key) {
return input[key];
});
}
return input;
}
var extract = function (str) {
return str.split('?')[1] || '';
};
var parse = function (str, opts) {
opts = index$3({arrayFormat: 'none'}, opts);
var formatter = parserForArrayFormat(opts);
// Create an object with no prototype
// https://github.com/sindresorhus/query-string/issues/47
var ret = Object.create(null);
if (typeof str !== 'string') {
return ret;
}
str = str.trim().replace(/^(\?|#|&)/, '');
if (!str) {
return ret;
}
str.split('&').forEach(function (param) {
var parts = param.replace(/\+/g, ' ').split('=');
// Firefox (pre 40) decodes `%3D` to `=`
// https://github.com/sindresorhus/query-string/pull/37
var key = parts.shift();
var val = parts.length > 0 ? parts.join('=') : undefined;
// missing `=` should be `null`:
// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
val = val === undefined ? null : decodeURIComponent(val);
formatter(decodeURIComponent(key), val, ret);
});
return Object.keys(ret).sort().reduce(function (result, key) {
var val = ret[key];
if (Boolean(val) && typeof val === 'object' && !Array.isArray(val)) {
// Sort object keys, not values
result[key] = keysSorter(val);
} else {
result[key] = val;
}
return result;
}, Object.create(null));
};
var stringify = function (obj, opts) {
var defaults = {
encode: true,
strict: true,
arrayFormat: 'none'
};
opts = index$3(defaults, opts);
var formatter = encoderForArrayFormat(opts);
return obj ? Object.keys(obj).sort().map(function (key) {
var val = obj[key];
if (val === undefined) {
return '';
}
if (val === null) {
return encode(key, opts);
}
if (Array.isArray(val)) {
var result = [];
val.slice().forEach(function (val2) {
if (val2 === undefined) {
return;
}
result.push(formatter(key, val2, result.length));
});
return result.join('&');
}
return encode(key, opts) + '=' + encode(val, opts);
}).filter(function (x) {
return x.length > 0;
}).join('&') : '';
};
var index = {
extract: extract,
parse: parse,
stringify: stringify
};
/* global location */
function cloneDeep (o) { return JSON.parse(JSON.stringify(o)) }
const browserSupport =
console.group != null;
function createTestLink (params) {
if (typeof location !== 'undefined') {
var query = index.parse(location.search);
delete query.test;
delete query.seed;
delete query.args;
delete query.repeat;
for (var name in params) {
if (params[name] != null) {
query[name] = params[name];
}
}
return location.protocol + '//' + location.host + location.pathname + '?' + index.stringify(query) + location.hash
}
}
/* globals location */
class TestHandler {
constructor () {
this.repeatingRun = 0;
this.tests = {};
if (typeof location !== 'undefined') {
this.opts = index.parse(location.search);
if (this.opts.case != null) {
this.opts.case = Number(this.opts.case);
}
if (this.opts.repeat === 'true') {
this.opts.repeat = true;
} else if (this.opts.repeat === 'false') {
this.opts.repeat = false;
}
} else {
this.opts = {};
}
this.opts.repeat = this.opts.repeat !== false;
}
getRandomSeed () {
return this.opts.seed || null
}
getTestList () {
return Object.keys(this.tests).map(name => this.tests[name])
}
isTestRunnig () {
return this.getTestList().some(test => test.status === 'running')
}
isSequentialTestRunning () {
return this.getTestList().some(test => !test.isParallel() && test.status === 'running')
}
isParallelTestRunning () {
return this.getTestList().some(test => test.isParallel() && test.status === 'running')
}
get numberOfTests () {
return this.getTestList().length
}
get numberOfCompletedTests () {
return this.getTestList().filter(test => test.status === 'done').length
}
get numberOfSuccessfullTests () {
return this.getTestList().filter(test => test.failed === false && test.status === 'done').length
}
register (test) {
if (test.name == null) {
throw new Error(`
Each test must be defined by a unique function name!
E.g. \`test('test description', async function uniqueName () { .. })\`
`
)
}
if (this.tests[test.name] != null) {
throw new Error(`
Each test must be defined by a unique function name!
=> \`test('${test.description}', async function ${test.name} () { .. })\` is already registered!
`
)
}
if (this.opts.test == null || test.name.indexOf(this.opts.test) >= 0) {
this.tests[test.name] = test;
if (!this.isTestRunnig() || (test.isParallel() && this.isParallelTestRunning())) {
// only if no test is running, or if parallel tests are already running
test.run();
}
}
}
_runNextSequentialTest () {
let nextSequential = this.getTestList().find(
t => t.status === 'pending' && !t.isParallel()
);
if (nextSequential != null) {
nextSequential.run();
return true
} else {
return false
}
}
_runNextParallelTests () {
let nextParallels = this.getTestList().filter(
t => t.status === 'pending' && t.isParallel()
);
if (nextParallels.length > 0) {
nextParallels.map(t => t.run());
return true
} else {
return false
}
}
testCompleted (test) {
this._runNextParallelTests();
if (!this.isTestRunnig()) {
this._runNextSequentialTest();
if (!this.isSequentialTestRunning()) {
this.done();
}
}
}
_runRepeatingTests () {
let repeatingTests = this.getTestList().filter(t => t.isRepeating());
if (repeatingTests.length > 0 && this.opts.repeat) {
this.repeatingRun++;
console.log(`%cRunning ${repeatingTests.length} tests again because they use random values.. (${this.repeatingRun}. repeating run)`, 'font-weight:bold');
this.tests = {};
repeatingTests.forEach(t => {
this.register(t.clone());
});
this.testCompleted();
}
}
done () {
if (this.numberOfTests === this.numberOfCompletedTests) {
if (this.numberOfTests === this.numberOfSuccessfullTests) {
if (browserSupport) {
console.log('\n%cAll tests passed!', 'font-weight:bold');
console.log('%c ',
'font-size: 1px; padding: 60px 80px; background-size: 170px 120px; line-height: 120px; background-image: url(https://cloud.githubusercontent.com/assets/5553757/25725585/ee1e2ac0-3120-11e7-9401-323c153a99f1.gif)'
);
this._runRepeatingTests();
} else {
console.log('\n -- All tests passed! --');
}
} else {
if (browserSupport) {
console.log(`\n%cPassed: ${this.numberOfSuccessfullTests} %cFailed: ${this.numberOfTests - this.numberOfSuccessfullTests}`, 'font-weight:bold; color: green', 'font-weight:bold; color:red');
} else {
console.log(`\nPassed: ${this.numberOfSuccessfullTests}\nFailed: ${this.numberOfTests - this.numberOfSuccessfullTests}`);
}
}
}
}
}
const testHandler = new TestHandler();
var commonjsGlobal$1 = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function commonjsRequire$1 () {
throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
}
function createCommonjsModule$1(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var isBrowser = typeof index !== 'undefined';
var environment = {
isBrowser: isBrowser
};
var Processor$1 = function Processor(options){
this.selfOptions = options || {};
this.pipes = {};
};
Processor$1.prototype.options = function(options) {
if (options) {
this.selfOptions = options;
}
return this.selfOptions;
};
Processor$1.prototype.pipe = function(name, pipe) {
if (typeof name === 'string') {
if (typeof pipe === 'undefined') {
return this.pipes[name];
} else {
this.pipes[name] = pipe;
}
}
if (name && name.name) {
pipe = name;
if (pipe.processor === this) { return pipe; }
this.pipes[pipe.name] = pipe;
}
pipe.processor = this;
return pipe;
};
Processor$1.prototype.process = function(input, pipe) {
var context = input;
context.options = this.options();
var nextPipe = pipe || input.pipe || 'default';
var lastPipe, lastContext;
while (nextPipe) {
if (typeof context.nextAfterChildren !== 'undefined') {
// children processed and coming back to parent
context.next = context.nextAfterChildren;
context.nextAfterChildren = null;
}
if (typeof nextPipe === 'string') {
nextPipe = this.pipe(nextPipe);
}
nextPipe.process(context);
lastContext = context;
lastPipe = nextPipe;
nextPipe = null;
if (context) {
if (context.next) {
context = context.next;
nextPipe = lastContext.nextPipe || context.pipe || lastPipe;
}
}
}
return context.hasResult ? context.result : undefined;
};
var Processor_1 = Processor$1;
var processor = {
Processor: Processor_1
};
var Pipe$1 = function Pipe(name) {
this.name = name;
this.filters = [];
};
Pipe$1.prototype.process = function(input) {
if (!this.processor) {
throw new Error('add this pipe to a processor before using it');
}
var debug = this.debug;
var length = this.filters.length;
var context = input;
for (var index = 0; index < length; index++) {
var filter = this.filters[index];
if (debug) {
this.log('filter: ' + filter.filterName);
}
filter(context);
if (typeof context === 'object' && context.exiting) {
context.exiting = false;
break;
}
}
if (!context.next && this.resultCheck) {
this.resultCheck(context);
}
};
Pipe$1.prototype.log = function(msg) {
console.log('[jsondiffpatch] ' + this.name + ' pipe, ' + msg);
};
Pipe$1.prototype.append = function() {
this.filters.push.apply(this.filters, arguments);
return this;
};
Pipe$1.prototype.prepend = function() {
this.filters.unshift.apply(this.filters, arguments);
return this;
};
Pipe$1.prototype.indexOf = function(filterName) {
if (!filterName) {
throw new Error('a filter name is required');
}
for (var index = 0; index < this.filters.length; index++) {
var filter = this.filters[index];
if (filter.filterName === filterName) {
return index;
}
}
throw new Error('filter not found: ' + filterName);
};
Pipe$1.prototype.list = function() {
var names = [];
for (var index = 0; index < this.filters.length; index++) {
var filter = this.filters[index];
names.push(filter.filterName);
}
return names;
};
Pipe$1.prototype.after = function(filterName) {
var index = this.indexOf(filterName);
var params = Array.prototype.slice.call(arguments, 1);
if (!params.length) {
throw new Error('a filter is required');
}
params.unshift(index + 1, 0);
Array.prototype.splice.apply(this.filters, params);
return this;
};
Pipe$1.prototype.before = function(filterName) {
var index = this.indexOf(filterName);
var params = Array.prototype.slice.call(arguments, 1);
if (!params.length) {
throw new Error('a filter is required');
}
params.unshift(index, 0);
Array.prototype.splice.apply(this.filters, params);
return this;
};
Pipe$1.prototype.clear = function() {
this.filters.length = 0;
return this;
};
Pipe$1.prototype.shouldHaveResult = function(should) {
if (should === false) {
this.resultCheck = null;
return;
}
if (this.resultCheck) {
return;
}
var pipe = this;
this.resultCheck = function(context) {
if (!context.hasResult) {
console.log(context);
var error = new Error(pipe.name + ' failed');
error.noResult = true;
throw error;
}
};
return this;
};
var Pipe_1 = Pipe$1;
var pipe = {
Pipe: Pipe_1
};
var Pipe$2 = pipe.Pipe;
var Context$1 = function Context(){
};
Context$1.prototype.setResult = function(result) {
this.result = result;
this.hasResult = true;
return this;
};
Context$1.prototype.exit = function() {
this.exiting = true;
return this;
};
Context$1.prototype.switchTo = function(next, pipe$$1) {
if (typeof next === 'string' || next instanceof Pipe$2) {
this.nextPipe = next;
} else {
this.next = next;
if (pipe$$1) {
this.nextPipe = pipe$$1;
}
}
return this;
};
Context$1.prototype.push = function(child, name) {
child.parent = this;
if (typeof name !== 'undefined') {
child.childName = name;
}
child.root = this.root || this;
child.options = child.options || this.options;
if (!this.children) {
this.children = [child];
this.nextAfterChildren = this.next || null;
this.next = child;
} else {
this.children[this.children.length - 1].next = child;
this.children.push(child);
}
child.next = this;
return this;
};
var Context_1 = Context$1;
var context = {
Context: Context_1
};
var isArray = (typeof Array.isArray === 'function') ?
// use native function
Array.isArray :
// use instanceof operator
function(a) {
return a instanceof Array;
};
function cloneRegExp(re) {
var regexMatch = /^\/(.*)\/([gimyu]*)$/.exec(re.toString());
return new RegExp(regexMatch[1], regexMatch[2]);
}
function clone(arg) {
if (typeof arg !== 'object') {
return arg;
}
if (arg === null) {
return null;
}
if (isArray(arg)) {
return arg.map(clone);
}
if (arg instanceof Date) {
return new Date(arg.getTime());
}
if (arg instanceof RegExp) {
return cloneRegExp(arg);
}
var cloned = {};
for (var name in arg) {
if (Object.prototype.hasOwnProperty.call(arg, name)) {
cloned[name] = clone(arg[name]);
}
}
return cloned;
}
var clone_1 = clone;
var Context = context.Context;
var DiffContext$1 = function DiffContext(left, right) {
this.left = left;
this.right = right;
this.pipe = 'diff';
};
DiffContext$1.prototype = new Context();
DiffContext$1.prototype.setResult = function(result) {
if (this.options.cloneDiffValues && typeof result === 'object') {
var clone = typeof this.options.cloneDiffValues === 'function' ?
this.options.cloneDiffValues : clone_1;
if (typeof result[0] === 'object') {
result[0] = clone(result[0]);
}
if (typeof result[1] === 'object') {
result[1] = clone(result[1]);
}
}
return Context.prototype.setResult.apply(this, arguments);
};
var DiffContext_1 = DiffContext$1;
var diff = {
DiffContext: DiffContext_1
};
var Context$2 = context.Context;
var PatchContext$1 = function PatchContext(left, delta) {
this.left = left;
this.delta = delta;
this.pipe = 'patch';
};
PatchContext$1.prototype = new Context$2();
var PatchContext_1 = PatchContext$1;
var patch = {
PatchContext: PatchContext_1
};
var Context$3 = context.Context;
var ReverseContext$1 = function ReverseContext(delta) {
this.delta = delta;
this.pipe = 'reverse';
};
ReverseContext$1.prototype = new Context$3();
var ReverseContext_1 = ReverseContext$1;
var reverse = {
ReverseContext: ReverseContext_1
};
var isArray$1 = (typeof Array.isArray === 'function') ?
// use native function
Array.isArray :
// use instanceof operator
function(a) {
return a instanceof Array;
};
var diffFilter = function trivialMatchesDiffFilter(context) {
if (context.left === context.right) {
context.setResult(undefined).exit();
return;
}
if (typeof context.left === 'undefined') {
if (typeof context.right === 'function') {
throw new Error('functions are not supported');
}
context.setResult([context.right]).exit();
return;
}
if (typeof context.right === 'undefined') {
context.setResult([context.left, 0, 0]).exit();
return;
}
if (typeof context.left === 'function' || typeof context.right === 'function') {
throw new Error('functions are not supported');
}
context.leftType = context.left === null ? 'null' : typeof context.left;
context.rightType = context.right === null ? 'null' : typeof context.right;
if (context.leftType !== context.rightType) {
context.setResult([context.left, context.right]).exit();
return;
}
if (context.leftType === 'boolean' || context.leftType === 'number') {
context.setResult([context.left, context.right]).exit();
return;
}
if (context.leftType === 'object') {
context.leftIsArray = isArray$1(context.left);
}
if (context.rightType === 'object') {
context.rightIsArray = isArray$1(context.right);
}
if (context.leftIsArray !== context.rightIsArray) {
context.setResult([context.left, context.right]).exit();
return;
}
if (context.left instanceof RegExp) {
if (context.right instanceof RegExp) {
context.setResult([context.left.toString(), context.right.toString()]).exit();
} else {
context.setResult([context.left, context.right]).exit();
return;
}
}
};
diffFilter.filterName = 'trivial';
var patchFilter = function trivialMatchesPatchFilter(context) {
if (typeof context.delta === 'undefined') {
context.setResult(context.left).exit();
return;
}
context.nested = !isArray$1(context.delta);
if (context.nested) {
return;
}
if (context.delta.length === 1) {
context.setResult(context.delta[0]).exit();
return;
}
if (context.delta.length === 2) {
if (context.left instanceof RegExp) {
var regexArgs = /^\/(.*)\/([gimyu]+)$/.exec(context.delta[1]);
if (regexArgs) {
context.setResult(new RegExp(regexArgs[1], regexArgs[2])).exit();
return;
}
}
context.setResult(context.delta[1]).exit();
return;
}
if (context.delta.length === 3 && context.delta[2] === 0) {
context.setResult(undefined).exit();
return;
}
};
patchFilter.filterName = 'trivial';
var reverseFilter = function trivialReferseFilter(context) {
if (typeof context.delta === 'undefined') {
context.setResult(context.delta).exit();
return;
}
context.nested = !isArray$1(context.delta);
if (context.nested) {
return;
}
if (context.delta.length === 1) {
context.setResult([context.delta[0], 0, 0]).exit();
return;
}
if (context.delta.length === 2) {
context.setResult([context.delta[1], context.delta[0]]).exit();
return;
}
if (context.delta.length === 3 && context.delta[2] === 0) {
context.setResult([context.delta[0]]).exit();
return;
}
};
reverseFilter.filterName = 'trivial';
var diffFilter_1 = diffFilter;
var patchFilter_1 = patchFilter;
var reverseFilter_1 = reverseFilter;
var trivial = {
diffFilter: diffFilter_1,
patchFilter: patchFilter_1,
reverseFilter: reverseFilter_1
};
var DiffContext$2 = diff.DiffContext;
var PatchContext$2 = patch.PatchContext;
var ReverseContext$2 = reverse.ReverseContext;
var collectChildrenDiffFilter = function collectChildrenDiffFilter(context) {
if (!context || !context.children) {
return;
}
var length = context.children.length;
var child;
var result = context.result;
for (var index = 0; index < length; index++) {
child = context.children[index];
if (typeof child.result === 'undefined') {
continue;
}
result = result || {};
result[child.childName] = child.result;
}
if (result && context.leftIsArray) {
result._t = 'a';
}
context.setResult(result).exit();
};
collectChildrenDiffFilter.filterName = 'collectChildren';
var objectsDiffFilter = function objectsDiffFilter(context) {
if (context.leftIsArray || context.leftType !== 'object') {
return;
}
var name, child, propertyFilter = context.options.propertyFilter;
for (name in context.left) {
if (!Object.prototype.hasOwnProperty.call(context.left, name)) {
continue;
}
if (propertyFilter && !propertyFilter(name, context)) {
continue;
}
child = new DiffContext$2(context.left[name], context.right[name]);
context.push(child, name);
}
for (name in context.right) {
if (!Object.prototype.hasOwnProperty.call(context.right, name)) {
continue;
}
if (propertyFilter && !propertyFilter(name, context)) {
continue;
}
if (typeof context.left[name] === 'undefined') {
child = new DiffContext$2(undefined, context.right[name]);
context.push(child, name);
}
}
if (!context.children || context.children.length === 0) {
context.setResult(undefined).exit();
return;
}
context.exit();
};
objectsDiffFilter.filterName = 'objects';
var patchFilter$1 = function nestedPatchFilter(context) {
if (!context.nested) {
return;
}
if (context.delta._t) {
return;
}
var name, child;
for (name in context.delta) {
child = new PatchContext$2(context.left[name], context.delta[name]);
context.push(child, name);
}
context.exit();
};
patchFilter$1.filterName = 'objects';
var collectChildrenPatchFilter = function collectChildrenPatchFilter(context) {
if (!context || !context.children) {
return;
}
if (context.delta._t) {
return;
}
var length = context.children.length;
var child;
for (var index = 0; index < length; index++) {
child = context.children[index];
if (Object.prototype.hasOwnProperty.call(context.left, child.childName) && child.result === undefined) {
delete context.left[child.childName];
} else if (context.left[child.childName] !== child.result) {
context.left[child.childName] = child.result;
}
}
context.setResult(context.left).exit();
};
collectChildrenPatchFilter.filterName = 'collectChildren';
var reverseFilter$1 = function nestedReverseFilter(context) {
if (!context.nested) {
return;
}
if (context.delta._t) {
return;
}
var name, child;
for (name in context.delta) {
child = new ReverseContext$2(context.delta[name]);
context.push(child, name);
}
context.exit();
};
reverseFilter$1.filterName = 'objects';
var collectChildrenReverseFilter = function collectChildrenReverseFilter(context) {
if (!context || !context.children) {
return;
}
if (context.delta._t) {
return;
}
var length = context.children.length;
var child;
var delta = {};
for (var index = 0; index < length; index++) {
child = context.children[index];
if (delta[child.childName] !== child.result) {
delta[child.childName] = child.result;
}
}
context.setResult(delta).exit();
};
collectChildrenReverseFilter.filterName = 'collectChildren';
var collectChildrenDiffFilter_1 = collectChildrenDiffFilter;
var objectsDiffFilter_1 = objectsDiffFilter;
var patchFilter_1$1 = patchFilter$1;
var collectChildrenPatchFilter_1 = collectChildrenPatchFilter;
var reverseFilter_1$1 = reverseFilter$1;
var collectChildrenReverseFilter_1 = collectChildrenReverseFilter;
var nested = {
collectChildrenDiffFilter: collectChildrenDiffFilter_1,
objectsDiffFilter: objectsDiffFilter_1,
patchFilter: patchFilter_1$1,
collectChildrenPatchFilter: collectChildrenPatchFilter_1,
reverseFilter: reverseFilter_1$1,
collectChildrenReverseFilter: collectChildrenReverseFilter_1
};
/*
LCS implementation that supports arrays or strings
reference: http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
*/
var defaultMatch = function(array1, array2, index1, index2) {
return array1[index1] === array2[index2];
};
var lengthMatrix = function(array1, array2, match, context) {
var len1 = array1.length;
var len2 = array2.length;
var x, y;
// initialize empty matrix of len1+1 x len2+1
var matrix = [len1 + 1];
for (x = 0; x < len1 + 1; x++) {
matrix[x] = [len2 + 1];
for (y = 0; y < len2 + 1; y++) {
matrix[x][y] = 0;
}
}
matrix.match = match;
// save sequence lengths for each coordinate
for (x = 1; x < len1 + 1; x++) {
for (y = 1; y < len2 + 1; y++) {
if (match(array1, array2, x - 1, y - 1, context)) {
matrix[x][y] = matrix[x - 1][y - 1] + 1;
} else {
matrix[x][y] = Math.max(matrix[x - 1][y], matrix[x][y - 1]);
}
}
}
return matrix;
};
var backtrack = function(matrix, array1, array2, index1, index2, context) {
if (index1 === 0 || index2 === 0) {
return {
sequence: [],
indices1: [],
indices2: []
};
}
if (matrix.match(array1, array2, index1 - 1, index2 - 1, context)) {
var subsequence = backtrack(matrix, array1, array2, index1 - 1, index2 - 1, context);
subsequence.sequence.push(array1[index1 - 1]);
subsequence.indices1.push(index1 - 1);
subsequence.indices2.push(index2 - 1);
return subsequence;
}
if (matrix[index1][index2 - 1] > matrix[index1 - 1][index2]) {
return backtrack(matrix, array1, array2, index1, index2 - 1, context);
} else {
return backtrack(matrix, array1, array2, index1 - 1, index2, context);
}
};
var get = function(array1, array2, match, context) {
context = context || {};
var matrix = lengthMatrix(array1, array2, match || defaultMatch, context);
var result = backtrack(matrix, array1, array2, array1.length, array2.length, context);
if (typeof array1 === 'string' && typeof array2 === 'string') {
result.sequence = result.sequence.join('');
}
return result;
};
var get_1 = get;
var lcs = {
get: get_1
};
var DiffContext$3 = diff.DiffContext;
var PatchContext$3 = patch.PatchContext;
var ReverseContext$3 = reverse.ReverseContext;
var ARRAY_MOVE = 3;
var isArray$2 = (typeof Array.isArray === 'function') ?
// use native function
Array.isArray :
// use instanceof operator
function(a) {
return a instanceof Array;
};
var arrayIndexOf = typeof Array.prototype.indexOf === 'function' ?
function(array, item) {
return array.indexOf(item);
} : function(array, item) {
var length = array.length;
for (var i = 0; i < length; i++) {
if (array[i] === item) {
return i;
}
}
return -1;
};
function arraysHaveMatchByRef(array1, array2, len1, len2) {
for (var index1 = 0; index1 < len1; index1++) {
var val1 = array1[index1];
for (var index2 = 0; index2 < len2; index2++) {
var val2 = array2[index2];
if (index1 !== index2 && val1 === val2) {
return true;
}
}
}
}
function matchItems(array1, array2, index1, index2, context) {
var value1 = array1[index1];
var value2 = array2[index2];
if (value1 === value2) {
return true;
}
if (typeof value1 !== 'object' || typeof value2 !== 'object') {
return false;
}
var objectHash = context.objectHash;
if (!objectHash) {
// no way to match objects was provided, try match by position
return context.matchByPosition && index1 === index2;
}
var hash1;
var hash2;
if (typeof index1 === 'number') {
context.hashCache1 = context.hashCache1 || [];
hash1 = context.hashCache1[index1];
if (typeof hash1 === 'undefined') {
context.hashCache1[index1] = hash1 = objectHash(value1, index1);
}
} else {
hash1 = objectHash(value1);
}
if (typeof hash1 === 'undefined') {
return false;
}
if (typeof index2 === 'number') {
context.hashCache2 = context.hashCache2 || [];
hash2 = context.hashCache2[index2];
if (typeof hash2 === 'undefined') {
context.hashCache2[index2] = hash2 = objectHash(value2, index2);
}
} else {
hash2 = objectHash(value2);
}
if (typeof hash2 === 'undefined') {
return false;
}
return hash1 === hash2;
}
var diffFilter$1 = function arraysDiffFilter(context) {
if (!context.leftIsArray) {
return;
}
var matchContext = {
objectHash: context.options && context.options.objectHash,
matchByPosition: context.options && context.options.matchByPosition
};
var commonHead = 0;
var commonTail = 0;
var index;
var index1;
var index2;
var array1 = context.left;
var array2 = context.right;
var len1 = array1.length;
var len2 = array2.length;
var child;
if (len1 > 0 && len2 > 0 && !matchContext.objectHash &&
typeof matchContext.matchByPosition !== 'boolean') {
matchContext.matchByPosition = !arraysHaveMatchByRef(array1, array2, len1, len2);
}
// separate common head
while (commonHead < len1 && commonHead < len2 &&
matchItems(array1, array2, commonHead, commonHead, matchContext)) {
index = commonHead;
child = new DiffContext$3(context.left[index], context.right[index]);
context.push(child, index);
commonHead++;
}
// separate common tail
while (commonTail + commonHead < len1 && commonTail + commonHead < len2 &&
matchItems(array1, array2, len1 - 1 - commonTail, len2 - 1 - commonTail, matchContext)) {
index1 = len1 - 1 - commonTail;
index2 = len2 - 1 - commonTail;
child = new DiffContext$3(context.left[index1], context.right[index2]);
context.push(child, index2);
commonTail++;
}
var result;
if (commonHead + commonTail === len1) {
if (len1 === len2) {
// arrays are identical
context.setResult(undefined).exit();
return;
}
// trivial case, a block (1 or more consecutive items) was added
result = result || {
_t: 'a'
};
for (index = commonHead; index < len2 - commonTail; index++) {
result[index] = [array2[index]];
}
context.setResult(result).exit();
return;
}
if (commonHead + commonTail === len2) {
// trivial case, a block (1 or more consecutive items) was removed
result = result || {
_t: 'a'
};
for (index = commonHead; index < len1 - commonTail; index++) {
result['_' + index] = [array1[index], 0, 0];
}
context.setResult(result).exit();
return;
}
// reset hash cache
delete matchContext.hashCache1;
delete matchContext.hashCache2;
// diff is not trivial, find the LCS (Longest Common Subsequence)
var trimmed1 = array1.slice(commonHead, len1 - commonTail);
var trimmed2 = array2.slice(commonHead, len2 - commonTail);
var seq = lcs.get(
trimmed1, trimmed2,
matchItems,
matchContext
);
var removedItems = [];
result = result || {
_t: 'a'
};
for (index = commonHead; index < len1 - commonTail; index++) {
if (arrayIndexOf(seq.indices1, index - commonHead) < 0) {
// removed
result['_' + index] = [array1[index], 0, 0];
removedItems.push(index);
}
}
var detectMove = true;
if (context.options && context.options.arrays && context.options.arrays.detectMove === false) {
detectMove = false;
}
var includeValueOnMove = false;
if (context.options && context.options.arrays && context.options.arrays.includeValueOnMove) {
includeValueOnMove = true;
}
var removedItemsLength = removedItems.length;
for (index = commonHead; index < len2 - commonTail; index++) {
var indexOnArray2 = arrayIndexOf(seq.indices2, index - commonHead);
if (indexOnArray2 < 0) {
// added, try to match with a removed item and register as position move
var isMove = false;
if (detectMove && removedItemsLength > 0) {
for (var removeItemIndex1 = 0; removeItemIndex1 < removedItemsLength; removeItemIndex1++) {
index1 = removedItems[removeItemIndex1];
if (matchItems(trimmed1, trimmed2, index1 - commonHead,
index - commonHead, matchContext)) {
// store position move as: [originalValue, newPosition, ARRAY_MOVE]
result['_' + index1].splice(1, 2, index, ARRAY_MOVE);
if (!includeValueOnMove) {
// don't include moved value on diff, to save bytes
result['_' + index1][0] = '';
}
index2 = index;
child = new DiffContext$3(context.left[index1], context.right[index2]);
context.push(child, index2);
removedItems.splice(removeItemIndex1, 1);
isMove = true;
break;
}
}
}
if (!isMove) {
// added
result[index] = [array2[index]];
}
} else {
// match, do inner diff
index1 = seq.indices1[indexOnArray2] + commonHead;
index2 = seq.indices2[indexOnArray2] + commonHead;
child = new DiffContext$3(context.left[index1], context.right[index2]);
context.push(child, index2);
}
}
context.setResult(result).exit();
};
diffFilter$1.filterName = 'arrays';
var compare = {
numerically: function(a, b) {
return a - b;
},
numericallyBy: function(name) {
return function(a, b) {
return a[name] - b[name];
};
}
};
var patchFilter$2 = function nestedPatchFilter(context) {
if (!context.nested) {
return;
}
if (context.delta._t !== 'a') {
return;
}
var index, index1;
var delta = context.delta;
var array = context.left;
// first, separate removals, insertions and modifications
var toRemove = [];
var toInsert = [];
var toModify = [];
for (index in delta) {
if (index !== '_t') {
if (index[0] === '_') {
// removed item from original array
if (delta[index][2] === 0 || delta[index][2] === ARRAY_MOVE) {
toRemove.push(parseInt(index.slice(1), 10));
} else {
throw new Error('only removal or move can be applied at original array indices' +
', invalid diff type: ' + delta[index][2]);
}
} else {
if (delta[index].length === 1) {
// added item at new array
toInsert.push({
index: parseInt(index, 10),
value: delta[index][0]
});
} else {
// modified item at new array
toModify.push({
index: parseInt(index, 10),
delta: delta[index]
});
}
}
}
}
// remove items, in reverse order to avoid sawing our own floor
toRemove = toRemove.sort(compare.numerically);
for (index = toRemove.length - 1; index >= 0; index--) {
index1 = toRemove[index];
var indexDiff = delta['_' + index1];
var removedValue = array.splice(index1, 1)[0];
if (indexDiff[2] === ARRAY_MOVE) {
// reinsert later
toInsert.push({
index: indexDiff[1],
value: removedValue
});
}
}
// insert items, in reverse order to avoid moving our own floor
toInsert = toInsert.sort(compare.numericallyBy('index'));
var toInsertLength = toInsert.length;
for (index = 0; index < toInsertLength; index++) {
var insertion = toInsert[index];
array.splice(insertion.index, 0, insertion.value);
}
// apply modifications
var toModifyLength = toModify.length;
var child;
if (toModifyLength > 0) {
for (index = 0; index < toModifyLength; index++) {
var modification = toModify[index];
child = new PatchContext$3(context.left[modification.index], modification.delta);
context.push(child, modification.index);
}
}
if (!context.children) {
context.setResult(context.left).exit();
return;
}
context.exit();
};
patchFilter$2.filterName = 'arrays';
var collectChildrenPatchFilter$1 = function collectChildrenPatchFilter(context) {
if (!context || !context.children) {
return;
}
if (context.delta._t !== 'a') {
return;
}
var length = context.children.length;
var child;
for (var index = 0; index < length; index++) {
child = context.children[index];
context.left[child.childName] = child.result;
}
context.setResult(context.left).exit();
};
collectChildrenPatchFilter$1.filterName = 'arraysCollectChildren';
var reverseFilter$2 = function arraysReverseFilter(context) {
if (!context.nested) {
if (context.delta[2] === ARRAY_MOVE) {
context.newName = '_' + context.delta[1];
context.setResult([context.delta[0], parseInt(context.childName.substr(1), 10), ARRAY_MOVE]).exit();
}
return;
}
if (context.delta._t !== 'a') {
return;
}
var name, child;
for (name in context.delta) {
if (name === '_t') {
continue;
}
child = new ReverseContext$3(context.delta[name]);
context.push(child, name);
}
context.exit();
};
reverseFilter$2.filterName = 'arrays';
var reverseArrayDeltaIndex = function(delta, index, itemDelta) {
if (typeof index === 'string' && index[0] === '_') {
return parseInt(index.substr(1), 10);
} else if (isArray$2(itemDelta) && itemDelta[2] === 0) {
return '_' + index;
}
var reverseIndex = +index;
for (var deltaIndex in delta) {
var deltaItem = delta[deltaIndex];
if (isArray$2(deltaItem)) {
if (deltaItem[2] === ARRAY_MOVE) {
var moveFromIndex = parseInt(deltaIndex.substr(1), 10);
var moveToIndex = deltaItem[1];
if (moveToIndex === +index) {
return moveFromIndex;
}
if (moveFromIndex <= reverseIndex && moveToIndex > reverseIndex) {
reverseIndex++;
} else if (moveFromIndex >= reverseIndex && moveToIndex < reverseIndex) {
reverseIndex--;
}
} else if (deltaItem[2] === 0) {
var deleteIndex = parseInt(deltaIndex.substr(1), 10);
if (deleteIndex <= reverseIndex) {
reverseIndex++;
}
} else if (deltaItem.length === 1 && deltaIndex <= reverseIndex) {
reverseIndex--;
}
}
}
return reverseIndex;
};
var collectChildrenReverseFilter$1 = function collectChildrenReverseFilter(context) {
if (!context || !context.children) {
return;
}
if (context.delta._t !== 'a') {
return;
}
var length = context.children.length;
var child;
var delta = {
_t: 'a'
};
for (var index = 0; index < length; index++) {
child = context.children[index];
var name = child.newName;
if (typeof name === 'undefined') {
name = reverseArrayDeltaIndex(context.delta, child.childName, child.result);
}
if (delta[name] !== child.result) {
delta[name] = child.result;
}
}
context.setResult(delta).exit();
};
collectChildrenReverseFilter$1.filterName = 'arraysCollectChildren';
var diffFilter_1$1 = diffFilter$1;
var patchFilter_1$2 = patchFilter$2;
var collectChildrenPatchFilter_1$1 = collectChildrenPatchFilter$1;
var reverseFilter_1$2 = reverseFilter$2;
var collectChildrenReverseFilter_1$1 = collectChildrenReverseFilter$1;
var arrays = {
diffFilter: diffFilter_1$1,
patchFilter: patchFilter_1$2,
collectChildrenPatchFilter: collectChildrenPatchFilter_1$1,
reverseFilter: reverseFilter_1$2,
collectChildrenReverseFilter: collectChildrenReverseFilter_1$1
};
var diffFilter$2 = function datesDiffFilter(context) {
if (context.left instanceof Date) {
if (context.right instanceof Date) {
if (context.left.getTime() !== context.right.getTime()) {
context.setResult([context.left, context.right]);
} else {
context.setResult(undefined);
}
} else {
context.setResult([context.left, context.right]);
}
context.exit();
} else if (context.right instanceof Date) {
context.setResult([context.left, context.right]).exit();
}
};
diffFilter$2.filterName = 'dates';
var diffFilter_1$2 = diffFilter$2;
var dates = {
diffFilter: diffFilter_1$2
};
/* global diff_match_patch */
var TEXT_DIFF = 2;
var DEFAULT_MIN_LENGTH = 60;
var cachedDiffPatch = null;
var getDiffMatchPatch = function(required) {
/*jshint camelcase: false */
if (!cachedDiffPatch) {
var instance;
if (typeof diff_match_patch !== 'undefined') {
// already loaded, probably a browser
instance = typeof diff_match_patch === 'function' ?
new diff_match_patch() : new diff_match_patch.diff_match_patch();
} else if (typeof commonjsRequire$1 === 'function') {
try {
var dmpModuleName = 'diff_match_patch_uncompressed';
var dmp = commonjsRequire$1('../../public/external/' + dmpModuleName);
instance = new dmp.diff_match_patch();
} catch (err) {
instance = null;
}
}
if (!instance) {
if (!required) {
return null;
}
var error = new Error('text diff_match_patch library not found');
error.diff_match_patch_not_found = true;
throw error;
}
cachedDiffPatch = {
diff: function(txt1, txt2) {
return instance.patch_toText(instance.patch_make(txt1, txt2));
},
patch: function(txt1, patch) {
var results = instance.patch_apply(instance.patch_fromText(patch), txt1);
for (var i = 0; i < results[1].length; i++) {
if (!results[1][i]) {
var error = new Error('text patch failed');
error.textPatchFailed = true;
}
}
return results[0];
}
};
}
return cachedDiffPatch;
};
var diffFilter$3 = function textsDiffFilter(context) {
if (context.leftType !== 'string') {
return;
}
var minLength = (context.options && context.options.textDiff &&
context.options.textDiff.minLength) || DEFAULT_MIN_LENGTH;
if (context.left.length < minLength ||
context.right.length < minLength) {
context.setResult([context.left, context.right]).exit();
return;
}
// large text, try to use a text-diff algorithm
var diffMatchPatch = getDiffMatchPatch();
if (!diffMatchPatch) {
// diff-match-patch library not available, fallback to regular string replace
context.setResult([context.left, context.right]).exit();
return;
}
var diff = diffMatchPatch.diff;
context.setResult([diff(context.left, context.right), 0, TEXT_DIFF]).exit();
};
diffFilter$3.filterName = 'texts';
var patchFilter$3 = function textsPatchFilter(context) {
if (context.nested) {
return;
}
if (context.delta[2] !== TEXT_DIFF) {
return;
}
// text-diff, use a text-patch algorithm
var patch = getDiffMatchPatch(true).patch;
context.setResult(patch(context.left, context.delta[0])).exit();
};
patchFilter$3.filterName = 'texts';
var textDeltaReverse = function(delta) {
var i, l, lines, line, lineTmp, header = null,
headerRegex = /^@@ +\-(\d+),(\d+) +\+(\d+),(\d+) +@@$/,
lineHeader;
lines = delta.split('\n');
for (i = 0, l = lines.length; i < l; i++) {
line = lines[i];
var lineStart = line.slice(0, 1);
if (lineStart === '@') {
header = headerRegex.exec(line);
lineHeader = i;
lines[lineHeader] = '@@ -' + header[3] + ',' + header[4] + ' +' + header[1] + ',' + header[2] + ' @@';
} else if (lineStart === '+') {
lines[i] = '-' + lines[i].slice(1);
if (lines[i - 1].slice(0, 1) === '+') {
// swap lines to keep default order (-+)
lineTmp = lines[i];
lines[i] = lines[i - 1];
lines[i - 1] = lineTmp;
}
} else if (lineStart === '-') {
lines[i] = '+' + lines[i].slice(1);
}
}
return lines.join('\n');
};
var reverseFilter$3 = function textsReverseFilter(context) {
if (context.nested) {
return;
}
if (context.delta[2] !== TEXT_DIFF) {
return;
}
// text-diff, use a text-diff algorithm
context.setResult([textDeltaReverse(context.delta[0]), 0, TEXT_DIFF]).exit();
};
reverseFilter$3.filterName = 'texts';
var diffFilter_1$3 = diffFilter$3;
var patchFilter_1$3 = patchFilter$3;
var reverseFilter_1$3 = reverseFilter$3;
var texts = {
diffFilter: diffFilter_1$3,
patchFilter: patchFilter_1$3,
reverseFilter: reverseFilter_1$3
};
var Processor = processor.Processor;
var Pipe = pipe.Pipe;
var DiffContext = diff.DiffContext;
var PatchContext = patch.PatchContext;
var ReverseContext = reverse.ReverseContext;
var DiffPatcher = function DiffPatcher(options) {
this.processor = new Processor(options);
this.processor.pipe(new Pipe('diff').append(
nested.collectChildrenDiffFilter,
trivial.diffFilter,
dates.diffFilter,
texts.diffFilter,
nested.objectsDiffFilter,
arrays.diffFilter
).shouldHaveResult());
this.processor.pipe(new Pipe('patch').append(
nested.collectChildrenPatchFilter,
arrays.collectChildrenPatchFilter,
trivial.patchFilter,
texts.patchFilter,
nested.patchFilter,
arrays.patchFilter
).shouldHaveResult());
this.processor.pipe(new Pipe('reverse').append(
nested.collectChildrenReverseFilter,
arrays.collectChildrenReverseFilter,
trivial.reverseFilter,
texts.reverseFilter,
nested.reverseFilter,
arrays.reverseFilter
).shouldHaveResult());
};
DiffPatcher.prototype.options = function() {
return this.processor.options.apply(this.processor, arguments);
};
DiffPatcher.prototype.diff = function(left, right) {
return this.processor.process(new DiffContext(left, right));
};
DiffPatcher.prototype.patch = function(left, delta) {
return this.processor.process(new PatchContext(left, delta));
};
DiffPatcher.prototype.reverse = function(delta) {
return this.processor.process(new ReverseContext(delta));
};
DiffPatcher.prototype.unpatch = function(right, delta) {
return this.patch(right, this.reverse(delta));
};
DiffPatcher.prototype.clone = function(value) {
return clone_1(value);
};
var DiffPatcher_1 = DiffPatcher;
var diffpatcher = {
DiffPatcher: DiffPatcher_1
};
// use as 2nd parameter for JSON.parse to revive Date instances
var dateReviver = function dateReviver(key, value) {
var parts;
if (typeof value === 'string') {
parts = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d*))?(Z|([+\-])(\d{2}):(\d{2}))$/.exec(value);
if (parts) {
return new Date(Date.UTC(+parts[1], +parts[2] - 1, +parts[3], +parts[4], +parts[5], +parts[6], +(parts[7] || 0)));
}
}
return value;
};
var main = createCommonjsModule$1(function (module, exports) {
var DiffPatcher = diffpatcher.DiffPatcher;
exports.DiffPatcher = DiffPatcher;
exports.create = function(options){
return new DiffPatcher(options);
};
exports.dateReviver = dateReviver;
var defaultInstance;
exports.diff = function() {
if (!defaultInstance) {
defaultInstance = new DiffPatcher();
}
return defaultInstance.diff.apply(defaultInstance, arguments);
};
exports.patch = function() {
if (!defaultInstance) {
defaultInstance = new DiffPatcher();
}
return defaultInstance.patch.apply(defaultInstance, arguments);
};
exports.unpatch = function() {
if (!defaultInstance) {
defaultInstance = new DiffPatcher();
}
return defaultInstance.unpatch.apply(defaultInstance, arguments);
};
exports.reverse = function() {
if (!defaultInstance) {
defaultInstance = new DiffPatcher();
}
return defaultInstance.reverse.apply(defaultInstance, arguments);
};
exports.clone = function() {
if (!defaultInstance) {
defaultInstance = new DiffPatcher();
}
return defaultInstance.clone.apply(defaultInstance, arguments);
};
if (environment.isBrowser) {
exports.homepage = '{{package-homepage}}';
exports.version = '{{package-version}}';
} else {
var packageInfoModuleName = '../package.json';
var packageInfo = commonjsRequire$1(packageInfoModuleName);
exports.homepage = packageInfo.homepage;
exports.version = packageInfo.version;
var formatterModuleName = './formatters';
var formatters = commonjsRequire$1(formatterModuleName);
exports.formatters = formatters;
// shortcut for console
exports.console = formatters.console;
}
});
var isArray$3 = (typeof Array.isArray === 'function') ?
// use native function
Array.isArray :
// use instanceof operator
function(a) {
return a instanceof Array;
};
var getObjectKeys = typeof Object.keys === 'function' ?
function(obj) {
return Object.keys(obj);
} : function(obj) {
var names = [];
for (var property in obj) {
if (Object.prototype.hasOwnProperty.call(obj, property)) {
names.push(property);
}
}
return names;
};
var trimUnderscore = function(str) {
if (str.substr(0, 1) === '_') {
return str.slice(1);
}
return str;
};
var arrayKeyToSortNumber = function(key) {
if (key === '_t') {
return -1;
} else {
if (key.substr(0, 1) === '_') {
return parseInt(key.slice(1), 10);
} else {
return parseInt(key, 10) + 0.1;
}
}
};
var arrayKeyComparer = function(key1, key2) {
return arrayKeyToSortNumber(key1) - arrayKeyToSortNumber(key2);
};
var BaseFormatter$1 = function BaseFormatter() {};
BaseFormatter$1.prototype.format = function(delta, left) {
var context = {};
this.prepareContext(context);
this.recurse(context, delta, left);
return this.finalize(context);
};
BaseFormatter$1.prototype.prepareContext = function(context) {
context.buffer = [];
context.out = function() {
this.buffer.push.apply(this.buffer, arguments);
};
};
BaseFormatter$1.prototype.typeFormattterNotFound = function(context, deltaType) {
throw new Error('cannot format delta type: ' + deltaType);
};
BaseFormatter$1.prototype.typeFormattterErrorFormatter = function(context, err) {
return err.toString();
};
BaseFormatter$1.prototype.finalize = function(context) {
if (isArray$3(context.buffer)) {
return context.buffer.join('');
}
};
BaseFormatter$1.prototype.recurse = function(context, delta, left, key, leftKey, movedFrom, isLast) {
var useMoveOriginHere = delta && movedFrom;
var leftValue = useMoveOriginHere ? movedFrom.value : left;
if (typeof delta === 'undefined' && typeof key === 'undefined') {
return undefined;
}
var type = this.getDeltaType(delta, movedFrom);
var nodeType = type === 'node' ? (delta._t === 'a' ? 'array' : 'object') : '';
if (typeof key !== 'undefined') {
this.nodeBegin(context, key, leftKey, type, nodeType, isLast);
} else {
this.rootBegin(context, type, nodeType);
}
var typeFormattter;
try {
typeFormattter = this['format_' + type] || this.typeFormattterNotFound(context, type);
typeFormattter.call(this, context, delta, leftValue, key, leftKey, movedFrom);
} catch (err) {
this.typeFormattterErrorFormatter(context, err, delta, leftValue, key, leftKey, movedFrom);
if (typeof console !== 'undefined' && console.error) {
console.error(err.stack);
}
}
if (typeof key !== 'undefined') {
this.nodeEnd(context, key, leftKey, type, nodeType, isLast);
} else {
this.rootEnd(context, type, nodeType);
}
};
BaseFormatter$1.prototype.formatDeltaChildren = function(context, delta, left) {
var self = this;
this.forEachDeltaKey(delta, left, function(key, leftKey, movedFrom, isLast) {
self.recurse(context, delta[key], left ? left[leftKey] : undefined,
key, leftKey, movedFrom, isLast);
});
};
BaseFormatter$1.prototype.forEachDeltaKey = function(delta, left, fn) {
var keys = getObjectKeys(delta);
var arrayKeys = delta._t === 'a';
var moveDestinations = {};
var name;
if (typeof left !== 'undefined') {
for (name in left) {
if (Object.prototype.hasOwnProperty.call(left, name)) {
if (typeof delta[name] === 'undefined' &&
((!arrayKeys) || typeof delta['_' + name] === 'undefined')) {
keys.push(name);
}
}
}
}
// look for move destinations
for (name in delta) {
if (Object.prototype.hasOwnProperty.call(delta, name)) {
var value = delta[name];
if (isArray$3(value) && value[2] === 3) {
moveDestinations[value[1].toString()] = {
key: name,
value: left && left[parseInt(name.substr(1))]
};
if (this.includeMoveDestinations !== false) {
if ((typeof left === 'undefined') &&
(typeof delta[value[1]] === 'undefined')) {
keys.push(value[1].toString());
}
}
}
}
}
if (arrayKeys) {
keys.sort(arrayKeyComparer);
} else {
keys.sort();
}
for (var index = 0, length = keys.length; index < length; index++) {
var key = keys[index];
if (arrayKeys && key === '_t') {
continue;
}
var leftKey = arrayKeys ?
(typeof key === 'number' ? key : parseInt(trimUnderscore(key), 10)) :
key;
var isLast = (index === length - 1);
fn(key, leftKey, moveDestinations[leftKey], isLast);
}
};
BaseFormatter$1.prototype.getDeltaType = function(delta, movedFrom) {
if (typeof delta === 'undefined') {
if (typeof movedFrom !== 'undefined') {
return 'movedestination';
}
return 'unchanged';
}
if (isArray$3(delta)) {
if (delta.length === 1) {
return 'added';
}
if (delta.length === 2) {
return 'modified';
}
if (delta.length === 3 && delta[2] === 0) {
return 'deleted';
}
if (delta.length === 3 && delta[2] === 2) {
return 'textdiff';
}
if (delta.length === 3 && delta[2] === 3) {
return 'moved';
}
} else if (typeof delta === 'object') {
return 'node';
}
return 'unknown';
};
BaseFormatter$1.prototype.parseTextDiff = function(value) {
var output = [];
var lines = value.split('\n@@ ');
for (var i = 0, l = lines.length; i < l; i++) {
var line = lines[i];
var lineOutput = {
pieces: []
};
var location = /^(?:@@ )?[-+]?(\d+),(\d+)/.exec(line).slice(1);
lineOutput.location = {
line: location[0],
chr: location[1]
};
var pieces = line.split('\n').slice(1);
for (var pieceIndex = 0, piecesLength = pieces.length; pieceIndex < piecesLength; pieceIndex++) {
var piece = pieces[pieceIndex];
if (!piece.length) {
continue;
}
var pieceOutput = {
type: 'context'
};
if (piece.substr(0, 1) === '+') {
pieceOutput.type = 'added';
} else if (piece.substr(0, 1) === '-') {
pieceOutput.type = 'deleted';
}
pieceOutput.text = piece.slice(1);
lineOutput.pieces.push(pieceOutput);
}
output.push(lineOutput);
}
return output;
};
var BaseFormatter_1 = BaseFormatter$1;
var base = {
BaseFormatter: BaseFormatter_1
};
var BaseFormatter = base.BaseFormatter;
var colors = {
added: 'color:green',
deleted: 'color:red',
movedestination: 'color:gray',
moved: 'color:blue',
unchanged: 'hide',
error: 'background:red',
textDiffLine: 'color:gray'
};
function ConsoleFormatter () {
this.includeMoveDestinations = false;
}
ConsoleFormatter.prototype = new BaseFormatter();
ConsoleFormatter.prototype.finalize = function (context) {
var match = context.styles.length === 0;
var styles = context.styles;
var buffer = context.buffer
.join('')
.split('\n');
buffer = buffer
.filter((t, i) => !(t.match(/^ +$/) && buffer[i] === t));
var styleCounter = 0;
for (var i = 0; i < buffer.length; i++) {
var b = buffer[i];
var styleOccurences = b.split('%c').length - 1;
if (styleOccurences === 0) {
buffer[i] = '%c' + b;
styles.splice(styleCounter, 0, '');
styleCounter++;
} else {
styleCounter += styleOccurences;
}
}
var text = buffer.join('\n');
return {
logArguments: [text].concat(styles),
match: match
}
};
ConsoleFormatter.prototype.prepareContext = function (context) {
BaseFormatter.prototype.prepareContext.call(this, context);
context.styles = context.styles || [];
context.indent = function (levels) {
this.indentLevel = (this.indentLevel || 0) +
(typeof levels === 'undefined' ? 1 : levels);
this.indentPad = new Array(this.indentLevel + 1).join(' ');
this.outLine();
};
context.outLine = function () {
this.buffer.push('\n' + (this.indentPad || ''));
};
context.out = function () {
for (var i = 0, l = arguments.length; i < l; i++) {
var lines = arguments[i].split('\n');
var text = lines.join('\n' + (this.indentPad || ''));
if (this.color == null || this.color[0] !== 'hide') {
if (this.color && this.color[0]) {
text = '%c' + text;
this.styles.push(this.color[0]);
}
this.buffer.push(text);
}
}
};
context.pushColor = function (color) {
this.color = this.color || [];
this.color.unshift(color);
};
context.popColor = function () {
this.color = this.color || [];
this.color.shift();
};
};
ConsoleFormatter.prototype.typeFormattterErrorFormatter = function (context, err) {
context.pushColor(colors.error);
context.out('[ERROR]' + err);
context.popColor();
};
ConsoleFormatter.prototype.formatValue = function (context, value) {
context.out(JSON.stringify(value, null, 2));
};
ConsoleFormatter.prototype.formatTextDiffString = function (context, value) {
var lines = this.parseTextDiff(value);
context.indent();
for (var i = 0, l = lines.length; i < l; i++) {
var line = lines[i];
context.pushColor(colors.textDiffLine);
context.out(line.location.line + ',' + line.location.chr + ' ');
context.popColor();
var pieces = line.pieces;
for (var pieceIndex = 0, piecesLength = pieces.length; pieceIndex < piecesLength; pieceIndex++) {
var piece = pieces[pieceIndex];
context.pushColor(colors[piece.type]);
context.out(piece.text);
context.popColor();
}
if (i < l - 1) {
context.outLine();
}
}
context.indent(-1);
};
ConsoleFormatter.prototype.rootBegin = function (context, type, nodeType) {
context.pushColor(colors[type]);
if (type === 'node') {
context.out(nodeType === 'array' ? '[' : '{');
context.indent();
}
};
ConsoleFormatter.prototype.rootEnd = function (context, type, nodeType) {
if (type === 'node') {
context.indent(-1);
context.out(nodeType === 'array' ? ']' : '}');
}
context.popColor();
};
ConsoleFormatter.prototype.nodeBegin = function (context, key, leftKey, type, nodeType) {
context.pushColor(colors[type]);
context.out(leftKey + ': ');
if (type === 'node') {
context.out(nodeType === 'array' ? '[' : '{');
context.indent();
}
};
ConsoleFormatter.prototype.nodeEnd = function (context, key, leftKey, type, nodeType, isLast) {
if (type === 'node') {
context.indent(-1);
context.out(nodeType === 'array' ? ']' : '}' +
(isLast ? '' : ','));
}
if (!isLast) {
context.outLine();
}
context.popColor();
};
/* jshint camelcase: false */
ConsoleFormatter.prototype.format_unchanged = function (context, delta, left) {
if (typeof left === 'undefined') {
return
}
this.formatValue(context, left);
};
ConsoleFormatter.prototype.format_movedestination = function (context, delta, left) {
if (typeof left === 'undefined') {
return
}
this.formatValue(context, left);
};
ConsoleFormatter.prototype.format_node = function (context, delta, left) {
// recurse
this.formatDeltaChildren(context, delta, left);
};
ConsoleFormatter.prototype.format_added = function (context, delta) {
this.formatValue(context, delta[0]);
};
ConsoleFormatter.prototype.format_modified = function (context, delta) {
context.pushColor(colors.deleted);
this.formatValue(context, delta[0]);
context.popColor();
context.out(' => ');
context.pushColor(colors.added);
this.formatValue(context, delta[1]);
context.popColor();
};
ConsoleFormatter.prototype.format_deleted = function (context, delta) {
this.formatValue(context, delta[0]);
};
ConsoleFormatter.prototype.format_moved = function (context, delta) {
context.out('==> ' + delta[1]);
};
ConsoleFormatter.prototype.format_textdiff = function (context, delta) {
this.formatTextDiffString(context, delta[0]);
};
var defaultInstance;
function format (delta, left) {
if (!defaultInstance) {
defaultInstance = new ConsoleFormatter();
}
return defaultInstance.format(delta, left)
}
class Logger {
constructor () {
this.buffer = [];
this.failed = false;
this.errors = 0;
}
fail () {
this.failed = true;
this.errors++;
}
log () {
this.buffer.push({
f: 'log',
args: Array.prototype.slice.call(arguments)
});
}
error () {
this.fail();
var args = Array.prototype.slice.call(arguments);
if (typeof args[0] === 'string') {
args[0] = '%c' + args[0];
args.splice(1, 0, 'color:red');
}
args.push(new Error().stack);
this.buffer.push({
f: 'log',
args: args
});
}
assert (condition, output) {
if (!condition) {
this.fail();
}
this.buffer.push({
f: 'log',
args: [`%c${output}`, `color: ${condition ? 'green' : 'red'}`]
});
}
group (f, ...args) {
if (args.length === 0 || typeof args[0] !== 'string') {
args.unshift('Group');
}
args[0] = '%c' + args[0];
this.buffer.push({
f: 'groupCollapsed',
args: args
});
var eBeforeExecution = this.errors;
try {
f();
} catch (e) {
this.fail();
this.buffer.push({
f: 'log',
args: ['%cUncaught ' + e.stack, 'color:red']
});
}
if (eBeforeExecution === this.errors) {
args.splice(1, 0, '');
} else {
args.splice(1, 0, 'color: red');
}
this.buffer.push({
f: 'groupEnd'
});
}
async asyncGroup (f, ...args) {
if (args.length === 0 || typeof args[0] !== 'string') {
args.unshift('Group');
}
args[0] = '%c' + args[0];
this.buffer.push({
f: 'groupCollapsed',
args: args
});
var eBeforeExecution = this.errors;
try {
await f();
} catch (e) {
this.fail();
this.buffer.push({
f: 'log',
args: ['%cUncaught ' + e.stack, 'color:red']
});
}
if (eBeforeExecution === this.errors) {
args.splice(1, 0, '');
} else {
args.splice(1, 0, 'color: red');
}
this.buffer.push({
f: 'groupEnd'
});
}
compare (o1, o2, name) {
var arg1 = typeof o1 === 'string' ? `"${o1}"` : cloneDeep(o1);
var arg2 = typeof o2 === 'string' ? `"${o2}"` : cloneDeep(o2);
this.group(() => {
var delta = main.diff(o1, o2);
var res = format(delta, o1);
if (!res.match) {
this.fail();
}
this.log.apply(this, res.logArguments);
}, name, arg1, arg2);
}
}
class TestCase extends Logger {
constructor (testDescription, testFunction, location, valueGenerators, opts) {
super();
this.valueGenerators = valueGenerators;
this.description = testDescription;
this.testFunction = testFunction;
this.location = location;
this.name = testFunction.name;
this._seed = null;
this.status = 'pending';
this.opts = opts || {};
}
isRepeating () {
return this._seed != null && testHandler.getRandomSeed() === null
}
isParallel () {
return this.opts.parallel === true
}
clone () {
return new TestCase(this.description, this.testFunction, this.valueGenerators, this.opts)
}
run () {
this.status = 'running';
var __iterateOverGenerators = async (gens, args, argcase) => {
if (gens.length === 0) {
argcase.i++;
if (testHandler.opts.case == null || testHandler.opts.case === argcase.i) {
var url = createTestLink({
test: this.name,
seed: this._seed,
case: argcase.i,
repeat: this.isRepeating()
});
args.push(url);
await this.asyncGroup(async () => {
await this.testFunction(this, ...args);
}, 'Arguments:', ...args);
}
} else {
var gen = gens.shift();
for (var arg of gen) {
await __iterateOverGenerators(gens.slice(), args.slice().concat([arg]), argcase);
}
}
};
var __testStarter = () => {
var test;
if (this.valueGenerators.length > 0) {
test = __iterateOverGenerators(this.valueGenerators, [], { i: 0 });
} else {
test = this.testFunction(this);
}
test.then(async () => {
this.status = 'done';
await this.print();
testHandler.testCompleted(this);
}, async (err) => {
this.status = 'done';
this.failed = true;
this.buffer.push({
f: 'log',
args: ['%cUncaught ' + err.stack, 'color: red']
});
await this.print();
testHandler.testCompleted(this);
});
};
setTimeout(__testStarter, 0);
}
getSeed () {
if (this._seed == null) {
this._seed = testHandler.getRandomSeed() || Math.random();
}
return this._seed
}
print () {
if (browserSupport) {
var url = createTestLink({
test: this.name,
seed: this._seed,
repeat: false
});
console.groupCollapsed(
`%c${testHandler.numberOfCompletedTests}/${testHandler.numberOfTests}%c ${this.failed ? 'X' : '√'} ${this.description}`,
'font-weight: bold',
`color: ${this.failed ? 'red' : 'green'}`
);
console.log(`%cLocation: ${this.location.fileName}:${this.location.lineNumber}\nRun test again: ${url}`, 'color: grey; font-style: italic; font-size: x-small');
this.buffer.forEach(function (b) {
console[b.f].apply(console, b.args);
});
console.groupEnd();
} else {
console.log(
`${testHandler.numberOfCompletedTests}/${testHandler.numberOfTests} ${this.failed ? 'X' : '√'} ${this.description}`
);
}
}
}
var stackframe = createCommonjsModule$1(function (module, exports) {
(function(root, factory) {
if (typeof undefined === 'function' && undefined.amd) {
undefined('stackframe', [], factory);
} else {
module.exports = factory();
}
}(commonjsGlobal$1, function() {
function _isNumber(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
function _capitalize(str) {
return str[0].toUpperCase() + str.substring(1);
}
function _getter(p) {
return function() {
return this[p];
};
}
var booleanProps = ['isConstructor', 'isEval', 'isNative', 'isToplevel'];
var numericProps = ['columnNumber', 'lineNumber'];
var stringProps = ['fileName', 'functionName', 'source'];
var arrayProps = ['args'];
var props = booleanProps.concat(numericProps, stringProps, arrayProps);
function StackFrame(obj) {
if (obj instanceof Object) {
for (var i = 0; i < props.length; i++) {
if (obj.hasOwnProperty(props[i]) && obj[props[i]] !== undefined) {
this['set' + _capitalize(props[i])](obj[props[i]]);
}
}
}
}
StackFrame.prototype = {
getArgs: function() {
return this.args;
},
setArgs: function(v) {
if (Object.prototype.toString.call(v) !== '[object Array]') {
throw new TypeError('Args must be an Array');
}
this.args = v;
},
getEvalOrigin: function() {
return this.evalOrigin;
},
setEvalOrigin: function(v) {
if (v instanceof StackFrame) {
this.evalOrigin = v;
} else if (v instanceof Object) {
this.evalOrigin = new StackFrame(v);
} else {
throw new TypeError('Eval Origin must be an Object or StackFrame');
}
},
toString: function() {
var functionName = this.getFunctionName() || '{anonymous}';
var args = '(' + (this.getArgs() || []).join(',') + ')';
var fileName = this.getFileName() ? ('@' + this.getFileName()) : '';
var lineNumber = _isNumber(this.getLineNumber()) ? (':' + this.getLineNumber()) : '';
var columnNumber = _isNumber(this.getColumnNumber()) ? (':' + this.getColumnNumber()) : '';
return functionName + args + fileName + lineNumber + columnNumber;
}
};
for (var i = 0; i < booleanProps.length; i++) {
StackFrame.prototype['get' + _capitalize(booleanProps[i])] = _getter(booleanProps[i]);
StackFrame.prototype['set' + _capitalize(booleanProps[i])] = (function(p) {
return function(v) {
this[p] = Boolean(v);
};
})(booleanProps[i]);
}
for (var j = 0; j < numericProps.length; j++) {
StackFrame.prototype['get' + _capitalize(numericProps[j])] = _getter(numericProps[j]);
StackFrame.prototype['set' + _capitalize(numericProps[j])] = (function(p) {
return function(v) {
if (!_isNumber(v)) {
throw new TypeError(p + ' must be a Number');
}
this[p] = Number(v);
};
})(numericProps[j]);
}
for (var k = 0; k < stringProps.length; k++) {
StackFrame.prototype['get' + _capitalize(stringProps[k])] = _getter(stringProps[k]);
StackFrame.prototype['set' + _capitalize(stringProps[k])] = (function(p) {
return function(v) {
this[p] = String(v);
};
})(stringProps[k]);
}
return StackFrame;
}));
});
var errorStackParser = createCommonjsModule$1(function (module, exports) {
(function(root, factory) {
if (typeof undefined === 'function' && undefined.amd) {
undefined('error-stack-parser', ['stackframe'], factory);
} else {
module.exports = factory(stackframe);
}
}(commonjsGlobal$1, function ErrorStackParser(StackFrame) {
var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+\:\d+/;
var CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+\:\d+|\(native\))/m;
var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code\])?$/;
return {
/**
* Given an Error object, extract the most information from it.
*
* @param {Error} error object
* @return {Array} of StackFrames
*/
parse: function ErrorStackParser$$parse(error) {
if (typeof error.stacktrace !== 'undefined' || typeof error['opera#sourceloc'] !== 'undefined') {
return this.parseOpera(error);
} else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {
return this.parseV8OrIE(error);
} else if (error.stack) {
return this.parseFFOrSafari(error);
} else {
throw new Error('Cannot parse given Error object');
}
},
// Separate line and column numbers from a string of the form: (URI:Line:Column)
extractLocation: function ErrorStackParser$$extractLocation(urlLike) {
// Fail-fast but return locations like "(native)"
if (urlLike.indexOf(':') === -1) {
return [urlLike];
}
var regExp = /(.+?)(?:\:(\d+))?(?:\:(\d+))?$/;
var parts = regExp.exec(urlLike.replace(/[\(\)]/g, ''));
return [parts[1], parts[2] || undefined, parts[3] || undefined];
},
parseV8OrIE: function ErrorStackParser$$parseV8OrIE(error) {
var filtered = error.stack.split('\n').filter(function(line) {
return !!line.match(CHROME_IE_STACK_REGEXP);
}, this);
return filtered.map(function(line) {
if (line.indexOf('(eval ') > -1) {
// Throw away eval information until we implement stacktrace.js/stackframe#8
line = line.replace(/eval code/g, 'eval').replace(/(\(eval at [^\()]*)|(\)\,.*$)/g, '');
}
var tokens = line.replace(/^\s+/, '').replace(/\(eval code/g, '(').split(/\s+/).slice(1);
var locationParts = this.extractLocation(tokens.pop());
var functionName = tokens.join(' ') || undefined;
var fileName = ['eval', '<anonymous>'].indexOf(locationParts[0]) > -1 ? undefined : locationParts[0];
return new StackFrame({
functionName: functionName,
fileName: fileName,
lineNumber: locationParts[1],
columnNumber: locationParts[2],
source: line
});
}, this);
},
parseFFOrSafari: function ErrorStackParser$$parseFFOrSafari(error) {
var filtered = error.stack.split('\n').filter(function(line) {
return !line.match(SAFARI_NATIVE_CODE_REGEXP);
}, this);
return filtered.map(function(line) {
// Throw away eval information until we implement stacktrace.js/stackframe#8
if (line.indexOf(' > eval') > -1) {
line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval\:\d+\:\d+/g, ':$1');
}
if (line.indexOf('@') === -1 && line.indexOf(':') === -1) {
// Safari eval frames only have function names and nothing else
return new StackFrame({
functionName: line
});
} else {
var tokens = line.split('@');
var locationParts = this.extractLocation(tokens.pop());
var functionName = tokens.join('@') || undefined;
return new StackFrame({
functionName: functionName,
fileName: locationParts[0],
lineNumber: locationParts[1],
columnNumber: locationParts[2],
source: line
});
}
}, this);
},
parseOpera: function ErrorStackParser$$parseOpera(e) {
if (!e.stacktrace || (e.message.indexOf('\n') > -1 &&
e.message.split('\n').length > e.stacktrace.split('\n').length)) {
return this.parseOpera9(e);
} else if (!e.stack) {
return this.parseOpera10(e);
} else {
return this.parseOpera11(e);
}
},
parseOpera9: function ErrorStackParser$$parseOpera9(e) {
var lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
var lines = e.message.split('\n');
var result = [];
for (var i = 2, len = lines.length; i < len; i += 2) {
var match = lineRE.exec(lines[i]);
if (match) {
result.push(new StackFrame({
fileName: match[2],
lineNumber: match[1],
source: lines[i]
}));
}
}
return result;
},
parseOpera10: function ErrorStackParser$$parseOpera10(e) {
var lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
var lines = e.stacktrace.split('\n');
var result = [];
for (var i = 0, len = lines.length; i < len; i += 2) {
var match = lineRE.exec(lines[i]);
if (match) {
result.push(
new StackFrame({
functionName: match[3] || undefined,
fileName: match[2],
lineNumber: match[1],
source: lines[i]
})
);
}
}
return result;
},
// Opera 10.65+ Error.stack very similar to FF/Safari
parseOpera11: function ErrorStackParser$$parseOpera11(error) {
var filtered = error.stack.split('\n').filter(function(line) {
return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
}, this);
return filtered.map(function(line) {
var tokens = line.split('@');
var locationParts = this.extractLocation(tokens.pop());
var functionCall = (tokens.shift() || '');
var functionName = functionCall
.replace(/<anonymous function(: (\w+))?>/, '$2')
.replace(/\([^\)]*\)/g, '') || undefined;
var argsRaw;
if (functionCall.match(/\(([^\)]*)\)/)) {
argsRaw = functionCall.replace(/^[^\(]+\(([^\)]*)\)$/, '$1');
}
var args = (argsRaw === undefined || argsRaw === '[arguments not available]') ?
undefined : argsRaw.split(',');
return new StackFrame({
functionName: functionName,
args: args,
fileName: locationParts[0],
lineNumber: locationParts[1],
columnNumber: locationParts[2],
source: line
});
}, this);
}
};
}));
});
var stackGenerator = createCommonjsModule$1(function (module, exports) {
(function(root, factory) {
if (typeof undefined === 'function' && undefined.amd) {
undefined('stack-generator', ['stackframe'], factory);
} else {
module.exports = factory(stackframe);
}
}(commonjsGlobal$1, function(StackFrame) {
return {
backtrace: function StackGenerator$$backtrace(opts) {
var stack = [];
var maxStackSize = 10;
if (typeof opts === 'object' && typeof opts.maxStackSize === 'number') {
maxStackSize = opts.maxStackSize;
}
var curr = arguments.callee;
while (curr && stack.length < maxStackSize) {
// Allow V8 optimizations
var args = new Array(curr['arguments'].length);
for (var i = 0; i < args.length; ++i) {
args[i] = curr['arguments'][i];
}
if (/function(?:\s+([\w$]+))+\s*\(/.test(curr.toString())) {
stack.push(new StackFrame({functionName: RegExp.$1 || undefined, args: args}));
} else {
stack.push(new StackFrame({args: args}));
}
try {
curr = curr.caller;
} catch (e) {
break;
}
}
return stack;
}
};
}));
});
var util = createCommonjsModule$1(function (module, exports) {
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/
/**
* This is a helper function for getting values from parameter/options
* objects.
*
* @param args The object we are extracting values from
* @param name The name of the property we are getting.
* @param defaultValue An optional value to return if the property is missing
* from the object. If this is not specified and the property is missing, an
* error will be thrown.
*/
function getArg(aArgs, aName, aDefaultValue) {
if (aName in aArgs) {
return aArgs[aName];
} else if (arguments.length === 3) {
return aDefaultValue;
} else {
throw new Error('"' + aName + '" is a required argument.');
}
}
exports.getArg = getArg;
var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
var dataUrlRegexp = /^data:.+\,.+$/;
function urlParse(aUrl) {
var match = aUrl.match(urlRegexp);
if (!match) {
return null;
}
return {
scheme: match[1],
auth: match[2],
host: match[3],
port: match[4],
path: match[5]
};
}
exports.urlParse = urlParse;
function urlGenerate(aParsedUrl) {
var url = '';
if (aParsedUrl.scheme) {
url += aParsedUrl.scheme + ':';
}
url += '//';
if (aParsedUrl.auth) {
url += aParsedUrl.auth + '@';
}
if (aParsedUrl.host) {
url += aParsedUrl.host;
}
if (aParsedUrl.port) {
url += ":" + aParsedUrl.port;
}
if (aParsedUrl.path) {
url += aParsedUrl.path;
}
return url;
}
exports.urlGenerate = urlGenerate;
/**
* Normalizes a path, or the path portion of a URL:
*
* - Replaces consecutive slashes with one slash.
* - Removes unnecessary '.' parts.
* - Removes unnecessary '<dir>/..' parts.
*
* Based on code in the Node.js 'path' core module.
*
* @param aPath The path or url to normalize.
*/
function normalize(aPath) {
var path = aPath;
var url = urlParse(aPath);
if (url) {
if (!url.path) {
return aPath;
}
path = url.path;
}
var isAbsolute = exports.isAbsolute(path);
var parts = path.split(/\/+/);
for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
part = parts[i];
if (part === '.') {
parts.splice(i, 1);
} else if (part === '..') {
up++;
} else if (up > 0) {
if (part === '') {
// The first part is blank if the path is absolute. Trying to go
// above the root is a no-op. Therefore we can remove all '..' parts
// directly after the root.
parts.splice(i + 1, up);
up = 0;
} else {
parts.splice(i, 2);
up--;
}
}
}
path = parts.join('/');
if (path === '') {
path = isAbsolute ? '/' : '.';
}
if (url) {
url.path = path;
return urlGenerate(url);
}
return path;
}
exports.normalize = normalize;
/**
* Joins two paths/URLs.
*
* @param aRoot The root path or URL.
* @param aPath The path or URL to be joined with the root.
*
* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
* scheme-relative URL: Then the scheme of aRoot, if any, is prepended
* first.
* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
* is updated with the result and aRoot is returned. Otherwise the result
* is returned.
* - If aPath is absolute, the result is aPath.
* - Otherwise the two paths are joined with a slash.
* - Joining for example 'http://' and 'www.example.com' is also supported.
*/
function join(aRoot, aPath) {
if (aRoot === "") {
aRoot = ".";
}
if (aPath === "") {
aPath = ".";
}
var aPathUrl = urlParse(aPath);
var aRootUrl = urlParse(aRoot);
if (aRootUrl) {
aRoot = aRootUrl.path || '/';
}
// `join(foo, '//www.example.org')`
if (aPathUrl && !aPathUrl.scheme) {
if (aRootUrl) {
aPathUrl.scheme = aRootUrl.scheme;
}
return urlGenerate(aPathUrl);
}
if (aPathUrl || aPath.match(dataUrlRegexp)) {
return aPath;
}
// `join('http://', 'www.example.com')`
if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
aRootUrl.host = aPath;
return urlGenerate(aRootUrl);
}
var joined = aPath.charAt(0) === '/'
? aPath
: normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
if (aRootUrl) {
aRootUrl.path = joined;
return urlGenerate(aRootUrl);
}
return joined;
}
exports.join = join;
exports.isAbsolute = function (aPath) {
return aPath.charAt(0) === '/' || !!aPath.match(urlRegexp);
};
/**
* Make a path relative to a URL or another path.
*
* @param aRoot The root path or URL.
* @param aPath The path or URL to be made relative to aRoot.
*/
function relative(aRoot, aPath) {
if (aRoot === "") {
aRoot = ".";
}
aRoot = aRoot.replace(/\/$/, '');
// It is possible for the path to be above the root. In this case, simply
// checking whether the root is a prefix of the path won't work. Instead, we
// need to remove components from the root one by one, until either we find
// a prefix that fits, or we run out of components to remove.
var level = 0;
while (aPath.indexOf(aRoot + '/') !== 0) {
var index = aRoot.lastIndexOf("/");
if (index < 0) {
return aPath;
}
// If the only part of the root that is left is the scheme (i.e. http://,
// file:///, etc.), one or more slashes (/), or simply nothing at all, we
// have exhausted all components, so the path is not relative to the root.
aRoot = aRoot.slice(0, index);
if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
return aPath;
}
++level;
}
// Make sure we add a "../" for each component we removed from the root.
return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
}
exports.relative = relative;
var supportsNullProto = (function () {
var obj = Object.create(null);
return !('__proto__' in obj);
}());
function identity (s) {
return s;
}
/**
* Because behavior goes wacky when you set `__proto__` on objects, we
* have to prefix all the strings in our set with an arbitrary character.
*
* See https://github.com/mozilla/source-map/pull/31 and
* https://github.com/mozilla/source-map/issues/30
*
* @param String aStr
*/
function toSetString(aStr) {
if (isProtoString(aStr)) {
return '$' + aStr;
}
return aStr;
}
exports.toSetString = supportsNullProto ? identity : toSetString;
function fromSetString(aStr) {
if (isProtoString(aStr)) {
return aStr.slice(1);
}
return aStr;
}
exports.fromSetString = supportsNullProto ? identity : fromSetString;
function isProtoString(s) {
if (!s) {
return false;
}
var length = s.length;
if (length < 9 /* "__proto__".length */) {
return false;
}
if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||
s.charCodeAt(length - 2) !== 95 /* '_' */ ||
s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
s.charCodeAt(length - 4) !== 116 /* 't' */ ||
s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
s.charCodeAt(length - 8) !== 95 /* '_' */ ||
s.charCodeAt(length - 9) !== 95 /* '_' */) {
return false;
}
for (var i = length - 10; i >= 0; i--) {
if (s.charCodeAt(i) !== 36 /* '$' */) {
return false;
}
}
return true;
}
/**
* Comparator between two mappings where the original positions are compared.
*
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
* mappings with the same original source/line/column, but different generated
* line and column the same. Useful when searching for a mapping with a
* stubbed out mapping.
*/
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
var cmp = mappingA.source - mappingB.source;
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.originalLine - mappingB.originalLine;
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.originalColumn - mappingB.originalColumn;
if (cmp !== 0 || onlyCompareOriginal) {
return cmp;
}
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.generatedLine - mappingB.generatedLine;
if (cmp !== 0) {
return cmp;
}
return mappingA.name - mappingB.name;
}
exports.compareByOriginalPositions = compareByOriginalPositions;
/**
* Comparator between two mappings with deflated source and name indices where
* the generated positions are compared.
*
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
* mappings with the same generated line and column, but different
* source/name/original line and column the same. Useful when searching for a
* mapping with a stubbed out mapping.
*/
function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
var cmp = mappingA.generatedLine - mappingB.generatedLine;
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
if (cmp !== 0 || onlyCompareGenerated) {
return cmp;
}
cmp = mappingA.source - mappingB.source;
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.originalLine - mappingB.originalLine;
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.originalColumn - mappingB.originalColumn;
if (cmp !== 0) {
return cmp;
}
return mappingA.name - mappingB.name;
}
exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
function strcmp(aStr1, aStr2) {
if (aStr1 === aStr2) {
return 0;
}
if (aStr1 > aStr2) {
return 1;
}
return -1;
}
/**
* Comparator between two mappings with inflated source and name strings where
* the generated positions are compared.
*/
function compareByGeneratedPositionsInflated(mappingA, mappingB) {
var cmp = mappingA.generatedLine - mappingB.generatedLine;
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
if (cmp !== 0) {
return cmp;
}
cmp = strcmp(mappingA.source, mappingB.source);
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.originalLine - mappingB.originalLine;
if (cmp !== 0) {
return cmp;
}
cmp = mappingA.originalColumn - mappingB.originalColumn;
if (cmp !== 0) {
return cmp;
}
return strcmp(mappingA.name, mappingB.name);
}
exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
});
var binarySearch = createCommonjsModule$1(function (module, exports) {
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/
exports.GREATEST_LOWER_BOUND = 1;
exports.LEAST_UPPER_BOUND = 2;
/**
* Recursive implementation of binary search.
*
* @param aLow Indices here and lower do not contain the needle.
* @param aHigh Indices here and higher do not contain the needle.
* @param aNeedle The element being searched for.
* @param aHaystack The non-empty array being searched.
* @param aCompare Function which takes two elements and returns -1, 0, or 1.
* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
* 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
* closest element that is smaller than or greater than the one we are
* searching for, respectively, if the exact element cannot be found.
*/
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
// This function terminates when one of the following is true:
//
// 1. We find the exact element we are looking for.
//
// 2. We did not find the exact element, but we can return the index of
// the next-closest element.
//
// 3. We did not find the exact element, and there is no next-closest
// element than the one we are searching for, so we return -1.
var mid = Math.floor((aHigh - aLow) / 2) + aLow;
var cmp = aCompare(aNeedle, aHaystack[mid], true);
if (cmp === 0) {
// Found the element we are looking for.
return mid;
}
else if (cmp > 0) {
// Our needle is greater than aHaystack[mid].
if (aHigh - mid > 1) {
// The element is in the upper half.
return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
}
// The exact needle element was not found in this haystack. Determine if
// we are in termination case (3) or (2) and return the appropriate thing.
if (aBias == exports.LEAST_UPPER_BOUND) {
return aHigh < aHaystack.length ? aHigh : -1;
} else {
return mid;
}
}
else {
// Our needle is less than aHaystack[mid].
if (mid - aLow > 1) {
// The element is in the lower half.
return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
}
// we are in termination case (3) or (2) and return the appropriate thing.
if (aBias == exports.LEAST_UPPER_BOUND) {
return mid;
} else {
return aLow < 0 ? -1 : aLow;
}
}
}
/**
* This is an implementation of binary search which will always try and return
* the index of the closest element if there is no exact hit. This is because
* mappings between original and generated line/col pairs are single points,
* and there is an implicit region between each of them, so a miss just means
* that you aren't on the very start of a region.
*
* @param aNeedle The element you are looking for.
* @param aHaystack The array that is being searched.
* @param aCompare A function which takes the needle and an element in the
* array and returns -1, 0, or 1 depending on whether the needle is less
* than, equal to, or greater than the element, respectively.
* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
* 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
* closest element that is smaller than or greater than the one we are
* searching for, respectively, if the exact element cannot be found.
* Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
*/
exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
if (aHaystack.length === 0) {
return -1;
}
var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
aCompare, aBias || exports.GREATEST_LOWER_BOUND);
if (index < 0) {
return -1;
}
// We have found either the exact element, or the next-closest element than
// the one we are searching for. However, there may be more than one such
// element. Make sure we always return the smallest of these.
while (index - 1 >= 0) {
if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
break;
}
--index;
}
return index;
};
});
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/
var has = Object.prototype.hasOwnProperty;
/**
* A data structure which is a combination of an array and a set. Adding a new
* member is O(1), testing for membership is O(1), and finding the index of an
* element is O(1). Removing elements from the set is not supported. Only
* strings are supported for membership.
*/
function ArraySet$1() {
this._array = [];
this._set = Object.create(null);
}
/**
* Static method for creating ArraySet instances from an existing array.
*/
ArraySet$1.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
var set = new ArraySet$1();
for (var i = 0, len = aArray.length; i < len; i++) {
set.add(aArray[i], aAllowDuplicates);
}
return set;
};
/**
* Return how many unique items are in this ArraySet. If duplicates have been
* added, than those do not count towards the size.
*
* @returns Number
*/
ArraySet$1.prototype.size = function ArraySet_size() {
return Object.getOwnPropertyNames(this._set).length;
};
/**
* Add the given string to this set.
*
* @param String aStr
*/
ArraySet$1.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
var sStr = util.toSetString(aStr);
var isDuplicate = has.call(this._set, sStr);
var idx = this._array.length;
if (!isDuplicate || aAllowDuplicates) {
this._array.push(aStr);
}
if (!isDuplicate) {
this._set[sStr] = idx;
}
};
/**
* Is the given string a member of this set?
*
* @param String aStr
*/
ArraySet$1.prototype.has = function ArraySet_has(aStr) {
var sStr = util.toSetString(aStr);
return has.call(this._set, sStr);
};
/**
* What is the index of the given string in the array?
*
* @param String aStr
*/
ArraySet$1.prototype.indexOf = function ArraySet_indexOf(aStr) {
var sStr = util.toSetString(aStr);
if (has.call(this._set, sStr)) {
return this._set[sStr];
}
throw new Error('"' + aStr + '" is not in the set.');
};
/**
* What is the element at the given index?
*
* @param Number aIdx
*/
ArraySet$1.prototype.at = function ArraySet_at(aIdx) {
if (aIdx >= 0 && aIdx < this._array.length) {
return this._array[aIdx];
}
throw new Error('No element indexed by ' + aIdx);
};
/**
* Returns the array representation of this set (which has the proper indices
* indicated by indexOf). Note that this is a copy of the internal array used
* for storing the members so that no one can mess with internal state.
*/
ArraySet$1.prototype.toArray = function ArraySet_toArray() {
return this._array.slice();
};
var ArraySet_1 = ArraySet$1;
var arraySet = {
ArraySet: ArraySet_1
};
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/
var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
/**
* Encode an integer in the range of 0 to 63 to a single base 64 digit.
*/
var encode$2 = function (number) {
if (0 <= number && number < intToCharMap.length) {
return intToCharMap[number];
}
throw new TypeError("Must be between 0 and 63: " + number);
};
/**
* Decode a single base 64 character code digit to an integer. Returns -1 on
* failure.
*/
var decode$1 = function (charCode) {
var bigA = 65; // 'A'
var bigZ = 90; // 'Z'
var littleA = 97; // 'a'
var littleZ = 122; // 'z'
var zero = 48; // '0'
var nine = 57; // '9'
var plus = 43; // '+'
var slash = 47; // '/'
var littleOffset = 26;
var numberOffset = 52;
// 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
if (bigA <= charCode && charCode <= bigZ) {
return (charCode - bigA);
}
// 26 - 51: abcdefghijklmnopqrstuvwxyz
if (littleA <= charCode && charCode <= littleZ) {
return (charCode - littleA + littleOffset);
}
// 52 - 61: 0123456789
if (zero <= charCode && charCode <= nine) {
return (charCode - zero + numberOffset);
}
// 62: +
if (charCode == plus) {
return 62;
}
// 63: /
if (charCode == slash) {
return 63;
}
// Invalid base64 digit.
return -1;
};
var base64 = {
encode: encode$2,
decode: decode$1
};
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*
* Based on the Base 64 VLQ implementation in Closure Compiler:
* https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
*
* Copyright 2011 The Closure Compiler Authors. All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// A single base 64 digit can contain 6 bits of data. For the base 64 variable
// length quantities we use in the source map spec, the first bit is the sign,
// the next four bits are the actual value, and the 6th bit is the
// continuation bit. The continuation bit tells us whether there are more
// digits in this value following this digit.
//
// Continuation
// | Sign
// | |
// V V
// 101011
var VLQ_BASE_SHIFT = 5;
// binary: 100000
var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
// binary: 011111
var VLQ_BASE_MASK = VLQ_BASE - 1;
// binary: 100000
var VLQ_CONTINUATION_BIT = VLQ_BASE;
/**
* Converts from a two-complement value to a value where the sign bit is
* placed in the least significant bit. For example, as decimals:
* 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
* 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
*/
function toVLQSigned(aValue) {
return aValue < 0
? ((-aValue) << 1) + 1
: (aValue << 1) + 0;
}
/**
* Converts to a two-complement value from a value where the sign bit is
* placed in the least significant bit. For example, as decimals:
* 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
* 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
*/
function fromVLQSigned(aValue) {
var isNegative = (aValue & 1) === 1;
var shifted = aValue >> 1;
return isNegative
? -shifted
: shifted;
}
/**
* Returns the base 64 VLQ encoded value.
*/
var encode$1 = function base64VLQ_encode(aValue) {
var encoded = "";
var digit;
var vlq = toVLQSigned(aValue);
do {
digit = vlq & VLQ_BASE_MASK;
vlq >>>= VLQ_BASE_SHIFT;
if (vlq > 0) {
// There are still more digits in this value, so we must make sure the
// continuation bit is marked.
digit |= VLQ_CONTINUATION_BIT;
}
encoded += base64.encode(digit);
} while (vlq > 0);
return encoded;
};
/**
* Decodes the next base 64 VLQ value from the given string and returns the
* value and the rest of the string via the out parameter.
*/
var decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
var strLen = aStr.length;
var result = 0;
var shift = 0;
var continuation, digit;
do {
if (aIndex >= strLen) {
throw new Error("Expected more digits in base 64 VLQ value.");
}
digit = base64.decode(aStr.charCodeAt(aIndex++));
if (digit === -1) {
throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
}
continuation = !!(digit & VLQ_CONTINUATION_BIT);
digit &= VLQ_BASE_MASK;
result = result + (digit << shift);
shift += VLQ_BASE_SHIFT;
} while (continuation);
aOutParam.value = fromVLQSigned(result);
aOutParam.rest = aIndex;
};
var base64Vlq = {
encode: encode$1,
decode: decode
};
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/
// It turns out that some (most?) JavaScript engines don't self-host
// `Array.prototype.sort`. This makes sense because C++ will likely remain
// faster than JS when doing raw CPU-intensive sorting. However, when using a
// custom comparator function, calling back and forth between the VM's C++ and
// JIT'd JS is rather slow *and* loses JIT type information, resulting in
// worse generated code for the comparator function than would be optimal. In
// fact, when sorting with a comparator, these costs outweigh the benefits of
// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
// a ~3500ms mean speed-up in `bench/bench.html`.
/**
* Swap the elements indexed by `x` and `y` in the array `ary`.
*
* @param {Array} ary
* The array.
* @param {Number} x
* The index of the first item.
* @param {Number} y
* The index of the second item.
*/
function swap(ary, x, y) {
var temp = ary[x];
ary[x] = ary[y];
ary[y] = temp;
}
/**
* Returns a random integer within the range `low .. high` inclusive.
*
* @param {Number} low
* The lower bound on the range.
* @param {Number} high
* The upper bound on the range.
*/
function randomIntInRange(low, high) {
return Math.round(low + (Math.random() * (high - low)));
}
/**
* The Quick Sort algorithm.
*
* @param {Array} ary
* An array to sort.
* @param {function} comparator
* Function to use to compare two items.
* @param {Number} p
* Start index of the array
* @param {Number} r
* End index of the array
*/
function doQuickSort(ary, comparator, p, r) {
// If our lower bound is less than our upper bound, we (1) partition the
// array into two pieces and (2) recurse on each half. If it is not, this is
// the empty array and our base case.
if (p < r) {
// (1) Partitioning.
//
// The partitioning chooses a pivot between `p` and `r` and moves all
// elements that are less than or equal to the pivot to the before it, and
// all the elements that are greater than it after it. The effect is that
// once partition is done, the pivot is in the exact place it will be when
// the array is put in sorted order, and it will not need to be moved
// again. This runs in O(n) time.
// Always choose a random pivot so that an input array which is reverse
// sorted does not cause O(n^2) running time.
var pivotIndex = randomIntInRange(p, r);
var i = p - 1;
swap(ary, pivotIndex, r);
var pivot = ary[r];
// Immediately after `j` is incremented in this loop, the following hold
// true:
//
// * Every element in `ary[p .. i]` is less than or equal to the pivot.
//
// * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
for (var j = p; j < r; j++) {
if (comparator(ary[j], pivot) <= 0) {
i += 1;
swap(ary, i, j);
}
}
swap(ary, i + 1, j);
var q = i + 1;
// (2) Recurse on each half.
doQuickSort(ary, comparator, p, q - 1);
doQuickSort(ary, comparator, q + 1, r);
}
}
/**
* Sort the given array in-place with the given comparator function.
*
* @param {Array} ary
* An array to sort.
* @param {function} comparator
* Function to use to compare two items.
*/
var quickSort_1 = function (ary, comparator) {
doQuickSort(ary, comparator, 0, ary.length - 1);
};
var quickSort$1 = {
quickSort: quickSort_1
};
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
* Copyright 2011 Mozilla Foundation and contributors
* Licensed under the New BSD license. See LICENSE or:
* http://opensource.org/licenses/BSD-3-Clause
*/
var ArraySet = arraySet.ArraySet;
var quickSort = quickSort$1.quickSort;
function SourceMapConsumer(aSourceMap) {
var sourceMap = aSourceMap;
if (typeof aSourceMap === 'string') {
sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
}
return sourceMap.sections != null
? new IndexedSourceMapConsumer(sourceMap)
: new BasicSourceMapConsumer(sourceMap);
}
SourceMapConsumer.fromSourceMap = function(aSourceMap) {
return BasicSourceMapConsumer.fromSourceMap(aSourceMap);
};
/**
* The version of the source mapping spec that we are consuming.
*/
SourceMapConsumer.prototype._version = 3;
// `__generatedMappings` and `__originalMappings` are arrays that hold the
// parsed mapping coordinates from the source map's "mappings" attribute. They
// are lazily instantiated, accessed via the `_generatedMappings` and
// `_originalMappings` getters respectively, and we only parse the mappings
// and create these arrays once queried for a source location. We jump through
// these hoops because there can be many thousands of mappings, and parsing
// them is expensive, so we only want to do it if we must.
//
// Each object in the arrays is of the form:
//
// {
// generatedLine: The line number in the generated code,
// generatedColumn: The column number in the generated code,
// source: The path to the original source file that generated this
// chunk of code,
// originalLine: The line number in the original source that
// corresponds to this chunk of generated code,
// originalColumn: The column number in the original source that
// corresponds to this chunk of generated code,
// name: The name of the original symbol which generated this chunk of
// code.
// }
//
// All properties except for `generatedLine` and `generatedColumn` can be
// `null`.
//
// `_generatedMappings` is ordered by the generated positions.
//
// `_originalMappings` is ordered by the original positions.
SourceMapConsumer.prototype.__generatedMappings = null;
Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
get: function () {
if (!this.__generatedMappings) {
this._parseMappings(this._mappings, this.sourceRoot);
}
return this.__generatedMappings;
}
});
SourceMapConsumer.prototype.__originalMappings = null;
Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
get: function () {
if (!this.__originalMappings) {
this._parseMappings(this._mappings, this.sourceRoot);
}
return this.__originalMappings;
}
});
SourceMapConsumer.prototype._charIsMappingSeparator =
function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
var c = aStr.charAt(index);
return c === ";" || c === ",";
};
/**
* Parse the mappings in a string in to a data structure which we can easily
* query (the ordered arrays in the `this.__generatedMappings` and
* `this.__originalMappings` properties).
*/
SourceMapConsumer.prototype._parseMappings =
function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
throw new Error("Subclasses must implement _parseMappings");
};
SourceMapConsumer.GENERATED_ORDER = 1;
SourceMapConsumer.ORIGINAL_ORDER = 2;
SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
SourceMapConsumer.LEAST_UPPER_BOUND = 2;
/**
* Iterate over each mapping between an original source/line/column and a
* generated line/column in this source map.
*
* @param Function aCallback
* The function that is called with each mapping.
* @param Object aContext
* Optional. If specified, this object will be the value of `this` every
* time that `aCallback` is called.
* @param aOrder
* Either `SourceMapConsumer.GENERATED_ORDER` or
* `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
* iterate over the mappings sorted by the generated file's line/column
* order or the original's source/line/column order, respectively. Defaults to
* `SourceMapConsumer.GENERATED_ORDER`.
*/
SourceMapConsumer.prototype.eachMapping =
function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
var context = aContext || null;
var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
var mappings;
switch (order) {
case SourceMapConsumer.GENERATED_ORDER:
mappings = this._generatedMappings;
break;
case SourceMapConsumer.ORIGINAL_ORDER:
mappings = this._originalMappings;
break;
default:
throw new Error("Unknown order of iteration.");
}
var sourceRoot = this.sourceRoot;
mappings.map(function (mapping) {
var source = mapping.source === null ? null : this._sources.at(mapping.source);
if (source != null && sourceRoot != null) {
source = util.join(sourceRoot, source);
}
return {
source: source,
generatedLine: mapping.generatedLine,
generatedColumn: mapping.generatedColumn,
originalLine: mapping.originalLine,
originalColumn: mapping.originalColumn,
name: mapping.name === null ? null : this._names.at(mapping.name)
};
}, this).forEach(aCallback, context);
};
/**
* Returns all generated line and column information for the original source,
* line, and column provided. If no column is provided, returns all mappings
* corresponding to a either the line we are searching for or the next
* closest line that has any mappings. Otherwise, returns all mappings
* corresponding to the given line and either the column we are searching for
* or the next closest column that has any offsets.
*
* The only argument is an object with the following properties:
*
* - source: The filename of the original source.
* - line: The line number in the original source.
* - column: Optional. the column number in the original source.
*
* and an array of objects is returned, each with the following properties:
*
* - line: The line number in the generated source, or null.
* - column: The column number in the generated source, or null.
*/
SourceMapConsumer.prototype.allGeneratedPositionsFor =
function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
var line = util.getArg(aArgs, 'line');
// When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
// returns the index of the closest mapping less than the needle. By
// setting needle.originalColumn to 0, we thus find the last mapping for
// the given line, provided such a mapping exists.
var needle = {
source: util.getArg(aArgs, 'source'),
originalLine: line,
originalColumn: util.getArg(aArgs, 'column', 0)
};
if (this.sourceRoot != null) {
needle.source = util.relative(this.sourceRoot, needle.source);
}
if (!this._sources.has(needle.source)) {
return [];
}
needle.source = this._sources.indexOf(needle.source);
var mappings = [];
var index = this._findMapping(needle,
this._originalMappings,
"originalLine",
"originalColumn",
util.compareByOriginalPositions,
binarySearch.LEAST_UPPER_BOUND);
if (index >= 0) {
var mapping = this._originalMappings[index];
if (aArgs.column === undefined) {
var originalLine = mapping.originalLine;
// Iterate until either we run out of mappings, or we run into
// a mapping for a different line than the one we found. Since
// mappings are sorted, this is guaranteed to find all mappings for
// the line we found.
while (mapping && mapping.originalLine === originalLine) {
mappings.push({
line: util.getArg(mapping, 'generatedLine', null),
column: util.getArg(mapping, 'generatedColumn', null),
lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
});
mapping = this._originalMappings[++index];
}
} else {
var originalColumn = mapping.originalColumn;
// Iterate until either we run out of mappings, or we run into
// a mapping for a different line than the one we were searching for.
// Since mappings are sorted, this is guaranteed to find all mappings for
// the line we are searching for.
while (mapping &&
mapping.originalLine === line &&
mapping.originalColumn == originalColumn) {
mappings.push({
line: util.getArg(mapping, 'generatedLine', null),
column: util.getArg(mapping, 'generatedColumn', null),
lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
});
mapping = this._originalMappings[++index];
}
}
}
return mappings;
};
var SourceMapConsumer_1 = SourceMapConsumer;
/**
* A BasicSourceMapConsumer instance represents a parsed source map which we can
* query for information about the original file positions by giving it a file
* position in the generated source.
*
* The only parameter is the raw source map (either as a JSON string, or
* already parsed to an object). According to the spec, source maps have the
* following attributes:
*
* - version: Which version of the source map spec this map is following.
* - sources: An array of URLs to the original source files.
* - names: An array of identifiers which can be referrenced by individual mappings.
* - sourceRoot: Optional. The URL root from which all sources are relative.
* - sourcesContent: Optional. An array of contents of the original source files.
* - mappings: A string of base64 VLQs which contain the actual mappings.
* - file: Optional. The generated file this source map is associated with.
*
* Here is an example source map, taken from the source map spec[0]:
*
* {
* version : 3,
* file: "out.js",
* sourceRoot : "",
* sources: ["foo.js", "bar.js"],
* names: ["src", "maps", "are", "fun"],
* mappings: "AA,AB;;ABCDE;"
* }
*
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
*/
function BasicSourceMapConsumer(aSourceMap) {
var sourceMap = aSourceMap;
if (typeof aSourceMap === 'string') {
sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
}
var version = util.getArg(sourceMap, 'version');
var sources = util.getArg(sourceMap, 'sources');
// Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
// requires the array) to play nice here.
var names = util.getArg(sourceMap, 'names', []);
var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
var mappings = util.getArg(sourceMap, 'mappings');
var file = util.getArg(sourceMap, 'file', null);
// Once again, Sass deviates from the spec and supplies the version as a
// string rather than a number, so we use loose equality checking here.
if (version != this._version) {
throw new Error('Unsupported version: ' + version);
}
sources = sources
.map(String)
// Some source maps produce relative source paths like "./foo.js" instead of
// "foo.js". Normalize these first so that future comparisons will succeed.
// See bugzil.la/1090768.
.map(util.normalize)
// Always ensure that absolute sources are internally stored relative to
// the source root, if the source root is absolute. Not doing this would
// be particularly problematic when the source root is a prefix of the
// source (valid, but why??). See github issue #199 and bugzil.la/1188982.
.map(function (source) {
return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
? util.relative(sourceRoot, source)
: source;
});
// Pass `true` below to allow duplicate names and sources. While source maps
// are intended to be compressed and deduplicated, the TypeScript compiler
// sometimes generates source maps with duplicates in them. See Github issue
// #72 and bugzil.la/889492.
this._names = ArraySet.fromArray(names.map(String), true);
this._sources = ArraySet.fromArray(sources, true);
this.sourceRoot = sourceRoot;
this.sourcesContent = sourcesContent;
this._mappings = mappings;
this.file = file;
}
BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
/**
* Create a BasicSourceMapConsumer from a SourceMapGenerator.
*
* @param SourceMapGenerator aSourceMap
* The source map that will be consumed.
* @returns BasicSourceMapConsumer
*/
BasicSourceMapConsumer.fromSourceMap =
function SourceMapConsumer_fromSourceMap(aSourceMap) {
var smc = Object.create(BasicSourceMapConsumer.prototype);
var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
smc.sourceRoot = aSourceMap._sourceRoot;
smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
smc.sourceRoot);
smc.file = aSourceMap._file;
// Because we are modifying the entries (by converting string sources and
// names to indices into the sources and names ArraySets), we have to make
// a copy of the entry or else bad things happen. Shared mutable state
// strikes again! See github issue #191.
var generatedMappings = aSourceMap._mappings.toArray().slice();
var destGeneratedMappings = smc.__generatedMappings = [];
var destOriginalMappings = smc.__originalMappings = [];
for (var i = 0, length = generatedMappings.length; i < length; i++) {
var srcMapping = generatedMappings[i];
var destMapping = new Mapping;
destMapping.generatedLine = srcMapping.generatedLine;
destMapping.generatedColumn = srcMapping.generatedColumn;
if (srcMapping.source) {
destMapping.source = sources.indexOf(srcMapping.source);
destMapping.originalLine = srcMapping.originalLine;
destMapping.originalColumn = srcMapping.originalColumn;
if (srcMapping.name) {
destMapping.name = names.indexOf(srcMapping.name);
}
destOriginalMappings.push(destMapping);
}
destGeneratedMappings.push(destMapping);
}
quickSort(smc.__originalMappings, util.compareByOriginalPositions);
return smc;
};
/**
* The version of the source mapping spec that we are consuming.
*/
BasicSourceMapConsumer.prototype._version = 3;
/**
* The list of original sources.
*/
Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
get: function () {
return this._sources.toArray().map(function (s) {
return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
}, this);
}
});
/**
* Provide the JIT with a nice shape / hidden class.
*/
function Mapping() {
this.generatedLine = 0;
this.generatedColumn = 0;
this.source = null;
this.originalLine = null;
this.originalColumn = null;
this.name = null;
}
/**
* Parse the mappings in a string in to a data structure which we can easily
* query (the ordered arrays in the `this.__generatedMappings` and
* `this.__originalMappings` properties).
*/
BasicSourceMapConsumer.prototype._parseMappings =
function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
var generatedLine = 1;
var previousGeneratedColumn = 0;
var previousOriginalLine = 0;
var previousOriginalColumn = 0;
var previousSource = 0;
var previousName = 0;
var length = aStr.length;
var index = 0;
var cachedSegments = {};
var temp = {};
var originalMappings = [];
var generatedMappings = [];
var mapping, str, segment, end, value;
while (index < length) {
if (aStr.charAt(index) === ';') {
generatedLine++;
index++;
previousGeneratedColumn = 0;
}
else if (aStr.charAt(index) === ',') {
index++;
}
else {
mapping = new Mapping();
mapping.generatedLine = generatedLine;
// Because each offset is encoded relative to the previous one,
// many segments often have the same encoding. We can exploit this
// fact by caching the parsed variable length fields of each segment,
// allowing us to avoid a second parse if we encounter the same
// segment again.
for (end = index; end < length; end++) {
if (this._charIsMappingSeparator(aStr, end)) {
break;
}
}
str = aStr.slice(index, end);
segment = cachedSegments[str];
if (segment) {
index += str.length;
} else {
segment = [];
while (index < end) {
base64Vlq.decode(aStr, index, temp);
value = temp.value;
index = temp.rest;
segment.push(value);
}
if (segment.length === 2) {
throw new Error('Found a source, but no line and column');
}
if (segment.length === 3) {
throw new Error('Found a source and line, but no column');
}
cachedSegments[str] = segment;
}
// Generated column.
mapping.generatedColumn = previousGeneratedColumn + segment[0];
previousGeneratedColumn = mapping.generatedColumn;
if (segment.length > 1) {
// Original source.
mapping.source = previousSource + segment[1];
previousSource += segment[1];
// Original line.
mapping.originalLine = previousOriginalLine + segment[2];
previousOriginalLine = mapping.originalLine;
// Lines are stored 0-based
mapping.originalLine += 1;
// Original column.
mapping.originalColumn = previousOriginalColumn + segment[3];
previousOriginalColumn = mapping.originalColumn;
if (segment.length > 4) {
// Original name.
mapping.name = previousName + segment[4];
previousName += segment[4];
}
}
generatedMappings.push(mapping);
if (typeof mapping.originalLine === 'number') {
originalMappings.push(mapping);
}
}
}
quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
this.__generatedMappings = generatedMappings;
quickSort(originalMappings, util.compareByOriginalPositions);
this.__originalMappings = originalMappings;
};
/**
* Find the mapping that best matches the hypothetical "needle" mapping that
* we are searching for in the given "haystack" of mappings.
*/
BasicSourceMapConsumer.prototype._findMapping =
function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
aColumnName, aComparator, aBias) {
// To return the position we are searching for, we must first find the
// mapping for the given position and then return the opposite position it
// points to. Because the mappings are sorted, we can use binary search to
// find the best mapping.
if (aNeedle[aLineName] <= 0) {
throw new TypeError('Line must be greater than or equal to 1, got '
+ aNeedle[aLineName]);
}
if (aNeedle[aColumnName] < 0) {
throw new TypeError('Column must be greater than or equal to 0, got '
+ aNeedle[aColumnName]);
}
return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
};
/**
* Compute the last column for each generated mapping. The last column is
* inclusive.
*/
BasicSourceMapConsumer.prototype.computeColumnSpans =
function SourceMapConsumer_computeColumnSpans() {
for (var index = 0; index < this._generatedMappings.length; ++index) {
var mapping = this._generatedMappings[index];
// Mappings do not contain a field for the last generated columnt. We
// can come up with an optimistic estimate, however, by assuming that
// mappings are contiguous (i.e. given two consecutive mappings, the
// first mapping ends where the second one starts).
if (index + 1 < this._generatedMappings.length) {
var nextMapping = this._generatedMappings[index + 1];
if (mapping.generatedLine === nextMapping.generatedLine) {
mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
continue;
}
}
// The last mapping for each line spans the entire line.
mapping.lastGeneratedColumn = Infinity;
}
};
/**
* Returns the original source, line, and column information for the generated
* source's line and column positions provided. The only argument is an object
* with the following properties:
*
* - line: The line number in the generated source.
* - column: The column number in the generated source.
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
* closest element that is smaller than or greater than the one we are
* searching for, respectively, if the exact element cannot be found.
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
*
* and an object is returned with the following properties:
*
* - source: The original source file, or null.
* - line: The line number in the original source, or null.
* - column: The column number in the original source, or null.
* - name: The original identifier, or null.
*/
BasicSourceMapConsumer.prototype.originalPositionFor =
function SourceMapConsumer_originalPositionFor(aArgs) {
var needle = {
generatedLine: util.getArg(aArgs, 'line'),
generatedColumn: util.getArg(aArgs, 'column')
};
var index = this._findMapping(
needle,
this._generatedMappings,
"generatedLine",
"generatedColumn",
util.compareByGeneratedPositionsDeflated,
util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
);
if (index >= 0) {
var mapping = this._generatedMappings[index];
if (mapping.generatedLine === needle.generatedLine) {
var source = util.getArg(mapping, 'source', null);
if (source !== null) {
source = this._sources.at(source);
if (this.sourceRoot != null) {
source = util.join(this.sourceRoot, source);
}
}
var name = util.getArg(mapping, 'name', null);
if (name !== null) {
name = this._names.at(name);
}
return {
source: source,
line: util.getArg(mapping, 'originalLine', null),
column: util.getArg(mapping, 'originalColumn', null),
name: name
};
}
}
return {
source: null,
line: null,
column: null,
name: null
};
};
/**
* Return true if we have the source content for every source in the source
* map, false otherwise.
*/
BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
function BasicSourceMapConsumer_hasContentsOfAllSources() {
if (!this.sourcesContent) {
return false;
}
return this.sourcesContent.length >= this._sources.size() &&
!this.sourcesContent.some(function (sc) { return sc == null; });
};
/**
* Returns the original source content. The only argument is the url of the
* original source file. Returns null if no original source content is
* available.
*/
BasicSourceMapConsumer.prototype.sourceContentFor =
function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
if (!this.sourcesContent) {
return null;
}
if (this.sourceRoot != null) {
aSource = util.relative(this.sourceRoot, aSource);
}
if (this._sources.has(aSource)) {
return this.sourcesContent[this._sources.indexOf(aSource)];
}
var url;
if (this.sourceRoot != null
&& (url = util.urlParse(this.sourceRoot))) {
// XXX: file:// URIs and absolute paths lead to unexpected behavior for
// many users. We can help them out when they expect file:// URIs to
// behave like it would if they were running a local HTTP server. See
// https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
if (url.scheme == "file"
&& this._sources.has(fileUriAbsPath)) {
return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
}
if ((!url.path || url.path == "/")
&& this._sources.has("/" + aSource)) {
return this.sourcesContent[this._sources.indexOf("/" + aSource)];
}
}
// This function is used recursively from
// IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
// don't want to throw if we can't find the source - we just want to
// return null, so we provide a flag to exit gracefully.
if (nullOnMissing) {
return null;
}
else {
throw new Error('"' + aSource + '" is not in the SourceMap.');
}
};
/**
* Returns the generated line and column information for the original source,
* line, and column positions provided. The only argument is an object with
* the following properties:
*
* - source: The filename of the original source.
* - line: The line number in the original source.
* - column: The column number in the original source.
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
* closest element that is smaller than or greater than the one we are
* searching for, respectively, if the exact element cannot be found.
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
*
* and an object is returned with the following properties:
*
* - line: The line number in the generated source, or null.
* - column: The column number in the generated source, or null.
*/
BasicSourceMapConsumer.prototype.generatedPositionFor =
function SourceMapConsumer_generatedPositionFor(aArgs) {
var source = util.getArg(aArgs, 'source');
if (this.sourceRoot != null) {
source = util.relative(this.sourceRoot, source);
}
if (!this._sources.has(source)) {
return {
line: null,
column: null,
lastColumn: null
};
}
source = this._sources.indexOf(source);
var needle = {
source: source,
originalLine: util.getArg(aArgs, 'line'),
originalColumn: util.getArg(aArgs, 'column')
};
var index = this._findMapping(
needle,
this._originalMappings,
"originalLine",
"originalColumn",
util.compareByOriginalPositions,
util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
);
if (index >= 0) {
var mapping = this._originalMappings[index];
if (mapping.source === needle.source) {
return {
line: util.getArg(mapping, 'generatedLine', null),
column: util.getArg(mapping, 'generatedColumn', null),
lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
};
}
}
return {
line: null,
column: null,
lastColumn: null
};
};
var BasicSourceMapConsumer_1 = BasicSourceMapConsumer;
/**
* An IndexedSourceMapConsumer instance represents a parsed source map which
* we can query for information. It differs from BasicSourceMapConsumer in
* that it takes "indexed" source maps (i.e. ones with a "sections" field) as
* input.
*
* The only parameter is a raw source map (either as a JSON string, or already
* parsed to an object). According to the spec for indexed source maps, they
* have the following attributes:
*
* - version: Which version of the source map spec this map is following.
* - file: Optional. The generated file this source map is associated with.
* - sections: A list of section definitions.
*
* Each value under the "sections" field has two fields:
* - offset: The offset into the original specified at which this section
* begins to apply, defined as an object with a "line" and "column"
* field.
* - map: A source map definition. This source map could also be indexed,
* but doesn't have to be.
*
* Instead of the "map" field, it's also possible to have a "url" field
* specifying a URL to retrieve a source map from, but that's currently
* unsupported.
*
* Here's an example source map, taken from the source map spec[0], but
* modified to omit a section which uses the "url" field.
*
* {
* version : 3,
* file: "app.js",
* sections: [{
* offset: {line:100, column:10},
* map: {
* version : 3,
* file: "section.js",
* sources: ["foo.js", "bar.js"],
* names: ["src", "maps", "are", "fun"],
* mappings: "AAAA,E;;ABCDE;"
* }
* }],
* }
*
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
*/
function IndexedSourceMapConsumer(aSourceMap) {
var sourceMap = aSourceMap;
if (typeof aSourceMap === 'string') {
sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
}
var version = util.getArg(sourceMap, 'version');
var sections = util.getArg(sourceMap, 'sections');
if (version != this._version) {
throw new Error('Unsupported version: ' + version);
}
this._sources = new ArraySet();
this._names = new ArraySet();
var lastOffset = {
line: -1,
column: 0
};
this._sections = sections.map(function (s) {
if (s.url) {
// The url field will require support for asynchronicity.
// See https://github.com/mozilla/source-map/issues/16
throw new Error('Support for url field in sections not implemented.');
}
var offset = util.getArg(s, 'offset');
var offsetLine = util.getArg(offset, 'line');
var offsetColumn = util.getArg(offset, 'column');
if (offsetLine < lastOffset.line ||
(offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
throw new Error('Section offsets must be ordered and non-overlapping.');
}
lastOffset = offset;
return {
generatedOffset: {
// The offset fields are 0-based, but we use 1-based indices when
// encoding/decoding from VLQ.
generatedLine: offsetLine + 1,
generatedColumn: offsetColumn + 1
},
consumer: new SourceMapConsumer(util.getArg(s, 'map'))
}
});
}
IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
/**
* The version of the source mapping spec that we are consuming.
*/
IndexedSourceMapConsumer.prototype._version = 3;
/**
* The list of original sources.
*/
Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
get: function () {
var sources = [];
for (var i = 0; i < this._sections.length; i++) {
for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
sources.push(this._sections[i].consumer.sources[j]);
}
}
return sources;
}
});
/**
* Returns the original source, line, and column information for the generated
* source's line and column positions provided. The only argument is an object
* with the following properties:
*
* - line: The line number in the generated source.
* - column: The column number in the generated source.
*
* and an object is returned with the following properties:
*
* - source: The original source file, or null.
* - line: The line number in the original source, or null.
* - column: The column number in the original source, or null.
* - name: The original identifier, or null.
*/
IndexedSourceMapConsumer.prototype.originalPositionFor =
function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
var needle = {
generatedLine: util.getArg(aArgs, 'line'),
generatedColumn: util.getArg(aArgs, 'column')
};
// Find the section containing the generated position we're trying to map
// to an original position.
var sectionIndex = binarySearch.search(needle, this._sections,
function(needle, section) {
var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
if (cmp) {
return cmp;
}
return (needle.generatedColumn -
section.generatedOffset.generatedColumn);
});
var section = this._sections[sectionIndex];
if (!section) {
return {
source: null,
line: null,
column: null,
name: null
};
}
return section.consumer.originalPositionFor({
line: needle.generatedLine -
(section.generatedOffset.generatedLine - 1),
column: needle.generatedColumn -
(section.generatedOffset.generatedLine === needle.generatedLine
? section.generatedOffset.generatedColumn - 1
: 0),
bias: aArgs.bias
});
};
/**
* Return true if we have the source content for every source in the source
* map, false otherwise.
*/
IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
function IndexedSourceMapConsumer_hasContentsOfAllSources() {
return this._sections.every(function (s) {
return s.consumer.hasContentsOfAllSources();
});
};
/**
* Returns the original source content. The only argument is the url of the
* original source file. Returns null if no original source content is
* available.
*/
IndexedSourceMapConsumer.prototype.sourceContentFor =
function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
for (var i = 0; i < this._sections.length; i++) {
var section = this._sections[i];
var content = section.consumer.sourceContentFor(aSource, true);
if (content) {
return content;
}
}
if (nullOnMissing) {
return null;
}
else {
throw new Error('"' + aSource + '" is not in the SourceMap.');
}
};
/**
* Returns the generated line and column information for the original source,
* line, and column positions provided. The only argument is an object with
* the following properties:
*
* - source: The filename of the original source.
* - line: The line number in the original source.
* - column: The column number in the original source.
*
* and an object is returned with the following properties:
*
* - line: The line number in the generated source, or null.
* - column: The column number in the generated source, or null.
*/
IndexedSourceMapConsumer.prototype.generatedPositionFor =
function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
for (var i = 0; i < this._sections.length; i++) {
var section = this._sections[i];
// Only consider this section if the requested source is in the list of
// sources of the consumer.
if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {
continue;
}
var generatedPosition = section.consumer.generatedPositionFor(aArgs);
if (generatedPosition) {
var ret = {
line: generatedPosition.line +
(section.generatedOffset.generatedLine - 1),
column: generatedPosition.column +
(section.generatedOffset.generatedLine === generatedPosition.line
? section.generatedOffset.generatedColumn - 1
: 0)
};
return ret;
}
}
return {
line: null,
column: null
};
};
/**
* Parse the mappings in a string in to a data structure which we can easily
* query (the ordered arrays in the `this.__generatedMappings` and
* `this.__originalMappings` properties).
*/
IndexedSourceMapConsumer.prototype._parseMappings =
function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
this.__generatedMappings = [];
this.__originalMappings = [];
for (var i = 0; i < this._sections.length; i++) {
var section = this._sections[i];
var sectionMappings = section.consumer._generatedMappings;
for (var j = 0; j < sectionMappings.length; j++) {
var mapping = sectionMappings[j];
var source = section.consumer._sources.at(mapping.source);
if (section.consumer.sourceRoot !== null) {
source = util.join(section.consumer.sourceRoot, source);
}
this._sources.add(source);
source = this._sources.indexOf(source);
var name = section.consumer._names.at(mapping.name);
this._names.add(name);
name = this._names.indexOf(name);
// The mappings coming from the consumer for the section have
// generated positions relative to the start of the section, so we
// need to offset them to be relative to the start of the concatenated
// generated file.
var adjustedMapping = {
source: source,
generatedLine: mapping.generatedLine +
(section.generatedOffset.generatedLine - 1),
generatedColumn: mapping.generatedColumn +
(section.generatedOffset.generatedLine === mapping.generatedLine
? section.generatedOffset.generatedColumn - 1
: 0),
originalLine: mapping.originalLine,
originalColumn: mapping.originalColumn,
name: name
};
this.__generatedMappings.push(adjustedMapping);
if (typeof adjustedMapping.originalLine === 'number') {
this.__originalMappings.push(adjustedMapping);
}
}
}
quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
quickSort(this.__originalMappings, util.compareByOriginalPositions);
};
var IndexedSourceMapConsumer_1 = IndexedSourceMapConsumer;
var sourceMapConsumer = {
SourceMapConsumer: SourceMapConsumer_1,
BasicSourceMapConsumer: BasicSourceMapConsumer_1,
IndexedSourceMapConsumer: IndexedSourceMapConsumer_1
};
var stacktraceGps = createCommonjsModule$1(function (module, exports) {
(function(root, factory) {
if (typeof undefined === 'function' && undefined.amd) {
undefined('stacktrace-gps', ['source-map', 'stackframe'], factory);
} else {
module.exports = factory(sourceMapConsumer, stackframe);
}
}(commonjsGlobal$1, function(SourceMap, StackFrame) {
function _xdr(url) {
return new Promise(function(resolve, reject) {
var req = new XMLHttpRequest();
req.open('get', url);
req.onerror = reject;
req.onreadystatechange = function onreadystatechange() {
if (req.readyState === 4) {
if ((req.status >= 200 && req.status < 300) ||
(url.substr(0, 7) === 'file://' && req.responseText)) {
resolve(req.responseText);
} else {
reject(new Error('HTTP status: ' + req.status + ' retrieving ' + url));
}
}
};
req.send();
});
}
/**
* Convert a Base64-encoded string into its original representation.
* Used for inline sourcemaps.
*
* @param {String} b64str Base-64 encoded string
* @returns {String} original representation of the base64-encoded string.
*/
function _atob(b64str) {
if (typeof index !== 'undefined' && index.atob) {
return index.atob(b64str);
} else {
throw new Error('You must supply a polyfill for window.atob in this environment');
}
}
function _parseJson(string) {
if (typeof JSON !== 'undefined' && JSON.parse) {
return JSON.parse(string);
} else {
throw new Error('You must supply a polyfill for JSON.parse in this environment');
}
}
function _findFunctionName(source, lineNumber/*, columnNumber*/) {
var syntaxes = [
// {name} = function ({args}) TODO args capture
/['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*function\b/,
// function {name}({args}) m[1]=name m[2]=args
/function\s+([^('"`]*?)\s*\(([^)]*)\)/,
// {name} = eval()
/['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*(?:eval|new Function)\b/,
// fn_name() {
/\b(?!(?:if|for|switch|while|with|catch)\b)(?:(?:static)\s+)?(\S+)\s*\(.*?\)\s*\{/,
// {name} = () => {
/['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*\(.*?\)\s*=>/
];
var lines = source.split('\n');
// Walk backwards in the source lines until we find the line which matches one of the patterns above
var code = '';
var maxLines = Math.min(lineNumber, 20);
for (var i = 0; i < maxLines; ++i) {
// lineNo is 1-based, source[] is 0-based
var line = lines[lineNumber - i - 1];
var commentPos = line.indexOf('//');
if (commentPos >= 0) {
line = line.substr(0, commentPos);
}
if (line) {
code = line + code;
var len = syntaxes.length;
for (var index$$1 = 0; index$$1 < len; index$$1++) {
var m = syntaxes[index$$1].exec(code);
if (m && m[1]) {
return m[1];
}
}
}
}
return undefined;
}
function _ensureSupportedEnvironment() {
if (typeof Object.defineProperty !== 'function' || typeof Object.create !== 'function') {
throw new Error('Unable to consume source maps in older browsers');
}
}
function _ensureStackFrameIsLegit(stackframe$$2) {
if (typeof stackframe$$2 !== 'object') {
throw new TypeError('Given StackFrame is not an object');
} else if (typeof stackframe$$2.fileName !== 'string') {
throw new TypeError('Given file name is not a String');
} else if (typeof stackframe$$2.lineNumber !== 'number' ||
stackframe$$2.lineNumber % 1 !== 0 ||
stackframe$$2.lineNumber < 1) {
throw new TypeError('Given line number must be a positive integer');
} else if (typeof stackframe$$2.columnNumber !== 'number' ||
stackframe$$2.columnNumber % 1 !== 0 ||
stackframe$$2.columnNumber < 0) {
throw new TypeError('Given column number must be a non-negative integer');
}
return true;
}
function _findSourceMappingURL(source) {
var m = /\/\/[#@] ?sourceMappingURL=([^\s'"]+)\s*$/m.exec(source);
if (m && m[1]) {
return m[1];
} else {
throw new Error('sourceMappingURL not found');
}
}
function _extractLocationInfoFromSourceMapSource(stackframe$$2, sourceMapConsumer$$1, sourceCache) {
return new Promise(function(resolve, reject) {
var loc = sourceMapConsumer$$1.originalPositionFor({
line: stackframe$$2.lineNumber,
column: stackframe$$2.columnNumber
});
if (loc.source) {
// cache mapped sources
var mappedSource = sourceMapConsumer$$1.sourceContentFor(loc.source);
if (mappedSource) {
sourceCache[loc.source] = mappedSource;
}
resolve(
// given stackframe and source location, update stackframe
new StackFrame({
functionName: loc.name || stackframe$$2.functionName,
args: stackframe$$2.args,
fileName: loc.source,
lineNumber: loc.line,
columnNumber: loc.column
}));
} else {
reject(new Error('Could not get original source for given stackframe and source map'));
}
});
}
/**
* @constructor
* @param {Object} opts
* opts.sourceCache = {url: "Source String"} => preload source cache
* opts.sourceMapConsumerCache = {/path/file.js.map: SourceMapConsumer}
* opts.offline = True to prevent network requests.
* Best effort without sources or source maps.
* opts.ajax = Promise returning function to make X-Domain requests
*/
return function StackTraceGPS(opts) {
if (!(this instanceof StackTraceGPS)) {
return new StackTraceGPS(opts);
}
opts = opts || {};
this.sourceCache = opts.sourceCache || {};
this.sourceMapConsumerCache = opts.sourceMapConsumerCache || {};
this.ajax = opts.ajax || _xdr;
this._atob = opts.atob || _atob;
this._get = function _get(location) {
return new Promise(function(resolve, reject) {
var isDataUrl = location.substr(0, 5) === 'data:';
if (this.sourceCache[location]) {
resolve(this.sourceCache[location]);
} else if (opts.offline && !isDataUrl) {
reject(new Error('Cannot make network requests in offline mode'));
} else {
if (isDataUrl) {
// data URLs can have parameters.
// see http://tools.ietf.org/html/rfc2397
var supportedEncodingRegexp =
/^data:application\/json;([\w=:"-]+;)*base64,/;
var match = location.match(supportedEncodingRegexp);
if (match) {
var sourceMapStart = match[0].length;
var encodedSource = location.substr(sourceMapStart);
var source = this._atob(encodedSource);
this.sourceCache[location] = source;
resolve(source);
} else {
reject(new Error('The encoding of the inline sourcemap is not supported'));
}
} else {
var xhrPromise = this.ajax(location, {method: 'get'});
// Cache the Promise to prevent duplicate in-flight requests
this.sourceCache[location] = xhrPromise;
xhrPromise.then(resolve, reject);
}
}
}.bind(this));
};
/**
* Creating SourceMapConsumers is expensive, so this wraps the creation of a
* SourceMapConsumer in a per-instance cache.
*
* @param sourceMappingURL = {String} URL to fetch source map from
* @param defaultSourceRoot = Default source root for source map if undefined
* @returns {Promise} that resolves a SourceMapConsumer
*/
this._getSourceMapConsumer = function _getSourceMapConsumer(sourceMappingURL, defaultSourceRoot) {
return new Promise(function(resolve, reject) {
if (this.sourceMapConsumerCache[sourceMappingURL]) {
resolve(this.sourceMapConsumerCache[sourceMappingURL]);
} else {
var sourceMapConsumerPromise = new Promise(function(resolve, reject) {
return this._get(sourceMappingURL).then(function(sourceMapSource) {
if (typeof sourceMapSource === 'string') {
sourceMapSource = _parseJson(sourceMapSource.replace(/^\)\]\}'/, ''));
}
if (typeof sourceMapSource.sourceRoot === 'undefined') {
sourceMapSource.sourceRoot = defaultSourceRoot;
}
resolve(new SourceMap.SourceMapConsumer(sourceMapSource));
}, reject);
}.bind(this));
this.sourceMapConsumerCache[sourceMappingURL] = sourceMapConsumerPromise;
resolve(sourceMapConsumerPromise);
}
}.bind(this));
};
/**
* Given a StackFrame, enhance function name and use source maps for a
* better StackFrame.
*
* @param {StackFrame} stackframe object
* @returns {Promise} that resolves with with source-mapped StackFrame
*/
this.pinpoint = function StackTraceGPS$$pinpoint(stackframe$$2) {
return new Promise(function(resolve, reject) {
this.getMappedLocation(stackframe$$2).then(function(mappedStackFrame) {
function resolveMappedStackFrame() {
resolve(mappedStackFrame);
}
this.findFunctionName(mappedStackFrame)
.then(resolve, resolveMappedStackFrame)
['catch'](resolveMappedStackFrame);
}.bind(this), reject);
}.bind(this));
};
/**
* Given a StackFrame, guess function name from location information.
*
* @param {StackFrame} stackframe
* @returns {Promise} that resolves with enhanced StackFrame.
*/
this.findFunctionName = function StackTraceGPS$$findFunctionName(stackframe$$2) {
return new Promise(function(resolve, reject) {
_ensureStackFrameIsLegit(stackframe$$2);
this._get(stackframe$$2.fileName).then(function getSourceCallback(source) {
var lineNumber = stackframe$$2.lineNumber;
var columnNumber = stackframe$$2.columnNumber;
var guessedFunctionName = _findFunctionName(source, lineNumber, columnNumber);
// Only replace functionName if we found something
if (guessedFunctionName) {
resolve(new StackFrame({
functionName: guessedFunctionName,
args: stackframe$$2.args,
fileName: stackframe$$2.fileName,
lineNumber: lineNumber,
columnNumber: columnNumber
}));
} else {
resolve(stackframe$$2);
}
}, reject)['catch'](reject);
}.bind(this));
};
/**
* Given a StackFrame, seek source-mapped location and return new enhanced StackFrame.
*
* @param {StackFrame} stackframe
* @returns {Promise} that resolves with enhanced StackFrame.
*/
this.getMappedLocation = function StackTraceGPS$$getMappedLocation(stackframe$$2) {
return new Promise(function(resolve, reject) {
_ensureSupportedEnvironment();
_ensureStackFrameIsLegit(stackframe$$2);
var sourceCache = this.sourceCache;
var fileName = stackframe$$2.fileName;
this._get(fileName).then(function(source) {
var sourceMappingURL = _findSourceMappingURL(source);
var isDataUrl = sourceMappingURL.substr(0, 5) === 'data:';
var defaultSourceRoot = fileName.substring(0, fileName.lastIndexOf('/') + 1);
if (sourceMappingURL[0] !== '/' && !isDataUrl && !(/^https?:\/\/|^\/\//i).test(sourceMappingURL)) {
sourceMappingURL = defaultSourceRoot + sourceMappingURL;
}
return this._getSourceMapConsumer(sourceMappingURL, defaultSourceRoot).then(function(sourceMapConsumer$$1) {
return _extractLocationInfoFromSourceMapSource(stackframe$$2, sourceMapConsumer$$1, sourceCache)
.then(resolve)['catch'](function() {
resolve(stackframe$$2);
});
});
}.bind(this), reject)['catch'](reject);
}.bind(this));
};
};
}));
});
var stacktrace = createCommonjsModule$1(function (module, exports) {
(function(root, factory) {
if (typeof undefined === 'function' && undefined.amd) {
undefined('stacktrace', ['error-stack-parser', 'stack-generator', 'stacktrace-gps'], factory);
} else {
module.exports = factory(errorStackParser, stackGenerator, stacktraceGps);
}
}(commonjsGlobal$1, function StackTrace(ErrorStackParser, StackGenerator, StackTraceGPS) {
var _options = {
filter: function(stackframe) {
// Filter out stackframes for this library by default
return (stackframe.functionName || '').indexOf('StackTrace$$') === -1 &&
(stackframe.functionName || '').indexOf('ErrorStackParser$$') === -1 &&
(stackframe.functionName || '').indexOf('StackTraceGPS$$') === -1 &&
(stackframe.functionName || '').indexOf('StackGenerator$$') === -1;
},
sourceCache: {}
};
var _generateError = function StackTrace$$GenerateError() {
try {
// Error must be thrown to get stack in IE
throw new Error();
} catch (err) {
return err;
}
};
/**
* Merge 2 given Objects. If a conflict occurs the second object wins.
* Does not do deep merges.
*
* @param {Object} first base object
* @param {Object} second overrides
* @returns {Object} merged first and second
* @private
*/
function _merge(first, second) {
var target = {};
[first, second].forEach(function(obj) {
for (var prop in obj) {
if (obj.hasOwnProperty(prop)) {
target[prop] = obj[prop];
}
}
return target;
});
return target;
}
function _isShapedLikeParsableError(err) {
return err.stack || err['opera#sourceloc'];
}
function _filtered(stackframes, filter) {
if (typeof filter === 'function') {
return stackframes.filter(filter);
}
return stackframes;
}
return {
/**
* Get a backtrace from invocation point.
*
* @param {Object} opts
* @returns {Array} of StackFrame
*/
get: function StackTrace$$get(opts) {
var err = _generateError();
return _isShapedLikeParsableError(err) ? this.fromError(err, opts) : this.generateArtificially(opts);
},
/**
* Get a backtrace from invocation point.
* IMPORTANT: Does not handle source maps or guess function names!
*
* @param {Object} opts
* @returns {Array} of StackFrame
*/
getSync: function StackTrace$$getSync(opts) {
opts = _merge(_options, opts);
var err = _generateError();
var stack = _isShapedLikeParsableError(err) ? ErrorStackParser.parse(err) : StackGenerator.backtrace(opts);
return _filtered(stack, opts.filter);
},
/**
* Given an error object, parse it.
*
* @param {Error} error object
* @param {Object} opts
* @returns {Promise} for Array[StackFrame}
*/
fromError: function StackTrace$$fromError(error, opts) {
opts = _merge(_options, opts);
var gps = new StackTraceGPS(opts);
return new Promise(function(resolve) {
var stackframes = _filtered(ErrorStackParser.parse(error), opts.filter);
resolve(Promise.all(stackframes.map(function(sf) {
return new Promise(function(resolve) {
function resolveOriginal() {
resolve(sf);
}
gps.pinpoint(sf).then(resolve, resolveOriginal)['catch'](resolveOriginal);
});
})));
}.bind(this));
},
/**
* Use StackGenerator to generate a backtrace.
*
* @param {Object} opts
* @returns {Promise} of Array[StackFrame]
*/
generateArtificially: function StackTrace$$generateArtificially(opts) {
opts = _merge(_options, opts);
var stackFrames = StackGenerator.backtrace(opts);
if (typeof opts.filter === 'function') {
stackFrames = stackFrames.filter(opts.filter);
}
return Promise.resolve(stackFrames);
},
/**
* Given a function, wrap it such that invocations trigger a callback that
* is called with a stack trace.
*
* @param {Function} fn to be instrumented
* @param {Function} callback function to call with a stack trace on invocation
* @param {Function} errback optional function to call with error if unable to get stack trace.
* @param {Object} thisArg optional context object (e.g. window)
*/
instrument: function StackTrace$$instrument(fn, callback, errback, thisArg) {
if (typeof fn !== 'function') {
throw new Error('Cannot instrument non-function object');
} else if (typeof fn.__stacktraceOriginalFn === 'function') {
// Already instrumented, return given Function
return fn;
}
var instrumented = function StackTrace$$instrumented() {
try {
this.get().then(callback, errback)['catch'](errback);
return fn.apply(thisArg || this, arguments);
} catch (e) {
if (_isShapedLikeParsableError(e)) {
this.fromError(e).then(callback, errback)['catch'](errback);
}
throw e;
}
}.bind(this);
instrumented.__stacktraceOriginalFn = fn;
return instrumented;
},
/**
* Given a function that has been instrumented,
* revert the function to it's original (non-instrumented) state.
*
* @param {Function} fn to de-instrument
*/
deinstrument: function StackTrace$$deinstrument(fn) {
if (typeof fn !== 'function') {
throw new Error('Cannot de-instrument non-function object');
} else if (typeof fn.__stacktraceOriginalFn === 'function') {
return fn.__stacktraceOriginalFn;
} else {
// Function not instrumented, return original
return fn;
}
},
/**
* Given an error message and Array of StackFrames, serialize and POST to given URL.
*
* @param {Array} stackframes
* @param {String} url
* @param {String} errorMsg
* @param {Object} requestOptions
*/
report: function StackTrace$$report(stackframes, url, errorMsg, requestOptions) {
return new Promise(function(resolve, reject) {
var req = new XMLHttpRequest();
req.onerror = reject;
req.onreadystatechange = function onreadystatechange() {
if (req.readyState === 4) {
if (req.status >= 200 && req.status < 400) {
resolve(req.responseText);
} else {
reject(new Error('POST to ' + url + ' failed with status: ' + req.status));
}
}
};
req.open('post', url);
// Set request headers
req.setRequestHeader('Content-Type', 'application/json');
if (requestOptions && typeof requestOptions.headers === 'object') {
var headers = requestOptions.headers;
for (var header in headers) {
if (headers.hasOwnProperty(header)) {
req.setRequestHeader(header, headers[header]);
}
}
}
var reportPayload = {stack: stackframes};
if (errorMsg !== undefined && errorMsg !== null) {
reportPayload.message = errorMsg;
}
req.send(JSON.stringify(reportPayload));
});
}
};
}));
});
function proxyConsole () {
function createProxy (fName) {
var originallog = console[fName];
console[fName] = function consoleProxy () {
var trace = new Error().stack.split('\n');
var i = trace.length - 1;
while (i > 0 && trace[i].match((/^ {4}at (?:<anonymous>|__iterateOverGenerators|__testStarter|TestCase.*\.asyncGroup|asyncGroup).*/))) {
i--;
}
var hasTestName = trace[i]
.match(/^ {4}at TestCase.*\.(\S+) .*/);
if (hasTestName !== null && hasTestName[1] !== 'print') {
var testcase = testHandler.tests[hasTestName[1]];
testcase[fName].apply(testcase, arguments);
} else {
originallog.apply(console, arguments);
}
};
}
['log', 'error', 'assert'].map(createProxy);
}
index.stacktrace = stacktrace;
function test (testDescription, ...args) {
let location = stacktrace.getSync()[1];
var testFunction = args.pop();
var testCase = new TestCase(testDescription, testFunction, location, args, { parallel: true });
testHandler.register(testCase);
}
proxyConsole();
var numberOfRBTreeTests = 10000;
function checkRedNodesDoNotHaveBlackChildren (t, tree) {
let correct = true;
function traverse (n) {
if (n == null) {
return
}
if (n.isRed()) {
if (n.left != null) {
correct = correct && !n.left.isRed();
}
if (n.right != null) {
correct = correct && !n.right.isRed();
}
}
traverse(n.left);
traverse(n.right);
}
traverse(tree.root);
t.assert(correct, 'Red nodes do not have black children');
}
function checkBlackHeightOfSubTreesAreEqual (t, tree) {
let correct = true;
function traverse (n) {
if (n == null) {
return 0
}
var sub1 = traverse(n.left);
var sub2 = traverse(n.right);
if (sub1 !== sub2) {
correct = false;
}
if (n.isRed()) {
return sub1
} else {
return sub1 + 1
}
}
traverse(tree.root);
t.assert(correct, 'Black-height of sub-trees are equal');
}
function checkRootNodeIsBlack (t, tree) {
t.assert(tree.root == null || tree.root.isBlack(), 'root node is black');
}
test('RedBlack Tree', async function redBlackTree (t) {
let tree = new Tree();
tree.put({_id: new ID(8433, 0)});
tree.put({_id: new ID(12844, 0)});
tree.put({_id: new ID(1795, 0)});
tree.put({_id: new ID(30302, 0)});
tree.put({_id: new ID(64287)});
tree.delete(new ID(8433, 0));
tree.put({_id: new ID(28996)});
tree.delete(new ID(64287));
tree.put({_id: new ID(22721)});
checkRootNodeIsBlack(t, tree);
checkBlackHeightOfSubTreesAreEqual(t, tree);
checkRedNodesDoNotHaveBlackChildren(t, tree);
});
test(`random tests (${numberOfRBTreeTests})`, async function random (t) {
let chance = new chance_1(t.getSeed() * 1000000000);
let tree = new Tree();
let elements = [];
for (var i = 0; i < numberOfRBTreeTests; i++) {
if (chance.bool({likelihood: 80})) {
// 80% chance to insert an element
let obj = new ID(chance.integer({min: 0, max: numberOfRBTreeTests}), chance.integer({min: 0, max: 1}));
let nodeExists = tree.find(obj);
if (nodeExists === null) {
if (elements.some(e => e.equals(obj))) {
t.assert(false, 'tree and elements contain different results');
}
elements.push(obj);
tree.put({_id: obj});
}
} else if (elements.length > 0) {
// ~20% chance to delete an element
var elem = chance.pickone(elements);
elements = elements.filter(function (e) {
return !e.equals(elem)
});
tree.delete(elem);
}
}
checkRootNodeIsBlack(t, tree);
checkBlackHeightOfSubTreesAreEqual(t, tree);
checkRedNodesDoNotHaveBlackChildren(t, tree);
// TEST if all nodes exist
let allNodesExist = true;
for (let id of elements) {
let node = tree.find(id);
if (!node._id.equals(id)) {
allNodesExist = false;
}
}
t.assert(allNodesExist, 'All inserted nodes exist');
// TEST lower bound search
let findAllNodesWithLowerBoundSerach = true;
for (let id of elements) {
let node = tree.findWithLowerBound(id);
if (!node._id.equals(id)) {
findAllNodesWithLowerBoundSerach = false;
}
}
t.assert(
findAllNodesWithLowerBoundSerach,
'Find every object with lower bound search'
);
// TEST iteration (with lower bound search)
let lowerBound = chance.pickone(elements);
let expectedResults = elements.filter((e, pos) =>
(lowerBound.lessThan(e) || e.equals(lowerBound)) &&
elements.indexOf(e) === pos
).length;
let actualResults = 0;
tree.iterate(lowerBound, null, function (val) {
if (val == null) {
t.assert(false, 'val is undefined!');
}
actualResults++;
});
t.assert(
expectedResults === actualResults,
'Iterating over a tree with lower bound yields the right amount of results'
);
expectedResults = elements.filter((e, pos) =>
elements.indexOf(e) === pos
).length;
actualResults = 0;
tree.iterate(null, null, function (val) {
if (val == null) {
t.assert(false, 'val is undefined!');
}
actualResults++;
});
t.assert(
expectedResults === actualResults,
'iterating over a tree without bounds yields the right amount of results'
);
let upperBound = chance.pickone(elements);
expectedResults = elements.filter((e, pos) =>
(e.lessThan(upperBound) || e.equals(upperBound)) &&
elements.indexOf(e) === pos
).length;
actualResults = 0;
tree.iterate(null, upperBound, function (val) {
if (val == null) {
t.assert(false, 'val is undefined!');
}
actualResults++;
});
t.assert(
expectedResults === actualResults,
'iterating over a tree with upper bound yields the right amount of results'
);
upperBound = chance.pickone(elements);
lowerBound = chance.pickone(elements);
if (upperBound.lessThan(lowerBound)) {
[lowerBound, upperBound] = [upperBound, lowerBound];
}
expectedResults = elements.filter((e, pos) =>
(lowerBound.lessThan(e) || e.equals(lowerBound)) &&
(e.lessThan(upperBound) || e.equals(upperBound)) &&
elements.indexOf(e) === pos
).length;
actualResults = 0;
tree.iterate(lowerBound, upperBound, function (val) {
if (val == null) {
t.assert(false, 'val is undefined!');
}
actualResults++;
});
t.assert(
expectedResults === actualResults,
'iterating over a tree with upper bound yields the right amount of results'
);
});
class DSNode {
constructor (id, len, gc) {
this._id = id;
this.len = len;
this.gc = gc;
}
clone () {
return new DSNode(this._id, this.len, this.gc)
}
}
class DeleteStore extends Tree {
logTable () {
const deletes = [];
this.iterate(null, null, function (n) {
deletes.push({
user: n._id.user,
clock: n._id.clock,
len: n.len,
gc: n.gc
});
});
console.table(deletes);
}
isDeleted (id) {
var n = this.findWithUpperBound(id);
return n !== null && n._id.user === id.user && id.clock < n._id.clock + n.len
}
mark (id, length, gc) {
if (length === 0) return
// Step 1. Unmark range
const leftD = this.findWithUpperBound(new ID(id.user, id.clock - 1));
// Resize left DSNode if necessary
if (leftD !== null && leftD._id.user === id.user) {
if (leftD._id.clock < id.clock && id.clock < leftD._id.clock + leftD.len) {
// node is overlapping. need to resize
if (id.clock + length < leftD._id.clock + leftD.len) {
// overlaps new mark range and some more
// create another DSNode to the right of new mark
this.put(new DSNode(new ID(id.user, id.clock + length), leftD._id.clock + leftD.len - id.clock - length, leftD.gc));
}
// resize left DSNode
leftD.len = id.clock - leftD._id.clock;
} // Otherwise there is no overlapping
}
// Resize right DSNode if necessary
const upper = new ID(id.user, id.clock + length - 1);
const rightD = this.findWithUpperBound(upper);
if (rightD !== null && rightD._id.user === id.user) {
if (rightD._id.clock < id.clock + length && id.clock <= rightD._id.clock && id.clock + length < rightD._id.clock + rightD.len) { // we only consider the case where we resize the node
const d = id.clock + length - rightD._id.clock;
rightD._id = new ID(rightD._id.user, rightD._id.clock + d);
rightD.len -= d;
}
}
// Now we only have to delete all inner marks
const deleteNodeIds = [];
this.iterate(id, upper, m => {
deleteNodeIds.push(m._id);
});
for (let i = deleteNodeIds.length - 1; i >= 0; i--) {
this.delete(deleteNodeIds[i]);
}
let newMark = new DSNode(id, length, gc);
// Step 2. Check if we can extend left or right
if (leftD !== null && leftD._id.user === id.user && leftD._id.clock + leftD.len === id.clock && leftD.gc === gc) {
// We can extend left
leftD.len += length;
newMark = leftD;
}
const rightNext = this.find(new ID(id.user, id.clock + length));
if (rightNext !== null && rightNext._id.user === id.user && id.clock + length === rightNext._id.clock && gc === rightNext.gc) {
// We can merge newMark and rightNext
newMark.len += rightNext.len;
this.delete(rightNext._id);
}
if (leftD !== newMark) {
// only put if we didn't extend left
this.put(newMark);
}
}
// TODO: exchange markDeleted for mark()
markDeleted (id, length) {
this.mark(id, length, false);
}
}
/**
* A BinaryDecoder handles the decoding of an ArrayBuffer.
*/
class BinaryDecoder {
/**
* @param {Uint8Array|Buffer} buffer The binary data that this instance
* decodes.
*/
constructor (buffer) {
if (buffer instanceof ArrayBuffer) {
this.uint8arr = new Uint8Array(buffer);
} else if (
buffer instanceof Uint8Array ||
(
typeof Buffer !== 'undefined' && buffer instanceof Buffer
)
) {
this.uint8arr = buffer;
} else {
throw new Error('Expected an ArrayBuffer or Uint8Array!')
}
this.pos = 0;
}
/**
* Clone this decoder instance.
* Optionally set a new position parameter.
*/
clone (newPos = this.pos) {
let decoder = new BinaryDecoder(this.uint8arr);
decoder.pos = newPos;
return decoder
}
/**
* Number of bytes.
*/
get length () {
return this.uint8arr.length
}
/**
* Skip one byte, jump to the next position.
*/
skip8 () {
this.pos++;
}
/**
* Read one byte as unsigned integer.
*/
readUint8 () {
return this.uint8arr[this.pos++]
}
/**
* Read 4 bytes as unsigned integer.
*
* @return {number} An unsigned integer.
*/
readUint32 () {
let uint =
this.uint8arr[this.pos] +
(this.uint8arr[this.pos + 1] << 8) +
(this.uint8arr[this.pos + 2] << 16) +
(this.uint8arr[this.pos + 3] << 24);
this.pos += 4;
return uint
}
/**
* Look ahead without incrementing position.
* to the next byte and read it as unsigned integer.
*
* @return {number} An unsigned integer.
*/
peekUint8 () {
return this.uint8arr[this.pos]
}
/**
* Read unsigned integer (32bit) with variable length.
* 1/8th of the storage is used as encoding overhead.
* * numbers < 2^7 is stored in one byte.
* * numbers < 2^14 is stored in two bytes.
*
* @return {number} An unsigned integer.
*/
readVarUint () {
let num = 0;
let len = 0;
while (true) {
let r = this.uint8arr[this.pos++];
num = num | ((r & 0b1111111) << len);
len += 7;
if (r < 1 << 7) {
return num >>> 0 // return unsigned number!
}
if (len > 35) {
throw new Error('Integer out of range!')
}
}
}
/**
* Read string of variable length
* * varUint is used to store the length of the string
*
* @return {String} The read String.
*/
readVarString () {
let len = this.readVarUint();
let bytes = new Array(len);
for (let i = 0; i < len; i++) {
bytes[i] = this.uint8arr[this.pos++];
}
let encodedString = bytes.map(b => String.fromCodePoint(b)).join('');
return decodeURIComponent(escape(encodedString))
}
/**
* Look ahead and read varString without incrementing position
*/
peekVarString () {
let pos = this.pos;
let s = this.readVarString();
this.pos = pos;
return s
}
/**
* Read ID.
* * If first varUint read is 0xFFFFFF a RootID is returned.
* * Otherwise an ID is returned.
*
* @return ID
*/
readID () {
let user = this.readVarUint();
if (user === RootFakeUserID) {
// read property name and type id
const rid = new RootID(this.readVarString(), null);
rid.type = this.readVarUint();
return rid
}
return new ID(user, this.readVarUint())
}
}
// TODO should have the same base class as Item
class GC {
constructor () {
this._id = null;
this._length = 0;
}
get _deleted () {
return true
}
_integrate (y) {
const id = this._id;
const userState = y.ss.getState(id.user);
if (id.clock === userState) {
y.ss.setState(id.user, id.clock + this._length);
}
y.ds.mark(this._id, this._length, true);
let n = y.os.put(this);
const prev = n.prev().val;
if (prev !== null && prev.constructor === GC && prev._id.user === n.val._id.user && prev._id.clock + prev._length === n.val._id.clock) {
// TODO: do merging for all items!
prev._length += n.val._length;
y.os.delete(n.val._id);
n = prev;
}
if (n.val) {
n = n.val;
}
const next = y.os.findNext(n._id);
if (next !== null && next.constructor === GC && next._id.user === n._id.user && next._id.clock === n._id.clock + n._length) {
n._length += next._length;
y.os.delete(next._id);
}
if (id.user !== RootFakeUserID) {
if (y.connector !== null && (y.connector._forwardAppliedStructs || id.user === y.userID)) {
y.connector.broadcastStruct(this);
}
if (y.persistence !== null) {
y.persistence.saveStruct(y, this);
}
}
}
/**
* Transform the properties of this type to binary and write it to an
* BinaryEncoder.
*
* This is called when this Item is sent to a remote peer.
*
* @param {BinaryEncoder} encoder The encoder to write data to.
* @private
*/
_toBinary (encoder) {
encoder.writeUint8(getStructReference(this.constructor));
encoder.writeID(this._id);
encoder.writeVarUint(this._length);
}
/**
* Read the next Item in a Decoder and fill this Item with the read data.
*
* This is called when data is received from a remote peer.
*
* @param {Y} y The Yjs instance that this Item belongs to.
* @param {BinaryDecoder} decoder The decoder object to read data from.
* @private
*/
_fromBinary (y, decoder) {
const id = decoder.readID();
this._id = id;
this._length = decoder.readVarUint();
const missing = [];
if (y.ss.getState(id.user) < id.clock) {
missing.push(new ID(id.user, id.clock - 1));
}
return missing
}
_splitAt () {
return this
}
_clonePartial (diff) {
const gc = new GC();
gc._id = new ID(this._id.user, this._id.clock + diff);
gc._length = this._length - diff;
return gc
}
}
class MissingEntry {
constructor (decoder, missing, struct) {
this.decoder = decoder;
this.missing = missing.length;
this.struct = struct;
}
}
/**
* @private
* Integrate remote struct
* When a remote struct is integrated, other structs might be ready to ready to
* integrate.
*/
function _integrateRemoteStructHelper (y, struct) {
const id = struct._id;
if (id === undefined) {
struct._integrate(y);
} else {
if (y.ss.getState(id.user) > id.clock) {
return
}
if (!y.gcEnabled || struct.constructor === GC || (struct._parent.constructor !== GC && struct._parent._deleted === false)) {
// Is either a GC or Item with an undeleted parent
// save to integrate
struct._integrate(y);
} else {
// Is an Item. parent was deleted.
struct._gc(y);
}
let msu = y._missingStructs.get(id.user);
if (msu != null) {
let clock = id.clock;
const finalClock = clock + struct._length;
for (;clock < finalClock; clock++) {
const missingStructs = msu.get(clock);
if (missingStructs !== undefined) {
missingStructs.forEach(missingDef => {
missingDef.missing--;
if (missingDef.missing === 0) {
const decoder = missingDef.decoder;
let oldPos = decoder.pos;
let missing = missingDef.struct._fromBinary(y, decoder);
decoder.pos = oldPos;
if (missing.length === 0) {
y._readyToIntegrate.push(missingDef.struct);
}
}
});
msu.delete(clock);
}
}
}
}
}
function stringifyStructs (y, decoder, strBuilder) {
const len = decoder.readUint32();
for (let i = 0; i < len; i++) {
let reference = decoder.readVarUint();
let Constr = getStruct(reference);
let struct = new Constr();
let missing = struct._fromBinary(y, decoder);
let logMessage = ' ' + struct._logString();
if (missing.length > 0) {
logMessage += ' .. missing: ' + missing.map(logID).join(', ');
}
strBuilder.push(logMessage);
}
}
function integrateRemoteStructs (y, decoder) {
const len = decoder.readUint32();
for (let i = 0; i < len; i++) {
let reference = decoder.readVarUint();
let Constr = getStruct(reference);
let struct = new Constr();
let decoderPos = decoder.pos;
let missing = struct._fromBinary(y, decoder);
if (missing.length === 0) {
while (struct != null) {
_integrateRemoteStructHelper(y, struct);
struct = y._readyToIntegrate.shift();
}
} else {
let _decoder = new BinaryDecoder(decoder.uint8arr);
_decoder.pos = decoderPos;
let missingEntry = new MissingEntry(_decoder, missing, struct);
let missingStructs = y._missingStructs;
for (let i = missing.length - 1; i >= 0; i--) {
let m = missing[i];
if (!missingStructs.has(m.user)) {
missingStructs.set(m.user, new Map());
}
let msu = missingStructs.get(m.user);
if (!msu.has(m.clock)) {
msu.set(m.clock, []);
}
let mArray = msu = msu.get(m.clock);
mArray.push(missingEntry);
}
}
}
}
const bits7 = 0b1111111;
const bits8 = 0b11111111;
/**
* A BinaryEncoder handles the encoding to an ArrayBuffer.
*/
class BinaryEncoder {
constructor () {
// TODO: implement chained Uint8Array buffers instead of Array buffer
// TODO: Rewrite all methods as functions!
this.data = [];
}
/**
* The current length of the encoded data.
*/
get length () {
return this.data.length
}
/**
* The current write pointer (the same as {@link length}).
*/
get pos () {
return this.data.length
}
/**
* Create an ArrayBuffer.
*
* @return {Uint8Array} A Uint8Array that represents the written data.
*/
createBuffer () {
return Uint8Array.from(this.data).buffer
}
/**
* Write one byte as an unsigned integer.
*
* @param {number} num The number that is to be encoded.
*/
writeUint8 (num) {
this.data.push(num & bits8);
}
/**
* Write one byte as an unsigned Integer at a specific location.
*
* @param {number} pos The location where the data will be written.
* @param {number} num The number that is to be encoded.
*/
setUint8 (pos, num) {
this.data[pos] = num & bits8;
}
/**
* Write two bytes as an unsigned integer.
*
* @param {number} num The number that is to be encoded.
*/
writeUint16 (num) {
this.data.push(num & bits8, (num >>> 8) & bits8);
}
/**
* Write two bytes as an unsigned integer at a specific location.
*
* @param {number} pos The location where the data will be written.
* @param {number} num The number that is to be encoded.
*/
setUint16 (pos, num) {
this.data[pos] = num & bits8;
this.data[pos + 1] = (num >>> 8) & bits8;
}
/**
* Write two bytes as an unsigned integer
*
* @param {number} num The number that is to be encoded.
*/
writeUint32 (num) {
for (let i = 0; i < 4; i++) {
this.data.push(num & bits8);
num >>>= 8;
}
}
/**
* Write two bytes as an unsigned integer at a specific location.
*
* @param {number} pos The location where the data will be written.
* @param {number} num The number that is to be encoded.
*/
setUint32 (pos, num) {
for (let i = 0; i < 4; i++) {
this.data[pos + i] = num & bits8;
num >>>= 8;
}
}
/**
* Write a variable length unsigned integer.
*
* @param {number} num The number that is to be encoded.
*/
writeVarUint (num) {
while (num >= 0b10000000) {
this.data.push(0b10000000 | (bits7 & num));
num >>>= 7;
}
this.data.push(bits7 & num);
}
/**
* Write a variable length string.
*
* @param {String} str The string that is to be encoded.
*/
writeVarString (str) {
let encodedString = unescape(encodeURIComponent(str));
let bytes = encodedString.split('').map(c => c.codePointAt());
let len = bytes.length;
this.writeVarUint(len);
for (let i = 0; i < len; i++) {
this.data.push(bytes[i]);
}
}
/**
* Write an ID at the current position.
*
* @param {ID} id The ID that is to be written.
*/
writeID (id) {
const user = id.user;
this.writeVarUint(user);
if (user !== RootFakeUserID) {
this.writeVarUint(id.clock);
} else {
this.writeVarString(id.name);
this.writeVarUint(id.type);
}
}
}
function readStateSet (decoder) {
let ss = new Map();
let ssLength = decoder.readUint32();
for (let i = 0; i < ssLength; i++) {
let user = decoder.readVarUint();
let clock = decoder.readVarUint();
ss.set(user, clock);
}
return ss
}
function writeStateSet (y, encoder) {
let lenPosition = encoder.pos;
let len = 0;
encoder.writeUint32(0);
for (let [user, clock] of y.ss.state) {
encoder.writeVarUint(user);
encoder.writeVarUint(clock);
len++;
}
encoder.setUint32(lenPosition, len);
}
function writeDeleteSet (y, encoder) {
let currentUser = null;
let currentLength;
let lastLenPos;
let numberOfUsers = 0;
let laterDSLenPus = encoder.pos;
encoder.writeUint32(0);
y.ds.iterate(null, null, function (n) {
var user = n._id.user;
var clock = n._id.clock;
var len = n.len;
var gc = n.gc;
if (currentUser !== user) {
numberOfUsers++;
// a new user was found
if (currentUser !== null) { // happens on first iteration
encoder.setUint32(lastLenPos, currentLength);
}
currentUser = user;
encoder.writeVarUint(user);
// pseudo-fill pos
lastLenPos = encoder.pos;
encoder.writeUint32(0);
currentLength = 0;
}
encoder.writeVarUint(clock);
encoder.writeVarUint(len);
encoder.writeUint8(gc ? 1 : 0);
currentLength++;
});
if (currentUser !== null) { // happens on first iteration
encoder.setUint32(lastLenPos, currentLength);
}
encoder.setUint32(laterDSLenPus, numberOfUsers);
}
function readDeleteSet (y, decoder) {
let dsLength = decoder.readUint32();
for (let i = 0; i < dsLength; i++) {
let user = decoder.readVarUint();
let dv = [];
let dvLength = decoder.readUint32();
for (let j = 0; j < dvLength; j++) {
let from = decoder.readVarUint();
let len = decoder.readVarUint();
let gc = decoder.readUint8() === 1;
dv.push([from, len, gc]);
}
if (dvLength > 0) {
let pos = 0;
let d = dv[pos];
let deletions = [];
y.ds.iterate(new ID(user, 0), new ID(user, Number.MAX_VALUE), function (n) {
// cases:
// 1. d deletes something to the right of n
// => go to next n (break)
// 2. d deletes something to the left of n
// => create deletions
// => reset d accordingly
// *)=> if d doesn't delete anything anymore, go to next d (continue)
// 3. not 2) and d deletes something that also n deletes
// => reset d so that it doesn't contain n's deletion
// *)=> if d does not delete anything anymore, go to next d (continue)
while (d != null) {
var diff = 0; // describe the diff of length in 1) and 2)
if (n._id.clock + n.len <= d[0]) {
// 1)
break
} else if (d[0] < n._id.clock) {
// 2)
// delete maximum the len of d
// else delete as much as possible
diff = Math.min(n._id.clock - d[0], d[1]);
// deleteItemRange(y, user, d[0], diff, true)
deletions.push([user, d[0], diff]);
} else {
// 3)
diff = n._id.clock + n.len - d[0]; // never null (see 1)
if (d[2] && !n.gc) {
// d marks as gc'd but n does not
// then delete either way
// deleteItemRange(y, user, d[0], Math.min(diff, d[1]), true)
deletions.push([user, d[0], Math.min(diff, d[1])]);
}
}
if (d[1] <= diff) {
// d doesn't delete anything anymore
d = dv[++pos];
} else {
d[0] = d[0] + diff; // reset pos
d[1] = d[1] - diff; // reset length
}
}
});
// TODO: It would be more performant to apply the deletes in the above loop
// Adapt the Tree implementation to support delete while iterating
for (let i = deletions.length - 1; i >= 0; i--) {
const del = deletions[i];
deleteItemRange(y, del[0], del[1], del[2], true);
}
// for the rest.. just apply it
for (; pos < dv.length; pos++) {
d = dv[pos];
deleteItemRange(y, user, d[0], d[1], true);
// deletions.push([user, d[0], d[1], d[2]])
}
}
}
}
function stringifySyncStep1 (y, decoder, strBuilder) {
let auth = decoder.readVarString();
let protocolVersion = decoder.readVarUint();
strBuilder.push(` - auth: "${auth}"`);
strBuilder.push(` - protocolVersion: ${protocolVersion}`);
// write SS
let ssBuilder = [];
let len = decoder.readUint32();
for (let i = 0; i < len; i++) {
let user = decoder.readVarUint();
let clock = decoder.readVarUint();
ssBuilder.push(`(${user}:${clock})`);
}
strBuilder.push(' == SS: ' + ssBuilder.join(','));
}
function sendSyncStep1 (connector, syncUser) {
let encoder = new BinaryEncoder();
encoder.writeVarString(connector.y.room);
encoder.writeVarString('sync step 1');
encoder.writeVarString(connector.authInfo || '');
encoder.writeVarUint(connector.protocolVersion);
writeStateSet(connector.y, encoder);
connector.send(syncUser, encoder.createBuffer());
}
/**
* @private
* Write all Items that are not not included in ss to
* the encoder object.
*/
function writeStructs (y, encoder, ss) {
const lenPos = encoder.pos;
encoder.writeUint32(0);
let len = 0;
for (let user of y.ss.state.keys()) {
let clock = ss.get(user) || 0;
if (user !== RootFakeUserID) {
const minBound = new ID(user, clock);
const overlappingLeft = y.os.findPrev(minBound);
const rightID = overlappingLeft === null ? null : overlappingLeft._id;
if (rightID !== null && rightID.user === user && rightID.clock + overlappingLeft._length > clock) {
const struct = overlappingLeft._clonePartial(clock - rightID.clock);
struct._toBinary(encoder);
len++;
}
y.os.iterate(minBound, new ID(user, Number.MAX_VALUE), function (struct) {
struct._toBinary(encoder);
len++;
});
}
}
encoder.setUint32(lenPos, len);
}
function readSyncStep1 (decoder, encoder, y, senderConn, sender) {
let protocolVersion = decoder.readVarUint();
// check protocol version
if (protocolVersion !== y.connector.protocolVersion) {
console.warn(
`You tried to sync with a Yjs instance that has a different protocol version
(You: ${protocolVersion}, Client: ${protocolVersion}).
`);
y.destroy();
}
// write sync step 2
encoder.writeVarString('sync step 2');
encoder.writeVarString(y.connector.authInfo || '');
const ss = readStateSet(decoder);
writeStructs(y, encoder, ss);
writeDeleteSet(y, encoder);
y.connector.send(senderConn.uid, encoder.createBuffer());
senderConn.receivedSyncStep2 = true;
if (y.connector.role === 'slave') {
sendSyncStep1(y.connector, sender);
}
}
function stringifySyncStep2 (y, decoder, strBuilder) {
strBuilder.push(' - auth: ' + decoder.readVarString());
strBuilder.push(' == OS:');
stringifyStructs(y, decoder, strBuilder);
// write DS to string
strBuilder.push(' == DS:');
let len = decoder.readUint32();
for (let i = 0; i < len; i++) {
let user = decoder.readVarUint();
strBuilder.push(` User: ${user}: `);
let len2 = decoder.readUint32();
for (let j = 0; j < len2; j++) {
let from = decoder.readVarUint();
let to = decoder.readVarUint();
let gc = decoder.readUint8() === 1;
strBuilder.push(`[${from}, ${to}, ${gc}]`);
}
}
}
function readSyncStep2 (decoder, encoder, y, senderConn, sender) {
integrateRemoteStructs(y, decoder);
readDeleteSet(y, decoder);
y.connector._setSyncedWith(sender);
}
function messageToString ([y, buffer]) {
let decoder = new BinaryDecoder(buffer);
decoder.readVarString(); // read roomname
let type = decoder.readVarString();
let strBuilder = [];
strBuilder.push('\n === ' + type + ' ===');
if (type === 'update') {
stringifyStructs(y, decoder, strBuilder);
} else if (type === 'sync step 1') {
stringifySyncStep1(y, decoder, strBuilder);
} else if (type === 'sync step 2') {
stringifySyncStep2(y, decoder, strBuilder);
} else {
strBuilder.push('-- Unknown message type - probably an encoding issue!!!');
}
return strBuilder.join('\n')
}
function messageToRoomname (buffer) {
let decoder = new BinaryDecoder(buffer);
decoder.readVarString(); // roomname
return decoder.readVarString() // messageType
}
function logID (id) {
if (id !== null && id._id != null) {
id = id._id;
}
if (id === null) {
return '()'
} else if (id instanceof ID) {
return `(${id.user},${id.clock})`
} else if (id instanceof RootID) {
return `(${id.name},${id.type})`
} else if (id.constructor === Y$1) {
return `y`
} else {
throw new Error('This is not a valid ID!')
}
}
/**
* Helper utility to convert an item to a readable format.
*
* @param {String} name The name of the item class (YText, ItemString, ..).
* @param {Item} item The item instance.
* @param {String} [append] Additional information to append to the returned
* string.
* @return {String} A readable string that represents the item object.
*
* @private
*/
function logItemHelper (name, item, append) {
const left = item._left !== null ? item._left._lastId : null;
const origin = item._origin !== null ? item._origin._lastId : null;
return `${name}(id:${logID(item._id)},start:${logID(item._start)},left:${logID(left)},origin:${logID(origin)},right:${logID(item._right)},parent:${logID(item._parent)},parentSub:${item._parentSub}${append !== undefined ? ' - ' + append : ''})`
}
/**
* @private
* Delete all items in an ID-range
* TODO: implement getItemCleanStartNode for better performance (only one lookup)
*/
function deleteItemRange (y, user, clock, range, gcChildren) {
const createDelete = y.connector !== null && y.connector._forwardAppliedStructs;
let item = y.os.getItemCleanStart(new ID(user, clock));
if (item !== null) {
if (!item._deleted) {
item._splitAt(y, range);
item._delete(y, createDelete, true);
}
let itemLen = item._length;
range -= itemLen;
clock += itemLen;
if (range > 0) {
let node = y.os.findNode(new ID(user, clock));
while (node !== null && node.val !== null && range > 0 && node.val._id.equals(new ID(user, clock))) {
const nodeVal = node.val;
if (!nodeVal._deleted) {
nodeVal._splitAt(y, range);
nodeVal._delete(y, createDelete, gcChildren);
}
const nodeLen = nodeVal._length;
range -= nodeLen;
clock += nodeLen;
node = node.next();
}
}
}
}
/**
* @private
* A Delete change is not a real Item, but it provides the same interface as an
* Item. The only difference is that it will not be saved in the ItemStore
* (OperationStore), but instead it is safed in the DeleteStore.
*/
class Delete {
constructor () {
this._target = null;
this._length = null;
}
/**
* @private
* Read the next Item in a Decoder and fill this Item with the read data.
*
* This is called when data is received from a remote peer.
*
* @param {Y} y The Yjs instance that this Item belongs to.
* @param {BinaryDecoder} decoder The decoder object to read data from.
*/
_fromBinary (y, decoder) {
// TODO: set target, and add it to missing if not found
// There is an edge case in p2p networks!
const targetID = decoder.readID();
this._targetID = targetID;
this._length = decoder.readVarUint();
if (y.os.getItem(targetID) === null) {
return [targetID]
} else {
return []
}
}
/**
* @private
* Transform the properties of this type to binary and write it to an
* BinaryEncoder.
*
* This is called when this Item is sent to a remote peer.
*
* @param {BinaryEncoder} encoder The encoder to write data to.
*/
_toBinary (encoder) {
encoder.writeUint8(getStructReference(this.constructor));
encoder.writeID(this._targetID);
encoder.writeVarUint(this._length);
}
/**
* @private
* Integrates this Item into the shared structure.
*
* This method actually applies the change to the Yjs instance. In the case of
* Delete it marks the delete target as deleted.
*
* * If created remotely (a remote user deleted something),
* this Delete is applied to all structs in id-range.
* * If created lokally (e.g. when y-array deletes a range of elements),
* this struct is broadcasted only (it is already executed)
*/
_integrate (y, locallyCreated = false) {
if (!locallyCreated) {
// from remote
const id = this._targetID;
deleteItemRange(y, id.user, id.clock, this._length, false);
} else if (y.connector !== null) {
// from local
y.connector.broadcastStruct(this);
}
if (y.persistence !== null) {
y.persistence.saveStruct(y, this);
}
}
/**
* Transform this YXml Type to a readable format.
* Useful for logging as all Items and Delete implement this method.
*
* @private
*/
_logString () {
return `Delete - target: ${logID(this._targetID)}, len: ${this._length}`
}
}
/**
* A transaction is created for every change on the Yjs model. It is possible
* to bundle changes on the Yjs model in a single transaction to
* minimize the number on messages sent and the number of observer calls.
* If possible the user of this library should bundle as many changes as
* possible. Here is an example to illustrate the advantages of bundling:
*
* @example
* const map = y.define('map', YMap)
* // Log content when change is triggered
* map.observe(function () {
* console.log('change triggered')
* })
* // Each change on the map type triggers a log message:
* map.set('a', 0) // => "change triggered"
* map.set('b', 0) // => "change triggered"
* // When put in a transaction, it will trigger the log after the transaction:
* y.transact(function () {
* map.set('a', 1)
* map.set('b', 1)
* }) // => "change triggered"
*
*/
class Transaction {
constructor (y) {
/**
* @type {Y} The Yjs instance.
*/
this.y = y;
/**
* All new types that are added during a transaction.
* @type {Set<Item>}
*/
this.newTypes = new Set();
/**
* All types that were directly modified (property added or child
* inserted/deleted). New types are not included in this Set.
* Maps from type to parentSubs (`item._parentSub = null` for YArray)
* @type {Set<YType,String>}
*/
this.changedTypes = new Map();
// TODO: rename deletedTypes
/**
* Set of all deleted Types and Structs.
* @type {Set<Item>}
*/
this.deletedStructs = new Set();
/**
* Saves the old state set of the Yjs instance. If a state was modified,
* the original value is saved here.
* @type {Map<Number,Number>}
*/
this.beforeState = new Map();
/**
* Stores the events for the types that observe also child elements.
* It is mainly used by `observeDeep`.
* @type {Map<YType,Array<YEvent>>}
*/
this.changedParentTypes = new Map();
}
}
/**
* @private
*/
function transactionTypeChanged (y, type, sub) {
if (type !== y && !type._deleted && !y._transaction.newTypes.has(type)) {
const changedTypes = y._transaction.changedTypes;
let subs = changedTypes.get(type);
if (subs === undefined) {
// create if it doesn't exist yet
subs = new Set();
changedTypes.set(type, subs);
}
subs.add(sub);
}
}
/**
* @private
* Helper utility to split an Item (see {@link Item#_splitAt})
* - copies all properties from a to b
* - connects a to b
* - assigns the correct _id
* - saves b to os
*/
function splitHelper (y, a, b, diff) {
const aID = a._id;
b._id = new ID(aID.user, aID.clock + diff);
b._origin = a;
b._left = a;
b._right = a._right;
if (b._right !== null) {
b._right._left = b;
}
b._right_origin = a._right_origin;
// do not set a._right_origin, as this will lead to problems when syncing
a._right = b;
b._parent = a._parent;
b._parentSub = a._parentSub;
b._deleted = a._deleted;
// now search all relevant items to the right and update origin
// if origin is not it foundOrigins, we don't have to search any longer
let foundOrigins = new Set();
foundOrigins.add(a);
let o = b._right;
while (o !== null && foundOrigins.has(o._origin)) {
if (o._origin === a) {
o._origin = b;
}
foundOrigins.add(o);
o = o._right;
}
y.os.put(b);
if (y._transaction.newTypes.has(a)) {
y._transaction.newTypes.add(b);
} else if (y._transaction.deletedStructs.has(a)) {
y._transaction.deletedStructs.add(b);
}
}
/**
* Abstract class that represents any content.
*/
class Item {
constructor () {
/**
* The uniqe identifier of this type.
* @type {ID}
*/
this._id = null;
/**
* The item that was originally to the left of this item.
* @type {Item}
*/
this._origin = null;
/**
* The item that is currently to the left of this item.
* @type {Item}
*/
this._left = null;
/**
* The item that is currently to the right of this item.
* @type {Item}
*/
this._right = null;
/**
* The item that was originally to the right of this item.
* @type {Item}
*/
this._right_origin = null;
/**
* The parent type.
* @type {Y|YType}
*/
this._parent = null;
/**
* If the parent refers to this item with some kind of key (e.g. YMap, the
* key is specified here. The key is then used to refer to the list in which
* to insert this item. If `parentSub = null` type._start is the list in
* which to insert to. Otherwise it is `parent._start`.
* @type {String}
*/
this._parentSub = null;
/**
* Whether this item was deleted or not.
* @type {Boolean}
*/
this._deleted = false;
/**
* If this type's effect is reundone this type refers to the type that undid
* this operation.
* @type {Item}
*/
this._redone = null;
}
/**
* Creates an Item with the same effect as this Item (without position effect)
*
* @private
*/
_copy () {
return new this.constructor()
}
/**
* Redoes the effect of this operation.
*
* @param {Y} y The Yjs instance.
*
* @private
*/
_redo (y) {
if (this._redone !== null) {
return this._redone
}
let struct = this._copy();
let left = this._left;
let right = this;
let parent = this._parent;
// make sure that parent is redone
if (parent._deleted === true && parent._redone === null) {
parent._redo(y);
}
if (parent._redone !== null) {
parent = parent._redone;
// find next cloned items
while (left !== null) {
if (left._redone !== null && left._redone._parent === parent) {
left = left._redone;
break
}
left = left._left;
}
while (right !== null) {
if (right._redone !== null && right._redone._parent === parent) {
right = right._redone;
}
right = right._right;
}
}
struct._origin = left;
struct._left = left;
struct._right = right;
struct._right_origin = right;
struct._parent = parent;
struct._parentSub = this._parentSub;
struct._integrate(y);
this._redone = struct;
return struct
}
/**
* Computes the last content address of this Item.
*
* @private
*/
get _lastId () {
return new ID(this._id.user, this._id.clock + this._length - 1)
}
/**
* Computes the length of this Item.
*
* @private
*/
get _length () {
return 1
}
/**
* Should return false if this Item is some kind of meta information
* (e.g. format information).
*
* * Whether this Item should be addressable via `yarray.get(i)`
* * Whether this Item should be counted when computing yarray.length
*
* @private
*/
get _countable () {
return true
}
/**
* Splits this Item so that another Items can be inserted in-between.
* This must be overwritten if _length > 1
* Returns right part after split
* * diff === 0 => this
* * diff === length => this._right
* * otherwise => split _content and return right part of split
* (see {@link ItemJSON}/{@link ItemString} for implementation)
*
* @private
*/
_splitAt (y, diff) {
if (diff === 0) {
return this
}
return this._right
}
/**
* Mark this Item as deleted.
*
* @param {Y} y The Yjs instance
* @param {boolean} createDelete Whether to propagate a message that this
* Type was deleted.
*
* @private
*/
_delete (y, createDelete = true) {
if (!this._deleted) {
this._deleted = true;
y.ds.mark(this._id, this._length, false);
let del = new Delete();
del._targetID = this._id;
del._length = this._length;
if (createDelete) {
// broadcast and persists Delete
del._integrate(y, true);
} else if (y.persistence !== null) {
// only persist Delete
y.persistence.saveStruct(y, del);
}
transactionTypeChanged(y, this._parent, this._parentSub);
y._transaction.deletedStructs.add(this);
}
}
_gcChildren (y) {}
_gc (y) {
const gc = new GC();
gc._id = this._id;
gc._length = this._length;
y.os.delete(this._id);
gc._integrate(y);
}
/**
* This is called right before this Item receives any children.
* It can be overwritten to apply pending changes before applying remote changes
*
* @private
*/
_beforeChange () {
// nop
}
/**
* Integrates this Item into the shared structure.
*
* This method actually applies the change to the Yjs instance. In case of
* Item it connects _left and _right to this Item and calls the
* {@link Item#beforeChange} method.
*
* * Integrate the struct so that other types/structs can see it
* * Add this struct to y.os
* * Check if this is struct deleted
*
* @private
*/
_integrate (y) {
y._transaction.newTypes.add(this);
const parent = this._parent;
const selfID = this._id;
const user = selfID === null ? y.userID : selfID.user;
const userState = y.ss.getState(user);
if (selfID === null) {
this._id = y.ss.getNextID(this._length);
} else if (selfID.user === RootFakeUserID) {
// nop
} else if (selfID.clock < userState) {
// already applied..
return []
} else if (selfID.clock === userState) {
y.ss.setState(selfID.user, userState + this._length);
} else {
// missing content from user
throw new Error('Can not apply yet!')
}
if (!parent._deleted && !y._transaction.changedTypes.has(parent) && !y._transaction.newTypes.has(parent)) {
// this is the first time parent is updated
// or this types is new
this._parent._beforeChange();
}
/*
# $this has to find a unique position between origin and the next known character
# case 1: $origin equals $o.origin: the $creator parameter decides if left or right
# let $OL= [o1,o2,o3,o4], whereby $this is to be inserted between o1 and o4
# o2,o3 and o4 origin is 1 (the position of o2)
# there is the case that $this.creator < o2.creator, but o3.creator < $this.creator
# then o2 knows o3. Since on another client $OL could be [o1,o3,o4] the problem is complex
# therefore $this would be always to the right of o3
# case 2: $origin < $o.origin
# if current $this insert_position > $o origin: $this ins
# else $insert_position will not change
# (maybe we encounter case 1 later, then this will be to the right of $o)
# case 3: $origin > $o.origin
# $this insert_position is to the left of $o (forever!)
*/
// handle conflicts
let o;
// set o to the first conflicting item
if (this._left !== null) {
o = this._left._right;
} else if (this._parentSub !== null) {
o = this._parent._map.get(this._parentSub) || null;
} else {
o = this._parent._start;
}
let conflictingItems = new Set();
let itemsBeforeOrigin = new Set();
// Let c in conflictingItems, b in itemsBeforeOrigin
// ***{origin}bbbb{this}{c,b}{c,b}{o}***
// Note that conflictingItems is a subset of itemsBeforeOrigin
while (o !== null && o !== this._right) {
itemsBeforeOrigin.add(o);
conflictingItems.add(o);
if (this._origin === o._origin) {
// case 1
if (o._id.user < this._id.user) {
this._left = o;
conflictingItems.clear();
}
} else if (itemsBeforeOrigin.has(o._origin)) {
// case 2
if (!conflictingItems.has(o._origin)) {
this._left = o;
conflictingItems.clear();
}
} else {
break
}
// TODO: try to use right_origin instead.
// Then you could basically omit conflictingItems!
// Note: you probably can't use right_origin in every case.. only when setting _left
o = o._right;
}
// reconnect left/right + update parent map/start if necessary
const parentSub = this._parentSub;
if (this._left === null) {
let right;
if (parentSub !== null) {
const pmap = parent._map;
right = pmap.get(parentSub) || null;
pmap.set(parentSub, this);
} else {
right = parent._start;
parent._start = this;
}
this._right = right;
if (right !== null) {
right._left = this;
}
} else {
const left = this._left;
const right = left._right;
this._right = right;
left._right = this;
if (right !== null) {
right._left = this;
}
}
if (parent._deleted) {
this._delete(y, false);
}
y.os.put(this);
transactionTypeChanged(y, parent, parentSub);
if (this._id.user !== RootFakeUserID) {
if (y.connector !== null && (y.connector._forwardAppliedStructs || this._id.user === y.userID)) {
y.connector.broadcastStruct(this);
}
if (y.persistence !== null) {
y.persistence.saveStruct(y, this);
}
}
}
/**
* Transform the properties of this type to binary and write it to an
* BinaryEncoder.
*
* This is called when this Item is sent to a remote peer.
*
* @param {BinaryEncoder} encoder The encoder to write data to.
*
* @private
*/
_toBinary (encoder) {
encoder.writeUint8(getStructReference(this.constructor));
let info = 0;
if (this._origin !== null) {
info += 0b1; // origin is defined
}
// TODO: remove
/* no longer send _left
if (this._left !== this._origin) {
info += 0b10 // do not copy origin to left
}
*/
if (this._right_origin !== null) {
info += 0b100;
}
if (this._parentSub !== null) {
info += 0b1000;
}
encoder.writeUint8(info);
encoder.writeID(this._id);
if (info & 0b1) {
encoder.writeID(this._origin._lastId);
}
// TODO: remove
/* see above
if (info & 0b10) {
encoder.writeID(this._left._lastId)
}
*/
if (info & 0b100) {
encoder.writeID(this._right_origin._id);
}
if ((info & 0b101) === 0) {
// neither origin nor right is defined
encoder.writeID(this._parent._id);
}
if (info & 0b1000) {
encoder.writeVarString(JSON.stringify(this._parentSub));
}
}
/**
* Read the next Item in a Decoder and fill this Item with the read data.
*
* This is called when data is received from a remote peer.
*
* @param {Y} y The Yjs instance that this Item belongs to.
* @param {BinaryDecoder} decoder The decoder object to read data from.
*
* @private
*/
_fromBinary (y, decoder) {
let missing = [];
const info = decoder.readUint8();
const id = decoder.readID();
this._id = id;
// read origin
if (info & 0b1) {
// origin != null
const originID = decoder.readID();
// we have to query for left again because it might have been split/merged..
const origin = y.os.getItemCleanEnd(originID);
if (origin === null) {
missing.push(originID);
} else {
this._origin = origin;
this._left = this._origin;
}
}
// read right
if (info & 0b100) {
// right != null
const rightID = decoder.readID();
// we have to query for right again because it might have been split/merged..
const right = y.os.getItemCleanStart(rightID);
if (right === null) {
missing.push(rightID);
} else {
this._right = right;
this._right_origin = right;
}
}
// read parent
if ((info & 0b101) === 0) {
// neither origin nor right is defined
const parentID = decoder.readID();
// parent does not change, so we don't have to search for it again
if (this._parent === null) {
let parent;
if (parentID.constructor === RootID) {
parent = y.os.get(parentID);
} else {
parent = y.os.getItem(parentID);
}
if (parent === null) {
missing.push(parentID);
} else {
this._parent = parent;
}
}
} else if (this._parent === null) {
if (this._origin !== null) {
if (this._origin.constructor === GC) {
// if origin is a gc, set parent also gc'd
this._parent = this._origin;
} else {
this._parent = this._origin._parent;
}
} else if (this._right_origin !== null) {
// if origin is a gc, set parent also gc'd
if (this._right_origin.constructor === GC) {
this._parent = this._right_origin;
} else {
this._parent = this._right_origin._parent;
}
}
}
if (info & 0b1000) {
// TODO: maybe put this in read parent condition (you can also read parentsub from left/right)
this._parentSub = JSON.parse(decoder.readVarString());
}
if (y.ss.getState(id.user) < id.clock) {
missing.push(new ID(id.user, id.clock - 1));
}
return missing
}
}
/**
* General event handler implementation.
*/
class EventHandler {
constructor () {
this.eventListeners = [];
}
/**
* To prevent memory leaks, call this method when the eventListeners won't be
* used anymore.
*/
destroy () {
this.eventListeners = null;
}
/**
* Adds an event listener that is called when
* {@link EventHandler#callEventListeners} is called.
*
* @param {Function} f The event handler.
*/
addEventListener (f) {
this.eventListeners.push(f);
}
/**
* Removes an event listener.
*
* @param {Function} f The event handler that was added with
* {@link EventHandler#addEventListener}
*/
removeEventListener (f) {
this.eventListeners = this.eventListeners.filter(function (g) {
return f !== g
});
}
/**
* Removes all event listeners.
*/
removeAllEventListeners () {
this.eventListeners = [];
}
/**
* Call all event listeners that were added via
* {@link EventHandler#addEventListener}.
*
* @param {Transaction} transaction The transaction object // TODO: do we need this?
* @param {YEvent} event An event object that describes the change on a type.
*/
callEventListeners (transaction, event) {
for (var i = 0; i < this.eventListeners.length; i++) {
try {
const f = this.eventListeners[i];
f(event);
} catch (e) {
/*
Your observer threw an error. This error was caught so that Yjs
can ensure data consistency! In order to debug this error you
have to check "Pause On Caught Exceptions" in developer tools.
*/
console.error(e);
}
}
}
}
// restructure children as if they were inserted one after another
function integrateChildren (y, start) {
let right;
do {
right = start._right;
start._right = null;
start._right_origin = null;
start._origin = start._left;
start._integrate(y);
start = right;
} while (right !== null)
}
function gcChildren (y, item) {
while (item !== null) {
item._delete(y, false, true);
item._gc(y);
item = item._right;
}
}
/**
* Abstract Yjs Type class
*/
class Type extends Item {
constructor () {
super();
this._map = new Map();
this._start = null;
this._y = null;
this._eventHandler = new EventHandler();
this._deepEventHandler = new EventHandler();
}
/**
* Compute the path from this type to the specified target.
*
* @example
* It should be accessible via `this.get(result[0]).get(result[1])..`
* const path = type.getPathTo(child)
* // assuming `type instanceof YArray`
* console.log(path) // might look like => [2, 'key1']
* child === type.get(path[0]).get(path[1])
*
* @param {YType} type Type target
* @return {Array<string>} Path to the target
*/
getPathTo (type) {
if (type === this) {
return []
}
const path = [];
const y = this._y;
while (type !== this && type !== y) {
let parent = type._parent;
if (type._parentSub !== null) {
path.unshift(type._parentSub);
} else {
// parent is array-ish
for (let [i, child] of parent) {
if (child === type) {
path.unshift(i);
break
}
}
}
type = parent;
}
if (type !== this) {
throw new Error('The type is not a child of this node')
}
return path
}
/**
* @private
* Call event listeners with an event. This will also add an event to all
* parents (for `.observeDeep` handlers).
*/
_callEventHandler (transaction, event) {
const changedParentTypes = transaction.changedParentTypes;
this._eventHandler.callEventListeners(transaction, event);
let type = this;
while (type !== this._y) {
let events = changedParentTypes.get(type);
if (events === undefined) {
events = [];
changedParentTypes.set(type, events);
}
events.push(event);
type = type._parent;
}
}
/**
* @private
* Helper method to transact if the y instance is available.
*
* TODO: Currently event handlers are not thrown when a type is not registered
* with a Yjs instance.
*/
_transact (f) {
const y = this._y;
if (y !== null) {
y.transact(f);
} else {
f(y);
}
}
/**
* Observe all events that are created on this type.
*
* @param {Function} f Observer function
*/
observe (f) {
this._eventHandler.addEventListener(f);
}
/**
* Observe all events that are created by this type and its children.
*
* @param {Function} f Observer function
*/
observeDeep (f) {
this._deepEventHandler.addEventListener(f);
}
/**
* Unregister an observer function.
*
* @param {Function} f Observer function
*/
unobserve (f) {
this._eventHandler.removeEventListener(f);
}
/**
* Unregister an observer function.
*
* @param {Function} f Observer function
*/
unobserveDeep (f) {
this._deepEventHandler.removeEventListener(f);
}
/**
* @private
* Integrate this type into the Yjs instance.
*
* * Save this struct in the os
* * This type is sent to other client
* * Observer functions are fired
*
* @param {Y} y The Yjs instance
*/
_integrate (y) {
super._integrate(y);
this._y = y;
// when integrating children we must make sure to
// integrate start
const start = this._start;
if (start !== null) {
this._start = null;
integrateChildren(y, start);
}
// integrate map children
const map = this._map;
this._map = new Map();
for (let t of map.values()) {
// TODO make sure that right elements are deleted!
integrateChildren(y, t);
}
}
_gcChildren (y) {
gcChildren(y, this._start);
this._start = null;
this._map.forEach(item => {
gcChildren(y, item);
});
this._map = new Map();
}
_gc (y) {
this._gcChildren(y);
super._gc(y);
}
/**
* @private
* Mark this Item as deleted.
*
* @param {Y} y The Yjs instance
* @param {boolean} createDelete Whether to propagate a message that this
* Type was deleted.
* @param {boolean} [gcChildren=y._hasUndoManager===false] Whether to garbage
* collect the children of this type.
*/
_delete (y, createDelete, gcChildren) {
if (gcChildren === undefined || !y.gcEnabled) {
gcChildren = y._hasUndoManager === false && y.gcEnabled;
}
super._delete(y, createDelete, gcChildren);
y._transaction.changedTypes.delete(this);
// delete map types
for (let value of this._map.values()) {
if (value instanceof Item && !value._deleted) {
value._delete(y, false, gcChildren);
}
}
// delete array types
let t = this._start;
while (t !== null) {
if (!t._deleted) {
t._delete(y, false, gcChildren);
}
t = t._right;
}
if (gcChildren) {
this._gcChildren(y);
}
}
}
class ItemJSON extends Item {
constructor () {
super();
this._content = null;
}
_copy () {
let struct = super._copy();
struct._content = this._content;
return struct
}
get _length () {
return this._content.length
}
_fromBinary (y, decoder) {
let missing = super._fromBinary(y, decoder);
let len = decoder.readVarUint();
this._content = new Array(len);
for (let i = 0; i < len; i++) {
const ctnt = decoder.readVarString();
let parsed;
if (ctnt === 'undefined') {
parsed = undefined;
} else {
parsed = JSON.parse(ctnt);
}
this._content[i] = parsed;
}
return missing
}
_toBinary (encoder) {
super._toBinary(encoder);
let len = this._content.length;
encoder.writeVarUint(len);
for (let i = 0; i < len; i++) {
let encoded;
let content = this._content[i];
if (content === undefined) {
encoded = 'undefined';
} else {
encoded = JSON.stringify(content);
}
encoder.writeVarString(encoded);
}
}
/**
* Transform this YXml Type to a readable format.
* Useful for logging as all Items and Delete implement this method.
*
* @private
*/
_logString () {
return logItemHelper('ItemJSON', this, `content:${JSON.stringify(this._content)}`)
}
_splitAt (y, diff) {
if (diff === 0) {
return this
} else if (diff >= this._length) {
return this._right
}
let item = new ItemJSON();
item._content = this._content.splice(diff);
splitHelper(y, this, item, diff);
return item
}
}
class ItemString extends Item {
constructor () {
super();
this._content = null;
}
_copy () {
let struct = super._copy();
struct._content = this._content;
return struct
}
get _length () {
return this._content.length
}
_fromBinary (y, decoder) {
let missing = super._fromBinary(y, decoder);
this._content = decoder.readVarString();
return missing
}
_toBinary (encoder) {
super._toBinary(encoder);
encoder.writeVarString(this._content);
}
/**
* Transform this YXml Type to a readable format.
* Useful for logging as all Items and Delete implement this method.
*
* @private
*/
_logString () {
return logItemHelper('ItemString', this, `content:"${this._content}"`)
}
_splitAt (y, diff) {
if (diff === 0) {
return this
} else if (diff >= this._length) {
return this._right
}
let item = new ItemString();
item._content = this._content.slice(diff);
this._content = this._content.slice(0, diff);
splitHelper(y, this, item, diff);
return item
}
}
/**
* YEvent describes the changes on a YType.
*/
class YEvent {
/**
* @param {YType} target The changed type.
*/
constructor (target) {
/**
* The type on which this event was created on.
* @type {YType}
*/
this.target = target;
/**
* The current target on which the observe callback is called.
* @type {YType}
*/
this.currentTarget = target;
}
/**
* Computes the path from `y` to the changed type.
*
* The following property holds:
* @example
* let type = y
* event.path.forEach(function (dir) {
* type = type.get(dir)
* })
* type === event.target // => true
*/
get path () {
return this.currentTarget.getPathTo(this.target)
}
}
/**
* Event that describes the changes on a YArray
*
* @param {YArray} yarray The changed type
* @param {Boolean} remote Whether the changed was caused by a remote peer
* @param {Transaction} transaction The transaction object
*/
class YArrayEvent extends YEvent {
constructor (yarray, remote, transaction) {
super(yarray);
this.remote = remote;
this._transaction = transaction;
this._addedElements = null;
this._removedElements = null;
}
/**
* Child elements that were added in this transaction.
*
* @return {Set}
*/
get addedElements () {
if (this._addedElements === null) {
const target = this.target;
const transaction = this._transaction;
const addedElements = new Set();
transaction.newTypes.forEach(function (type) {
if (type._parent === target && !transaction.deletedStructs.has(type)) {
addedElements.add(type);
}
});
this._addedElements = addedElements;
}
return this._addedElements
}
/**
* Child elements that were removed in this transaction.
*
* @return {Set}
*/
get removedElements () {
if (this._removedElements === null) {
const target = this.target;
const transaction = this._transaction;
const removedElements = new Set();
transaction.deletedStructs.forEach(function (struct) {
if (struct._parent === target && !transaction.newTypes.has(struct)) {
removedElements.add(struct);
}
});
this._removedElements = removedElements;
}
return this._removedElements
}
}
/**
* A shared Array implementation.
*/
class YArray extends Type {
/**
* @private
* Creates YArray Event and calls observers.
*/
_callObserver (transaction, parentSubs, remote) {
this._callEventHandler(transaction, new YArrayEvent(this, remote, transaction));
}
/**
* Returns the i-th element from a YArray.
*
* @param {Integer} index The index of the element to return from the YArray
*/
get (index) {
let n = this._start;
while (n !== null) {
if (!n._deleted && n._countable) {
if (index < n._length) {
if (n.constructor === ItemJSON || n.constructor === ItemString) {
return n._content[index]
} else {
return n
}
}
index -= n._length;
}
n = n._right;
}
}
/**
* Transforms this YArray to a JavaScript Array.
*
* @return {Array}
*/
toArray () {
return this.map(c => c)
}
/**
* Transforms this Shared Type to a JSON object.
*
* @return {Array}
*/
toJSON () {
return this.map(c => {
if (c instanceof Type) {
if (c.toJSON !== null) {
return c.toJSON()
} else {
return c.toString()
}
}
return c
})
}
/**
* Returns an Array with the result of calling a provided function on every
* element of this YArray.
*
* @param {Function} f Function that produces an element of the new Array
* @return {Array} A new array with each element being the result of the
* callback function
*/
map (f) {
const res = [];
this.forEach((c, i) => {
res.push(f(c, i, this));
});
return res
}
/**
* Executes a provided function on once on overy element of this YArray.
*
* @param {Function} f A function to execute on every element of this YArray.
*/
forEach (f) {
let index = 0;
let n = this._start;
while (n !== null) {
if (!n._deleted && n._countable) {
if (n instanceof Type) {
f(n, index++, this);
} else {
const content = n._content;
const contentLen = content.length;
for (let i = 0; i < contentLen; i++) {
index++;
f(content[i], index, this);
}
}
}
n = n._right;
}
}
/**
* Computes the length of this YArray.
*/
get length () {
let length = 0;
let n = this._start;
while (n !== null) {
if (!n._deleted && n._countable) {
length += n._length;
}
n = n._right;
}
return length
}
[Symbol.iterator] () {
return {
next: function () {
while (this._item !== null && (this._item._deleted || this._item._length <= this._itemElement)) {
// item is deleted or itemElement does not exist (is deleted)
this._item = this._item._right;
this._itemElement = 0;
}
if (this._item === null) {
return {
done: true
}
}
let content;
if (this._item instanceof Type) {
content = this._item;
} else {
content = this._item._content[this._itemElement++];
}
return {
value: content,
done: false
}
},
_item: this._start,
_itemElement: 0,
_count: 0
}
}
/**
* Deletes elements starting from an index.
*
* @param {Integer} index Index at which to start deleting elements
* @param {Integer} length The number of elements to remove. Defaults to 1.
*/
delete (index, length = 1) {
this._y.transact(() => {
let item = this._start;
let count = 0;
while (item !== null && length > 0) {
if (!item._deleted && item._countable) {
if (count <= index && index < count + item._length) {
const diffDel = index - count;
item = item._splitAt(this._y, diffDel);
item._splitAt(this._y, length);
length -= item._length;
item._delete(this._y);
count += diffDel;
} else {
count += item._length;
}
}
item = item._right;
}
});
if (length > 0) {
throw new Error('Delete exceeds the range of the YArray')
}
}
/**
* @private
* Inserts content after an element container.
*
* @param {Item} left The element container to use as a reference.
* @param {Array} content The Array of content to insert (see {@see insert})
*/
insertAfter (left, content) {
this._transact(y => {
let right;
if (left === null) {
right = this._start;
} else {
right = left._right;
}
let prevJsonIns = null;
for (let i = 0; i < content.length; i++) {
let c = content[i];
if (typeof c === 'function') {
c = new c(); // eslint-disable-line new-cap
}
if (c instanceof Type) {
if (prevJsonIns !== null) {
if (y !== null) {
prevJsonIns._integrate(y);
}
left = prevJsonIns;
prevJsonIns = null;
}
c._origin = left;
c._left = left;
c._right = right;
c._right_origin = right;
c._parent = this;
if (y !== null) {
c._integrate(y);
} else if (left === null) {
this._start = c;
} else {
left._right = c;
}
left = c;
} else {
if (prevJsonIns === null) {
prevJsonIns = new ItemJSON();
prevJsonIns._origin = left;
prevJsonIns._left = left;
prevJsonIns._right = right;
prevJsonIns._right_origin = right;
prevJsonIns._parent = this;
prevJsonIns._content = [];
}
prevJsonIns._content.push(c);
}
}
if (prevJsonIns !== null) {
if (y !== null) {
prevJsonIns._integrate(y);
} else if (prevJsonIns._left === null) {
this._start = prevJsonIns;
}
}
});
return content
}
/**
* Inserts new content at an index.
*
* Important: This function expects an array of content. Not just a content
* object. The reason for this "weirdness" is that inserting several elements
* is very efficient when it is done as a single operation.
*
* @example
* // Insert character 'a' at position 0
* yarray.insert(0, ['a'])
* // Insert numbers 1, 2 at position 1
* yarray.insert(2, [1, 2])
*
* @param {Integer} index The index to insert content at.
* @param {Array} content The array of content
*/
insert (index, content) {
this._transact(() => {
let left = null;
let right = this._start;
let count = 0;
const y = this._y;
while (right !== null) {
const rightLen = right._deleted ? 0 : (right._length - 1);
if (count <= index && index <= count + rightLen) {
const splitDiff = index - count;
right = right._splitAt(y, splitDiff);
left = right._left;
count += splitDiff;
break
}
if (!right._deleted) {
count += right._length;
}
left = right;
right = right._right;
}
if (index > count) {
throw new Error('Index exceeds array range!')
}
this.insertAfter(left, content);
});
}
/**
* Appends content to this YArray.
*
* @param {Array} content Array of content to append.
*/
push (content) {
let n = this._start;
let lastUndeleted = null;
while (n !== null) {
if (!n._deleted) {
lastUndeleted = n;
}
n = n._right;
}
this.insertAfter(lastUndeleted, content);
}
/**
* Transform this YXml Type to a readable format.
* Useful for logging as all Items and Delete implement this method.
*
* @private
*/
_logString () {
return logItemHelper('YArray', this, `start:${logID(this._start)}"`)
}
}
/**
* Event that describes the changes on a YMap.
*
* @param {YMap} ymap The YArray that changed.
* @param {Set<any>} subs The keys that changed.
* @param {boolean} remote Whether the change was created by a remote peer.
*/
class YMapEvent extends YEvent {
constructor (ymap, subs, remote) {
super(ymap);
this.keysChanged = subs;
this.remote = remote;
}
}
/**
* A shared Map implementation.
*/
class YMap extends Type {
/**
* @private
* Creates YMap Event and calls observers.
*/
_callObserver (transaction, parentSubs, remote) {
this._callEventHandler(transaction, new YMapEvent(this, parentSubs, remote));
}
/**
* Transforms this Shared Type to a JSON object.
*
* @return {Object}
*/
toJSON () {
const map = {};
for (let [key, item] of this._map) {
if (!item._deleted) {
let res;
if (item instanceof Type) {
if (item.toJSON !== undefined) {
res = item.toJSON();
} else {
res = item.toString();
}
} else {
res = item._content[0];
}
map[key] = res;
}
}
return map
}
/**
* Returns the keys for each element in the YMap Type.
*
* @return {Array}
*/
keys () {
// TODO: Should return either Iterator or Set!
let keys = [];
for (let [key, value] of this._map) {
if (!value._deleted) {
keys.push(key);
}
}
return keys
}
/**
* Remove a specified element from this YMap.
*
* @param {encodable} key The key of the element to remove.
*/
delete (key) {
this._transact((y) => {
let c = this._map.get(key);
if (y !== null && c !== undefined) {
c._delete(y);
}
});
}
/**
* Adds or updates an element with a specified key and value.
*
* @param {encodable} key The key of the element to add to this YMap.
* @param {encodable | YType} value The value of the element to add to this
* YMap.
*/
set (key, value) {
this._transact(y => {
const old = this._map.get(key) || null;
if (old !== null) {
if (
old.constructor === ItemJSON &&
!old._deleted && old._content[0] === value
) {
// Trying to overwrite with same value
// break here
return value
}
if (y !== null) {
old._delete(y);
}
}
let v;
if (typeof value === 'function') {
v = new value(); // eslint-disable-line new-cap
value = v;
} else if (value instanceof Item) {
v = value;
} else {
v = new ItemJSON();
v._content = [value];
}
v._right = old;
v._right_origin = old;
v._parent = this;
v._parentSub = key;
if (y !== null) {
v._integrate(y);
} else {
this._map.set(key, v);
}
});
return value
}
/**
* Returns a specified element from this YMap.
*
* @param {encodable} key The key of the element to return.
*/
get (key) {
let v = this._map.get(key);
if (v === undefined || v._deleted) {
return undefined
}
if (v instanceof Type) {
return v
} else {
return v._content[v._content.length - 1]
}
}
/**
* Returns a boolean indicating whether the specified key exists or not.
*
* @param {encodable} key The key to test.
*/
has (key) {
let v = this._map.get(key);
if (v === undefined || v._deleted) {
return false
} else {
return true
}
}
/**
* Transform this YXml Type to a readable format.
* Useful for logging as all Items and Delete implement this method.
*
* @private
*/
_logString () {
return logItemHelper('YMap', this, `mapSize:${this._map.size}`)
}
}
class ItemEmbed extends Item {
constructor () {
super();
this.embed = null;
}
_copy (undeleteChildren, copyPosition) {
let struct = super._copy(undeleteChildren, copyPosition);
struct.embed = this.embed;
return struct
}
get _length () {
return 1
}
_fromBinary (y, decoder) {
const missing = super._fromBinary(y, decoder);
this.embed = JSON.parse(decoder.readVarString());
return missing
}
_toBinary (encoder) {
super._toBinary(encoder);
encoder.writeVarString(JSON.stringify(this.embed));
}
/**
* Transform this YXml Type to a readable format.
* Useful for logging as all Items and Delete implement this method.
*
* @private
*/
_logString () {
return logItemHelper('ItemEmbed', this, `embed:${JSON.stringify(this.embed)}`)
}
}
class ItemFormat extends Item {
constructor () {
super();
this.key = null;
this.value = null;
}
_copy (undeleteChildren, copyPosition) {
let struct = super._copy(undeleteChildren, copyPosition);
struct.key = this.key;
struct.value = this.value;
return struct
}
get _length () {
return 1
}
get _countable () {
return false
}
_fromBinary (y, decoder) {
const missing = super._fromBinary(y, decoder);
this.key = decoder.readVarString();
this.value = JSON.parse(decoder.readVarString());
return missing
}
_toBinary (encoder) {
super._toBinary(encoder);
encoder.writeVarString(this.key);
encoder.writeVarString(JSON.stringify(this.value));
}
/**
* Transform this YXml Type to a readable format.
* Useful for logging as all Items and Delete implement this method.
*
* @private
*/
_logString () {
return logItemHelper('ItemFormat', this, `key:${JSON.stringify(this.key)},value:${JSON.stringify(this.value)}`)
}
}
/**
* @private
*/
function integrateItem (item, parent, y, left, right) {
item._origin = left;
item._left = left;
item._right = right;
item._right_origin = right;
item._parent = parent;
if (y !== null) {
item._integrate(y);
} else if (left === null) {
parent._start = item;
} else {
left._right = item;
}
}
/**
* @private
*/
function findNextPosition (currentAttributes, parent, left, right, count) {
while (right !== null && count > 0) {
switch (right.constructor) {
case ItemEmbed:
case ItemString:
const rightLen = right._deleted ? 0 : (right._length - 1);
if (count <= rightLen) {
right = right._splitAt(parent._y, count);
left = right._left;
return [left, right, currentAttributes]
}
if (right._deleted === false) {
count -= right._length;
}
break
case ItemFormat:
if (right._deleted === false) {
updateCurrentAttributes(currentAttributes, right);
}
break
}
left = right;
right = right._right;
}
return [left, right, currentAttributes]
}
/**
* @private
*/
function findPosition (parent, index) {
let currentAttributes = new Map();
let left = null;
let right = parent._start;
return findNextPosition(currentAttributes, parent, left, right, index)
}
/**
* Negate applied formats
*
* @private
*/
function insertNegatedAttributes (y, parent, left, right, negatedAttributes) {
// check if we really need to remove attributes
while (
right !== null && (
right._deleted === true || (
right.constructor === ItemFormat &&
(negatedAttributes.get(right.key) === right.value)
)
)
) {
if (right._deleted === false) {
negatedAttributes.delete(right.key);
}
left = right;
right = right._right;
}
for (let [key, val] of negatedAttributes) {
let format = new ItemFormat();
format.key = key;
format.value = val;
integrateItem(format, parent, y, left, right);
left = format;
}
return [left, right]
}
/**
* @private
*/
function updateCurrentAttributes (currentAttributes, item) {
const value = item.value;
const key = item.key;
if (value === null) {
currentAttributes.delete(key);
} else {
currentAttributes.set(key, value);
}
}
/**
* @private
*/
function minimizeAttributeChanges (left, right, currentAttributes, attributes) {
// go right while attributes[right.key] === right.value (or right is deleted)
while (true) {
if (right === null) {
break
} else if (right._deleted === true) {
// continue
} else if (right.constructor === ItemFormat && (attributes[right.key] || null) === right.value) {
// found a format, update currentAttributes and continue
updateCurrentAttributes(currentAttributes, right);
} else {
break
}
left = right;
right = right._right;
}
return [left, right]
}
/**
* @private
*/
function insertAttributes (y, parent, left, right, attributes, currentAttributes) {
const negatedAttributes = new Map();
// insert format-start items
for (let key in attributes) {
const val = attributes[key];
const currentVal = currentAttributes.get(key);
if (currentVal !== val) {
// save negated attribute (set null if currentVal undefined)
negatedAttributes.set(key, currentVal || null);
let format = new ItemFormat();
format.key = key;
format.value = val;
integrateItem(format, parent, y, left, right);
left = format;
}
}
return [left, right, negatedAttributes]
}
/**
* @private
*/
function insertText (y, text, parent, left, right, currentAttributes, attributes) {
for (let [key] of currentAttributes) {
if (attributes.hasOwnProperty(key) === false) {
attributes[key] = null;
}
}
[left, right] = minimizeAttributeChanges(left, right, currentAttributes, attributes);
let negatedAttributes;
[left, right, negatedAttributes] = insertAttributes(y, parent, left, right, attributes, currentAttributes);
// insert content
let item;
if (text.constructor === String) {
item = new ItemString();
item._content = text;
} else {
item = new ItemEmbed();
item.embed = text;
}
integrateItem(item, parent, y, left, right);
left = item;
return insertNegatedAttributes(y, parent, left, right, negatedAttributes)
}
/**
* @private
*/
function formatText (y, length, parent, left, right, currentAttributes, attributes) {
[left, right] = minimizeAttributeChanges(left, right, currentAttributes, attributes);
let negatedAttributes;
[left, right, negatedAttributes] = insertAttributes(y, parent, left, right, attributes, currentAttributes);
// iterate until first non-format or null is found
// delete all formats with attributes[format.key] != null
while (length > 0 && right !== null) {
if (right._deleted === false) {
switch (right.constructor) {
case ItemFormat:
if (attributes.hasOwnProperty(right.key)) {
if (attributes[right.key] === right.value) {
negatedAttributes.delete(right.key);
} else {
negatedAttributes.set(right.key, right.value);
}
right._delete(y);
}
updateCurrentAttributes(currentAttributes, right);
break
case ItemEmbed:
case ItemString:
right._splitAt(y, length);
length -= right._length;
break
}
}
left = right;
right = right._right;
}
return insertNegatedAttributes(y, parent, left, right, negatedAttributes)
}
/**
* @private
*/
function deleteText (y, length, parent, left, right, currentAttributes) {
while (length > 0 && right !== null) {
if (right._deleted === false) {
switch (right.constructor) {
case ItemFormat:
updateCurrentAttributes(currentAttributes, right);
break
case ItemEmbed:
case ItemString:
right._splitAt(y, length);
length -= right._length;
right._delete(y);
break
}
}
left = right;
right = right._right;
}
return [left, right]
}
// TODO: In the quill delta representation we should also use the format {ops:[..]}
/**
* The Quill Delta format represents changes on a text document with
* formatting information. For mor information visit {@link https://quilljs.com/docs/delta/|Quill Delta}
*
* @example
* {
* ops: [
* { insert: 'Gandalf', attributes: { bold: true } },
* { insert: ' the ' },
* { insert: 'Grey', attributes: { color: '#cccccc' } }
* ]
* }
*
* @typedef {Array<Object>} Delta
*/
/**
* Attributes that can be assigned to a selection of text.
*
* @example
* {
* bold: true,
* font-size: '40px'
* }
*
* @typedef {Object} TextAttributes
*/
/**
* Event that describes the changes on a YText type.
*
* @private
*/
class YTextEvent extends YArrayEvent {
constructor (ytext, remote, transaction) {
super(ytext, remote, transaction);
this._delta = null;
}
// TODO: Should put this in a separate function. toDelta shouldn't be included
// in every Yjs distribution
/**
* Compute the changes in the delta format.
*
* @return {Delta} A {@link https://quilljs.com/docs/delta/|Quill Delta}) that
* represents the changes on the document.
*
* @public
*/
get delta () {
if (this._delta === null) {
const y = this.target._y;
y.transact(() => {
let item = this.target._start;
const delta = [];
const added = this.addedElements;
const removed = this.removedElements;
this._delta = delta;
let action = null;
let attributes = {}; // counts added or removed new attributes for retain
const currentAttributes = new Map(); // saves all current attributes for insert
const oldAttributes = new Map();
let insert = '';
let retain = 0;
let deleteLen = 0;
const addOp = function addOp () {
if (action !== null) {
let op;
switch (action) {
case 'delete':
op = { delete: deleteLen };
deleteLen = 0;
break
case 'insert':
op = { insert };
if (currentAttributes.size > 0) {
op.attributes = {};
for (let [key, value] of currentAttributes) {
if (value !== null) {
op.attributes[key] = value;
}
}
}
insert = '';
break
case 'retain':
op = { retain };
if (Object.keys(attributes).length > 0) {
op.attributes = {};
for (let key in attributes) {
op.attributes[key] = attributes[key];
}
}
retain = 0;
break
}
delta.push(op);
action = null;
}
};
while (item !== null) {
switch (item.constructor) {
case ItemEmbed:
if (added.has(item)) {
addOp();
action = 'insert';
insert = item.embed;
addOp();
} else if (removed.has(item)) {
if (action !== 'delete') {
addOp();
action = 'delete';
}
deleteLen += 1;
} else if (item._deleted === false) {
if (action !== 'retain') {
addOp();
action = 'retain';
}
retain += 1;
}
break
case ItemString:
if (added.has(item)) {
if (action !== 'insert') {
addOp();
action = 'insert';
}
insert += item._content;
} else if (removed.has(item)) {
if (action !== 'delete') {
addOp();
action = 'delete';
}
deleteLen += item._length;
} else if (item._deleted === false) {
if (action !== 'retain') {
addOp();
action = 'retain';
}
retain += item._length;
}
break
case ItemFormat:
if (added.has(item)) {
const curVal = currentAttributes.get(item.key) || null;
if (curVal !== item.value) {
if (action === 'retain') {
addOp();
}
if (item.value === (oldAttributes.get(item.key) || null)) {
delete attributes[item.key];
} else {
attributes[item.key] = item.value;
}
} else {
item._delete(y);
}
} else if (removed.has(item)) {
oldAttributes.set(item.key, item.value);
const curVal = currentAttributes.get(item.key) || null;
if (curVal !== item.value) {
if (action === 'retain') {
addOp();
}
attributes[item.key] = curVal;
}
} else if (item._deleted === false) {
oldAttributes.set(item.key, item.value);
if (attributes.hasOwnProperty(item.key)) {
if (attributes[item.key] !== item.value) {
if (action === 'retain') {
addOp();
}
if (item.value === null) {
attributes[item.key] = item.value;
} else {
delete attributes[item.key];
}
} else {
item._delete(y);
}
}
}
if (item._deleted === false) {
if (action === 'insert') {
addOp();
}
updateCurrentAttributes(currentAttributes, item);
}
break
}
item = item._right;
}
addOp();
while (this._delta.length > 0) {
let lastOp = this._delta[this._delta.length - 1];
if (lastOp.hasOwnProperty('retain') && !lastOp.hasOwnProperty('attributes')) {
// retain delta's if they don't assign attributes
this._delta.pop();
} else {
break
}
}
});
}
return this._delta
}
}
/**
* Type that represents text with formatting information.
*
* This type replaces y-richtext as this implementation is able to handle
* block formats (format information on a paragraph), embeds (complex elements
* like pictures and videos), and text formats (**bold**, *italic*).
*
* @param {String} string The initial value of the YText.
*/
class YText extends YArray {
constructor (string) {
super();
if (typeof string === 'string') {
const start = new ItemString();
start._parent = this;
start._content = string;
this._start = start;
}
}
/**
* @private
* Creates YMap Event and calls observers.
*/
_callObserver (transaction, parentSubs, remote) {
this._callEventHandler(transaction, new YTextEvent(this, remote, transaction));
}
/**
* Returns the unformatted string representation of this YText type.
*
* @public
*/
toString () {
let str = '';
let n = this._start;
while (n !== null) {
if (!n._deleted && n._countable) {
str += n._content;
}
n = n._right;
}
return str
}
/**
* Apply a {@link Delta} on this shared YText type.
*
* @param {Delta} delta The changes to apply on this element.
*
* @public
*/
applyDelta (delta) {
this._transact(y => {
let left = null;
let right = this._start;
const currentAttributes = new Map();
for (let i = 0; i < delta.length; i++) {
let op = delta[i];
if (op.hasOwnProperty('insert')) {
[left, right] = insertText(y, op.insert, this, left, right, currentAttributes, op.attributes || {});
} else if (op.hasOwnProperty('retain')) {
[left, right] = formatText(y, op.retain, this, left, right, currentAttributes, op.attributes || {});
} else if (op.hasOwnProperty('delete')) {
[left, right] = deleteText(y, op.delete, this, left, right, currentAttributes);
}
}
});
}
/**
* Returns the Delta representation of this YText type.
*
* @return {Delta} The Delta representation of this type.
*
* @public
*/
toDelta () {
let ops = [];
let currentAttributes = new Map();
let str = '';
let n = this._start;
function packStr () {
if (str.length > 0) {
// pack str with attributes to ops
let attributes = {};
let addAttributes = false;
for (let [key, value] of currentAttributes) {
addAttributes = true;
attributes[key] = value;
}
let op = { insert: str };
if (addAttributes) {
op.attributes = attributes;
}
ops.push(op);
str = '';
}
}
while (n !== null) {
if (!n._deleted) {
switch (n.constructor) {
case ItemString:
str += n._content;
break
case ItemFormat:
packStr();
updateCurrentAttributes(currentAttributes, n);
break
}
}
n = n._right;
}
packStr();
return ops
}
/**
* Insert text at a given index.
*
* @param {Integer} index The index at which to start inserting.
* @param {String} text The text to insert at the specified position.
* @param {TextAttributes} attributes Optionally define some formatting
* information to apply on the inserted
* Text.
*
* @public
*/
insert (index, text, attributes = {}) {
if (text.length <= 0) {
return
}
this._transact(y => {
let [left, right, currentAttributes] = findPosition(this, index);
insertText(y, text, this, left, right, currentAttributes, attributes);
});
}
/**
* Inserts an embed at a index.
*
* @param {Integer} index The index to insert the embed at.
* @param {Object} embed The Object that represents the embed.
* @param {TextAttributes} attributes Attribute information to apply on the
* embed
*
* @public
*/
insertEmbed (index, embed, attributes = {}) {
if (embed.constructor !== Object) {
throw new Error('Embed must be an Object')
}
this._transact(y => {
let [left, right, currentAttributes] = findPosition(this, index);
insertText(y, embed, this, left, right, currentAttributes, attributes);
});
}
/**
* Deletes text starting from an index.
*
* @param {Integer} index Index at which to start deleting.
* @param {Integer} length The number of characters to remove. Defaults to 1.
*
* @public
*/
delete (index, length) {
if (length === 0) {
return
}
this._transact(y => {
let [left, right, currentAttributes] = findPosition(this, index);
deleteText(y, length, this, left, right, currentAttributes);
});
}
/**
* Assigns properties to a range of text.
*
* @param {Integer} index The position where to start formatting.
* @param {Integer} length The amount of characters to assign properties to.
* @param {TextAttributes} attributes Attribute information to apply on the
* text.
*
* @public
*/
format (index, length, attributes) {
this._transact(y => {
let [left, right, currentAttributes] = findPosition(this, index);
if (right === null) {
return
}
formatText(y, length, this, left, right, currentAttributes, attributes);
});
}
// TODO: De-duplicate code. The following code is in every type.
/**
* Transform this YText to a readable format.
* Useful for logging as all Items implement this method.
*
* @private
*/
_logString () {
return logItemHelper('YText', this)
}
}
/**
* Check if `parent` is a parent of `child`.
*
* @param {Type} parent
* @param {Type} child
* @return {Boolean} Whether `parent` is a parent of `child`.
*
* @public
*/
function isParentOf (parent, child) {
child = child._parent;
while (child !== null) {
if (child === parent) {
return true
}
child = child._parent;
}
return false
}
/**
* Default filter method (does nothing).
*
* @param {String} nodeName The nodeName of the element
* @param {Map} attrs Map of key-value pairs that are attributes of the node.
* @return {Map | null} The allowed attributes or null, if the element should be
* filtered.
*/
function defaultFilter (nodeName, attrs) {
// TODO: implement basic filter that filters out dangerous properties!
return attrs
}
/**
*
*/
function filterDomAttributes (dom, filter) {
const attrs = new Map();
for (let i = dom.attributes.length - 1; i >= 0; i--) {
const attr = dom.attributes[i];
attrs.set(attr.name, attr.value);
}
return filter(dom.nodeName, attrs)
}
/**
* Applies a filter on a type.
*
* @param {Y} y The Yjs instance.
* @param {DomBinding} binding The DOM binding instance that has the dom filter.
* @param {YXmlElement | YXmlFragment } type The type to apply the filter to.
*
* @private
*/
function applyFilterOnType (y, binding, type) {
if (isParentOf(binding.type, type)) {
const nodeName = type.nodeName;
let attributes = new Map();
if (type.getAttributes !== undefined) {
let attrs = type.getAttributes();
for (let key in attrs) {
attributes.set(key, attrs[key]);
}
}
const filteredAttributes = binding.filter(nodeName, new Map(attributes));
if (filteredAttributes === null) {
type._delete(y);
} else {
// iterate original attributes
attributes.forEach((value, key) => {
// delete all attributes that are not in filteredAttributes
if (filteredAttributes.has(key) === false) {
type.removeAttribute(key);
}
});
}
}
}
/**
* Creates a Yjs type (YXml) based on the contents of a DOM Element.
*
* @param {Element|TextNode} element The DOM Element
* @param {?Document} _document Optional. Provide the global document object
* @param {Hooks} [hooks = {}] Optional. Set of Yjs Hooks
* @param {Filter} [filter=defaultFilter] Optional. Dom element filter
* @param {?DomBinding} binding Warning: This property is for internal use only!
* @return {YXmlElement | YXmlText}
*/
function domToType (element, _document = document, hooks = {}, filter = defaultFilter, binding) {
let type;
switch (element.nodeType) {
case _document.ELEMENT_NODE:
let hookName = null;
let hook;
// configure `hookName !== undefined` if element is a hook.
if (element.hasAttribute('data-yjs-hook')) {
hookName = element.getAttribute('data-yjs-hook');
hook = hooks[hookName];
if (hook === undefined) {
console.error(`Unknown hook "${hookName}". Deleting yjsHook dataset property.`);
delete element.removeAttribute('data-yjs-hook');
hookName = null;
}
}
if (hookName === null) {
// Not a hook
const attrs = filterDomAttributes(element, filter);
if (attrs === null) {
type = false;
} else {
type = new YXmlElement(element.nodeName);
attrs.forEach((val, key) => {
type.setAttribute(key, val);
});
type.insert(0, domsToTypes(element.childNodes, document, hooks, filter, binding));
}
} else {
// Is a hook
type = new YXmlHook(hookName);
hook.fillType(element, type);
}
break
case _document.TEXT_NODE:
type = new YXmlText();
type.insert(0, element.nodeValue);
break
default:
throw new Error('Can\'t transform this node type to a YXml type!')
}
createAssociation(binding, element, type);
return type
}
/**
* Iterates items until an undeleted item is found.
*
* @private
*/
function iterateUntilUndeleted (item) {
while (item !== null && item._deleted) {
item = item._right;
}
return item
}
/**
* Removes an association (the information that a DOM element belongs to a
* type).
*
* @param {DomBinding} domBinding The binding object
* @param {Element} dom The dom that is to be associated with type
* @param {YXmlElement|YXmlHook} type The type that is to be associated with dom
*
*/
function removeAssociation (domBinding, dom, type) {
domBinding.domToType.delete(dom);
domBinding.typeToDom.delete(type);
}
/**
* Creates an association (the information that a DOM element belongs to a
* type).
*
* @param {DomBinding} domBinding The binding object
* @param {Element} dom The dom that is to be associated with type
* @param {YXmlElement|YXmlHook} type The type that is to be associated with dom
*
*/
function createAssociation (domBinding, dom, type) {
if (domBinding !== undefined) {
domBinding.domToType.set(dom, type);
domBinding.typeToDom.set(type, dom);
}
}
/**
* If oldDom is associated with a type, associate newDom with the type and
* forget about oldDom. If oldDom is not associated with any type, nothing happens.
*
* @param {DomBinding} domBinding The binding object
* @param {Element} oldDom The existing dom
* @param {Element} newDom The new dom object
*/
function switchAssociation (domBinding, oldDom, newDom) {
if (domBinding !== undefined) {
const type = domBinding.domToType.get(oldDom);
if (type !== undefined) {
removeAssociation(domBinding, oldDom, type);
createAssociation(domBinding, newDom, type);
}
}
}
/**
* Insert Dom Elements after one of the children of this YXmlFragment.
* The Dom elements will be bound to a new YXmlElement and inserted at the
* specified position.
*
* @param {YXmlElement} type The type in which to insert DOM elements.
* @param {YXmlElement|null} prev The reference node. New YxmlElements are
* inserted after this node. Set null to insert at
* the beginning.
* @param {Array<Element>} doms The Dom elements to insert.
* @param {?Document} _document Optional. Provide the global document object.
* @param {DomBinding} binding The dom binding
* @return {Array<YXmlElement>} The YxmlElements that are inserted.
*
* @private
*/
function insertDomElementsAfter (type, prev, doms, _document, binding) {
const types = domsToTypes(doms, _document, binding.opts.hooks, binding.filter, binding);
return type.insertAfter(prev, types)
}
function domsToTypes (doms, _document, hooks, filter, binding) {
const types = [];
for (let dom of doms) {
const t = domToType(dom, _document, hooks, filter, binding);
if (t !== false) {
types.push(t);
}
}
return types
}
/**
* @private
*/
function insertNodeHelper (yxml, prevExpectedNode, child, _document, binding) {
let insertedNodes = insertDomElementsAfter(yxml, prevExpectedNode, [child], _document, binding);
if (insertedNodes.length > 0) {
return insertedNodes[0]
} else {
return prevExpectedNode
}
}
/**
* Remove children until `elem` is found.
*
* @param {Element} parent The parent of `elem` and `currentChild`.
* @param {Element} currentChild Start removing elements with `currentChild`. If
* `currentChild` is `elem` it won't be removed.
* @param {Element|null} elem The elemnt to look for.
*
* @private
*/
function removeDomChildrenUntilElementFound (parent, currentChild, elem) {
while (currentChild !== elem) {
const del = currentChild;
currentChild = currentChild.nextSibling;
parent.removeChild(del);
}
}
/**
* Define the elements to which a set of CSS queries apply.
* {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors|CSS_Selectors}
*
* @example
* query = '.classSelector'
* query = 'nodeSelector'
* query = '#idSelector'
*
* @typedef {string} CSS_Selector
*/
/**
* Represents a subset of the nodes of a YXmlElement / YXmlFragment and a
* position within them.
*
* Can be created with {@link YXmlFragment#createTreeWalker}
*
* @public
*/
class YXmlTreeWalker {
constructor (root, f) {
this._filter = f || (() => true);
this._root = root;
this._currentNode = root;
this._firstCall = true;
}
[Symbol.iterator] () {
return this
}
/**
* Get the next node.
*
* @return {YXmlElement} The next node.
*
* @public
*/
next () {
let n = this._currentNode;
if (this._firstCall) {
this._firstCall = false;
if (!n._deleted && this._filter(n)) {
return { value: n, done: false }
}
}
do {
if (!n._deleted && (n.constructor === YXmlFragment._YXmlElement || n.constructor === YXmlFragment) && n._start !== null) {
// walk down in the tree
n = n._start;
} else {
// walk right or up in the tree
while (n !== this._root) {
if (n._right !== null) {
n = n._right;
break
}
n = n._parent;
}
if (n === this._root) {
n = null;
}
}
if (n === this._root) {
break
}
} while (n !== null && (n._deleted || !this._filter(n)))
this._currentNode = n;
if (n === null) {
return { done: true }
} else {
return { value: n, done: false }
}
}
}
/**
* An Event that describes changes on a YXml Element or Yxml Fragment
*
* @protected
*/
class YXmlEvent extends YEvent {
/**
* @param {YType} target The target on which the event is created.
* @param {Set} subs The set of changed attributes. `null` is included if the
* child list changed.
* @param {Boolean} remote Whether this change was created by a remote peer.
* @param {Transaction} transaction The transaction instance with wich the
* change was created.
*/
constructor (target, subs, remote, transaction) {
super(target);
/**
* The transaction instance for the computed change.
* @type {Transaction}
*/
this._transaction = transaction;
/**
* Whether the children changed.
* @type {Boolean}
*/
this.childListChanged = false;
/**
* Set of all changed attributes.
* @type {Set}
*/
this.attributesChanged = new Set();
/**
* Whether this change was created by a remote peer.
* @type {Boolean}
*/
this.remote = remote;
subs.forEach((sub) => {
if (sub === null) {
this.childListChanged = true;
} else {
this.attributesChanged.add(sub);
}
});
}
}
/**
* Dom filter function.
*
* @callback domFilter
* @param {string} nodeName The nodeName of the element
* @param {Map} attributes The map of attributes.
* @return {boolean} Whether to include the Dom node in the YXmlElement.
*/
/**
* Define the elements to which a set of CSS queries apply.
* {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors|CSS_Selectors}
*
* @example
* query = '.classSelector'
* query = 'nodeSelector'
* query = '#idSelector'
*
* @typedef {string} CSS_Selector
*/
/**
* Represents a list of {@link YXmlElement}.and {@link YXmlText} types.
* A YxmlFragment is similar to a {@link YXmlElement}, but it does not have a
* nodeName and it does not have attributes. Though it can be bound to a DOM
* element - in this case the attributes and the nodeName are not shared.
*
* @public
*/
class YXmlFragment extends YArray {
/**
* Create a subtree of childNodes.
*
* @example
* const walker = elem.createTreeWalker(dom => dom.nodeName === 'div')
* for (let node in walker) {
* // `node` is a div node
* nop(node)
* }
*
* @param {Function} filter Function that is called on each child element and
* returns a Boolean indicating whether the child
* is to be included in the subtree.
* @return {TreeWalker} A subtree and a position within it.
*
* @public
*/
createTreeWalker (filter) {
return new YXmlTreeWalker(this, filter)
}
/**
* Returns the first YXmlElement that matches the query.
* Similar to DOM's {@link querySelector}.
*
* Query support:
* - tagname
* TODO:
* - id
* - attribute
*
* @param {CSS_Selector} query The query on the children.
* @return {?YXmlElement} The first element that matches the query or null.
*
* @public
*/
querySelector (query) {
query = query.toUpperCase();
const iterator = new YXmlTreeWalker(this, element => element.nodeName === query);
const next = iterator.next();
if (next.done) {
return null
} else {
return next.value
}
}
/**
* Returns all YXmlElements that match the query.
* Similar to Dom's {@link querySelectorAll}.
*
* TODO: Does not yet support all queries. Currently only query by tagName.
*
* @param {CSS_Selector} query The query on the children
* @return {Array<YXmlElement>} The elements that match this query.
*
* @public
*/
querySelectorAll (query) {
query = query.toUpperCase();
return Array.from(new YXmlTreeWalker(this, element => element.nodeName === query))
}
/**
* Creates YArray Event and calls observers.
*
* @private
*/
_callObserver (transaction, parentSubs, remote) {
this._callEventHandler(transaction, new YXmlEvent(this, parentSubs, remote, transaction));
}
/**
* Get the string representation of all the children of this YXmlFragment.
*
* @return {string} The string representation of all children.
*/
toString () {
return this.map(xml => xml.toString()).join('')
}
/**
* @private
* Unbind from Dom and mark this Item as deleted.
*
* @param {Y} y The Yjs instance
* @param {boolean} createDelete Whether to propagate a message that this
* Type was deleted.
* @param {boolean} [gcChildren=y._hasUndoManager===false] Whether to garbage
* collect the children of this type.
*
* @private
*/
_delete (y, createDelete, gcChildren) {
super._delete(y, createDelete, gcChildren);
}
/**
* Creates a Dom Element that mirrors this YXmlElement.
*
* @param {Document} [_document=document] The document object (you must define
* this when calling this method in
* nodejs)
* @param {Object<key:hookDefinition>} [hooks={}] Optional property to customize how hooks
* are presented in the DOM
* @param {DomBinding} [binding] You should not set this property. This is
* used if DomBinding wants to create a
* association to the created DOM type
* @return {Element} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
*
* @public
*/
toDom (_document = document, hooks = {}, binding) {
const fragment = _document.createDocumentFragment();
createAssociation(binding, fragment, this);
this.forEach(xmlType => {
fragment.insertBefore(xmlType.toDom(_document, hooks, binding), null);
});
return fragment
}
/**
* Transform this YXml Type to a readable format.
* Useful for logging as all Items and Delete implement this method.
*
* @private
*/
_logString () {
return logItemHelper('YXml', this)
}
}
/**
* An YXmlElement imitates the behavior of a
* {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}.
*
* * An YXmlElement has attributes (key value pairs)
* * An YXmlElement has childElements that must inherit from YXmlElement
*
* @param {String} nodeName Node name
*/
class YXmlElement extends YXmlFragment {
constructor (nodeName = 'UNDEFINED') {
super();
this.nodeName = nodeName.toUpperCase();
}
/**
* @private
* Creates an Item with the same effect as this Item (without position effect)
*/
_copy () {
let struct = super._copy();
struct.nodeName = this.nodeName;
return struct
}
/**
* @private
* Read the next Item in a Decoder and fill this Item with the read data.
*
* This is called when data is received from a remote peer.
*
* @param {Y} y The Yjs instance that this Item belongs to.
* @param {BinaryDecoder} decoder The decoder object to read data from.
*/
_fromBinary (y, decoder) {
const missing = super._fromBinary(y, decoder);
this.nodeName = decoder.readVarString();
return missing
}
/**
* Transform the properties of this type to binary and write it to an
* BinaryEncoder.
*
* This is called when this Item is sent to a remote peer.
*
* @param {BinaryEncoder} encoder The encoder to write data to.
*
* @private
*/
_toBinary (encoder) {
super._toBinary(encoder);
encoder.writeVarString(this.nodeName);
}
/**
* Integrates this Item into the shared structure.
*
* This method actually applies the change to the Yjs instance. In case of
* Item it connects _left and _right to this Item and calls the
* {@link Item#beforeChange} method.
*
* * Checks for nodeName
* * Sets domFilter
*
* @param {Y} y The Yjs instance
*
* @private
*/
_integrate (y) {
if (this.nodeName === null) {
throw new Error('nodeName must be defined!')
}
super._integrate(y);
}
/**
* Returns the string representation of this YXmlElement.
* The attributes are ordered by attribute-name, so you can easily use this
* method to compare YXmlElements
*
* @return {String} The string representation of this type.
*
* @public
*/
toString () {
const attrs = this.getAttributes();
const stringBuilder = [];
const keys = [];
for (let key in attrs) {
keys.push(key);
}
keys.sort();
const keysLen = keys.length;
for (let i = 0; i < keysLen; i++) {
const key = keys[i];
stringBuilder.push(key + '="' + attrs[key] + '"');
}
const nodeName = this.nodeName.toLocaleLowerCase();
const attrsString = stringBuilder.length > 0 ? ' ' + stringBuilder.join(' ') : '';
return `<${nodeName}${attrsString}>${super.toString()}</${nodeName}>`
}
/**
* Removes an attribute from this YXmlElement.
*
* @param {String} attributeName The attribute name that is to be removed.
*
* @public
*/
removeAttribute (attributeName) {
return YMap.prototype.delete.call(this, attributeName)
}
/**
* Sets or updates an attribute.
*
* @param {String} attributeName The attribute name that is to be set.
* @param {String} attributeValue The attribute value that is to be set.
*
* @public
*/
setAttribute (attributeName, attributeValue) {
return YMap.prototype.set.call(this, attributeName, attributeValue)
}
/**
* Returns an attribute value that belongs to the attribute name.
*
* @param {String} attributeName The attribute name that identifies the
* queried value.
* @return {String} The queried attribute value.
*
* @public
*/
getAttribute (attributeName) {
return YMap.prototype.get.call(this, attributeName)
}
/**
* Returns all attribute name/value pairs in a JSON Object.
*
* @return {Object} A JSON Object that describes the attributes.
*
* @public
*/
getAttributes () {
const obj = {};
for (let [key, value] of this._map) {
if (!value._deleted) {
obj[key] = value._content[0];
}
}
return obj
}
// TODO: outsource the binding property.
/**
* Creates a Dom Element that mirrors this YXmlElement.
*
* @param {Document} [_document=document] The document object (you must define
* this when calling this method in
* nodejs)
* @param {Object<key:hookDefinition>} [hooks={}] Optional property to customize how hooks
* are presented in the DOM
* @param {DomBinding} [binding] You should not set this property. This is
* used if DomBinding wants to create a
* association to the created DOM type.
* @return {Element} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
*
* @public
*/
toDom (_document = document, hooks = {}, binding) {
const dom = _document.createElement(this.nodeName);
let attrs = this.getAttributes();
for (let key in attrs) {
dom.setAttribute(key, attrs[key]);
}
this.forEach(yxml => {
dom.appendChild(yxml.toDom(_document, hooks, binding));
});
createAssociation(binding, dom, this);
return dom
}
}
/**
* You can manage binding to a custom type with YXmlHook.
*
* @public
*/
class YXmlHook extends YMap {
/**
* @param {String} hookName nodeName of the Dom Node.
*/
constructor (hookName) {
super();
this.hookName = null;
if (hookName !== undefined) {
this.hookName = hookName;
}
}
/**
* Creates an Item with the same effect as this Item (without position effect)
*
* @private
*/
_copy () {
const struct = super._copy();
struct.hookName = this.hookName;
return struct
}
/**
* Creates a Dom Element that mirrors this YXmlElement.
*
* @param {Document} [_document=document] The document object (you must define
* this when calling this method in
* nodejs)
* @param {Object<key:hookDefinition>} [hooks] Optional property to customize how hooks
* are presented in the DOM
* @param {DomBinding} [binding] You should not set this property. This is
* used if DomBinding wants to create a
* association to the created DOM type
* @return {Element} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
*
* @public
*/
toDom (_document = document, hooks = {}, binding) {
const hook = hooks[this.hookName];
let dom;
if (hook !== undefined) {
dom = hook.createDom(this);
} else {
dom = document.createElement(this.hookName);
}
dom.setAttribute('data-yjs-hook', this.hookName);
createAssociation(binding, dom, this);
return dom
}
/**
* Read the next Item in a Decoder and fill this Item with the read data.
*
* This is called when data is received from a remote peer.
*
* @param {Y} y The Yjs instance that this Item belongs to.
* @param {BinaryDecoder} decoder The decoder object to read data from.
*
* @private
*/
_fromBinary (y, decoder) {
const missing = super._fromBinary(y, decoder);
this.hookName = decoder.readVarString();
return missing
}
/**
* Transform the properties of this type to binary and write it to an
* BinaryEncoder.
*
* This is called when this Item is sent to a remote peer.
*
* @param {BinaryEncoder} encoder The encoder to write data to.
*
* @private
*/
_toBinary (encoder) {
super._toBinary(encoder);
encoder.writeVarString(this.hookName);
}
/**
* Integrate this type into the Yjs instance.
*
* * Save this struct in the os
* * This type is sent to other client
* * Observer functions are fired
*
* @param {Y} y The Yjs instance
*
* @private
*/
_integrate (y) {
if (this.hookName === null) {
throw new Error('hookName must be defined!')
}
super._integrate(y);
}
}
/**
* Represents text in a Dom Element. In the future this type will also handle
* simple formatting information like bold and italic.
*
* @param {String} arg1 Initial value.
*/
class YXmlText extends YText {
/**
* Creates a Dom Element that mirrors this YXmlText.
*
* @param {Document} [_document=document] The document object (you must define
* this when calling this method in
* nodejs)
* @param {Object<key:hookDefinition>} [hooks] Optional property to customize how hooks
* are presented in the DOM
* @param {DomBinding} [binding] You should not set this property. This is
* used if DomBinding wants to create a
* association to the created DOM type.
* @return {Element} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
*
* @public
*/
toDom (_document = document, hooks, binding) {
const dom = _document.createTextNode(this.toString());
createAssociation(binding, dom, this);
return dom
}
/**
* Mark this Item as deleted.
*
* @param {Y} y The Yjs instance
* @param {boolean} createDelete Whether to propagate a message that this
* Type was deleted.
* @param {boolean} [gcChildren=y._hasUndoManager===false] Whether to garbage
* collect the children of this type.
*
* @private
*/
_delete (y, createDelete, gcChildren) {
super._delete(y, createDelete, gcChildren);
}
}
YXmlFragment._YXmlElement = YXmlElement;
YXmlFragment._YXmlHook = YXmlHook;
const structs = new Map();
const references = new Map();
/**
* Register a new Yjs types. The same type must be defined with the same
* reference on all clients!
*
* @param {Number} reference
* @param {class} structConstructor
*
* @public
*/
function registerStruct (reference, structConstructor) {
structs.set(reference, structConstructor);
references.set(structConstructor, reference);
}
/**
* @private
*/
function getStruct (reference) {
return structs.get(reference)
}
/**
* @private
*/
function getStructReference (typeConstructor) {
return references.get(typeConstructor)
}
// TODO: reorder (Item* should have low numbers)
registerStruct(0, ItemJSON);
registerStruct(1, ItemString);
registerStruct(10, ItemFormat);
registerStruct(11, ItemEmbed);
registerStruct(2, Delete);
registerStruct(3, YArray);
registerStruct(4, YMap);
registerStruct(5, YText);
registerStruct(6, YXmlFragment);
registerStruct(7, YXmlElement);
registerStruct(8, YXmlText);
registerStruct(9, YXmlHook);
registerStruct(12, GC);
const RootFakeUserID = 0xFFFFFF;
class RootID {
constructor (name, typeConstructor) {
this.user = RootFakeUserID;
this.name = name;
this.type = getStructReference(typeConstructor);
}
equals (id) {
return id !== null && id.user === this.user && id.name === this.name && id.type === this.type
}
lessThan (id) {
if (id.constructor === RootID) {
return this.user < id.user || (this.user === id.user && (this.name < id.name || (this.name === id.name && this.type < id.type)))
} else {
return true
}
}
}
class OperationStore extends Tree {
constructor (y) {
super();
this.y = y;
}
logTable () {
const items = [];
this.iterate(null, null, function (item) {
if (item.constructor === GC) {
items.push({
id: logID(item),
content: item._length,
deleted: 'GC'
});
} else {
items.push({
id: logID(item),
origin: logID(item._origin === null ? null : item._origin._lastId),
left: logID(item._left === null ? null : item._left._lastId),
right: logID(item._right),
right_origin: logID(item._right_origin),
parent: logID(item._parent),
parentSub: item._parentSub,
deleted: item._deleted,
content: JSON.stringify(item._content)
});
}
});
console.table(items);
}
get (id) {
let struct = this.find(id);
if (struct === null && id instanceof RootID) {
const Constr = getStruct(id.type);
const y = this.y;
struct = new Constr();
struct._id = id;
struct._parent = y;
y.transact(() => {
struct._integrate(y);
});
this.put(struct);
}
return struct
}
// Use getItem for structs with _length > 1
getItem (id) {
var item = this.findWithUpperBound(id);
if (item === null) {
return null
}
const itemID = item._id;
if (id.user === itemID.user && id.clock < itemID.clock + item._length) {
return item
} else {
return null
}
}
// Return an insertion such that id is the first element of content
// This function manipulates an item, if necessary
getItemCleanStart (id) {
var ins = this.getItem(id);
if (ins === null || ins._length === 1) {
return ins
}
const insID = ins._id;
if (insID.clock === id.clock) {
return ins
} else {
return ins._splitAt(this.y, id.clock - insID.clock)
}
}
// Return an insertion such that id is the last element of content
// This function manipulates an operation, if necessary
getItemCleanEnd (id) {
var ins = this.getItem(id);
if (ins === null || ins._length === 1) {
return ins
}
const insID = ins._id;
if (insID.clock + ins._length - 1 === id.clock) {
return ins
} else {
ins._splitAt(this.y, id.clock - insID.clock + 1);
return ins
}
}
}
class StateStore {
constructor (y) {
this.y = y;
this.state = new Map();
}
logTable () {
const entries = [];
for (let [user, state] of this.state) {
entries.push({
user, state
});
}
console.table(entries);
}
getNextID (len) {
const user = this.y.userID;
const state = this.getState(user);
this.setState(user, state + len);
return new ID(user, state)
}
updateRemoteState (struct) {
let user = struct._id.user;
let userState = this.state.get(user);
while (struct !== null && struct._id.clock === userState) {
userState += struct._length;
struct = this.y.os.get(new ID(user, userState));
}
this.state.set(user, userState);
}
getState (user) {
let state = this.state.get(user);
if (state == null) {
return 0
}
return state
}
setState (user, state) {
// TODO: modify missingi structs here
const beforeState = this.y._transaction.beforeState;
if (!beforeState.has(user)) {
beforeState.set(user, this.getState(user));
}
this.state.set(user, state);
}
}
/* global crypto */
function generateRandomUint32 () {
if (typeof crypto !== 'undefined' && crypto.getRandomValue != null) {
// browser
let arr = new Uint32Array(1);
crypto.getRandomValues(arr);
return arr[0]
} else if (typeof crypto !== 'undefined' && crypto.randomBytes != null) {
// node
let buf = crypto.randomBytes(4);
return new Uint32Array(buf.buffer)[0]
} else {
return Math.ceil(Math.random() * 0xFFFFFFFF)
}
}
/**
* Handles named events.
*/
class NamedEventHandler {
constructor () {
this._eventListener = new Map();
this._stateListener = new Map();
}
/**
* @private
* Returns all listeners that listen to a specified name.
*
* @param {String} name The query event name.
*/
_getListener (name) {
let listeners = this._eventListener.get(name);
if (listeners === undefined) {
listeners = {
once: new Set(),
on: new Set()
};
this._eventListener.set(name, listeners);
}
return listeners
}
/**
* Adds a named event listener. The listener is removed after it has been
* called once.
*
* @param {String} name The event name to listen to.
* @param {Function} f The function that is executed when the event is fired.
*/
once (name, f) {
let listeners = this._getListener(name);
listeners.once.add(f);
}
/**
* Adds a named event listener.
*
* @param {String} name The event name to listen to.
* @param {Function} f The function that is executed when the event is fired.
*/
on (name, f) {
let listeners = this._getListener(name);
listeners.on.add(f);
}
/**
* @private
* Init the saved state for an event name.
*/
_initStateListener (name) {
let state = this._stateListener.get(name);
if (state === undefined) {
state = {};
state.promise = new Promise(function (resolve) {
state.resolve = resolve;
});
this._stateListener.set(name, state);
}
return state
}
/**
* Returns a Promise that is resolved when the event name is called.
* The Promise is immediately resolved when the event name was called in the
* past.
*/
when (name) {
return this._initStateListener(name).promise
}
/**
* Remove an event listener that was registered with either
* {@link EventHandler#on} or {@link EventHandler#once}.
*/
off (name, f) {
if (name == null || f == null) {
throw new Error('You must specify event name and function!')
}
const listener = this._eventListener.get(name);
if (listener !== undefined) {
listener.on.delete(f);
listener.once.delete(f);
}
}
/**
* Emit a named event. All registered event listeners that listen to the
* specified name will receive the event.
*
* @param {String} name The event name.
* @param {Array} args The arguments that are applied to the event listener.
*/
emit (name, ...args) {
this._initStateListener(name).resolve();
const listener = this._eventListener.get(name);
if (listener !== undefined) {
listener.on.forEach(f => f.apply(null, args));
listener.once.forEach(f => f.apply(null, args));
listener.once = new Set();
} else if (name === 'error') {
console.error(args[0]);
}
}
destroy () {
this._eventListener = null;
}
}
// TODO: rename mutex
/**
* Creates a mutual exclude function with the following property:
*
* @example
* const mutualExclude = createMutualExclude()
* mutualExclude(function () {
* // This function is immediately executed
* mutualExclude(function () {
* // This function is never executed, as it is called with the same
* // mutualExclude
* })
* })
*
* @return {Function} A mutual exclude function
* @public
*/
function createMutualExclude () {
var token = true;
return function mutualExclude (f) {
if (token) {
token = false;
try {
f();
} catch (e) {
console.error(e);
}
token = true;
}
}
}
/**
* Abstract class for bindings.
*
* A binding handles data binding from a Yjs type to a data object. For example,
* you can bind a Quill editor instance to a YText instance with the `QuillBinding` class.
*
* It is expected that a concrete implementation accepts two parameters
* (type and binding target).
*
* @example
* const quill = new Quill(document.createElement('div'))
* const type = y.define('quill', Y.Text)
* const binding = new Y.QuillBinding(quill, type)
*
*/
class Binding {
/**
* @param {YType} type Yjs type.
* @param {any} target Binding Target.
*/
constructor (type, target) {
/**
* The Yjs type that is bound to `target`
* @type {YType}
*/
this.type = type;
/**
* The target that `type` is bound to.
* @type {*}
*/
this.target = target;
/**
* @private
*/
this._mutualExclude = createMutualExclude();
}
/**
* Remove all data observers (both from the type and the target).
*/
destroy () {
this.type = null;
this.target = null;
}
}
// TODO: Implement function to describe ranges
/**
* A relative position that is based on the Yjs model. In contrast to an
* absolute position (position by index), the relative position can be
* recomputed when remote changes are received. For example:
*
* ```Insert(0, 'x')('a|bc') = 'xa|bc'``` Where | is the cursor position.
*
* A relative cursor position can be obtained with the function
* {@link getRelativePosition} and it can be transformed to an absolute position
* with {@link fromRelativePosition}.
*
* Pro tip: Use this to implement shared cursor locations in YText or YXml!
* The relative position is {@link encodable}, so you can send it to other
* clients.
*
* @example
* // Current cursor position is at position 10
* let relativePosition = getRelativePosition(yText, 10)
* // modify yText
* yText.insert(0, 'abc')
* yText.delete(3, 10)
* // Compute the cursor position
* let absolutePosition = fromRelativePosition(y, relativePosition)
* absolutePosition.type // => yText
* console.log('cursor location is ' + absolutePosition.offset) // => cursor location is 3
*
* @typedef {encodable} RelativePosition
*/
/**
* Create a relativePosition based on a absolute position.
*
* @param {YType} type The base type (e.g. YText or YArray).
* @param {Integer} offset The absolute position.
*/
function getRelativePosition (type, offset) {
// TODO: rename to createRelativePosition
let t = type._start;
while (t !== null) {
if (t._deleted === false) {
if (t._length > offset) {
return [t._id.user, t._id.clock + offset]
}
offset -= t._length;
}
t = t._right;
}
return ['endof', type._id.user, type._id.clock || null, type._id.name || null, type._id.type || null]
}
/**
* @typedef {Object} AbsolutePosition The result of {@link fromRelativePosition}
* @property {YType} type The type on which to apply the absolute position.
* @property {Integer} offset The absolute offset.r
*/
/**
* Transforms a relative position back to a relative position.
*
* @param {Y} y The Yjs instance in which to query for the absolute position.
* @param {RelativePosition} rpos The relative position.
* @return {AbsolutePosition} The absolute position in the Yjs model
* (type + offset).
*/
function fromRelativePosition (y, rpos) {
if (rpos[0] === 'endof') {
let id;
if (rpos[3] === null) {
id = new ID(rpos[1], rpos[2]);
} else {
id = new RootID(rpos[3], rpos[4]);
}
const type = y.os.get(id);
if (type === null || type.constructor === GC) {
return null
}
return {
type,
offset: type.length
}
} else {
let offset = 0;
let struct = y.os.findNodeWithUpperBound(new ID(rpos[0], rpos[1])).val;
const parent = struct._parent;
if (struct.constructor === GC || parent._deleted) {
return null
}
if (!struct._deleted) {
offset = rpos[1] - struct._id.clock;
}
struct = struct._left;
while (struct !== null) {
if (!struct._deleted) {
offset += struct._length;
}
struct = struct._left;
}
return {
type: parent,
offset: offset
}
}
}
/* globals getSelection */
let browserSelection = null;
let relativeSelection = null;
/**
* @private
*/
let beforeTransactionSelectionFixer;
if (typeof getSelection !== 'undefined') {
beforeTransactionSelectionFixer = function _beforeTransactionSelectionFixer (y, domBinding, transaction, remote) {
if (!remote) {
return
}
relativeSelection = { from: null, to: null, fromY: null, toY: null };
browserSelection = getSelection();
const anchorNode = browserSelection.anchorNode;
const anchorNodeType = domBinding.domToType.get(anchorNode);
if (anchorNode !== null && anchorNodeType !== undefined) {
relativeSelection.from = getRelativePosition(anchorNodeType, browserSelection.anchorOffset);
relativeSelection.fromY = anchorNodeType._y;
}
const focusNode = browserSelection.focusNode;
const focusNodeType = domBinding.domToType.get(focusNode);
if (focusNode !== null && focusNodeType !== undefined) {
relativeSelection.to = getRelativePosition(focusNodeType, browserSelection.focusOffset);
relativeSelection.toY = focusNodeType._y;
}
};
} else {
beforeTransactionSelectionFixer = function _fakeBeforeTransactionSelectionFixer () {};
}
/**
* @private
*/
function afterTransactionSelectionFixer (y, domBinding, transaction, remote) {
if (relativeSelection === null || !remote) {
return
}
const to = relativeSelection.to;
const from = relativeSelection.from;
const fromY = relativeSelection.fromY;
const toY = relativeSelection.toY;
let shouldUpdate = false;
let anchorNode = browserSelection.anchorNode;
let anchorOffset = browserSelection.anchorOffset;
let focusNode = browserSelection.focusNode;
let focusOffset = browserSelection.focusOffset;
if (from !== null) {
let sel = fromRelativePosition(fromY, from);
if (sel !== null) {
let node = domBinding.typeToDom.get(sel.type);
let offset = sel.offset;
if (node !== anchorNode || offset !== anchorOffset) {
anchorNode = node;
anchorOffset = offset;
shouldUpdate = true;
}
}
}
if (to !== null) {
let sel = fromRelativePosition(toY, to);
if (sel !== null) {
let node = domBinding.typeToDom.get(sel.type);
let offset = sel.offset;
if (node !== focusNode || offset !== focusOffset) {
focusNode = node;
focusOffset = offset;
shouldUpdate = true;
}
}
}
if (shouldUpdate) {
browserSelection.setBaseAndExtent(
anchorNode,
anchorOffset,
focusNode,
focusOffset
);
}
}
/* global getSelection */
function findScrollReference (scrollingElement) {
if (scrollingElement !== null) {
let anchor = getSelection().anchorNode;
if (anchor == null) {
let children = scrollingElement.children; // only iterate through non-text nodes
for (let i = 0; i < children.length; i++) {
const elem = children[i];
const rect = elem.getBoundingClientRect();
if (rect.top >= 0) {
return { elem, top: rect.top }
}
}
} else {
if (anchor.nodeType === document.TEXT_NODE) {
anchor = anchor.parentElement;
}
const top = anchor.getBoundingClientRect().top;
return { elem: anchor, top: top }
}
}
return null
}
function fixScroll (scrollingElement, ref) {
if (ref !== null) {
const { elem, top } = ref;
const currentTop = elem.getBoundingClientRect().top;
const newScroll = scrollingElement.scrollTop + currentTop - top;
if (newScroll >= 0) {
scrollingElement.scrollTop = newScroll;
}
}
}
/**
* @private
*/
function typeObserver (events) {
this._mutualExclude(() => {
const scrollRef = findScrollReference(this.scrollingElement);
events.forEach(event => {
const yxml = event.target;
const dom = this.typeToDom.get(yxml);
if (dom !== undefined && dom !== false) {
if (yxml.constructor === YXmlText) {
dom.nodeValue = yxml.toString();
// TODO: use hasOwnProperty instead of === undefined check
} else if (event.attributesChanged !== undefined) {
// update attributes
event.attributesChanged.forEach(attributeName => {
const value = yxml.getAttribute(attributeName);
if (value === undefined) {
dom.removeAttribute(attributeName);
} else {
dom.setAttribute(attributeName, value);
}
});
/*
* TODO: instead of hard-checking the types, it would be best to
* specify the type's features. E.g.
* - _yxmlHasAttributes
* - _yxmlHasChildren
* Furthermore, the features shouldn't be encoded in the types,
* only in the attributes (above)
*/
if (event.childListChanged && yxml.constructor !== YXmlHook) {
let currentChild = dom.firstChild;
yxml.forEach(childType => {
const childNode = this.typeToDom.get(childType);
switch (childNode) {
case undefined:
// Does not exist. Create it.
const node = childType.toDom(this.opts.document, this.opts.hooks, this);
dom.insertBefore(node, currentChild);
break
case false:
// nop
break
default:
// Is already attached to the dom.
// Find it and remove all dom nodes in-between.
removeDomChildrenUntilElementFound(dom, currentChild, childNode);
currentChild = childNode.nextSibling;
break
}
});
removeDomChildrenUntilElementFound(dom, currentChild, null);
}
}
}
});
fixScroll(this.scrollingElement, scrollRef);
});
}
/**
* A SimpleDiff describes a change on a String.
*
* @example
* console.log(a) // the old value
* console.log(b) // the updated value
* // Apply changes of diff (pseudocode)
* a.remove(diff.pos, diff.remove) // Remove `diff.remove` characters
* a.insert(diff.pos, diff.insert) // Insert `diff.insert`
* a === b // values match
*
* @typedef {Object} SimpleDiff
* @property {Number} pos The index where changes were applied
* @property {Number} delete The number of characters to delete starting
* at `index`.
* @property {String} insert The new text to insert at `index` after applying
* `delete`
*/
/**
* Create a diff between two strings. This diff implementation is highly
* efficient, but not very sophisticated.
*
* @public
* @param {String} a The old version of the string
* @param {String} b The updated version of the string
* @return {SimpleDiff} The diff description.
*/
function simpleDiff (a, b) {
let left = 0; // number of same characters counting from left
let right = 0; // number of same characters counting from right
while (left < a.length && left < b.length && a[left] === b[left]) {
left++;
}
if (left !== a.length || left !== b.length) {
// Only check right if a !== b
while (right + left < a.length && right + left < b.length && a[a.length - right - 1] === b[b.length - right - 1]) {
right++;
}
}
return {
pos: left, // TODO: rename to index (also in type above)
remove: a.length - left - right,
insert: b.slice(left, b.length - right)
}
}
/**
* 1. Check if any of the nodes was deleted
* 2. Iterate over the children.
* 2.1 If a node exists that is not yet bound to a type, insert a new node
* 2.2 If _contents.length < dom.childNodes.length, fill the
* rest of _content with childNodes
* 2.3 If a node was moved, delete it and
* recreate a new yxml element that is bound to that node.
* You can detect that a node was moved because expectedId
* !== actualId in the list
* @private
*/
function applyChangesFromDom (binding, dom, yxml, _document) {
if (yxml == null || yxml === false || yxml.constructor === YXmlHook) {
return
}
const y = yxml._y;
const knownChildren = new Set();
for (let i = dom.childNodes.length - 1; i >= 0; i--) {
const type = binding.domToType.get(dom.childNodes[i]);
if (type !== undefined && type !== false) {
knownChildren.add(type);
}
}
// 1. Check if any of the nodes was deleted
yxml.forEach(function (childType) {
if (knownChildren.has(childType) === false) {
childType._delete(y);
removeAssociation(binding, binding.typeToDom.get(childType), childType);
}
});
// 2. iterate
const childNodes = dom.childNodes;
const len = childNodes.length;
let prevExpectedType = null;
let expectedType = iterateUntilUndeleted(yxml._start);
for (let domCnt = 0; domCnt < len; domCnt++) {
const childNode = childNodes[domCnt];
const childType = binding.domToType.get(childNode);
if (childType !== undefined) {
if (childType === false) {
// should be ignored or is going to be deleted
continue
}
if (expectedType !== null) {
if (expectedType !== childType) {
// 2.3 Not expected node
if (childType._parent !== yxml) {
// child was moved from another parent
// childType is going to be deleted by its previous parent
removeAssociation(binding, childNode, childType);
} else {
// child was moved to a different position.
removeAssociation(binding, childNode, childType);
childType._delete(y);
}
prevExpectedType = insertNodeHelper(yxml, prevExpectedType, childNode, _document, binding);
} else {
// Found expected node. Continue.
prevExpectedType = expectedType;
expectedType = iterateUntilUndeleted(expectedType._right);
}
} else {
// 2.2 Fill _content with child nodes
prevExpectedType = insertNodeHelper(yxml, prevExpectedType, childNode, _document, binding);
}
} else {
// 2.1 A new node was found
prevExpectedType = insertNodeHelper(yxml, prevExpectedType, childNode, _document, binding);
}
}
}
/**
* @private
*/
function domObserver (mutations, _document) {
this._mutualExclude(() => {
this.type._y.transact(() => {
let diffChildren = new Set();
mutations.forEach(mutation => {
const dom = mutation.target;
const yxml = this.domToType.get(dom);
if (yxml === undefined) { // In case yxml is undefined, we double check if we forgot to bind the dom
let parent;
let yParent;
do {
parent = dom.parentNode;
yParent = this.domToType.get(parent);
} while (yParent === undefined && parent !== null)
if (yParent !== false && yParent !== undefined && yParent.constructor !== YXmlHook) {
diffChildren.add(parent);
}
return
} else if (yxml === false || yxml.constructor === YXmlHook) {
// dom element is filtered / a dom hook
return
}
switch (mutation.type) {
case 'characterData':
var change = simpleDiff(yxml.toString(), dom.nodeValue);
yxml.delete(change.pos, change.remove);
yxml.insert(change.pos, change.insert);
break
case 'attributes':
if (yxml.constructor === YXmlFragment) {
break
}
let name = mutation.attributeName;
let val = dom.getAttribute(name);
// check if filter accepts attribute
let attributes = new Map();
attributes.set(name, val);
if (yxml.constructor !== YXmlFragment && this.filter(dom.nodeName, attributes).size > 0) {
if (yxml.getAttribute(name) !== val) {
if (val == null) {
yxml.removeAttribute(name);
} else {
yxml.setAttribute(name, val);
}
}
}
break
case 'childList':
diffChildren.add(mutation.target);
break
}
});
for (let dom of diffChildren) {
const yxml = this.domToType.get(dom);
applyChangesFromDom(this, dom, yxml, _document);
}
});
});
}
/* global MutationObserver */
/**
* A binding that binds the children of a YXmlFragment to a DOM element.
*
* This binding is automatically destroyed when its parent is deleted.
*
* @example
* const div = document.createElement('div')
* const type = y.define('xml', Y.XmlFragment)
* const binding = new Y.QuillBinding(type, div)
*
*/
class DomBinding extends Binding {
/**
* @param {YXmlFragment} type The bind source. This is the ultimate source of
* truth.
* @param {Element} target The bind target. Mirrors the target.
* @param {Object} [opts] Optional configurations
* @param {FilterFunction} [opts.filter=defaultFilter] The filter function to use.
*/
constructor (type, target, opts = {}) {
// Binding handles textType as this.type and domTextarea as this.target
super(type, target);
this.opts = opts;
opts.document = opts.document || document;
opts.hooks = opts.hooks || {};
this.scrollingElement = opts.scrollingElement || null;
/**
* Maps each DOM element to the type that it is associated with.
* @type {Map}
*/
this.domToType = new Map();
/**
* Maps each YXml type to the DOM element that it is associated with.
* @type {Map}
*/
this.typeToDom = new Map();
/**
* Defines which DOM attributes and elements to filter out.
* Also filters remote changes.
* @type {FilterFunction}
*/
this.filter = opts.filter || defaultFilter;
// set initial value
target.innerHTML = '';
type.forEach(child => {
target.insertBefore(child.toDom(opts.document, opts.hooks, this), null);
});
this._typeObserver = typeObserver.bind(this);
this._domObserver = (mutations) => {
domObserver.call(this, mutations, opts.document);
};
type.observeDeep(this._typeObserver);
this._mutationObserver = new MutationObserver(this._domObserver);
this._mutationObserver.observe(target, {
childList: true,
attributes: true,
characterData: true,
subtree: true
});
const y = type._y;
// Force flush dom changes before Type changes are applied (they might
// modify the dom)
this._beforeTransactionHandler = (y, transaction, remote) => {
this._domObserver(this._mutationObserver.takeRecords());
beforeTransactionSelectionFixer(y, this, transaction, remote);
};
y.on('beforeTransaction', this._beforeTransactionHandler);
this._afterTransactionHandler = (y, transaction, remote) => {
afterTransactionSelectionFixer(y, this, transaction, remote);
// remove associations
// TODO: this could be done more efficiently
// e.g. Always delete using the following approach, or removeAssociation
// in dom/type-observer..
transaction.deletedStructs.forEach(type => {
const dom = this.typeToDom.get(type);
if (dom !== undefined) {
removeAssociation(this, dom, type);
}
});
};
y.on('afterTransaction', this._afterTransactionHandler);
// Before calling observers, apply dom filter to all changed and new types.
this._beforeObserverCallsHandler = (y, transaction) => {
// Apply dom filter to new and changed types
transaction.changedTypes.forEach((subs, type) => {
// Only check attributes. New types are filtered below.
if ((subs.size > 1 || (subs.size === 1 && subs.has(null) === false))) {
applyFilterOnType(y, this, type);
}
});
transaction.newTypes.forEach(type => {
applyFilterOnType(y, this, type);
});
};
y.on('beforeObserverCalls', this._beforeObserverCallsHandler);
createAssociation(this, target, type);
}
/**
* NOTE: currently does not apply filter to existing elements!
* @param {FilterFunction} filter The filter function to use from now on.
*/
setFilter (filter) {
this.filter = filter;
// TODO: apply filter to all elements
}
/**
* Remove all properties that are handled by this class.
*/
destroy () {
this.domToType = null;
this.typeToDom = null;
this.type.unobserve(this._typeObserver);
this._mutationObserver.disconnect();
const y = this.type._y;
y.off('beforeTransaction', this._beforeTransactionHandler);
y.off('beforeObserverCalls', this._beforeObserverCallsHandler);
y.off('afterObserverCalls', this._afterObserverCallsHandler);
y.off('afterTransaction', this._afterTransactionHandler);
super.destroy();
}
}
/**
* A filter defines which elements and attributes to share.
* Return null if the node should be filtered. Otherwise return the Map of
* accepted attributes.
*
* @typedef {function(nodeName: String, attrs: Map): Map|null} FilterFunction
*/
/**
* Anything that can be encoded with `JSON.stringify` and can be decoded with
* `JSON.parse`.
*
* The following property should hold:
* `JSON.parse(JSON.stringify(key))===key`
*
* At the moment the only safe values are number and string.
*
* @typedef {(number|string)} encodable
*/
/**
* A Yjs instance handles the state of shared data.
*
* @param {string} room Users in the same room share the same content
* @param {Object} opts Connector definition
* @param {AbstractPersistence} persistence Persistence adapter instance
*/
class Y$1 extends NamedEventHandler {
constructor (room, opts, persistence, conf = {}) {
super();
this.gcEnabled = conf.gc || false;
/**
* The room name that this Yjs instance connects to.
* @type {String}
*/
this.room = room;
if (opts != null) {
opts.connector.room = room;
}
this._contentReady = false;
this._opts = opts;
if (typeof opts.userID !== 'number') {
this.userID = generateRandomUint32();
} else {
this.userID = opts.userID;
}
// TODO: This should be a Map so we can use encodables as keys
this.share = {};
this.ds = new DeleteStore(this);
this.os = new OperationStore(this);
this.ss = new StateStore(this);
this._missingStructs = new Map();
this._readyToIntegrate = [];
this._transaction = null;
/**
* The {@link AbstractConnector}.that is used by this Yjs instance.
* @type {AbstractConnector}
*/
this.connector = null;
this.connected = false;
let initConnection = () => {
if (opts != null) {
this.connector = new Y$1[opts.connector.name](this, opts.connector);
this.connected = true;
this.emit('connectorReady');
}
};
/**
* The {@link AbstractPersistence} that is used by this Yjs instance.
* @type {AbstractPersistence}
*/
this.persistence = null;
if (persistence != null) {
this.persistence = persistence;
persistence._init(this).then(initConnection);
} else {
initConnection();
}
// for compatibility with isParentOf
this._parent = null;
this._hasUndoManager = false;
}
_setContentReady () {
if (!this._contentReady) {
this._contentReady = true;
this.emit('content');
}
}
whenContentReady () {
if (this._contentReady) {
return Promise.resolve()
} else {
return new Promise(resolve => {
this.once('content', resolve);
})
}
}
_beforeChange () {}
/**
* Changes that happen inside of a transaction are bundled. This means that
* the observer fires _after_ the transaction is finished and that all changes
* that happened inside of the transaction are sent as one message to the
* other peers.
*
* @param {Function} f The function that should be executed as a transaction
* @param {?Boolean} remote Optional. Whether this transaction is initiated by
* a remote peer. This should not be set manually!
* Defaults to false.
*/
transact (f, remote = false) {
let initialCall = this._transaction === null;
if (initialCall) {
this._transaction = new Transaction(this);
this.emit('beforeTransaction', this, this._transaction, remote);
}
try {
f(this);
} catch (e) {
console.error(e);
}
if (initialCall) {
this.emit('beforeObserverCalls', this, this._transaction, remote);
const transaction = this._transaction;
this._transaction = null;
// emit change events on changed types
transaction.changedTypes.forEach(function (subs, type) {
if (!type._deleted) {
type._callObserver(transaction, subs, remote);
}
});
transaction.changedParentTypes.forEach(function (events, type) {
if (!type._deleted) {
events = events
.filter(event =>
!event.target._deleted
);
events
.forEach(event => {
event.currentTarget = type;
});
// we don't have to check for events.length
// because there is no way events is empty..
type._deepEventHandler.callEventListeners(transaction, events);
}
});
// when all changes & events are processed, emit afterTransaction event
this.emit('afterTransaction', this, transaction, remote);
}
}
/**
* @private
* Fake _start for root properties (y.set('name', type))
*/
get _start () {
return null
}
/**
* @private
* Fake _start for root properties (y.set('name', type))
*/
set _start (start) {
return null
}
/**
* Define a shared data type.
*
* Multiple calls of `y.define(name, TypeConstructor)` yield the same result
* and do not overwrite each other. I.e.
* `y.define(name, type) === y.define(name, type)`
*
* After this method is called, the type is also available on `y.share[name]`.
*
* *Best Practices:*
* Either define all types right after the Yjs instance is created or always
* use `y.define(..)` when accessing a type.
*
* @example
* // Option 1
* const y = new Y(..)
* y.define('myArray', YArray)
* y.define('myMap', YMap)
* // .. when accessing the type use y.share[name]
* y.share.myArray.insert(..)
* y.share.myMap.set(..)
*
* // Option2
* const y = new Y(..)
* // .. when accessing the type use `y.define(..)`
* y.define('myArray', YArray).insert(..)
* y.define('myMap', YMap).set(..)
*
* @param {String} name
* @param {YType Constructor} TypeConstructor The constructor of the type definition
* @returns {YType} The created type
*/
define (name, TypeConstructor) {
let id = new RootID(name, TypeConstructor);
let type = this.os.get(id);
if (this.share[name] === undefined) {
this.share[name] = type;
} else if (this.share[name] !== type) {
throw new Error('Type is already defined with a different constructor')
}
return type
}
/**
* Get a defined type. The type must be defined locally. First define the
* type with {@link define}.
*
* This returns the same value as `y.share[name]`
*
* @param {String} name The typename
*/
get (name) {
return this.share[name]
}
/**
* Disconnect this Yjs Instance from the network. The connector will
* unsubscribe from the room and document updates are not shared anymore.
*/
disconnect () {
if (this.connected) {
this.connected = false;
return this.connector.disconnect()
} else {
return Promise.resolve()
}
}
/**
* If disconnected, tell the connector to reconnect to the room.
*/
reconnect () {
if (!this.connected) {
this.connected = true;
return this.connector.reconnect()
} else {
return Promise.resolve()
}
}
/**
* Disconnect from the room, and destroy all traces of this Yjs instance.
* Persisted data will remain until removed by the persistence adapter.
*/
destroy () {
super.destroy();
this.share = null;
if (this.connector != null) {
if (this.connector.destroy != null) {
this.connector.destroy();
} else {
this.connector.disconnect();
}
}
if (this.persistence !== null) {
this.persistence.deinit(this);
this.persistence = null;
}
this.os = null;
this.ds = null;
this.ss = null;
}
}
Y$1.extend = function extendYjs () {
for (var i = 0; i < arguments.length; i++) {
var f = arguments[i];
if (typeof f === 'function') {
f(Y$1);
} else {
throw new Error('Expected a function!')
}
}
};
class ReverseOperation {
constructor (y, transaction) {
this.created = new Date();
const beforeState = transaction.beforeState;
if (beforeState.has(y.userID)) {
this.toState = new ID(y.userID, y.ss.getState(y.userID) - 1);
this.fromState = new ID(y.userID, beforeState.get(y.userID));
} else {
this.toState = null;
this.fromState = null;
}
this.deletedStructs = transaction.deletedStructs;
}
}
function applyReverseOperation (y, scope, reverseBuffer) {
let performedUndo = false;
y.transact(() => {
while (!performedUndo && reverseBuffer.length > 0) {
let undoOp = reverseBuffer.pop();
// make sure that it is possible to iterate {from}-{to}
if (undoOp.fromState !== null) {
y.os.getItemCleanStart(undoOp.fromState);
y.os.getItemCleanEnd(undoOp.toState);
y.os.iterate(undoOp.fromState, undoOp.toState, op => {
while (op._deleted && op._redone !== null) {
op = op._redone;
}
if (op._deleted === false && isParentOf(scope, op)) {
performedUndo = true;
op._delete(y);
}
});
}
for (let op of undoOp.deletedStructs) {
if (
isParentOf(scope, op) &&
op._parent !== y &&
(
op._id.user !== y.userID ||
undoOp.fromState === null ||
op._id.clock < undoOp.fromState.clock ||
op._id.clock > undoOp.toState.clock
)
) {
performedUndo = true;
op._redo(y);
}
}
}
});
return performedUndo
}
/**
* Saves a history of locally applied operations. The UndoManager handles the
* undoing and redoing of locally created changes.
*/
class UndoManager {
/**
* @param {YType} scope The scope on which to listen for changes.
* @param {Object} options Optionally provided configuration.
*/
constructor (scope, options = {}) {
this.options = options;
options.captureTimeout = options.captureTimeout == null ? 500 : options.captureTimeout;
this._undoBuffer = [];
this._redoBuffer = [];
this._scope = scope;
this._undoing = false;
this._redoing = false;
this._lastTransactionWasUndo = false;
const y = scope._y;
this.y = y;
y._hasUndoManager = true;
y.on('afterTransaction', (y, transaction, remote) => {
if (!remote && transaction.changedParentTypes.has(scope)) {
let reverseOperation = new ReverseOperation(y, transaction);
if (!this._undoing) {
let lastUndoOp = this._undoBuffer.length > 0 ? this._undoBuffer[this._undoBuffer.length - 1] : null;
if (
this._redoing === false &&
this._lastTransactionWasUndo === false &&
lastUndoOp !== null &&
reverseOperation.created - lastUndoOp.created <= options.captureTimeout
) {
lastUndoOp.created = reverseOperation.created;
if (reverseOperation.toState !== null) {
lastUndoOp.toState = reverseOperation.toState;
if (lastUndoOp.fromState === null) {
lastUndoOp.fromState = reverseOperation.fromState;
}
}
reverseOperation.deletedStructs.forEach(lastUndoOp.deletedStructs.add, lastUndoOp.deletedStructs);
} else {
this._lastTransactionWasUndo = false;
this._undoBuffer.push(reverseOperation);
}
if (!this._redoing) {
this._redoBuffer = [];
}
} else {
this._lastTransactionWasUndo = true;
this._redoBuffer.push(reverseOperation);
}
}
});
}
/**
* Undo the last locally created change.
*/
undo () {
this._undoing = true;
const performedUndo = applyReverseOperation(this.y, this._scope, this._undoBuffer);
this._undoing = false;
return performedUndo
}
/**
* Redo the last locally created change.
*/
redo () {
this._redoing = true;
const performedRedo = applyReverseOperation(this.y, this._scope, this._redoBuffer);
this._redoing = false;
return performedRedo
}
}
/**
* Helpers.
*/
var s = 1000;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var y = d * 365.25;
/**
* Parse or format the given `val`.
*
* Options:
*
* - `long` verbose formatting [false]
*
* @param {String|Number} val
* @param {Object} [options]
* @throws {Error} throw an error if val is not a non-empty string or a number
* @return {String|Number}
* @api public
*/
var ms = function(val, options) {
options = options || {};
var type = typeof val;
if (type === 'string' && val.length > 0) {
return parse$1(val);
} else if (type === 'number' && isNaN(val) === false) {
return options.long ? fmtLong(val) : fmtShort(val);
}
throw new Error(
'val is not a non-empty string or a valid number. val=' +
JSON.stringify(val)
);
};
/**
* Parse the given `str` and return milliseconds.
*
* @param {String} str
* @return {Number}
* @api private
*/
function parse$1(str) {
str = String(str);
if (str.length > 100) {
return;
}
var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
str
);
if (!match) {
return;
}
var n = parseFloat(match[1]);
var type = (match[2] || 'ms').toLowerCase();
switch (type) {
case 'years':
case 'year':
case 'yrs':
case 'yr':
case 'y':
return n * y;
case 'days':
case 'day':
case 'd':
return n * d;
case 'hours':
case 'hour':
case 'hrs':
case 'hr':
case 'h':
return n * h;
case 'minutes':
case 'minute':
case 'mins':
case 'min':
case 'm':
return n * m;
case 'seconds':
case 'second':
case 'secs':
case 'sec':
case 's':
return n * s;
case 'milliseconds':
case 'millisecond':
case 'msecs':
case 'msec':
case 'ms':
return n;
default:
return undefined;
}
}
/**
* Short format for `ms`.
*
* @param {Number} ms
* @return {String}
* @api private
*/
function fmtShort(ms) {
if (ms >= d) {
return Math.round(ms / d) + 'd';
}
if (ms >= h) {
return Math.round(ms / h) + 'h';
}
if (ms >= m) {
return Math.round(ms / m) + 'm';
}
if (ms >= s) {
return Math.round(ms / s) + 's';
}
return ms + 'ms';
}
/**
* Long format for `ms`.
*
* @param {Number} ms
* @return {String}
* @api private
*/
function fmtLong(ms) {
return plural(ms, d, 'day') ||
plural(ms, h, 'hour') ||
plural(ms, m, 'minute') ||
plural(ms, s, 'second') ||
ms + ' ms';
}
/**
* Pluralization helper.
*/
function plural(ms, n, name) {
if (ms < n) {
return;
}
if (ms < n * 1.5) {
return Math.floor(ms / n) + ' ' + name;
}
return Math.ceil(ms / n) + ' ' + name + 's';
}
var debug$1 = createCommonjsModule(function (module, exports) {
/**
* This is the common logic for both the Node.js and web browser
* implementations of `debug()`.
*
* Expose `debug()` as the module.
*/
exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
exports.coerce = coerce;
exports.disable = disable;
exports.enable = enable;
exports.enabled = enabled;
exports.humanize = ms;
/**
* The currently active debug mode names, and names to skip.
*/
exports.names = [];
exports.skips = [];
/**
* Map of special "%n" handling functions, for the debug "format" argument.
*
* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
*/
exports.formatters = {};
/**
* Previous log timestamp.
*/
var prevTime;
/**
* Select a color.
* @param {String} namespace
* @return {Number}
* @api private
*/
function selectColor(namespace) {
var hash = 0, i;
for (i in namespace) {
hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
hash |= 0; // Convert to 32bit integer
}
return exports.colors[Math.abs(hash) % exports.colors.length];
}
/**
* Create a debugger with the given `namespace`.
*
* @param {String} namespace
* @return {Function}
* @api public
*/
function createDebug(namespace) {
function debug() {
// disabled?
if (!debug.enabled) return;
var self = debug;
// set `diff` timestamp
var curr = +new Date();
var ms$$1 = curr - (prevTime || curr);
self.diff = ms$$1;
self.prev = prevTime;
self.curr = curr;
prevTime = curr;
// turn the `arguments` into a proper Array
var args = new Array(arguments.length);
for (var i = 0; i < args.length; i++) {
args[i] = arguments[i];
}
args[0] = exports.coerce(args[0]);
if ('string' !== typeof args[0]) {
// anything else let's inspect with %O
args.unshift('%O');
}
// apply any `formatters` transformations
var index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
// if we encounter an escaped % then don't increase the array index
if (match === '%%') return match;
index++;
var formatter = exports.formatters[format];
if ('function' === typeof formatter) {
var val = args[index];
match = formatter.call(self, val);
// now we need to remove `args[index]` since it's inlined in the `format`
args.splice(index, 1);
index--;
}
return match;
});
// apply env-specific formatting (colors, etc.)
exports.formatArgs.call(self, args);
var logFn = debug.log || exports.log || console.log.bind(console);
logFn.apply(self, args);
}
debug.namespace = namespace;
debug.enabled = exports.enabled(namespace);
debug.useColors = exports.useColors();
debug.color = selectColor(namespace);
// env-specific initialization logic for debug instances
if ('function' === typeof exports.init) {
exports.init(debug);
}
return debug;
}
/**
* Enables a debug mode by namespaces. This can include modes
* separated by a colon and wildcards.
*
* @param {String} namespaces
* @api public
*/
function enable(namespaces) {
exports.save(namespaces);
exports.names = [];
exports.skips = [];
var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
var len = split.length;
for (var i = 0; i < len; i++) {
if (!split[i]) continue; // ignore empty strings
namespaces = split[i].replace(/\*/g, '.*?');
if (namespaces[0] === '-') {
exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
} else {
exports.names.push(new RegExp('^' + namespaces + '$'));
}
}
}
/**
* Disable debug output.
*
* @api public
*/
function disable() {
exports.enable('');
}
/**
* Returns true if the given mode name is enabled, false otherwise.
*
* @param {String} name
* @return {Boolean}
* @api public
*/
function enabled(name) {
var i, len;
for (i = 0, len = exports.skips.length; i < len; i++) {
if (exports.skips[i].test(name)) {
return false;
}
}
for (i = 0, len = exports.names.length; i < len; i++) {
if (exports.names[i].test(name)) {
return true;
}
}
return false;
}
/**
* Coerce `val`.
*
* @param {Mixed} val
* @return {Mixed}
* @api private
*/
function coerce(val) {
if (val instanceof Error) return val.stack || val.message;
return val;
}
});
var debug_1 = debug$1.coerce;
var debug_2 = debug$1.disable;
var debug_3 = debug$1.enable;
var debug_4 = debug$1.enabled;
var debug_5 = debug$1.humanize;
var debug_6 = debug$1.names;
var debug_7 = debug$1.skips;
var debug_8 = debug$1.formatters;
var browser = createCommonjsModule(function (module, exports) {
/**
* This is the web browser implementation of `debug()`.
*
* Expose `debug()` as the module.
*/
exports = module.exports = debug$1;
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = 'undefined' != typeof chrome
&& 'undefined' != typeof chrome.storage
? chrome.storage.local
: localstorage();
/**
* Colors.
*/
exports.colors = [
'lightseagreen',
'forestgreen',
'goldenrod',
'dodgerblue',
'darkorchid',
'crimson'
];
/**
* Currently only WebKit-based Web Inspectors, Firefox >= v31,
* and the Firebug extension (any Firefox version) are known
* to support "%c" CSS customizations.
*
* TODO: add a `localStorage` variable to explicitly enable/disable colors
*/
function useColors() {
// NB: In an Electron preload script, document will be defined but not fully
// initialized. Since we know we're in Chrome, we'll just detect this case
// explicitly
if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
return true;
}
// is webkit? http://stackoverflow.com/a/16459606/376773
// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
// is firebug? http://stackoverflow.com/a/398120/376773
(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
// is firefox >= v31?
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
// double check webkit in userAgent just in case we are in a worker
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
}
/**
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
*/
exports.formatters.j = function(v) {
try {
return JSON.stringify(v);
} catch (err) {
return '[UnexpectedJSONParseError]: ' + err.message;
}
};
/**
* Colorize log arguments if enabled.
*
* @api public
*/
function formatArgs(args) {
var useColors = this.useColors;
args[0] = (useColors ? '%c' : '')
+ this.namespace
+ (useColors ? ' %c' : ' ')
+ args[0]
+ (useColors ? '%c ' : ' ')
+ '+' + exports.humanize(this.diff);
if (!useColors) return;
var c = 'color: ' + this.color;
args.splice(1, 0, c, 'color: inherit');
// the final "%c" is somewhat tricky, because there could be other
// arguments passed either before or after the %c, so we need to
// figure out the correct index to insert the CSS into
var index = 0;
var lastC = 0;
args[0].replace(/%[a-zA-Z%]/g, function(match) {
if ('%%' === match) return;
index++;
if ('%c' === match) {
// we only are interested in the *last* %c
// (the user may have provided their own)
lastC = index;
}
});
args.splice(lastC, 0, c);
}
/**
* Invokes `console.log()` when available.
* No-op when `console.log` is not a "function".
*
* @api public
*/
function log() {
// this hackery is required for IE8/9, where
// the `console.log` function doesn't have 'apply'
return 'object' === typeof console
&& console.log
&& Function.prototype.apply.call(console.log, console, arguments);
}
/**
* Save `namespaces`.
*
* @param {String} namespaces
* @api private
*/
function save(namespaces) {
try {
if (null == namespaces) {
exports.storage.removeItem('debug');
} else {
exports.storage.debug = namespaces;
}
} catch(e) {}
}
/**
* Load `namespaces`.
*
* @return {String} returns the previously persisted debug modes
* @api private
*/
function load() {
var r;
try {
r = exports.storage.debug;
} catch(e) {}
// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
if (!r && typeof process !== 'undefined' && 'env' in process) {
r = process.env.DEBUG;
}
return r;
}
/**
* Enable namespaces listed in `localStorage.debug` initially.
*/
exports.enable(load());
/**
* Localstorage attempts to return the localstorage.
*
* This is necessary because safari throws
* when a user disables cookies/localstorage
* and you attempt to access it.
*
* @return {LocalStorage}
* @api private
*/
function localstorage() {
try {
return window.localStorage;
} catch (e) {}
}
});
var browser_1 = browser.log;
var browser_2 = browser.formatArgs;
var browser_3 = browser.save;
var browser_4 = browser.load;
var browser_5 = browser.useColors;
var browser_6 = browser.storage;
var browser_7 = browser.colors;
// TODO: rename Connector
class AbstractConnector {
constructor (y, opts) {
this.y = y;
this.opts = opts;
if (opts.role == null || opts.role === 'master') {
this.role = 'master';
} else if (opts.role === 'slave') {
this.role = 'slave';
} else {
throw new Error("Role must be either 'master' or 'slave'!")
}
this.log = browser('y:connector');
this.logMessage = browser('y:connector-message');
this._forwardAppliedStructs = opts.forwardAppliedOperations || false; // TODO: rename
this.role = opts.role;
this.connections = new Map();
this.isSynced = false;
this.userEventListeners = [];
this.whenSyncedListeners = [];
this.currentSyncTarget = null;
this.debug = opts.debug === true;
this.broadcastBuffer = new BinaryEncoder();
this.broadcastBufferSize = 0;
this.protocolVersion = 11;
this.authInfo = opts.auth || null;
this.checkAuth = opts.checkAuth || function () { return Promise.resolve('write') }; // default is everyone has write access
if (opts.maxBufferLength == null) {
this.maxBufferLength = -1;
} else {
this.maxBufferLength = opts.maxBufferLength;
}
}
reconnect () {
this.log('reconnecting..');
}
disconnect () {
this.log('discronnecting..');
this.connections = new Map();
this.isSynced = false;
this.currentSyncTarget = null;
this.whenSyncedListeners = [];
return Promise.resolve()
}
onUserEvent (f) {
this.userEventListeners.push(f);
}
removeUserEventListener (f) {
this.userEventListeners = this.userEventListeners.filter(g => f !== g);
}
userLeft (user) {
if (this.connections.has(user)) {
this.log('%s: User left %s', this.y.userID, user);
this.connections.delete(user);
// check if isSynced event can be sent now
this._setSyncedWith(null);
for (var f of this.userEventListeners) {
f({
action: 'userLeft',
user: user
});
}
}
}
userJoined (user, role, auth) {
if (role == null) {
throw new Error('You must specify the role of the joined user!')
}
if (this.connections.has(user)) {
throw new Error('This user already joined!')
}
this.log('%s: User joined %s', this.y.userID, user);
this.connections.set(user, {
uid: user,
isSynced: false,
role: role,
processAfterAuth: [],
processAfterSync: [],
auth: auth || null,
receivedSyncStep2: false
});
let defer = {};
defer.promise = new Promise(function (resolve) { defer.resolve = resolve; });
this.connections.get(user).syncStep2 = defer;
for (var f of this.userEventListeners) {
f({
action: 'userJoined',
user: user,
role: role
});
}
this._syncWithUser(user);
}
// Execute a function _when_ we are connected.
// If not connected, wait until connected
whenSynced (f) {
if (this.isSynced) {
f();
} else {
this.whenSyncedListeners.push(f);
}
}
_syncWithUser (userID) {
if (this.role === 'slave') {
return // "The current sync has not finished or this is controlled by a master!"
}
sendSyncStep1(this, userID);
}
_fireIsSyncedListeners () {
if (!this.isSynced) {
this.isSynced = true;
// It is safer to remove this!
// call whensynced listeners
for (var f of this.whenSyncedListeners) {
f();
}
this.whenSyncedListeners = [];
this.y._setContentReady();
this.y.emit('synced');
}
}
send (uid, buffer) {
const y = this.y;
if (!(buffer instanceof ArrayBuffer || buffer instanceof Uint8Array)) {
throw new Error('Expected Message to be an ArrayBuffer or Uint8Array - don\'t use this method to send custom messages')
}
this.log('User%s to User%s: Send \'%y\'', y.userID, uid, buffer);
this.logMessage('User%s to User%s: Send %Y', y.userID, uid, [y, buffer]);
}
broadcast (buffer) {
const y = this.y;
if (!(buffer instanceof ArrayBuffer || buffer instanceof Uint8Array)) {
throw new Error('Expected Message to be an ArrayBuffer or Uint8Array - don\'t use this method to send custom messages')
}
this.log('User%s: Broadcast \'%y\'', y.userID, buffer);
this.logMessage('User%s: Broadcast: %Y', y.userID, [y, buffer]);
}
/*
Buffer operations, and broadcast them when ready.
*/
broadcastStruct (struct) {
const firstContent = this.broadcastBuffer.length === 0;
if (firstContent) {
this.broadcastBuffer.writeVarString(this.y.room);
this.broadcastBuffer.writeVarString('update');
this.broadcastBufferSize = 0;
this.broadcastBufferSizePos = this.broadcastBuffer.pos;
this.broadcastBuffer.writeUint32(0);
}
this.broadcastBufferSize++;
struct._toBinary(this.broadcastBuffer);
if (this.maxBufferLength > 0 && this.broadcastBuffer.length > this.maxBufferLength) {
// it is necessary to send the buffer now
// cache the buffer and check if server is responsive
const buffer = this.broadcastBuffer;
buffer.setUint32(this.broadcastBufferSizePos, this.broadcastBufferSize);
this.broadcastBuffer = new BinaryEncoder();
this.whenRemoteResponsive().then(() => {
this.broadcast(buffer.createBuffer());
});
} else if (firstContent) {
// send the buffer when all transactions are finished
// (or buffer exceeds maxBufferLength)
setTimeout(() => {
if (this.broadcastBuffer.length > 0) {
const buffer = this.broadcastBuffer;
buffer.setUint32(this.broadcastBufferSizePos, this.broadcastBufferSize);
this.broadcast(buffer.createBuffer());
this.broadcastBuffer = new BinaryEncoder();
}
}, 0);
}
}
/*
* Somehow check the responsiveness of the remote clients/server
* Default behavior:
* Wait 100ms before broadcasting the next batch of operations
*
* Only used when maxBufferLength is set
*
*/
whenRemoteResponsive () {
return new Promise(function (resolve) {
setTimeout(resolve, 100);
})
}
/*
You received a raw message, and you know that it is intended for Yjs. Then call this function.
*/
receiveMessage (sender, buffer, skipAuth) {
const y = this.y;
const userID = y.userID;
skipAuth = skipAuth || false;
if (!(buffer instanceof ArrayBuffer || buffer instanceof Uint8Array)) {
return Promise.reject(new Error('Expected Message to be an ArrayBuffer or Uint8Array!'))
}
if (sender === userID) {
return Promise.resolve()
}
let decoder = new BinaryDecoder(buffer);
let encoder = new BinaryEncoder();
let roomname = decoder.readVarString(); // read room name
encoder.writeVarString(roomname);
let messageType = decoder.readVarString();
let senderConn = this.connections.get(sender);
this.log('User%s from User%s: Receive \'%s\'', userID, sender, messageType);
this.logMessage('User%s from User%s: Receive %Y', userID, sender, [y, buffer]);
if (senderConn == null && !skipAuth) {
throw new Error('Received message from unknown peer!')
}
if (messageType === 'sync step 1' || messageType === 'sync step 2') {
let auth = decoder.readVarUint();
if (senderConn.auth == null) {
senderConn.processAfterAuth.push([messageType, senderConn, decoder, encoder, sender]);
// check auth
return this.checkAuth(auth, y, sender).then(authPermissions => {
if (senderConn.auth == null) {
senderConn.auth = authPermissions;
y.emit('userAuthenticated', {
user: senderConn.uid,
auth: authPermissions
});
}
let messages = senderConn.processAfterAuth;
senderConn.processAfterAuth = [];
messages.forEach(m =>
this.computeMessage(m[0], m[1], m[2], m[3], m[4])
);
})
}
}
if ((skipAuth || senderConn.auth != null) && (messageType !== 'update' || senderConn.isSynced)) {
this.computeMessage(messageType, senderConn, decoder, encoder, sender, skipAuth);
} else {
senderConn.processAfterSync.push([messageType, senderConn, decoder, encoder, sender, false]);
}
}
computeMessage (messageType, senderConn, decoder, encoder, sender, skipAuth) {
if (messageType === 'sync step 1' && (senderConn.auth === 'write' || senderConn.auth === 'read')) {
// cannot wait for sync step 1 to finish, because we may wait for sync step 2 in sync step 1 (->lock)
readSyncStep1(decoder, encoder, this.y, senderConn, sender);
} else {
const y = this.y;
y.transact(function () {
if (messageType === 'sync step 2' && senderConn.auth === 'write') {
readSyncStep2(decoder, encoder, y, senderConn, sender);
} else if (messageType === 'update' && (skipAuth || senderConn.auth === 'write')) {
integrateRemoteStructs(y, decoder);
} else {
throw new Error('Unable to receive message')
}
}, true);
}
}
_setSyncedWith (user) {
if (user != null) {
const userConn = this.connections.get(user);
userConn.isSynced = true;
const messages = userConn.processAfterSync;
userConn.processAfterSync = [];
messages.forEach(m => {
this.computeMessage(m[0], m[1], m[2], m[3], m[4]);
});
}
const conns = Array.from(this.connections.values());
if (conns.length > 0 && conns.every(u => u.isSynced)) {
this._fireIsSyncedListeners();
}
}
}
/**
* Read the Decoder and fill the Yjs instance with data in the decoder.
*
* @param {Y} y The Yjs instance
* @param {BinaryDecoder} decoder The BinaryDecoder to read from.
*/
function fromBinary (y, decoder) {
y.transact(function () {
integrateRemoteStructs(y, decoder);
readDeleteSet(y, decoder);
});
}
/**
* Encode the Yjs model to binary format.
*
* @param {Y} y The Yjs instance
* @return {BinaryEncoder} The encoder instance that can be transformed
* to ArrayBuffer or Buffer.
*/
function toBinary (y) {
let encoder = new BinaryEncoder();
writeStructs(y, encoder, new Map());
writeDeleteSet(y, encoder);
return encoder
}
function getFreshCnf () {
let buffer = new BinaryEncoder();
buffer.writeUint32(0);
return {
len: 0,
buffer
}
}
/**
* Abstract persistence class.
*/
class AbstractPersistence {
constructor (opts) {
this.opts = opts;
this.ys = new Map();
}
_init (y) {
let cnf = this.ys.get(y);
if (cnf === undefined) {
cnf = getFreshCnf();
cnf.mutualExclude = createMutualExclude();
this.ys.set(y, cnf);
return this.init(y).then(() => {
y.on('afterTransaction', (y, transaction) => {
let cnf = this.ys.get(y);
if (cnf.len > 0) {
cnf.buffer.setUint32(0, cnf.len);
this.saveUpdate(y, cnf.buffer.createBuffer(), transaction);
let _cnf = getFreshCnf();
for (let key in _cnf) {
cnf[key] = _cnf[key];
}
}
});
return this.retrieve(y)
}).then(function () {
return Promise.resolve(cnf)
})
} else {
return Promise.resolve(cnf)
}
}
deinit (y) {
this.ys.delete(y);
y.persistence = null;
}
destroy () {
this.ys = null;
}
/**
* Remove all persisted data that belongs to a room.
* Automatically destroys all Yjs all Yjs instances that persist to
* the room. If `destroyYjsInstances = false` the persistence functionality
* will be removed from the Yjs instances.
*
* ** Must be overwritten! **
*/
removePersistedData (room, destroyYjsInstances = true) {
this.ys.forEach((cnf, y) => {
if (y.room === room) {
if (destroyYjsInstances) {
y.destroy();
} else {
this.deinit(y);
}
}
});
}
/* overwrite */
saveUpdate (buffer) {
}
/**
* Save struct to update buffer.
* saveUpdate is called when transaction ends
*/
saveStruct (y, struct) {
let cnf = this.ys.get(y);
if (cnf !== undefined) {
cnf.mutualExclude(function () {
struct._toBinary(cnf.buffer);
cnf.len++;
});
}
}
/* overwrite */
retrieve (y, model, updates) {
let cnf = this.ys.get(y);
if (cnf !== undefined) {
cnf.mutualExclude(function () {
y.transact(function () {
if (model != null) {
fromBinary(y, new BinaryDecoder(new Uint8Array(model)));
}
if (updates != null) {
for (let i = 0; i < updates.length; i++) {
integrateRemoteStructs(y, new BinaryDecoder(new Uint8Array(updates[i])));
}
}
});
y.emit('persistenceReady');
});
}
}
/* overwrite */
persist (y) {
return toBinary(y).createBuffer()
}
}
function typeObserver$1 () {
this._mutualExclude(() => {
const textarea = this.target;
const textType = this.type;
const relativeStart = getRelativePosition(textType, textarea.selectionStart);
const relativeEnd = getRelativePosition(textType, textarea.selectionEnd);
textarea.value = textType.toString();
const start = fromRelativePosition(textType._y, relativeStart);
const end = fromRelativePosition(textType._y, relativeEnd);
textarea.setSelectionRange(start, end);
});
}
function domObserver$1 () {
this._mutualExclude(() => {
let diff = simpleDiff(this.type.toString(), this.target.value);
this.type.delete(diff.pos, diff.remove);
this.type.insert(diff.pos, diff.insert);
});
}
/**
* A binding that binds a YText to a dom textarea.
*
* This binding is automatically destroyed when its parent is deleted.
*
* @example
* const textare = document.createElement('textarea')
* const type = y.define('textarea', Y.Text)
* const binding = new Y.QuillBinding(type, textarea)
*
*/
class TextareaBinding extends Binding {
constructor (textType, domTextarea) {
// Binding handles textType as this.type and domTextarea as this.target
super(textType, domTextarea);
// set initial value
domTextarea.value = textType.toString();
// Observers are handled by this class
this._typeObserver = typeObserver$1.bind(this);
this._domObserver = domObserver$1.bind(this);
textType.observe(this._typeObserver);
domTextarea.addEventListener('input', this._domObserver);
}
destroy () {
// Remove everything that is handled by this class
this.type.unobserve(this._typeObserver);
this.target.unobserve(this._domObserver);
super.destroy();
}
}
function typeObserver$2 (event) {
const quill = this.target;
// Force flush Quill changes.
quill.update('yjs');
this._mutualExclude(function () {
// Apply computed delta.
quill.updateContents(event.delta, 'yjs');
// Force flush Quill changes. Ignore applied changes.
quill.update('yjs');
});
}
function quillObserver (delta) {
this._mutualExclude(() => {
this.type.applyDelta(delta.ops);
});
}
/**
* A Binding that binds a YText type to a Quill editor.
*
* @example
* const quill = new Quill(document.createElement('div'))
* const type = y.define('quill', Y.Text)
* const binding = new Y.QuillBinding(quill, type)
* // Now modifications on the DOM will be reflected in the Type, and the other
* // way around!
*/
class QuillBinding extends Binding {
/**
* @param {YText} textType
* @param {Quill} quill
*/
constructor (textType, quill) {
// Binding handles textType as this.type and quill as this.target.
super(textType, quill);
// Set initial value.
quill.setContents(textType.toDelta(), 'yjs');
// Observers are handled by this class.
this._typeObserver = typeObserver$2.bind(this);
this._quillObserver = quillObserver.bind(this);
textType.observe(this._typeObserver);
quill.on('text-change', this._quillObserver);
}
destroy () {
// Remove everything that is handled by this class.
this.type.unobserve(this._typeObserver);
this.target.off('text-change', this._quillObserver);
super.destroy();
}
}
// TODO: The following assignments should be moved to yjs-dist
Y$1.AbstractConnector = AbstractConnector;
Y$1.AbstractPersistence = AbstractPersistence;
Y$1.Array = YArray;
Y$1.Map = YMap;
Y$1.Text = YText;
Y$1.XmlElement = YXmlElement;
Y$1.XmlFragment = YXmlFragment;
Y$1.XmlText = YXmlText;
Y$1.XmlHook = YXmlHook;
Y$1.TextareaBinding = TextareaBinding;
Y$1.QuillBinding = QuillBinding;
Y$1.DomBinding = DomBinding;
DomBinding.domToType = domToType;
DomBinding.domsToTypes = domsToTypes;
DomBinding.switchAssociation = switchAssociation;
Y$1.utils = {
BinaryDecoder,
UndoManager,
getRelativePosition,
fromRelativePosition,
registerStruct,
integrateRemoteStructs,
toBinary,
fromBinary
};
Y$1.debug = browser;
browser.formatters.Y = messageToString;
browser.formatters.y = messageToRoomname;
var rooms = {};
class TestRoom {
constructor (roomname) {
this.room = roomname;
this.users = new Map();
}
join (connector$$1) {
const userID = connector$$1.y.userID;
this.users.set(userID, connector$$1);
for (let [uid, user] of this.users) {
if (uid !== userID && (user.role === 'master' || connector$$1.role === 'master')) {
// The order is important because there is no timeout in send/receiveMessage
// (the user that receives a sync step must already now about the sender)
if (user.role === 'master') {
connector$$1.userJoined(uid, user.role);
user.userJoined(userID, connector$$1.role);
} else if (connector$$1.role === 'master') {
user.userJoined(userID, connector$$1.role);
connector$$1.userJoined(uid, user.role);
}
}
}
}
leave (connector$$1) {
this.users.delete(connector$$1.y.userID);
this.users.forEach(user => {
user.userLeft(connector$$1.y.userID);
});
}
send (sender, receiver, m) {
var user = this.users.get(receiver);
if (user != null) {
user.receiveMessage(sender, m);
}
}
broadcast (sender, m) {
this.users.forEach((user, receiver) => {
this.send(sender, receiver, m);
});
}
async flushAll (users) {
let flushing = true;
let allUsers = Array.from(this.users.values());
if (users == null) {
users = allUsers.map(user => user.y);
}
while (flushing) {
await wait(10);
let res = await Promise.all(allUsers.map(user => user._flushAll(users)));
flushing = res.some(status => status === 'flushing');
}
}
}
function getTestRoom (roomname) {
if (rooms[roomname] == null) {
rooms[roomname] = new TestRoom(roomname);
}
return rooms[roomname]
}
class TestConnector extends AbstractConnector {
constructor (y, options) {
if (options === undefined) {
throw new Error('Options must not be undefined!')
}
if (options.room == null) {
throw new Error('You must define a room name!')
}
options.forwardAppliedOperations = options.role === 'master';
super(y, options);
this.options = options;
this.room = options.room;
this.chance = options.chance;
this.testRoom = getTestRoom(this.room);
this.testRoom.join(this);
}
disconnect () {
this.testRoom.leave(this);
return super.disconnect()
}
logBufferParsed () {
console.log(' === Logging buffer of user ' + this.y.userID + ' === ');
for (let [user, conn] of this.connections) {
console.log(` ${user}:`);
for (let i = 0; i < conn.buffer.length; i++) {
console.log(messageToString(conn.buffer[i]));
}
}
}
reconnect () {
this.testRoom.join(this);
super.reconnect();
return new Promise(resolve => {
this.whenSynced(resolve);
})
}
send (uid, message) {
super.send(uid, message);
this.testRoom.send(this.y.userID, uid, message);
}
broadcast (message) {
super.broadcast(message);
this.testRoom.broadcast(this.y.userID, message);
}
async whenSynced (f) {
var synced = false;
var periodicFlushTillSync = () => {
if (synced) {
f();
} else {
this.testRoom.flushAll([this.y]).then(function () {
setTimeout(periodicFlushTillSync, 10);
});
}
};
periodicFlushTillSync();
return super.whenSynced(function () {
synced = true;
})
}
receiveMessage (sender, m) {
if (this.y.userID !== sender && this.connections.has(sender)) {
var buffer = this.connections.get(sender).buffer;
if (buffer == null) {
buffer = this.connections.get(sender).buffer = [];
}
buffer.push(m);
if (this.chance.bool({likelihood: 30})) {
// flush 1/2 with 30% chance
var flushLength = Math.round(buffer.length / 2);
buffer.splice(0, flushLength).forEach(m => {
super.receiveMessage(sender, m);
});
}
}
}
async _flushAll (flushUsers) {
if (flushUsers.some(u => u.connector.y.userID === this.y.userID)) {
// this one needs to sync with every other user
flushUsers = Array.from(this.connections.keys()).map(uid => this.testRoom.users.get(uid).y);
}
for (let i = 0; i < flushUsers.length; i++) {
let userID = flushUsers[i].connector.y.userID;
if (userID !== this.y.userID && this.connections.has(userID)) {
let buffer = this.connections.get(userID).buffer;
if (buffer != null) {
var messages = buffer.splice(0);
for (let j = 0; j < messages.length; j++) {
super.receiveMessage(userID, messages[j]);
}
}
}
}
return 'done'
}
}
/**
* Try to merge all items in os with their successors.
*
* Some transformations (like delete) fragment items.
* Item(c: 'ab') + Delete(1,1) + Delete(0, 1) -> Item(c: 'a',deleted);Item(c: 'b',deleted)
*
* This functions merges the fragmented nodes together:
* Item(c: 'a',deleted);Item(c: 'b',deleted) -> Item(c: 'ab', deleted)
*
* TODO: The Tree implementation does not support deletions in-spot.
* This is why all deletions must be performed after the traversal.
*
*/
function defragmentItemContent (y) {
const os = y.os;
if (os.length < 2) {
return
}
let deletes = [];
let node = os.findSmallestNode();
let next = node.next();
while (next !== null) {
let a = node.val;
let b = next.val;
if (
(a instanceof ItemJSON || a instanceof ItemString) &&
a.constructor === b.constructor &&
a._deleted === b._deleted &&
a._right === b &&
(new ID(a._id.user, a._id.clock + a._length)).equals(b._id)
) {
a._right = b._right;
if (a instanceof ItemJSON) {
a._content = a._content.concat(b._content);
} else if (a instanceof ItemString) {
a._content += b._content;
}
// delete b later
deletes.push(b._id);
// do not iterate node!
// !(node = next)
} else {
// not able to merge node, get next node
node = next;
}
// update next
next = next.next();
}
for (let i = deletes.length - 1; i >= 0; i--) {
os.delete(deletes[i]);
}
}
var quill = createCommonjsModule(function (module, exports) {
/*!
* Quill Editor v1.3.6
* https://quilljs.com/
* Copyright (c) 2014, Jason Chen
* Copyright (c) 2013, salesforce.com
*/
(function webpackUniversalModuleDefinition(root, factory) {
module.exports = factory();
})(typeof self !== 'undefined' ? self : commonjsGlobal, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 109);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var container_1 = __webpack_require__(17);
var format_1 = __webpack_require__(18);
var leaf_1 = __webpack_require__(19);
var scroll_1 = __webpack_require__(45);
var inline_1 = __webpack_require__(46);
var block_1 = __webpack_require__(47);
var embed_1 = __webpack_require__(48);
var text_1 = __webpack_require__(49);
var attributor_1 = __webpack_require__(12);
var class_1 = __webpack_require__(32);
var style_1 = __webpack_require__(33);
var store_1 = __webpack_require__(31);
var Registry = __webpack_require__(1);
var Parchment = {
Scope: Registry.Scope,
create: Registry.create,
find: Registry.find,
query: Registry.query,
register: Registry.register,
Container: container_1.default,
Format: format_1.default,
Leaf: leaf_1.default,
Embed: embed_1.default,
Scroll: scroll_1.default,
Block: block_1.default,
Inline: inline_1.default,
Text: text_1.default,
Attributor: {
Attribute: attributor_1.default,
Class: class_1.default,
Style: style_1.default,
Store: store_1.default,
},
};
exports.default = Parchment;
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var ParchmentError = /** @class */ (function (_super) {
__extends(ParchmentError, _super);
function ParchmentError(message) {
var _this = this;
message = '[Parchment] ' + message;
_this = _super.call(this, message) || this;
_this.message = message;
_this.name = _this.constructor.name;
return _this;
}
return ParchmentError;
}(Error));
exports.ParchmentError = ParchmentError;
var attributes = {};
var classes = {};
var tags = {};
var types = {};
exports.DATA_KEY = '__blot';
var Scope;
(function (Scope) {
Scope[Scope["TYPE"] = 3] = "TYPE";
Scope[Scope["LEVEL"] = 12] = "LEVEL";
Scope[Scope["ATTRIBUTE"] = 13] = "ATTRIBUTE";
Scope[Scope["BLOT"] = 14] = "BLOT";
Scope[Scope["INLINE"] = 7] = "INLINE";
Scope[Scope["BLOCK"] = 11] = "BLOCK";
Scope[Scope["BLOCK_BLOT"] = 10] = "BLOCK_BLOT";
Scope[Scope["INLINE_BLOT"] = 6] = "INLINE_BLOT";
Scope[Scope["BLOCK_ATTRIBUTE"] = 9] = "BLOCK_ATTRIBUTE";
Scope[Scope["INLINE_ATTRIBUTE"] = 5] = "INLINE_ATTRIBUTE";
Scope[Scope["ANY"] = 15] = "ANY";
})(Scope = exports.Scope || (exports.Scope = {}));
function create(input, value) {
var match = query(input);
if (match == null) {
throw new ParchmentError("Unable to create " + input + " blot");
}
var BlotClass = match;
var node =
// @ts-ignore
input instanceof Node || input['nodeType'] === Node.TEXT_NODE ? input : BlotClass.create(value);
return new BlotClass(node, value);
}
exports.create = create;
function find(node, bubble) {
if (bubble === void 0) { bubble = false; }
if (node == null)
return null;
// @ts-ignore
if (node[exports.DATA_KEY] != null)
return node[exports.DATA_KEY].blot;
if (bubble)
return find(node.parentNode, bubble);
return null;
}
exports.find = find;
function query(query, scope) {
if (scope === void 0) { scope = Scope.ANY; }
var match;
if (typeof query === 'string') {
match = types[query] || attributes[query];
// @ts-ignore
}
else if (query instanceof Text || query['nodeType'] === Node.TEXT_NODE) {
match = types['text'];
}
else if (typeof query === 'number') {
if (query & Scope.LEVEL & Scope.BLOCK) {
match = types['block'];
}
else if (query & Scope.LEVEL & Scope.INLINE) {
match = types['inline'];
}
}
else if (query instanceof HTMLElement) {
var names = (query.getAttribute('class') || '').split(/\s+/);
for (var i in names) {
match = classes[names[i]];
if (match)
break;
}
match = match || tags[query.tagName];
}
if (match == null)
return null;
// @ts-ignore
if (scope & Scope.LEVEL & match.scope && scope & Scope.TYPE & match.scope)
return match;
return null;
}
exports.query = query;
function register() {
var Definitions = [];
for (var _i = 0; _i < arguments.length; _i++) {
Definitions[_i] = arguments[_i];
}
if (Definitions.length > 1) {
return Definitions.map(function (d) {
return register(d);
});
}
var Definition = Definitions[0];
if (typeof Definition.blotName !== 'string' && typeof Definition.attrName !== 'string') {
throw new ParchmentError('Invalid definition');
}
else if (Definition.blotName === 'abstract') {
throw new ParchmentError('Cannot register abstract class');
}
types[Definition.blotName || Definition.attrName] = Definition;
if (typeof Definition.keyName === 'string') {
attributes[Definition.keyName] = Definition;
}
else {
if (Definition.className != null) {
classes[Definition.className] = Definition;
}
if (Definition.tagName != null) {
if (Array.isArray(Definition.tagName)) {
Definition.tagName = Definition.tagName.map(function (tagName) {
return tagName.toUpperCase();
});
}
else {
Definition.tagName = Definition.tagName.toUpperCase();
}
var tagNames = Array.isArray(Definition.tagName) ? Definition.tagName : [Definition.tagName];
tagNames.forEach(function (tag) {
if (tags[tag] == null || Definition.className == null) {
tags[tag] = Definition;
}
});
}
}
return Definition;
}
exports.register = register;
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
var diff = __webpack_require__(51);
var equal = __webpack_require__(11);
var extend = __webpack_require__(3);
var op = __webpack_require__(20);
var NULL_CHARACTER = String.fromCharCode(0); // Placeholder char for embed in diff()
var Delta = function (ops) {
// Assume we are given a well formed ops
if (Array.isArray(ops)) {
this.ops = ops;
} else if (ops != null && Array.isArray(ops.ops)) {
this.ops = ops.ops;
} else {
this.ops = [];
}
};
Delta.prototype.insert = function (text, attributes) {
var newOp = {};
if (text.length === 0) return this;
newOp.insert = text;
if (attributes != null && typeof attributes === 'object' && Object.keys(attributes).length > 0) {
newOp.attributes = attributes;
}
return this.push(newOp);
};
Delta.prototype['delete'] = function (length) {
if (length <= 0) return this;
return this.push({ 'delete': length });
};
Delta.prototype.retain = function (length, attributes) {
if (length <= 0) return this;
var newOp = { retain: length };
if (attributes != null && typeof attributes === 'object' && Object.keys(attributes).length > 0) {
newOp.attributes = attributes;
}
return this.push(newOp);
};
Delta.prototype.push = function (newOp) {
var index = this.ops.length;
var lastOp = this.ops[index - 1];
newOp = extend(true, {}, newOp);
if (typeof lastOp === 'object') {
if (typeof newOp['delete'] === 'number' && typeof lastOp['delete'] === 'number') {
this.ops[index - 1] = { 'delete': lastOp['delete'] + newOp['delete'] };
return this;
}
// Since it does not matter if we insert before or after deleting at the same index,
// always prefer to insert first
if (typeof lastOp['delete'] === 'number' && newOp.insert != null) {
index -= 1;
lastOp = this.ops[index - 1];
if (typeof lastOp !== 'object') {
this.ops.unshift(newOp);
return this;
}
}
if (equal(newOp.attributes, lastOp.attributes)) {
if (typeof newOp.insert === 'string' && typeof lastOp.insert === 'string') {
this.ops[index - 1] = { insert: lastOp.insert + newOp.insert };
if (typeof newOp.attributes === 'object') this.ops[index - 1].attributes = newOp.attributes;
return this;
} else if (typeof newOp.retain === 'number' && typeof lastOp.retain === 'number') {
this.ops[index - 1] = { retain: lastOp.retain + newOp.retain };
if (typeof newOp.attributes === 'object') this.ops[index - 1].attributes = newOp.attributes;
return this;
}
}
}
if (index === this.ops.length) {
this.ops.push(newOp);
} else {
this.ops.splice(index, 0, newOp);
}
return this;
};
Delta.prototype.chop = function () {
var lastOp = this.ops[this.ops.length - 1];
if (lastOp && lastOp.retain && !lastOp.attributes) {
this.ops.pop();
}
return this;
};
Delta.prototype.filter = function (predicate) {
return this.ops.filter(predicate);
};
Delta.prototype.forEach = function (predicate) {
this.ops.forEach(predicate);
};
Delta.prototype.map = function (predicate) {
return this.ops.map(predicate);
};
Delta.prototype.partition = function (predicate) {
var passed = [], failed = [];
this.forEach(function(op) {
var target = predicate(op) ? passed : failed;
target.push(op);
});
return [passed, failed];
};
Delta.prototype.reduce = function (predicate, initial) {
return this.ops.reduce(predicate, initial);
};
Delta.prototype.changeLength = function () {
return this.reduce(function (length, elem) {
if (elem.insert) {
return length + op.length(elem);
} else if (elem.delete) {
return length - elem.delete;
}
return length;
}, 0);
};
Delta.prototype.length = function () {
return this.reduce(function (length, elem) {
return length + op.length(elem);
}, 0);
};
Delta.prototype.slice = function (start, end) {
start = start || 0;
if (typeof end !== 'number') end = Infinity;
var ops = [];
var iter = op.iterator(this.ops);
var index = 0;
while (index < end && iter.hasNext()) {
var nextOp;
if (index < start) {
nextOp = iter.next(start - index);
} else {
nextOp = iter.next(end - index);
ops.push(nextOp);
}
index += op.length(nextOp);
}
return new Delta(ops);
};
Delta.prototype.compose = function (other) {
var thisIter = op.iterator(this.ops);
var otherIter = op.iterator(other.ops);
var delta = new Delta();
while (thisIter.hasNext() || otherIter.hasNext()) {
if (otherIter.peekType() === 'insert') {
delta.push(otherIter.next());
} else if (thisIter.peekType() === 'delete') {
delta.push(thisIter.next());
} else {
var length = Math.min(thisIter.peekLength(), otherIter.peekLength());
var thisOp = thisIter.next(length);
var otherOp = otherIter.next(length);
if (typeof otherOp.retain === 'number') {
var newOp = {};
if (typeof thisOp.retain === 'number') {
newOp.retain = length;
} else {
newOp.insert = thisOp.insert;
}
// Preserve null when composing with a retain, otherwise remove it for inserts
var attributes = op.attributes.compose(thisOp.attributes, otherOp.attributes, typeof thisOp.retain === 'number');
if (attributes) newOp.attributes = attributes;
delta.push(newOp);
// Other op should be delete, we could be an insert or retain
// Insert + delete cancels out
} else if (typeof otherOp['delete'] === 'number' && typeof thisOp.retain === 'number') {
delta.push(otherOp);
}
}
}
return delta.chop();
};
Delta.prototype.concat = function (other) {
var delta = new Delta(this.ops.slice());
if (other.ops.length > 0) {
delta.push(other.ops[0]);
delta.ops = delta.ops.concat(other.ops.slice(1));
}
return delta;
};
Delta.prototype.diff = function (other, index) {
if (this.ops === other.ops) {
return new Delta();
}
var strings = [this, other].map(function (delta) {
return delta.map(function (op) {
if (op.insert != null) {
return typeof op.insert === 'string' ? op.insert : NULL_CHARACTER;
}
var prep = (delta === other) ? 'on' : 'with';
throw new Error('diff() called ' + prep + ' non-document');
}).join('');
});
var delta = new Delta();
var diffResult = diff(strings[0], strings[1], index);
var thisIter = op.iterator(this.ops);
var otherIter = op.iterator(other.ops);
diffResult.forEach(function (component) {
var length = component[1].length;
while (length > 0) {
var opLength = 0;
switch (component[0]) {
case diff.INSERT:
opLength = Math.min(otherIter.peekLength(), length);
delta.push(otherIter.next(opLength));
break;
case diff.DELETE:
opLength = Math.min(length, thisIter.peekLength());
thisIter.next(opLength);
delta['delete'](opLength);
break;
case diff.EQUAL:
opLength = Math.min(thisIter.peekLength(), otherIter.peekLength(), length);
var thisOp = thisIter.next(opLength);
var otherOp = otherIter.next(opLength);
if (equal(thisOp.insert, otherOp.insert)) {
delta.retain(opLength, op.attributes.diff(thisOp.attributes, otherOp.attributes));
} else {
delta.push(otherOp)['delete'](opLength);
}
break;
}
length -= opLength;
}
});
return delta.chop();
};
Delta.prototype.eachLine = function (predicate, newline) {
newline = newline || '\n';
var iter = op.iterator(this.ops);
var line = new Delta();
var i = 0;
while (iter.hasNext()) {
if (iter.peekType() !== 'insert') return;
var thisOp = iter.peek();
var start = op.length(thisOp) - iter.peekLength();
var index = typeof thisOp.insert === 'string' ?
thisOp.insert.indexOf(newline, start) - start : -1;
if (index < 0) {
line.push(iter.next());
} else if (index > 0) {
line.push(iter.next(index));
} else {
if (predicate(line, iter.next(1).attributes || {}, i) === false) {
return;
}
i += 1;
line = new Delta();
}
}
if (line.length() > 0) {
predicate(line, {}, i);
}
};
Delta.prototype.transform = function (other, priority) {
priority = !!priority;
if (typeof other === 'number') {
return this.transformPosition(other, priority);
}
var thisIter = op.iterator(this.ops);
var otherIter = op.iterator(other.ops);
var delta = new Delta();
while (thisIter.hasNext() || otherIter.hasNext()) {
if (thisIter.peekType() === 'insert' && (priority || otherIter.peekType() !== 'insert')) {
delta.retain(op.length(thisIter.next()));
} else if (otherIter.peekType() === 'insert') {
delta.push(otherIter.next());
} else {
var length = Math.min(thisIter.peekLength(), otherIter.peekLength());
var thisOp = thisIter.next(length);
var otherOp = otherIter.next(length);
if (thisOp['delete']) {
// Our delete either makes their delete redundant or removes their retain
continue;
} else if (otherOp['delete']) {
delta.push(otherOp);
} else {
// We retain either their retain or insert
delta.retain(length, op.attributes.transform(thisOp.attributes, otherOp.attributes, priority));
}
}
}
return delta.chop();
};
Delta.prototype.transformPosition = function (index, priority) {
priority = !!priority;
var thisIter = op.iterator(this.ops);
var offset = 0;
while (thisIter.hasNext() && offset <= index) {
var length = thisIter.peekLength();
var nextType = thisIter.peekType();
thisIter.next();
if (nextType === 'delete') {
index -= Math.min(length, index - offset);
continue;
} else if (nextType === 'insert' && (offset < index || !priority)) {
index += length;
}
offset += length;
}
return index;
};
module.exports = Delta;
/***/ }),
/* 3 */
/***/ (function(module, exports) {
var hasOwn = Object.prototype.hasOwnProperty;
var toStr = Object.prototype.toString;
var isArray = function isArray(arr) {
if (typeof Array.isArray === 'function') {
return Array.isArray(arr);
}
return toStr.call(arr) === '[object Array]';
};
var isPlainObject = function isPlainObject(obj) {
if (!obj || toStr.call(obj) !== '[object Object]') {
return false;
}
var hasOwnConstructor = hasOwn.call(obj, 'constructor');
var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
// Not own constructor property must be Object
if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
return false;
}
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
var key;
for (key in obj) { /**/ }
return typeof key === 'undefined' || hasOwn.call(obj, key);
};
module.exports = function extend() {
var options, name, src, copy, copyIsArray, clone;
var target = arguments[0];
var i = 1;
var length = arguments.length;
var deep = false;
// Handle a deep copy situation
if (typeof target === 'boolean') {
deep = target;
target = arguments[1] || {};
// skip the boolean and the target
i = 2;
}
if (target == null || (typeof target !== 'object' && typeof target !== 'function')) {
target = {};
}
for (; i < length; ++i) {
options = arguments[i];
// Only deal with non-null/undefined values
if (options != null) {
// Extend the base object
for (name in options) {
src = target[name];
copy = options[name];
// Prevent never-ending loop
if (target !== copy) {
// Recurse if we're merging plain objects or arrays
if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
if (copyIsArray) {
copyIsArray = false;
clone = src && isArray(src) ? src : [];
} else {
clone = src && isPlainObject(src) ? src : {};
}
// Never move original objects, clone them
target[name] = extend(deep, clone, copy);
// Don't bring in undefined values
} else if (typeof copy !== 'undefined') {
target[name] = copy;
}
}
}
}
}
// Return the modified object
return target;
};
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.BlockEmbed = exports.bubbleFormats = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _extend = __webpack_require__(3);
var _extend2 = _interopRequireDefault(_extend);
var _quillDelta = __webpack_require__(2);
var _quillDelta2 = _interopRequireDefault(_quillDelta);
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _break = __webpack_require__(16);
var _break2 = _interopRequireDefault(_break);
var _inline = __webpack_require__(6);
var _inline2 = _interopRequireDefault(_inline);
var _text = __webpack_require__(7);
var _text2 = _interopRequireDefault(_text);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var NEWLINE_LENGTH = 1;
var BlockEmbed = function (_Parchment$Embed) {
_inherits(BlockEmbed, _Parchment$Embed);
function BlockEmbed() {
_classCallCheck(this, BlockEmbed);
return _possibleConstructorReturn(this, (BlockEmbed.__proto__ || Object.getPrototypeOf(BlockEmbed)).apply(this, arguments));
}
_createClass(BlockEmbed, [{
key: 'attach',
value: function attach() {
_get(BlockEmbed.prototype.__proto__ || Object.getPrototypeOf(BlockEmbed.prototype), 'attach', this).call(this);
this.attributes = new _parchment2.default.Attributor.Store(this.domNode);
}
}, {
key: 'delta',
value: function delta() {
return new _quillDelta2.default().insert(this.value(), (_extend2.default)(this.formats(), this.attributes.values()));
}
}, {
key: 'format',
value: function format(name, value) {
var attribute = _parchment2.default.query(name, _parchment2.default.Scope.BLOCK_ATTRIBUTE);
if (attribute != null) {
this.attributes.attribute(attribute, value);
}
}
}, {
key: 'formatAt',
value: function formatAt(index, length, name, value) {
this.format(name, value);
}
}, {
key: 'insertAt',
value: function insertAt(index, value, def) {
if (typeof value === 'string' && value.endsWith('\n')) {
var block = _parchment2.default.create(Block.blotName);
this.parent.insertBefore(block, index === 0 ? this : this.next);
block.insertAt(0, value.slice(0, -1));
} else {
_get(BlockEmbed.prototype.__proto__ || Object.getPrototypeOf(BlockEmbed.prototype), 'insertAt', this).call(this, index, value, def);
}
}
}]);
return BlockEmbed;
}(_parchment2.default.Embed);
BlockEmbed.scope = _parchment2.default.Scope.BLOCK_BLOT;
// It is important for cursor behavior BlockEmbeds use tags that are block level elements
var Block = function (_Parchment$Block) {
_inherits(Block, _Parchment$Block);
function Block(domNode) {
_classCallCheck(this, Block);
var _this2 = _possibleConstructorReturn(this, (Block.__proto__ || Object.getPrototypeOf(Block)).call(this, domNode));
_this2.cache = {};
return _this2;
}
_createClass(Block, [{
key: 'delta',
value: function delta() {
if (this.cache.delta == null) {
this.cache.delta = this.descendants(_parchment2.default.Leaf).reduce(function (delta, leaf) {
if (leaf.length() === 0) {
return delta;
} else {
return delta.insert(leaf.value(), bubbleFormats(leaf));
}
}, new _quillDelta2.default()).insert('\n', bubbleFormats(this));
}
return this.cache.delta;
}
}, {
key: 'deleteAt',
value: function deleteAt(index, length) {
_get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'deleteAt', this).call(this, index, length);
this.cache = {};
}
}, {
key: 'formatAt',
value: function formatAt(index, length, name, value) {
if (length <= 0) return;
if (_parchment2.default.query(name, _parchment2.default.Scope.BLOCK)) {
if (index + length === this.length()) {
this.format(name, value);
}
} else {
_get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'formatAt', this).call(this, index, Math.min(length, this.length() - index - 1), name, value);
}
this.cache = {};
}
}, {
key: 'insertAt',
value: function insertAt(index, value, def) {
if (def != null) return _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'insertAt', this).call(this, index, value, def);
if (value.length === 0) return;
var lines = value.split('\n');
var text = lines.shift();
if (text.length > 0) {
if (index < this.length() - 1 || this.children.tail == null) {
_get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'insertAt', this).call(this, Math.min(index, this.length() - 1), text);
} else {
this.children.tail.insertAt(this.children.tail.length(), text);
}
this.cache = {};
}
var block = this;
lines.reduce(function (index, line) {
block = block.split(index, true);
block.insertAt(0, line);
return line.length;
}, index + text.length);
}
}, {
key: 'insertBefore',
value: function insertBefore(blot, ref) {
var head = this.children.head;
_get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'insertBefore', this).call(this, blot, ref);
if (head instanceof _break2.default) {
head.remove();
}
this.cache = {};
}
}, {
key: 'length',
value: function length() {
if (this.cache.length == null) {
this.cache.length = _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'length', this).call(this) + NEWLINE_LENGTH;
}
return this.cache.length;
}
}, {
key: 'moveChildren',
value: function moveChildren(target, ref) {
_get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'moveChildren', this).call(this, target, ref);
this.cache = {};
}
}, {
key: 'optimize',
value: function optimize(context) {
_get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'optimize', this).call(this, context);
this.cache = {};
}
}, {
key: 'path',
value: function path(index) {
return _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'path', this).call(this, index, true);
}
}, {
key: 'removeChild',
value: function removeChild(child) {
_get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'removeChild', this).call(this, child);
this.cache = {};
}
}, {
key: 'split',
value: function split(index) {
var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
if (force && (index === 0 || index >= this.length() - NEWLINE_LENGTH)) {
var clone = this.clone();
if (index === 0) {
this.parent.insertBefore(clone, this);
return this;
} else {
this.parent.insertBefore(clone, this.next);
return clone;
}
} else {
var next = _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'split', this).call(this, index, force);
this.cache = {};
return next;
}
}
}]);
return Block;
}(_parchment2.default.Block);
Block.blotName = 'block';
Block.tagName = 'P';
Block.defaultChild = 'break';
Block.allowedChildren = [_inline2.default, _parchment2.default.Embed, _text2.default];
function bubbleFormats(blot) {
var formats = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
if (blot == null) return formats;
if (typeof blot.formats === 'function') {
formats = (_extend2.default)(formats, blot.formats());
}
if (blot.parent == null || blot.parent.blotName == 'scroll' || blot.parent.statics.scope !== blot.statics.scope) {
return formats;
}
return bubbleFormats(blot.parent, formats);
}
exports.bubbleFormats = bubbleFormats;
exports.BlockEmbed = BlockEmbed;
exports.default = Block;
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.overload = exports.expandConfig = undefined;
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
__webpack_require__(50);
var _quillDelta = __webpack_require__(2);
var _quillDelta2 = _interopRequireDefault(_quillDelta);
var _editor = __webpack_require__(14);
var _editor2 = _interopRequireDefault(_editor);
var _emitter3 = __webpack_require__(8);
var _emitter4 = _interopRequireDefault(_emitter3);
var _module = __webpack_require__(9);
var _module2 = _interopRequireDefault(_module);
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _selection = __webpack_require__(15);
var _selection2 = _interopRequireDefault(_selection);
var _extend = __webpack_require__(3);
var _extend2 = _interopRequireDefault(_extend);
var _logger = __webpack_require__(10);
var _logger2 = _interopRequireDefault(_logger);
var _theme = __webpack_require__(34);
var _theme2 = _interopRequireDefault(_theme);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var debug = (_logger2.default)('quill');
var Quill = function () {
_createClass(Quill, null, [{
key: 'debug',
value: function debug(limit) {
if (limit === true) {
limit = 'log';
}
_logger2.default.level(limit);
}
}, {
key: 'find',
value: function find(node) {
return node.__quill || _parchment2.default.find(node);
}
}, {
key: 'import',
value: function _import(name) {
if (this.imports[name] == null) {
debug.error('Cannot import ' + name + '. Are you sure it was registered?');
}
return this.imports[name];
}
}, {
key: 'register',
value: function register(path, target) {
var _this = this;
var overwrite = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
if (typeof path !== 'string') {
var name = path.attrName || path.blotName;
if (typeof name === 'string') {
// register(Blot | Attributor, overwrite)
this.register('formats/' + name, path, target);
} else {
Object.keys(path).forEach(function (key) {
_this.register(key, path[key], target);
});
}
} else {
if (this.imports[path] != null && !overwrite) {
debug.warn('Overwriting ' + path + ' with', target);
}
this.imports[path] = target;
if ((path.startsWith('blots/') || path.startsWith('formats/')) && target.blotName !== 'abstract') {
_parchment2.default.register(target);
} else if (path.startsWith('modules') && typeof target.register === 'function') {
target.register();
}
}
}
}]);
function Quill(container) {
var _this2 = this;
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
_classCallCheck(this, Quill);
this.options = expandConfig(container, options);
this.container = this.options.container;
if (this.container == null) {
return debug.error('Invalid Quill container', container);
}
if (this.options.debug) {
Quill.debug(this.options.debug);
}
var html = this.container.innerHTML.trim();
this.container.classList.add('ql-container');
this.container.innerHTML = '';
this.container.__quill = this;
this.root = this.addContainer('ql-editor');
this.root.classList.add('ql-blank');
this.root.setAttribute('data-gramm', false);
this.scrollingContainer = this.options.scrollingContainer || this.root;
this.emitter = new _emitter4.default();
this.scroll = _parchment2.default.create(this.root, {
emitter: this.emitter,
whitelist: this.options.formats
});
this.editor = new _editor2.default(this.scroll);
this.selection = new _selection2.default(this.scroll, this.emitter);
this.theme = new this.options.theme(this, this.options);
this.keyboard = this.theme.addModule('keyboard');
this.clipboard = this.theme.addModule('clipboard');
this.history = this.theme.addModule('history');
this.theme.init();
this.emitter.on(_emitter4.default.events.EDITOR_CHANGE, function (type) {
if (type === _emitter4.default.events.TEXT_CHANGE) {
_this2.root.classList.toggle('ql-blank', _this2.editor.isBlank());
}
});
this.emitter.on(_emitter4.default.events.SCROLL_UPDATE, function (source, mutations) {
var range = _this2.selection.lastRange;
var index = range && range.length === 0 ? range.index : undefined;
modify.call(_this2, function () {
return _this2.editor.update(null, mutations, index);
}, source);
});
var contents = this.clipboard.convert('<div class=\'ql-editor\' style="white-space: normal;">' + html + '<p><br></p></div>');
this.setContents(contents);
this.history.clear();
if (this.options.placeholder) {
this.root.setAttribute('data-placeholder', this.options.placeholder);
}
if (this.options.readOnly) {
this.disable();
}
}
_createClass(Quill, [{
key: 'addContainer',
value: function addContainer(container) {
var refNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
if (typeof container === 'string') {
var className = container;
container = document.createElement('div');
container.classList.add(className);
}
this.container.insertBefore(container, refNode);
return container;
}
}, {
key: 'blur',
value: function blur() {
this.selection.setRange(null);
}
}, {
key: 'deleteText',
value: function deleteText(index, length, source) {
var _this3 = this;
var _overload = overload(index, length, source);
var _overload2 = _slicedToArray(_overload, 4);
index = _overload2[0];
length = _overload2[1];
source = _overload2[3];
return modify.call(this, function () {
return _this3.editor.deleteText(index, length);
}, source, index, -1 * length);
}
}, {
key: 'disable',
value: function disable() {
this.enable(false);
}
}, {
key: 'enable',
value: function enable() {
var enabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
this.scroll.enable(enabled);
this.container.classList.toggle('ql-disabled', !enabled);
}
}, {
key: 'focus',
value: function focus() {
var scrollTop = this.scrollingContainer.scrollTop;
this.selection.focus();
this.scrollingContainer.scrollTop = scrollTop;
this.scrollIntoView();
}
}, {
key: 'format',
value: function format(name, value) {
var _this4 = this;
var source = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _emitter4.default.sources.API;
return modify.call(this, function () {
var range = _this4.getSelection(true);
var change = new _quillDelta2.default();
if (range == null) {
return change;
} else if (_parchment2.default.query(name, _parchment2.default.Scope.BLOCK)) {
change = _this4.editor.formatLine(range.index, range.length, _defineProperty({}, name, value));
} else if (range.length === 0) {
_this4.selection.format(name, value);
return change;
} else {
change = _this4.editor.formatText(range.index, range.length, _defineProperty({}, name, value));
}
_this4.setSelection(range, _emitter4.default.sources.SILENT);
return change;
}, source);
}
}, {
key: 'formatLine',
value: function formatLine(index, length, name, value, source) {
var _this5 = this;
var formats = void 0;
var _overload3 = overload(index, length, name, value, source);
var _overload4 = _slicedToArray(_overload3, 4);
index = _overload4[0];
length = _overload4[1];
formats = _overload4[2];
source = _overload4[3];
return modify.call(this, function () {
return _this5.editor.formatLine(index, length, formats);
}, source, index, 0);
}
}, {
key: 'formatText',
value: function formatText(index, length, name, value, source) {
var _this6 = this;
var formats = void 0;
var _overload5 = overload(index, length, name, value, source);
var _overload6 = _slicedToArray(_overload5, 4);
index = _overload6[0];
length = _overload6[1];
formats = _overload6[2];
source = _overload6[3];
return modify.call(this, function () {
return _this6.editor.formatText(index, length, formats);
}, source, index, 0);
}
}, {
key: 'getBounds',
value: function getBounds(index) {
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var bounds = void 0;
if (typeof index === 'number') {
bounds = this.selection.getBounds(index, length);
} else {
bounds = this.selection.getBounds(index.index, index.length);
}
var containerBounds = this.container.getBoundingClientRect();
return {
bottom: bounds.bottom - containerBounds.top,
height: bounds.height,
left: bounds.left - containerBounds.left,
right: bounds.right - containerBounds.left,
top: bounds.top - containerBounds.top,
width: bounds.width
};
}
}, {
key: 'getContents',
value: function getContents() {
var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getLength() - index;
var _overload7 = overload(index, length);
var _overload8 = _slicedToArray(_overload7, 2);
index = _overload8[0];
length = _overload8[1];
return this.editor.getContents(index, length);
}
}, {
key: 'getFormat',
value: function getFormat() {
var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getSelection(true);
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
if (typeof index === 'number') {
return this.editor.getFormat(index, length);
} else {
return this.editor.getFormat(index.index, index.length);
}
}
}, {
key: 'getIndex',
value: function getIndex(blot) {
return blot.offset(this.scroll);
}
}, {
key: 'getLength',
value: function getLength() {
return this.scroll.length();
}
}, {
key: 'getLeaf',
value: function getLeaf(index) {
return this.scroll.leaf(index);
}
}, {
key: 'getLine',
value: function getLine(index) {
return this.scroll.line(index);
}
}, {
key: 'getLines',
value: function getLines() {
var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Number.MAX_VALUE;
if (typeof index !== 'number') {
return this.scroll.lines(index.index, index.length);
} else {
return this.scroll.lines(index, length);
}
}
}, {
key: 'getModule',
value: function getModule(name) {
return this.theme.modules[name];
}
}, {
key: 'getSelection',
value: function getSelection() {
var focus = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
if (focus) this.focus();
this.update(); // Make sure we access getRange with editor in consistent state
return this.selection.getRange()[0];
}
}, {
key: 'getText',
value: function getText() {
var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getLength() - index;
var _overload9 = overload(index, length);
var _overload10 = _slicedToArray(_overload9, 2);
index = _overload10[0];
length = _overload10[1];
return this.editor.getText(index, length);
}
}, {
key: 'hasFocus',
value: function hasFocus() {
return this.selection.hasFocus();
}
}, {
key: 'insertEmbed',
value: function insertEmbed(index, embed, value) {
var _this7 = this;
var source = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : Quill.sources.API;
return modify.call(this, function () {
return _this7.editor.insertEmbed(index, embed, value);
}, source, index);
}
}, {
key: 'insertText',
value: function insertText(index, text, name, value, source) {
var _this8 = this;
var formats = void 0;
var _overload11 = overload(index, 0, name, value, source);
var _overload12 = _slicedToArray(_overload11, 4);
index = _overload12[0];
formats = _overload12[2];
source = _overload12[3];
return modify.call(this, function () {
return _this8.editor.insertText(index, text, formats);
}, source, index, text.length);
}
}, {
key: 'isEnabled',
value: function isEnabled() {
return !this.container.classList.contains('ql-disabled');
}
}, {
key: 'off',
value: function off() {
return this.emitter.off.apply(this.emitter, arguments);
}
}, {
key: 'on',
value: function on() {
return this.emitter.on.apply(this.emitter, arguments);
}
}, {
key: 'once',
value: function once() {
return this.emitter.once.apply(this.emitter, arguments);
}
}, {
key: 'pasteHTML',
value: function pasteHTML(index, html, source) {
this.clipboard.dangerouslyPasteHTML(index, html, source);
}
}, {
key: 'removeFormat',
value: function removeFormat(index, length, source) {
var _this9 = this;
var _overload13 = overload(index, length, source);
var _overload14 = _slicedToArray(_overload13, 4);
index = _overload14[0];
length = _overload14[1];
source = _overload14[3];
return modify.call(this, function () {
return _this9.editor.removeFormat(index, length);
}, source, index);
}
}, {
key: 'scrollIntoView',
value: function scrollIntoView() {
this.selection.scrollIntoView(this.scrollingContainer);
}
}, {
key: 'setContents',
value: function setContents(delta) {
var _this10 = this;
var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _emitter4.default.sources.API;
return modify.call(this, function () {
delta = new _quillDelta2.default(delta);
var length = _this10.getLength();
var deleted = _this10.editor.deleteText(0, length);
var applied = _this10.editor.applyDelta(delta);
var lastOp = applied.ops[applied.ops.length - 1];
if (lastOp != null && typeof lastOp.insert === 'string' && lastOp.insert[lastOp.insert.length - 1] === '\n') {
_this10.editor.deleteText(_this10.getLength() - 1, 1);
applied.delete(1);
}
var ret = deleted.compose(applied);
return ret;
}, source);
}
}, {
key: 'setSelection',
value: function setSelection(index, length, source) {
if (index == null) {
this.selection.setRange(null, length || Quill.sources.API);
} else {
var _overload15 = overload(index, length, source);
var _overload16 = _slicedToArray(_overload15, 4);
index = _overload16[0];
length = _overload16[1];
source = _overload16[3];
this.selection.setRange(new _selection.Range(index, length), source);
if (source !== _emitter4.default.sources.SILENT) {
this.selection.scrollIntoView(this.scrollingContainer);
}
}
}
}, {
key: 'setText',
value: function setText(text) {
var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _emitter4.default.sources.API;
var delta = new _quillDelta2.default().insert(text);
return this.setContents(delta, source);
}
}, {
key: 'update',
value: function update() {
var source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _emitter4.default.sources.USER;
var change = this.scroll.update(source); // Will update selection before selection.update() does if text changes
this.selection.update(source);
return change;
}
}, {
key: 'updateContents',
value: function updateContents(delta) {
var _this11 = this;
var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _emitter4.default.sources.API;
return modify.call(this, function () {
delta = new _quillDelta2.default(delta);
return _this11.editor.applyDelta(delta, source);
}, source, true);
}
}]);
return Quill;
}();
Quill.DEFAULTS = {
bounds: null,
formats: null,
modules: {},
placeholder: '',
readOnly: false,
scrollingContainer: null,
strict: true,
theme: 'default'
};
Quill.events = _emitter4.default.events;
Quill.sources = _emitter4.default.sources;
// eslint-disable-next-line no-undef
Quill.version = "1.3.6";
Quill.imports = {
'delta': _quillDelta2.default,
'parchment': _parchment2.default,
'core/module': _module2.default,
'core/theme': _theme2.default
};
function expandConfig(container, userConfig) {
userConfig = (_extend2.default)(true, {
container: container,
modules: {
clipboard: true,
keyboard: true,
history: true
}
}, userConfig);
if (!userConfig.theme || userConfig.theme === Quill.DEFAULTS.theme) {
userConfig.theme = _theme2.default;
} else {
userConfig.theme = Quill.import('themes/' + userConfig.theme);
if (userConfig.theme == null) {
throw new Error('Invalid theme ' + userConfig.theme + '. Did you register it?');
}
}
var themeConfig = (_extend2.default)(true, {}, userConfig.theme.DEFAULTS);
[themeConfig, userConfig].forEach(function (config) {
config.modules = config.modules || {};
Object.keys(config.modules).forEach(function (module) {
if (config.modules[module] === true) {
config.modules[module] = {};
}
});
});
var moduleNames = Object.keys(themeConfig.modules).concat(Object.keys(userConfig.modules));
var moduleConfig = moduleNames.reduce(function (config, name) {
var moduleClass = Quill.import('modules/' + name);
if (moduleClass == null) {
debug.error('Cannot load ' + name + ' module. Are you sure you registered it?');
} else {
config[name] = moduleClass.DEFAULTS || {};
}
return config;
}, {});
// Special case toolbar shorthand
if (userConfig.modules != null && userConfig.modules.toolbar && userConfig.modules.toolbar.constructor !== Object) {
userConfig.modules.toolbar = {
container: userConfig.modules.toolbar
};
}
userConfig = (_extend2.default)(true, {}, Quill.DEFAULTS, { modules: moduleConfig }, themeConfig, userConfig);
['bounds', 'container', 'scrollingContainer'].forEach(function (key) {
if (typeof userConfig[key] === 'string') {
userConfig[key] = document.querySelector(userConfig[key]);
}
});
userConfig.modules = Object.keys(userConfig.modules).reduce(function (config, name) {
if (userConfig.modules[name]) {
config[name] = userConfig.modules[name];
}
return config;
}, {});
return userConfig;
}
// Handle selection preservation and TEXT_CHANGE emission
// common to modification APIs
function modify(modifier, source, index, shift) {
if (this.options.strict && !this.isEnabled() && source === _emitter4.default.sources.USER) {
return new _quillDelta2.default();
}
var range = index == null ? null : this.getSelection();
var oldDelta = this.editor.delta;
var change = modifier();
if (range != null) {
if (index === true) index = range.index;
if (shift == null) {
range = shiftRange(range, change, source);
} else if (shift !== 0) {
range = shiftRange(range, index, shift, source);
}
this.setSelection(range, _emitter4.default.sources.SILENT);
}
if (change.length() > 0) {
var _emitter;
var args = [_emitter4.default.events.TEXT_CHANGE, change, oldDelta, source];
(_emitter = this.emitter).emit.apply(_emitter, [_emitter4.default.events.EDITOR_CHANGE].concat(args));
if (source !== _emitter4.default.sources.SILENT) {
var _emitter2;
(_emitter2 = this.emitter).emit.apply(_emitter2, args);
}
}
return change;
}
function overload(index, length, name, value, source) {
var formats = {};
if (typeof index.index === 'number' && typeof index.length === 'number') {
// Allow for throwaway end (used by insertText/insertEmbed)
if (typeof length !== 'number') {
source = value, value = name, name = length, length = index.length, index = index.index;
} else {
length = index.length, index = index.index;
}
} else if (typeof length !== 'number') {
source = value, value = name, name = length, length = 0;
}
// Handle format being object, two format name/value strings or excluded
if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
formats = name;
source = value;
} else if (typeof name === 'string') {
if (value != null) {
formats[name] = value;
} else {
source = name;
}
}
// Handle optional source
source = source || _emitter4.default.sources.API;
return [index, length, formats, source];
}
function shiftRange(range, index, length, source) {
if (range == null) return null;
var start = void 0,
end = void 0;
if (index instanceof _quillDelta2.default) {
var _map = [range.index, range.index + range.length].map(function (pos) {
return index.transformPosition(pos, source !== _emitter4.default.sources.USER);
});
var _map2 = _slicedToArray(_map, 2);
start = _map2[0];
end = _map2[1];
} else {
var _map3 = [range.index, range.index + range.length].map(function (pos) {
if (pos < index || pos === index && source === _emitter4.default.sources.USER) return pos;
if (length >= 0) {
return pos + length;
} else {
return Math.max(index, pos + length);
}
});
var _map4 = _slicedToArray(_map3, 2);
start = _map4[0];
end = _map4[1];
}
return new _selection.Range(start, end - start);
}
exports.expandConfig = expandConfig;
exports.overload = overload;
exports.default = Quill;
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _text = __webpack_require__(7);
var _text2 = _interopRequireDefault(_text);
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Inline = function (_Parchment$Inline) {
_inherits(Inline, _Parchment$Inline);
function Inline() {
_classCallCheck(this, Inline);
return _possibleConstructorReturn(this, (Inline.__proto__ || Object.getPrototypeOf(Inline)).apply(this, arguments));
}
_createClass(Inline, [{
key: 'formatAt',
value: function formatAt(index, length, name, value) {
if (Inline.compare(this.statics.blotName, name) < 0 && _parchment2.default.query(name, _parchment2.default.Scope.BLOT)) {
var blot = this.isolate(index, length);
if (value) {
blot.wrap(name, value);
}
} else {
_get(Inline.prototype.__proto__ || Object.getPrototypeOf(Inline.prototype), 'formatAt', this).call(this, index, length, name, value);
}
}
}, {
key: 'optimize',
value: function optimize(context) {
_get(Inline.prototype.__proto__ || Object.getPrototypeOf(Inline.prototype), 'optimize', this).call(this, context);
if (this.parent instanceof Inline && Inline.compare(this.statics.blotName, this.parent.statics.blotName) > 0) {
var parent = this.parent.isolate(this.offset(), this.length());
this.moveChildren(parent);
parent.wrap(this);
}
}
}], [{
key: 'compare',
value: function compare(self, other) {
var selfIndex = Inline.order.indexOf(self);
var otherIndex = Inline.order.indexOf(other);
if (selfIndex >= 0 || otherIndex >= 0) {
return selfIndex - otherIndex;
} else if (self === other) {
return 0;
} else if (self < other) {
return -1;
} else {
return 1;
}
}
}]);
return Inline;
}(_parchment2.default.Inline);
Inline.allowedChildren = [Inline, _parchment2.default.Embed, _text2.default];
// Lower index means deeper in the DOM tree, since not found (-1) is for embeds
Inline.order = ['cursor', 'inline', // Must be lower
'underline', 'strike', 'italic', 'bold', 'script', 'link', 'code' // Must be higher
];
exports.default = Inline;
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var TextBlot = function (_Parchment$Text) {
_inherits(TextBlot, _Parchment$Text);
function TextBlot() {
_classCallCheck(this, TextBlot);
return _possibleConstructorReturn(this, (TextBlot.__proto__ || Object.getPrototypeOf(TextBlot)).apply(this, arguments));
}
return TextBlot;
}(_parchment2.default.Text);
exports.default = TextBlot;
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _eventemitter = __webpack_require__(54);
var _eventemitter2 = _interopRequireDefault(_eventemitter);
var _logger = __webpack_require__(10);
var _logger2 = _interopRequireDefault(_logger);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var debug = (_logger2.default)('quill:events');
var EVENTS = ['selectionchange', 'mousedown', 'mouseup', 'click'];
EVENTS.forEach(function (eventName) {
document.addEventListener(eventName, function () {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
[].slice.call(document.querySelectorAll('.ql-container')).forEach(function (node) {
// TODO use WeakMap
if (node.__quill && node.__quill.emitter) {
var _node$__quill$emitter;
(_node$__quill$emitter = node.__quill.emitter).handleDOM.apply(_node$__quill$emitter, args);
}
});
});
});
var Emitter = function (_EventEmitter) {
_inherits(Emitter, _EventEmitter);
function Emitter() {
_classCallCheck(this, Emitter);
var _this = _possibleConstructorReturn(this, (Emitter.__proto__ || Object.getPrototypeOf(Emitter)).call(this));
_this.listeners = {};
_this.on('error', debug.error);
return _this;
}
_createClass(Emitter, [{
key: 'emit',
value: function emit() {
debug.log.apply(debug, arguments);
_get(Emitter.prototype.__proto__ || Object.getPrototypeOf(Emitter.prototype), 'emit', this).apply(this, arguments);
}
}, {
key: 'handleDOM',
value: function handleDOM(event) {
for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
(this.listeners[event.type] || []).forEach(function (_ref) {
var node = _ref.node,
handler = _ref.handler;
if (event.target === node || node.contains(event.target)) {
handler.apply(undefined, [event].concat(args));
}
});
}
}, {
key: 'listenDOM',
value: function listenDOM(eventName, node, handler) {
if (!this.listeners[eventName]) {
this.listeners[eventName] = [];
}
this.listeners[eventName].push({ node: node, handler: handler });
}
}]);
return Emitter;
}(_eventemitter2.default);
Emitter.events = {
EDITOR_CHANGE: 'editor-change',
SCROLL_BEFORE_UPDATE: 'scroll-before-update',
SCROLL_OPTIMIZE: 'scroll-optimize',
SCROLL_UPDATE: 'scroll-update',
SELECTION_CHANGE: 'selection-change',
TEXT_CHANGE: 'text-change'
};
Emitter.sources = {
API: 'api',
SILENT: 'silent',
USER: 'user'
};
exports.default = Emitter;
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Module = function Module(quill) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
_classCallCheck(this, Module);
this.quill = quill;
this.options = options;
};
Module.DEFAULTS = {};
exports.default = Module;
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var levels = ['error', 'warn', 'log', 'info'];
var level = 'warn';
function debug(method) {
if (levels.indexOf(method) <= levels.indexOf(level)) {
var _console;
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
(_console = console)[method].apply(_console, args); // eslint-disable-line no-console
}
}
function namespace(ns) {
return levels.reduce(function (logger, method) {
logger[method] = debug.bind(console, method, ns);
return logger;
}, {});
}
debug.level = namespace.level = function (newLevel) {
level = newLevel;
};
exports.default = namespace;
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
var pSlice = Array.prototype.slice;
var objectKeys = __webpack_require__(52);
var isArguments = __webpack_require__(53);
var deepEqual = module.exports = function (actual, expected, opts) {
if (!opts) opts = {};
// 7.1. All identical values are equivalent, as determined by ===.
if (actual === expected) {
return true;
} else if (actual instanceof Date && expected instanceof Date) {
return actual.getTime() === expected.getTime();
// 7.3. Other pairs that do not both pass typeof value == 'object',
// equivalence is determined by ==.
} else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {
return opts.strict ? actual === expected : actual == expected;
// 7.4. For all other Object pairs, including Array objects, equivalence is
// determined by having the same number of owned properties (as verified
// with Object.prototype.hasOwnProperty.call), the same set of keys
// (although not necessarily the same order), equivalent values for every
// corresponding key, and an identical 'prototype' property. Note: this
// accounts for both named and indexed properties on Arrays.
} else {
return objEquiv(actual, expected, opts);
}
};
function isUndefinedOrNull(value) {
return value === null || value === undefined;
}
function isBuffer (x) {
if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;
if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
return false;
}
if (x.length > 0 && typeof x[0] !== 'number') return false;
return true;
}
function objEquiv(a, b, opts) {
var i, key;
if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
return false;
// an identical 'prototype' property.
if (a.prototype !== b.prototype) return false;
//~~~I've managed to break Object.keys through screwy arguments passing.
// Converting to array solves the problem.
if (isArguments(a)) {
if (!isArguments(b)) {
return false;
}
a = pSlice.call(a);
b = pSlice.call(b);
return deepEqual(a, b, opts);
}
if (isBuffer(a)) {
if (!isBuffer(b)) {
return false;
}
if (a.length !== b.length) return false;
for (i = 0; i < a.length; i++) {
if (a[i] !== b[i]) return false;
}
return true;
}
try {
var ka = objectKeys(a),
kb = objectKeys(b);
} catch (e) {//happens when one is a string literal and the other isn't
return false;
}
// having the same number of owned properties (keys incorporates
// hasOwnProperty)
if (ka.length != kb.length)
return false;
//the same set of keys (although not necessarily the same order),
ka.sort();
kb.sort();
//~~~cheap key test
for (i = ka.length - 1; i >= 0; i--) {
if (ka[i] != kb[i])
return false;
}
//equivalent values for every corresponding key, and
//~~~possibly expensive deep test
for (i = ka.length - 1; i >= 0; i--) {
key = ka[i];
if (!deepEqual(a[key], b[key], opts)) return false;
}
return typeof a === typeof b;
}
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var Registry = __webpack_require__(1);
var Attributor = /** @class */ (function () {
function Attributor(attrName, keyName, options) {
if (options === void 0) { options = {}; }
this.attrName = attrName;
this.keyName = keyName;
var attributeBit = Registry.Scope.TYPE & Registry.Scope.ATTRIBUTE;
if (options.scope != null) {
// Ignore type bits, force attribute bit
this.scope = (options.scope & Registry.Scope.LEVEL) | attributeBit;
}
else {
this.scope = Registry.Scope.ATTRIBUTE;
}
if (options.whitelist != null)
this.whitelist = options.whitelist;
}
Attributor.keys = function (node) {
return [].map.call(node.attributes, function (item) {
return item.name;
});
};
Attributor.prototype.add = function (node, value) {
if (!this.canAdd(node, value))
return false;
node.setAttribute(this.keyName, value);
return true;
};
Attributor.prototype.canAdd = function (node, value) {
var match = Registry.query(node, Registry.Scope.BLOT & (this.scope | Registry.Scope.TYPE));
if (match == null)
return false;
if (this.whitelist == null)
return true;
if (typeof value === 'string') {
return this.whitelist.indexOf(value.replace(/["']/g, '')) > -1;
}
else {
return this.whitelist.indexOf(value) > -1;
}
};
Attributor.prototype.remove = function (node) {
node.removeAttribute(this.keyName);
};
Attributor.prototype.value = function (node) {
var value = node.getAttribute(this.keyName);
if (this.canAdd(node, value) && value) {
return value;
}
return '';
};
return Attributor;
}());
exports.default = Attributor;
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.Code = undefined;
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _quillDelta = __webpack_require__(2);
var _quillDelta2 = _interopRequireDefault(_quillDelta);
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _block = __webpack_require__(4);
var _block2 = _interopRequireDefault(_block);
var _inline = __webpack_require__(6);
var _inline2 = _interopRequireDefault(_inline);
var _text = __webpack_require__(7);
var _text2 = _interopRequireDefault(_text);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Code = function (_Inline) {
_inherits(Code, _Inline);
function Code() {
_classCallCheck(this, Code);
return _possibleConstructorReturn(this, (Code.__proto__ || Object.getPrototypeOf(Code)).apply(this, arguments));
}
return Code;
}(_inline2.default);
Code.blotName = 'code';
Code.tagName = 'CODE';
var CodeBlock = function (_Block) {
_inherits(CodeBlock, _Block);
function CodeBlock() {
_classCallCheck(this, CodeBlock);
return _possibleConstructorReturn(this, (CodeBlock.__proto__ || Object.getPrototypeOf(CodeBlock)).apply(this, arguments));
}
_createClass(CodeBlock, [{
key: 'delta',
value: function delta() {
var _this3 = this;
var text = this.domNode.textContent;
if (text.endsWith('\n')) {
// Should always be true
text = text.slice(0, -1);
}
return text.split('\n').reduce(function (delta, frag) {
return delta.insert(frag).insert('\n', _this3.formats());
}, new _quillDelta2.default());
}
}, {
key: 'format',
value: function format(name, value) {
if (name === this.statics.blotName && value) return;
var _descendant = this.descendant(_text2.default, this.length() - 1),
_descendant2 = _slicedToArray(_descendant, 1),
text = _descendant2[0];
if (text != null) {
text.deleteAt(text.length() - 1, 1);
}
_get(CodeBlock.prototype.__proto__ || Object.getPrototypeOf(CodeBlock.prototype), 'format', this).call(this, name, value);
}
}, {
key: 'formatAt',
value: function formatAt(index, length, name, value) {
if (length === 0) return;
if (_parchment2.default.query(name, _parchment2.default.Scope.BLOCK) == null || name === this.statics.blotName && value === this.statics.formats(this.domNode)) {
return;
}
var nextNewline = this.newlineIndex(index);
if (nextNewline < 0 || nextNewline >= index + length) return;
var prevNewline = this.newlineIndex(index, true) + 1;
var isolateLength = nextNewline - prevNewline + 1;
var blot = this.isolate(prevNewline, isolateLength);
var next = blot.next;
blot.format(name, value);
if (next instanceof CodeBlock) {
next.formatAt(0, index - prevNewline + length - isolateLength, name, value);
}
}
}, {
key: 'insertAt',
value: function insertAt(index, value, def) {
if (def != null) return;
var _descendant3 = this.descendant(_text2.default, index),
_descendant4 = _slicedToArray(_descendant3, 2),
text = _descendant4[0],
offset = _descendant4[1];
text.insertAt(offset, value);
}
}, {
key: 'length',
value: function length() {
var length = this.domNode.textContent.length;
if (!this.domNode.textContent.endsWith('\n')) {
return length + 1;
}
return length;
}
}, {
key: 'newlineIndex',
value: function newlineIndex(searchIndex) {
var reverse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
if (!reverse) {
var offset = this.domNode.textContent.slice(searchIndex).indexOf('\n');
return offset > -1 ? searchIndex + offset : -1;
} else {
return this.domNode.textContent.slice(0, searchIndex).lastIndexOf('\n');
}
}
}, {
key: 'optimize',
value: function optimize(context) {
if (!this.domNode.textContent.endsWith('\n')) {
this.appendChild(_parchment2.default.create('text', '\n'));
}
_get(CodeBlock.prototype.__proto__ || Object.getPrototypeOf(CodeBlock.prototype), 'optimize', this).call(this, context);
var next = this.next;
if (next != null && next.prev === this && next.statics.blotName === this.statics.blotName && this.statics.formats(this.domNode) === next.statics.formats(next.domNode)) {
next.optimize(context);
next.moveChildren(this);
next.remove();
}
}
}, {
key: 'replace',
value: function replace(target) {
_get(CodeBlock.prototype.__proto__ || Object.getPrototypeOf(CodeBlock.prototype), 'replace', this).call(this, target);
[].slice.call(this.domNode.querySelectorAll('*')).forEach(function (node) {
var blot = _parchment2.default.find(node);
if (blot == null) {
node.parentNode.removeChild(node);
} else if (blot instanceof _parchment2.default.Embed) {
blot.remove();
} else {
blot.unwrap();
}
});
}
}], [{
key: 'create',
value: function create(value) {
var domNode = _get(CodeBlock.__proto__ || Object.getPrototypeOf(CodeBlock), 'create', this).call(this, value);
domNode.setAttribute('spellcheck', false);
return domNode;
}
}, {
key: 'formats',
value: function formats() {
return true;
}
}]);
return CodeBlock;
}(_block2.default);
CodeBlock.blotName = 'code-block';
CodeBlock.tagName = 'PRE';
CodeBlock.TAB = ' ';
exports.Code = Code;
exports.default = CodeBlock;
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _quillDelta = __webpack_require__(2);
var _quillDelta2 = _interopRequireDefault(_quillDelta);
var _op = __webpack_require__(20);
var _op2 = _interopRequireDefault(_op);
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _code = __webpack_require__(13);
var _code2 = _interopRequireDefault(_code);
var _cursor = __webpack_require__(24);
var _cursor2 = _interopRequireDefault(_cursor);
var _block = __webpack_require__(4);
var _block2 = _interopRequireDefault(_block);
var _break = __webpack_require__(16);
var _break2 = _interopRequireDefault(_break);
var _clone = __webpack_require__(21);
var _clone2 = _interopRequireDefault(_clone);
var _deepEqual = __webpack_require__(11);
var _deepEqual2 = _interopRequireDefault(_deepEqual);
var _extend = __webpack_require__(3);
var _extend2 = _interopRequireDefault(_extend);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var ASCII = /^[ -~]*$/;
var Editor = function () {
function Editor(scroll) {
_classCallCheck(this, Editor);
this.scroll = scroll;
this.delta = this.getDelta();
}
_createClass(Editor, [{
key: 'applyDelta',
value: function applyDelta(delta) {
var _this = this;
var consumeNextNewline = false;
this.scroll.update();
var scrollLength = this.scroll.length();
this.scroll.batchStart();
delta = normalizeDelta(delta);
delta.reduce(function (index, op) {
var length = op.retain || op.delete || op.insert.length || 1;
var attributes = op.attributes || {};
if (op.insert != null) {
if (typeof op.insert === 'string') {
var text = op.insert;
if (text.endsWith('\n') && consumeNextNewline) {
consumeNextNewline = false;
text = text.slice(0, -1);
}
if (index >= scrollLength && !text.endsWith('\n')) {
consumeNextNewline = true;
}
_this.scroll.insertAt(index, text);
var _scroll$line = _this.scroll.line(index),
_scroll$line2 = _slicedToArray(_scroll$line, 2),
line = _scroll$line2[0],
offset = _scroll$line2[1];
var formats = (_extend2.default)({}, (_block.bubbleFormats)(line));
if (line instanceof _block2.default) {
var _line$descendant = line.descendant(_parchment2.default.Leaf, offset),
_line$descendant2 = _slicedToArray(_line$descendant, 1),
leaf = _line$descendant2[0];
formats = (_extend2.default)(formats, (_block.bubbleFormats)(leaf));
}
attributes = _op2.default.attributes.diff(formats, attributes) || {};
} else if (_typeof(op.insert) === 'object') {
var key = Object.keys(op.insert)[0]; // There should only be one key
if (key == null) return index;
_this.scroll.insertAt(index, key, op.insert[key]);
}
scrollLength += length;
}
Object.keys(attributes).forEach(function (name) {
_this.scroll.formatAt(index, length, name, attributes[name]);
});
return index + length;
}, 0);
delta.reduce(function (index, op) {
if (typeof op.delete === 'number') {
_this.scroll.deleteAt(index, op.delete);
return index;
}
return index + (op.retain || op.insert.length || 1);
}, 0);
this.scroll.batchEnd();
return this.update(delta);
}
}, {
key: 'deleteText',
value: function deleteText(index, length) {
this.scroll.deleteAt(index, length);
return this.update(new _quillDelta2.default().retain(index).delete(length));
}
}, {
key: 'formatLine',
value: function formatLine(index, length) {
var _this2 = this;
var formats = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
this.scroll.update();
Object.keys(formats).forEach(function (format) {
if (_this2.scroll.whitelist != null && !_this2.scroll.whitelist[format]) return;
var lines = _this2.scroll.lines(index, Math.max(length, 1));
var lengthRemaining = length;
lines.forEach(function (line) {
var lineLength = line.length();
if (!(line instanceof _code2.default)) {
line.format(format, formats[format]);
} else {
var codeIndex = index - line.offset(_this2.scroll);
var codeLength = line.newlineIndex(codeIndex + lengthRemaining) - codeIndex + 1;
line.formatAt(codeIndex, codeLength, format, formats[format]);
}
lengthRemaining -= lineLength;
});
});
this.scroll.optimize();
return this.update(new _quillDelta2.default().retain(index).retain(length, (_clone2.default)(formats)));
}
}, {
key: 'formatText',
value: function formatText(index, length) {
var _this3 = this;
var formats = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
Object.keys(formats).forEach(function (format) {
_this3.scroll.formatAt(index, length, format, formats[format]);
});
return this.update(new _quillDelta2.default().retain(index).retain(length, (_clone2.default)(formats)));
}
}, {
key: 'getContents',
value: function getContents(index, length) {
return this.delta.slice(index, index + length);
}
}, {
key: 'getDelta',
value: function getDelta() {
return this.scroll.lines().reduce(function (delta, line) {
return delta.concat(line.delta());
}, new _quillDelta2.default());
}
}, {
key: 'getFormat',
value: function getFormat(index) {
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var lines = [],
leaves = [];
if (length === 0) {
this.scroll.path(index).forEach(function (path) {
var _path = _slicedToArray(path, 1),
blot = _path[0];
if (blot instanceof _block2.default) {
lines.push(blot);
} else if (blot instanceof _parchment2.default.Leaf) {
leaves.push(blot);
}
});
} else {
lines = this.scroll.lines(index, length);
leaves = this.scroll.descendants(_parchment2.default.Leaf, index, length);
}
var formatsArr = [lines, leaves].map(function (blots) {
if (blots.length === 0) return {};
var formats = (_block.bubbleFormats)(blots.shift());
while (Object.keys(formats).length > 0) {
var blot = blots.shift();
if (blot == null) return formats;
formats = combineFormats((_block.bubbleFormats)(blot), formats);
}
return formats;
});
return _extend2.default.apply(_extend2.default, formatsArr);
}
}, {
key: 'getText',
value: function getText(index, length) {
return this.getContents(index, length).filter(function (op) {
return typeof op.insert === 'string';
}).map(function (op) {
return op.insert;
}).join('');
}
}, {
key: 'insertEmbed',
value: function insertEmbed(index, embed, value) {
this.scroll.insertAt(index, embed, value);
return this.update(new _quillDelta2.default().retain(index).insert(_defineProperty({}, embed, value)));
}
}, {
key: 'insertText',
value: function insertText(index, text) {
var _this4 = this;
var formats = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
text = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
this.scroll.insertAt(index, text);
Object.keys(formats).forEach(function (format) {
_this4.scroll.formatAt(index, text.length, format, formats[format]);
});
return this.update(new _quillDelta2.default().retain(index).insert(text, (_clone2.default)(formats)));
}
}, {
key: 'isBlank',
value: function isBlank() {
if (this.scroll.children.length == 0) return true;
if (this.scroll.children.length > 1) return false;
var block = this.scroll.children.head;
if (block.statics.blotName !== _block2.default.blotName) return false;
if (block.children.length > 1) return false;
return block.children.head instanceof _break2.default;
}
}, {
key: 'removeFormat',
value: function removeFormat(index, length) {
var text = this.getText(index, length);
var _scroll$line3 = this.scroll.line(index + length),
_scroll$line4 = _slicedToArray(_scroll$line3, 2),
line = _scroll$line4[0],
offset = _scroll$line4[1];
var suffixLength = 0,
suffix = new _quillDelta2.default();
if (line != null) {
if (!(line instanceof _code2.default)) {
suffixLength = line.length() - offset;
} else {
suffixLength = line.newlineIndex(offset) - offset + 1;
}
suffix = line.delta().slice(offset, offset + suffixLength - 1).insert('\n');
}
var contents = this.getContents(index, length + suffixLength);
var diff = contents.diff(new _quillDelta2.default().insert(text).concat(suffix));
var delta = new _quillDelta2.default().retain(index).concat(diff);
return this.applyDelta(delta);
}
}, {
key: 'update',
value: function update(change) {
var mutations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
var cursorIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
var oldDelta = this.delta;
if (mutations.length === 1 && mutations[0].type === 'characterData' && mutations[0].target.data.match(ASCII) && _parchment2.default.find(mutations[0].target)) {
// Optimization for character changes
var textBlot = _parchment2.default.find(mutations[0].target);
var formats = (_block.bubbleFormats)(textBlot);
var index = textBlot.offset(this.scroll);
var oldValue = mutations[0].oldValue.replace(_cursor2.default.CONTENTS, '');
var oldText = new _quillDelta2.default().insert(oldValue);
var newText = new _quillDelta2.default().insert(textBlot.value());
var diffDelta = new _quillDelta2.default().retain(index).concat(oldText.diff(newText, cursorIndex));
change = diffDelta.reduce(function (delta, op) {
if (op.insert) {
return delta.insert(op.insert, formats);
} else {
return delta.push(op);
}
}, new _quillDelta2.default());
this.delta = oldDelta.compose(change);
} else {
this.delta = this.getDelta();
if (!change || !(_deepEqual2.default)(oldDelta.compose(change), this.delta)) {
change = oldDelta.diff(this.delta, cursorIndex);
}
}
return change;
}
}]);
return Editor;
}();
function combineFormats(formats, combined) {
return Object.keys(combined).reduce(function (merged, name) {
if (formats[name] == null) return merged;
if (combined[name] === formats[name]) {
merged[name] = combined[name];
} else if (Array.isArray(combined[name])) {
if (combined[name].indexOf(formats[name]) < 0) {
merged[name] = combined[name].concat([formats[name]]);
}
} else {
merged[name] = [combined[name], formats[name]];
}
return merged;
}, {});
}
function normalizeDelta(delta) {
return delta.reduce(function (delta, op) {
if (op.insert === 1) {
var attributes = (_clone2.default)(op.attributes);
delete attributes['image'];
return delta.insert({ image: op.attributes.image }, attributes);
}
if (op.attributes != null && (op.attributes.list === true || op.attributes.bullet === true)) {
op = (_clone2.default)(op);
if (op.attributes.list) {
op.attributes.list = 'ordered';
} else {
op.attributes.list = 'bullet';
delete op.attributes.bullet;
}
}
if (typeof op.insert === 'string') {
var text = op.insert.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
return delta.insert(text, op.attributes);
}
return delta.push(op);
}, new _quillDelta2.default());
}
exports.default = Editor;
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.Range = undefined;
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _clone = __webpack_require__(21);
var _clone2 = _interopRequireDefault(_clone);
var _deepEqual = __webpack_require__(11);
var _deepEqual2 = _interopRequireDefault(_deepEqual);
var _emitter3 = __webpack_require__(8);
var _emitter4 = _interopRequireDefault(_emitter3);
var _logger = __webpack_require__(10);
var _logger2 = _interopRequireDefault(_logger);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var debug = (_logger2.default)('quill:selection');
var Range = function Range(index) {
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
_classCallCheck(this, Range);
this.index = index;
this.length = length;
};
var Selection = function () {
function Selection(scroll, emitter) {
var _this = this;
_classCallCheck(this, Selection);
this.emitter = emitter;
this.scroll = scroll;
this.composing = false;
this.mouseDown = false;
this.root = this.scroll.domNode;
this.cursor = _parchment2.default.create('cursor', this);
// savedRange is last non-null range
this.lastRange = this.savedRange = new Range(0, 0);
this.handleComposition();
this.handleDragging();
this.emitter.listenDOM('selectionchange', document, function () {
if (!_this.mouseDown) {
setTimeout(_this.update.bind(_this, _emitter4.default.sources.USER), 1);
}
});
this.emitter.on(_emitter4.default.events.EDITOR_CHANGE, function (type, delta) {
if (type === _emitter4.default.events.TEXT_CHANGE && delta.length() > 0) {
_this.update(_emitter4.default.sources.SILENT);
}
});
this.emitter.on(_emitter4.default.events.SCROLL_BEFORE_UPDATE, function () {
if (!_this.hasFocus()) return;
var native = _this.getNativeRange();
if (native == null) return;
if (native.start.node === _this.cursor.textNode) return; // cursor.restore() will handle
// TODO unclear if this has negative side effects
_this.emitter.once(_emitter4.default.events.SCROLL_UPDATE, function () {
try {
_this.setNativeRange(native.start.node, native.start.offset, native.end.node, native.end.offset);
} catch (ignored) {}
});
});
this.emitter.on(_emitter4.default.events.SCROLL_OPTIMIZE, function (mutations, context) {
if (context.range) {
var _context$range = context.range,
startNode = _context$range.startNode,
startOffset = _context$range.startOffset,
endNode = _context$range.endNode,
endOffset = _context$range.endOffset;
_this.setNativeRange(startNode, startOffset, endNode, endOffset);
}
});
this.update(_emitter4.default.sources.SILENT);
}
_createClass(Selection, [{
key: 'handleComposition',
value: function handleComposition() {
var _this2 = this;
this.root.addEventListener('compositionstart', function () {
_this2.composing = true;
});
this.root.addEventListener('compositionend', function () {
_this2.composing = false;
if (_this2.cursor.parent) {
var range = _this2.cursor.restore();
if (!range) return;
setTimeout(function () {
_this2.setNativeRange(range.startNode, range.startOffset, range.endNode, range.endOffset);
}, 1);
}
});
}
}, {
key: 'handleDragging',
value: function handleDragging() {
var _this3 = this;
this.emitter.listenDOM('mousedown', document.body, function () {
_this3.mouseDown = true;
});
this.emitter.listenDOM('mouseup', document.body, function () {
_this3.mouseDown = false;
_this3.update(_emitter4.default.sources.USER);
});
}
}, {
key: 'focus',
value: function focus() {
if (this.hasFocus()) return;
this.root.focus();
this.setRange(this.savedRange);
}
}, {
key: 'format',
value: function format(_format, value) {
if (this.scroll.whitelist != null && !this.scroll.whitelist[_format]) return;
this.scroll.update();
var nativeRange = this.getNativeRange();
if (nativeRange == null || !nativeRange.native.collapsed || _parchment2.default.query(_format, _parchment2.default.Scope.BLOCK)) return;
if (nativeRange.start.node !== this.cursor.textNode) {
var blot = _parchment2.default.find(nativeRange.start.node, false);
if (blot == null) return;
// TODO Give blot ability to not split
if (blot instanceof _parchment2.default.Leaf) {
var after = blot.split(nativeRange.start.offset);
blot.parent.insertBefore(this.cursor, after);
} else {
blot.insertBefore(this.cursor, nativeRange.start.node); // Should never happen
}
this.cursor.attach();
}
this.cursor.format(_format, value);
this.scroll.optimize();
this.setNativeRange(this.cursor.textNode, this.cursor.textNode.data.length);
this.update();
}
}, {
key: 'getBounds',
value: function getBounds(index) {
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var scrollLength = this.scroll.length();
index = Math.min(index, scrollLength - 1);
length = Math.min(index + length, scrollLength - 1) - index;
var node = void 0,
_scroll$leaf = this.scroll.leaf(index),
_scroll$leaf2 = _slicedToArray(_scroll$leaf, 2),
leaf = _scroll$leaf2[0],
offset = _scroll$leaf2[1];
if (leaf == null) return null;
var _leaf$position = leaf.position(offset, true);
var _leaf$position2 = _slicedToArray(_leaf$position, 2);
node = _leaf$position2[0];
offset = _leaf$position2[1];
var range = document.createRange();
if (length > 0) {
range.setStart(node, offset);
var _scroll$leaf3 = this.scroll.leaf(index + length);
var _scroll$leaf4 = _slicedToArray(_scroll$leaf3, 2);
leaf = _scroll$leaf4[0];
offset = _scroll$leaf4[1];
if (leaf == null) return null;
var _leaf$position3 = leaf.position(offset, true);
var _leaf$position4 = _slicedToArray(_leaf$position3, 2);
node = _leaf$position4[0];
offset = _leaf$position4[1];
range.setEnd(node, offset);
return range.getBoundingClientRect();
} else {
var side = 'left';
var rect = void 0;
if (node instanceof Text) {
if (offset < node.data.length) {
range.setStart(node, offset);
range.setEnd(node, offset + 1);
} else {
range.setStart(node, offset - 1);
range.setEnd(node, offset);
side = 'right';
}
rect = range.getBoundingClientRect();
} else {
rect = leaf.domNode.getBoundingClientRect();
if (offset > 0) side = 'right';
}
return {
bottom: rect.top + rect.height,
height: rect.height,
left: rect[side],
right: rect[side],
top: rect.top,
width: 0
};
}
}
}, {
key: 'getNativeRange',
value: function getNativeRange() {
var selection = document.getSelection();
if (selection == null || selection.rangeCount <= 0) return null;
var nativeRange = selection.getRangeAt(0);
if (nativeRange == null) return null;
var range = this.normalizeNative(nativeRange);
debug.info('getNativeRange', range);
return range;
}
}, {
key: 'getRange',
value: function getRange() {
var normalized = this.getNativeRange();
if (normalized == null) return [null, null];
var range = this.normalizedToRange(normalized);
return [range, normalized];
}
}, {
key: 'hasFocus',
value: function hasFocus() {
return document.activeElement === this.root;
}
}, {
key: 'normalizedToRange',
value: function normalizedToRange(range) {
var _this4 = this;
var positions = [[range.start.node, range.start.offset]];
if (!range.native.collapsed) {
positions.push([range.end.node, range.end.offset]);
}
var indexes = positions.map(function (position) {
var _position = _slicedToArray(position, 2),
node = _position[0],
offset = _position[1];
var blot = _parchment2.default.find(node, true);
var index = blot.offset(_this4.scroll);
if (offset === 0) {
return index;
} else if (blot instanceof _parchment2.default.Container) {
return index + blot.length();
} else {
return index + blot.index(node, offset);
}
});
var end = Math.min(Math.max.apply(Math, _toConsumableArray(indexes)), this.scroll.length() - 1);
var start = Math.min.apply(Math, [end].concat(_toConsumableArray(indexes)));
return new Range(start, end - start);
}
}, {
key: 'normalizeNative',
value: function normalizeNative(nativeRange) {
if (!contains(this.root, nativeRange.startContainer) || !nativeRange.collapsed && !contains(this.root, nativeRange.endContainer)) {
return null;
}
var range = {
start: { node: nativeRange.startContainer, offset: nativeRange.startOffset },
end: { node: nativeRange.endContainer, offset: nativeRange.endOffset },
native: nativeRange
};
[range.start, range.end].forEach(function (position) {
var node = position.node,
offset = position.offset;
while (!(node instanceof Text) && node.childNodes.length > 0) {
if (node.childNodes.length > offset) {
node = node.childNodes[offset];
offset = 0;
} else if (node.childNodes.length === offset) {
node = node.lastChild;
offset = node instanceof Text ? node.data.length : node.childNodes.length + 1;
} else {
break;
}
}
position.node = node, position.offset = offset;
});
return range;
}
}, {
key: 'rangeToNative',
value: function rangeToNative(range) {
var _this5 = this;
var indexes = range.collapsed ? [range.index] : [range.index, range.index + range.length];
var args = [];
var scrollLength = this.scroll.length();
indexes.forEach(function (index, i) {
index = Math.min(scrollLength - 1, index);
var node = void 0,
_scroll$leaf5 = _this5.scroll.leaf(index),
_scroll$leaf6 = _slicedToArray(_scroll$leaf5, 2),
leaf = _scroll$leaf6[0],
offset = _scroll$leaf6[1];
var _leaf$position5 = leaf.position(offset, i !== 0);
var _leaf$position6 = _slicedToArray(_leaf$position5, 2);
node = _leaf$position6[0];
offset = _leaf$position6[1];
args.push(node, offset);
});
if (args.length < 2) {
args = args.concat(args);
}
return args;
}
}, {
key: 'scrollIntoView',
value: function scrollIntoView(scrollingContainer) {
var range = this.lastRange;
if (range == null) return;
var bounds = this.getBounds(range.index, range.length);
if (bounds == null) return;
var limit = this.scroll.length() - 1;
var _scroll$line = this.scroll.line(Math.min(range.index, limit)),
_scroll$line2 = _slicedToArray(_scroll$line, 1),
first = _scroll$line2[0];
var last = first;
if (range.length > 0) {
var _scroll$line3 = this.scroll.line(Math.min(range.index + range.length, limit));
var _scroll$line4 = _slicedToArray(_scroll$line3, 1);
last = _scroll$line4[0];
}
if (first == null || last == null) return;
var scrollBounds = scrollingContainer.getBoundingClientRect();
if (bounds.top < scrollBounds.top) {
scrollingContainer.scrollTop -= scrollBounds.top - bounds.top;
} else if (bounds.bottom > scrollBounds.bottom) {
scrollingContainer.scrollTop += bounds.bottom - scrollBounds.bottom;
}
}
}, {
key: 'setNativeRange',
value: function setNativeRange(startNode, startOffset) {
var endNode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : startNode;
var endOffset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : startOffset;
var force = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
debug.info('setNativeRange', startNode, startOffset, endNode, endOffset);
if (startNode != null && (this.root.parentNode == null || startNode.parentNode == null || endNode.parentNode == null)) {
return;
}
var selection = document.getSelection();
if (selection == null) return;
if (startNode != null) {
if (!this.hasFocus()) this.root.focus();
var native = (this.getNativeRange() || {}).native;
if (native == null || force || startNode !== native.startContainer || startOffset !== native.startOffset || endNode !== native.endContainer || endOffset !== native.endOffset) {
if (startNode.tagName == "BR") {
startOffset = [].indexOf.call(startNode.parentNode.childNodes, startNode);
startNode = startNode.parentNode;
}
if (endNode.tagName == "BR") {
endOffset = [].indexOf.call(endNode.parentNode.childNodes, endNode);
endNode = endNode.parentNode;
}
var range = document.createRange();
range.setStart(startNode, startOffset);
range.setEnd(endNode, endOffset);
selection.removeAllRanges();
selection.addRange(range);
}
} else {
selection.removeAllRanges();
this.root.blur();
document.body.focus(); // root.blur() not enough on IE11+Travis+SauceLabs (but not local VMs)
}
}
}, {
key: 'setRange',
value: function setRange(range) {
var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var source = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _emitter4.default.sources.API;
if (typeof force === 'string') {
source = force;
force = false;
}
debug.info('setRange', range);
if (range != null) {
var args = this.rangeToNative(range);
this.setNativeRange.apply(this, _toConsumableArray(args).concat([force]));
} else {
this.setNativeRange(null);
}
this.update(source);
}
}, {
key: 'update',
value: function update() {
var source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _emitter4.default.sources.USER;
var oldRange = this.lastRange;
var _getRange = this.getRange(),
_getRange2 = _slicedToArray(_getRange, 2),
lastRange = _getRange2[0],
nativeRange = _getRange2[1];
this.lastRange = lastRange;
if (this.lastRange != null) {
this.savedRange = this.lastRange;
}
if (!(_deepEqual2.default)(oldRange, this.lastRange)) {
var _emitter;
if (!this.composing && nativeRange != null && nativeRange.native.collapsed && nativeRange.start.node !== this.cursor.textNode) {
this.cursor.restore();
}
var args = [_emitter4.default.events.SELECTION_CHANGE, (_clone2.default)(this.lastRange), (_clone2.default)(oldRange), source];
(_emitter = this.emitter).emit.apply(_emitter, [_emitter4.default.events.EDITOR_CHANGE].concat(args));
if (source !== _emitter4.default.sources.SILENT) {
var _emitter2;
(_emitter2 = this.emitter).emit.apply(_emitter2, args);
}
}
}
}]);
return Selection;
}();
function contains(parent, descendant) {
try {
// Firefox inserts inaccessible nodes around video elements
descendant.parentNode;
} catch (e) {
return false;
}
// IE11 has bug with Text nodes
// https://connect.microsoft.com/IE/feedback/details/780874/node-contains-is-incorrect
if (descendant instanceof Text) {
descendant = descendant.parentNode;
}
return parent.contains(descendant);
}
exports.Range = Range;
exports.default = Selection;
/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Break = function (_Parchment$Embed) {
_inherits(Break, _Parchment$Embed);
function Break() {
_classCallCheck(this, Break);
return _possibleConstructorReturn(this, (Break.__proto__ || Object.getPrototypeOf(Break)).apply(this, arguments));
}
_createClass(Break, [{
key: 'insertInto',
value: function insertInto(parent, ref) {
if (parent.children.length === 0) {
_get(Break.prototype.__proto__ || Object.getPrototypeOf(Break.prototype), 'insertInto', this).call(this, parent, ref);
} else {
this.remove();
}
}
}, {
key: 'length',
value: function length() {
return 0;
}
}, {
key: 'value',
value: function value() {
return '';
}
}], [{
key: 'value',
value: function value() {
return undefined;
}
}]);
return Break;
}(_parchment2.default.Embed);
Break.blotName = 'break';
Break.tagName = 'BR';
exports.default = Break;
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var linked_list_1 = __webpack_require__(44);
var shadow_1 = __webpack_require__(30);
var Registry = __webpack_require__(1);
var ContainerBlot = /** @class */ (function (_super) {
__extends(ContainerBlot, _super);
function ContainerBlot(domNode) {
var _this = _super.call(this, domNode) || this;
_this.build();
return _this;
}
ContainerBlot.prototype.appendChild = function (other) {
this.insertBefore(other);
};
ContainerBlot.prototype.attach = function () {
_super.prototype.attach.call(this);
this.children.forEach(function (child) {
child.attach();
});
};
ContainerBlot.prototype.build = function () {
var _this = this;
this.children = new linked_list_1.default();
// Need to be reversed for if DOM nodes already in order
[].slice
.call(this.domNode.childNodes)
.reverse()
.forEach(function (node) {
try {
var child = makeBlot(node);
_this.insertBefore(child, _this.children.head || undefined);
}
catch (err) {
if (err instanceof Registry.ParchmentError)
return;
else
throw err;
}
});
};
ContainerBlot.prototype.deleteAt = function (index, length) {
if (index === 0 && length === this.length()) {
return this.remove();
}
this.children.forEachAt(index, length, function (child, offset, length) {
child.deleteAt(offset, length);
});
};
ContainerBlot.prototype.descendant = function (criteria, index) {
var _a = this.children.find(index), child = _a[0], offset = _a[1];
if ((criteria.blotName == null && criteria(child)) ||
(criteria.blotName != null && child instanceof criteria)) {
return [child, offset];
}
else if (child instanceof ContainerBlot) {
return child.descendant(criteria, offset);
}
else {
return [null, -1];
}
};
ContainerBlot.prototype.descendants = function (criteria, index, length) {
if (index === void 0) { index = 0; }
if (length === void 0) { length = Number.MAX_VALUE; }
var descendants = [];
var lengthLeft = length;
this.children.forEachAt(index, length, function (child, index, length) {
if ((criteria.blotName == null && criteria(child)) ||
(criteria.blotName != null && child instanceof criteria)) {
descendants.push(child);
}
if (child instanceof ContainerBlot) {
descendants = descendants.concat(child.descendants(criteria, index, lengthLeft));
}
lengthLeft -= length;
});
return descendants;
};
ContainerBlot.prototype.detach = function () {
this.children.forEach(function (child) {
child.detach();
});
_super.prototype.detach.call(this);
};
ContainerBlot.prototype.formatAt = function (index, length, name, value) {
this.children.forEachAt(index, length, function (child, offset, length) {
child.formatAt(offset, length, name, value);
});
};
ContainerBlot.prototype.insertAt = function (index, value, def) {
var _a = this.children.find(index), child = _a[0], offset = _a[1];
if (child) {
child.insertAt(offset, value, def);
}
else {
var blot = def == null ? Registry.create('text', value) : Registry.create(value, def);
this.appendChild(blot);
}
};
ContainerBlot.prototype.insertBefore = function (childBlot, refBlot) {
if (this.statics.allowedChildren != null &&
!this.statics.allowedChildren.some(function (child) {
return childBlot instanceof child;
})) {
throw new Registry.ParchmentError("Cannot insert " + childBlot.statics.blotName + " into " + this.statics.blotName);
}
childBlot.insertInto(this, refBlot);
};
ContainerBlot.prototype.length = function () {
return this.children.reduce(function (memo, child) {
return memo + child.length();
}, 0);
};
ContainerBlot.prototype.moveChildren = function (targetParent, refNode) {
this.children.forEach(function (child) {
targetParent.insertBefore(child, refNode);
});
};
ContainerBlot.prototype.optimize = function (context) {
_super.prototype.optimize.call(this, context);
if (this.children.length === 0) {
if (this.statics.defaultChild != null) {
var child = Registry.create(this.statics.defaultChild);
this.appendChild(child);
child.optimize(context);
}
else {
this.remove();
}
}
};
ContainerBlot.prototype.path = function (index, inclusive) {
if (inclusive === void 0) { inclusive = false; }
var _a = this.children.find(index, inclusive), child = _a[0], offset = _a[1];
var position = [[this, index]];
if (child instanceof ContainerBlot) {
return position.concat(child.path(offset, inclusive));
}
else if (child != null) {
position.push([child, offset]);
}
return position;
};
ContainerBlot.prototype.removeChild = function (child) {
this.children.remove(child);
};
ContainerBlot.prototype.replace = function (target) {
if (target instanceof ContainerBlot) {
target.moveChildren(this);
}
_super.prototype.replace.call(this, target);
};
ContainerBlot.prototype.split = function (index, force) {
if (force === void 0) { force = false; }
if (!force) {
if (index === 0)
return this;
if (index === this.length())
return this.next;
}
var after = this.clone();
this.parent.insertBefore(after, this.next);
this.children.forEachAt(index, this.length(), function (child, offset, length) {
child = child.split(offset, force);
after.appendChild(child);
});
return after;
};
ContainerBlot.prototype.unwrap = function () {
this.moveChildren(this.parent, this.next);
this.remove();
};
ContainerBlot.prototype.update = function (mutations, context) {
var _this = this;
var addedNodes = [];
var removedNodes = [];
mutations.forEach(function (mutation) {
if (mutation.target === _this.domNode && mutation.type === 'childList') {
addedNodes.push.apply(addedNodes, mutation.addedNodes);
removedNodes.push.apply(removedNodes, mutation.removedNodes);
}
});
removedNodes.forEach(function (node) {
// Check node has actually been removed
// One exception is Chrome does not immediately remove IFRAMEs
// from DOM but MutationRecord is correct in its reported removal
if (node.parentNode != null &&
// @ts-ignore
node.tagName !== 'IFRAME' &&
document.body.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) {
return;
}
var blot = Registry.find(node);
if (blot == null)
return;
if (blot.domNode.parentNode == null || blot.domNode.parentNode === _this.domNode) {
blot.detach();
}
});
addedNodes
.filter(function (node) {
return node.parentNode == _this.domNode;
})
.sort(function (a, b) {
if (a === b)
return 0;
if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING) {
return 1;
}
return -1;
})
.forEach(function (node) {
var refBlot = null;
if (node.nextSibling != null) {
refBlot = Registry.find(node.nextSibling);
}
var blot = makeBlot(node);
if (blot.next != refBlot || blot.next == null) {
if (blot.parent != null) {
blot.parent.removeChild(_this);
}
_this.insertBefore(blot, refBlot || undefined);
}
});
};
return ContainerBlot;
}(shadow_1.default));
function makeBlot(node) {
var blot = Registry.find(node);
if (blot == null) {
try {
blot = Registry.create(node);
}
catch (e) {
blot = Registry.create(Registry.Scope.INLINE);
[].slice.call(node.childNodes).forEach(function (child) {
// @ts-ignore
blot.domNode.appendChild(child);
});
if (node.parentNode) {
node.parentNode.replaceChild(blot.domNode, node);
}
blot.attach();
}
}
return blot;
}
exports.default = ContainerBlot;
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var attributor_1 = __webpack_require__(12);
var store_1 = __webpack_require__(31);
var container_1 = __webpack_require__(17);
var Registry = __webpack_require__(1);
var FormatBlot = /** @class */ (function (_super) {
__extends(FormatBlot, _super);
function FormatBlot(domNode) {
var _this = _super.call(this, domNode) || this;
_this.attributes = new store_1.default(_this.domNode);
return _this;
}
FormatBlot.formats = function (domNode) {
if (typeof this.tagName === 'string') {
return true;
}
else if (Array.isArray(this.tagName)) {
return domNode.tagName.toLowerCase();
}
return undefined;
};
FormatBlot.prototype.format = function (name, value) {
var format = Registry.query(name);
if (format instanceof attributor_1.default) {
this.attributes.attribute(format, value);
}
else if (value) {
if (format != null && (name !== this.statics.blotName || this.formats()[name] !== value)) {
this.replaceWith(name, value);
}
}
};
FormatBlot.prototype.formats = function () {
var formats = this.attributes.values();
var format = this.statics.formats(this.domNode);
if (format != null) {
formats[this.statics.blotName] = format;
}
return formats;
};
FormatBlot.prototype.replaceWith = function (name, value) {
var replacement = _super.prototype.replaceWith.call(this, name, value);
this.attributes.copy(replacement);
return replacement;
};
FormatBlot.prototype.update = function (mutations, context) {
var _this = this;
_super.prototype.update.call(this, mutations, context);
if (mutations.some(function (mutation) {
return mutation.target === _this.domNode && mutation.type === 'attributes';
})) {
this.attributes.build();
}
};
FormatBlot.prototype.wrap = function (name, value) {
var wrapper = _super.prototype.wrap.call(this, name, value);
if (wrapper instanceof FormatBlot && wrapper.statics.scope === this.statics.scope) {
this.attributes.move(wrapper);
}
return wrapper;
};
return FormatBlot;
}(container_1.default));
exports.default = FormatBlot;
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var shadow_1 = __webpack_require__(30);
var Registry = __webpack_require__(1);
var LeafBlot = /** @class */ (function (_super) {
__extends(LeafBlot, _super);
function LeafBlot() {
return _super !== null && _super.apply(this, arguments) || this;
}
LeafBlot.value = function (domNode) {
return true;
};
LeafBlot.prototype.index = function (node, offset) {
if (this.domNode === node ||
this.domNode.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) {
return Math.min(offset, 1);
}
return -1;
};
LeafBlot.prototype.position = function (index, inclusive) {
var offset = [].indexOf.call(this.parent.domNode.childNodes, this.domNode);
if (index > 0)
offset += 1;
return [this.parent.domNode, offset];
};
LeafBlot.prototype.value = function () {
return _a = {}, _a[this.statics.blotName] = this.statics.value(this.domNode) || true, _a;
var _a;
};
LeafBlot.scope = Registry.Scope.INLINE_BLOT;
return LeafBlot;
}(shadow_1.default));
exports.default = LeafBlot;
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
var equal = __webpack_require__(11);
var extend = __webpack_require__(3);
var lib = {
attributes: {
compose: function (a, b, keepNull) {
if (typeof a !== 'object') a = {};
if (typeof b !== 'object') b = {};
var attributes = extend(true, {}, b);
if (!keepNull) {
attributes = Object.keys(attributes).reduce(function (copy, key) {
if (attributes[key] != null) {
copy[key] = attributes[key];
}
return copy;
}, {});
}
for (var key in a) {
if (a[key] !== undefined && b[key] === undefined) {
attributes[key] = a[key];
}
}
return Object.keys(attributes).length > 0 ? attributes : undefined;
},
diff: function(a, b) {
if (typeof a !== 'object') a = {};
if (typeof b !== 'object') b = {};
var attributes = Object.keys(a).concat(Object.keys(b)).reduce(function (attributes, key) {
if (!equal(a[key], b[key])) {
attributes[key] = b[key] === undefined ? null : b[key];
}
return attributes;
}, {});
return Object.keys(attributes).length > 0 ? attributes : undefined;
},
transform: function (a, b, priority) {
if (typeof a !== 'object') return b;
if (typeof b !== 'object') return undefined;
if (!priority) return b; // b simply overwrites us without priority
var attributes = Object.keys(b).reduce(function (attributes, key) {
if (a[key] === undefined) attributes[key] = b[key]; // null is a valid value
return attributes;
}, {});
return Object.keys(attributes).length > 0 ? attributes : undefined;
}
},
iterator: function (ops) {
return new Iterator(ops);
},
length: function (op) {
if (typeof op['delete'] === 'number') {
return op['delete'];
} else if (typeof op.retain === 'number') {
return op.retain;
} else {
return typeof op.insert === 'string' ? op.insert.length : 1;
}
}
};
function Iterator(ops) {
this.ops = ops;
this.index = 0;
this.offset = 0;
}
Iterator.prototype.hasNext = function () {
return this.peekLength() < Infinity;
};
Iterator.prototype.next = function (length) {
if (!length) length = Infinity;
var nextOp = this.ops[this.index];
if (nextOp) {
var offset = this.offset;
var opLength = lib.length(nextOp);
if (length >= opLength - offset) {
length = opLength - offset;
this.index += 1;
this.offset = 0;
} else {
this.offset += length;
}
if (typeof nextOp['delete'] === 'number') {
return { 'delete': length };
} else {
var retOp = {};
if (nextOp.attributes) {
retOp.attributes = nextOp.attributes;
}
if (typeof nextOp.retain === 'number') {
retOp.retain = length;
} else if (typeof nextOp.insert === 'string') {
retOp.insert = nextOp.insert.substr(offset, length);
} else {
// offset should === 0, length should === 1
retOp.insert = nextOp.insert;
}
return retOp;
}
} else {
return { retain: Infinity };
}
};
Iterator.prototype.peek = function () {
return this.ops[this.index];
};
Iterator.prototype.peekLength = function () {
if (this.ops[this.index]) {
// Should never return 0 if our index is being managed correctly
return lib.length(this.ops[this.index]) - this.offset;
} else {
return Infinity;
}
};
Iterator.prototype.peekType = function () {
if (this.ops[this.index]) {
if (typeof this.ops[this.index]['delete'] === 'number') {
return 'delete';
} else if (typeof this.ops[this.index].retain === 'number') {
return 'retain';
} else {
return 'insert';
}
}
return 'retain';
};
module.exports = lib;
/***/ }),
/* 21 */
/***/ (function(module, exports) {
var clone = (function() {
function _instanceof(obj, type) {
return type != null && obj instanceof type;
}
var nativeMap;
try {
nativeMap = Map;
} catch(_) {
// maybe a reference error because no `Map`. Give it a dummy value that no
// value will ever be an instanceof.
nativeMap = function() {};
}
var nativeSet;
try {
nativeSet = Set;
} catch(_) {
nativeSet = function() {};
}
var nativePromise;
try {
nativePromise = Promise;
} catch(_) {
nativePromise = function() {};
}
/**
* Clones (copies) an Object using deep copying.
*
* This function supports circular references by default, but if you are certain
* there are no circular references in your object, you can save some CPU time
* by calling clone(obj, false).
*
* Caution: if `circular` is false and `parent` contains circular references,
* your program may enter an infinite loop and crash.
*
* @param `parent` - the object to be cloned
* @param `circular` - set to true if the object to be cloned may contain
* circular references. (optional - true by default)
* @param `depth` - set to a number if the object is only to be cloned to
* a particular depth. (optional - defaults to Infinity)
* @param `prototype` - sets the prototype to be used when cloning an object.
* (optional - defaults to parent prototype).
* @param `includeNonEnumerable` - set to true if the non-enumerable properties
* should be cloned as well. Non-enumerable properties on the prototype
* chain will be ignored. (optional - false by default)
*/
function clone(parent, circular, depth, prototype, includeNonEnumerable) {
if (typeof circular === 'object') {
depth = circular.depth;
prototype = circular.prototype;
includeNonEnumerable = circular.includeNonEnumerable;
circular = circular.circular;
}
// maintain two arrays for circular references, where corresponding parents
// and children have the same index
var allParents = [];
var allChildren = [];
var useBuffer = typeof Buffer != 'undefined';
if (typeof circular == 'undefined')
circular = true;
if (typeof depth == 'undefined')
depth = Infinity;
// recurse this function so we don't reset allParents and allChildren
function _clone(parent, depth) {
// cloning null always returns null
if (parent === null)
return null;
if (depth === 0)
return parent;
var child;
var proto;
if (typeof parent != 'object') {
return parent;
}
if (_instanceof(parent, nativeMap)) {
child = new nativeMap();
} else if (_instanceof(parent, nativeSet)) {
child = new nativeSet();
} else if (_instanceof(parent, nativePromise)) {
child = new nativePromise(function (resolve, reject) {
parent.then(function(value) {
resolve(_clone(value, depth - 1));
}, function(err) {
reject(_clone(err, depth - 1));
});
});
} else if (clone.__isArray(parent)) {
child = [];
} else if (clone.__isRegExp(parent)) {
child = new RegExp(parent.source, __getRegExpFlags(parent));
if (parent.lastIndex) child.lastIndex = parent.lastIndex;
} else if (clone.__isDate(parent)) {
child = new Date(parent.getTime());
} else if (useBuffer && Buffer.isBuffer(parent)) {
child = new Buffer(parent.length);
parent.copy(child);
return child;
} else if (_instanceof(parent, Error)) {
child = Object.create(parent);
} else {
if (typeof prototype == 'undefined') {
proto = Object.getPrototypeOf(parent);
child = Object.create(proto);
}
else {
child = Object.create(prototype);
proto = prototype;
}
}
if (circular) {
var index = allParents.indexOf(parent);
if (index != -1) {
return allChildren[index];
}
allParents.push(parent);
allChildren.push(child);
}
if (_instanceof(parent, nativeMap)) {
parent.forEach(function(value, key) {
var keyChild = _clone(key, depth - 1);
var valueChild = _clone(value, depth - 1);
child.set(keyChild, valueChild);
});
}
if (_instanceof(parent, nativeSet)) {
parent.forEach(function(value) {
var entryChild = _clone(value, depth - 1);
child.add(entryChild);
});
}
for (var i in parent) {
var attrs;
if (proto) {
attrs = Object.getOwnPropertyDescriptor(proto, i);
}
if (attrs && attrs.set == null) {
continue;
}
child[i] = _clone(parent[i], depth - 1);
}
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(parent);
for (var i = 0; i < symbols.length; i++) {
// Don't need to worry about cloning a symbol because it is a primitive,
// like a number or string.
var symbol = symbols[i];
var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
continue;
}
child[symbol] = _clone(parent[symbol], depth - 1);
if (!descriptor.enumerable) {
Object.defineProperty(child, symbol, {
enumerable: false
});
}
}
}
if (includeNonEnumerable) {
var allPropertyNames = Object.getOwnPropertyNames(parent);
for (var i = 0; i < allPropertyNames.length; i++) {
var propertyName = allPropertyNames[i];
var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);
if (descriptor && descriptor.enumerable) {
continue;
}
child[propertyName] = _clone(parent[propertyName], depth - 1);
Object.defineProperty(child, propertyName, {
enumerable: false
});
}
}
return child;
}
return _clone(parent, depth);
}
/**
* Simple flat clone using prototype, accepts only objects, usefull for property
* override on FLAT configuration object (no nested props).
*
* USE WITH CAUTION! This may not behave as you wish if you do not know how this
* works.
*/
clone.clonePrototype = function clonePrototype(parent) {
if (parent === null)
return null;
var c = function () {};
c.prototype = parent;
return new c();
};
// private utility functions
function __objToStr(o) {
return Object.prototype.toString.call(o);
}
clone.__objToStr = __objToStr;
function __isDate(o) {
return typeof o === 'object' && __objToStr(o) === '[object Date]';
}
clone.__isDate = __isDate;
function __isArray(o) {
return typeof o === 'object' && __objToStr(o) === '[object Array]';
}
clone.__isArray = __isArray;
function __isRegExp(o) {
return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
}
clone.__isRegExp = __isRegExp;
function __getRegExpFlags(re) {
var flags = '';
if (re.global) flags += 'g';
if (re.ignoreCase) flags += 'i';
if (re.multiline) flags += 'm';
return flags;
}
clone.__getRegExpFlags = __getRegExpFlags;
return clone;
})();
if (typeof module === 'object' && module.exports) {
module.exports = clone;
}
/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _emitter = __webpack_require__(8);
var _emitter2 = _interopRequireDefault(_emitter);
var _block = __webpack_require__(4);
var _block2 = _interopRequireDefault(_block);
var _break = __webpack_require__(16);
var _break2 = _interopRequireDefault(_break);
var _code = __webpack_require__(13);
var _code2 = _interopRequireDefault(_code);
var _container = __webpack_require__(25);
var _container2 = _interopRequireDefault(_container);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
function isLine(blot) {
return blot instanceof _block2.default || blot instanceof _block.BlockEmbed;
}
var Scroll = function (_Parchment$Scroll) {
_inherits(Scroll, _Parchment$Scroll);
function Scroll(domNode, config) {
_classCallCheck(this, Scroll);
var _this = _possibleConstructorReturn(this, (Scroll.__proto__ || Object.getPrototypeOf(Scroll)).call(this, domNode));
_this.emitter = config.emitter;
if (Array.isArray(config.whitelist)) {
_this.whitelist = config.whitelist.reduce(function (whitelist, format) {
whitelist[format] = true;
return whitelist;
}, {});
}
// Some reason fixes composition issues with character languages in Windows/Chrome, Safari
_this.domNode.addEventListener('DOMNodeInserted', function () {});
_this.optimize();
_this.enable();
return _this;
}
_createClass(Scroll, [{
key: 'batchStart',
value: function batchStart() {
this.batch = true;
}
}, {
key: 'batchEnd',
value: function batchEnd() {
this.batch = false;
this.optimize();
}
}, {
key: 'deleteAt',
value: function deleteAt(index, length) {
var _line = this.line(index),
_line2 = _slicedToArray(_line, 2),
first = _line2[0],
offset = _line2[1];
var _line3 = this.line(index + length),
_line4 = _slicedToArray(_line3, 1),
last = _line4[0];
_get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'deleteAt', this).call(this, index, length);
if (last != null && first !== last && offset > 0) {
if (first instanceof _block.BlockEmbed || last instanceof _block.BlockEmbed) {
this.optimize();
return;
}
if (first instanceof _code2.default) {
var newlineIndex = first.newlineIndex(first.length(), true);
if (newlineIndex > -1) {
first = first.split(newlineIndex + 1);
if (first === last) {
this.optimize();
return;
}
}
} else if (last instanceof _code2.default) {
var _newlineIndex = last.newlineIndex(0);
if (_newlineIndex > -1) {
last.split(_newlineIndex + 1);
}
}
var ref = last.children.head instanceof _break2.default ? null : last.children.head;
first.moveChildren(last, ref);
first.remove();
}
this.optimize();
}
}, {
key: 'enable',
value: function enable() {
var enabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
this.domNode.setAttribute('contenteditable', enabled);
}
}, {
key: 'formatAt',
value: function formatAt(index, length, format, value) {
if (this.whitelist != null && !this.whitelist[format]) return;
_get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'formatAt', this).call(this, index, length, format, value);
this.optimize();
}
}, {
key: 'insertAt',
value: function insertAt(index, value, def) {
if (def != null && this.whitelist != null && !this.whitelist[value]) return;
if (index >= this.length()) {
if (def == null || _parchment2.default.query(value, _parchment2.default.Scope.BLOCK) == null) {
var blot = _parchment2.default.create(this.statics.defaultChild);
this.appendChild(blot);
if (def == null && value.endsWith('\n')) {
value = value.slice(0, -1);
}
blot.insertAt(0, value, def);
} else {
var embed = _parchment2.default.create(value, def);
this.appendChild(embed);
}
} else {
_get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'insertAt', this).call(this, index, value, def);
}
this.optimize();
}
}, {
key: 'insertBefore',
value: function insertBefore(blot, ref) {
if (blot.statics.scope === _parchment2.default.Scope.INLINE_BLOT) {
var wrapper = _parchment2.default.create(this.statics.defaultChild);
wrapper.appendChild(blot);
blot = wrapper;
}
_get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'insertBefore', this).call(this, blot, ref);
}
}, {
key: 'leaf',
value: function leaf(index) {
return this.path(index).pop() || [null, -1];
}
}, {
key: 'line',
value: function line(index) {
if (index === this.length()) {
return this.line(index - 1);
}
return this.descendant(isLine, index);
}
}, {
key: 'lines',
value: function lines() {
var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Number.MAX_VALUE;
var getLines = function getLines(blot, index, length) {
var lines = [],
lengthLeft = length;
blot.children.forEachAt(index, length, function (child, index, length) {
if (isLine(child)) {
lines.push(child);
} else if (child instanceof _parchment2.default.Container) {
lines = lines.concat(getLines(child, index, lengthLeft));
}
lengthLeft -= length;
});
return lines;
};
return getLines(this, index, length);
}
}, {
key: 'optimize',
value: function optimize() {
var mutations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
if (this.batch === true) return;
_get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'optimize', this).call(this, mutations, context);
if (mutations.length > 0) {
this.emitter.emit(_emitter2.default.events.SCROLL_OPTIMIZE, mutations, context);
}
}
}, {
key: 'path',
value: function path(index) {
return _get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'path', this).call(this, index).slice(1); // Exclude self
}
}, {
key: 'update',
value: function update(mutations) {
if (this.batch === true) return;
var source = _emitter2.default.sources.USER;
if (typeof mutations === 'string') {
source = mutations;
}
if (!Array.isArray(mutations)) {
mutations = this.observer.takeRecords();
}
if (mutations.length > 0) {
this.emitter.emit(_emitter2.default.events.SCROLL_BEFORE_UPDATE, source, mutations);
}
_get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'update', this).call(this, mutations.concat([])); // pass copy
if (mutations.length > 0) {
this.emitter.emit(_emitter2.default.events.SCROLL_UPDATE, source, mutations);
}
}
}]);
return Scroll;
}(_parchment2.default.Scroll);
Scroll.blotName = 'scroll';
Scroll.className = 'ql-editor';
Scroll.tagName = 'DIV';
Scroll.defaultChild = 'block';
Scroll.allowedChildren = [_block2.default, _block.BlockEmbed, _container2.default];
exports.default = Scroll;
/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.SHORTKEY = exports.default = undefined;
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _clone = __webpack_require__(21);
var _clone2 = _interopRequireDefault(_clone);
var _deepEqual = __webpack_require__(11);
var _deepEqual2 = _interopRequireDefault(_deepEqual);
var _extend = __webpack_require__(3);
var _extend2 = _interopRequireDefault(_extend);
var _quillDelta = __webpack_require__(2);
var _quillDelta2 = _interopRequireDefault(_quillDelta);
var _op = __webpack_require__(20);
var _op2 = _interopRequireDefault(_op);
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _quill = __webpack_require__(5);
var _quill2 = _interopRequireDefault(_quill);
var _logger = __webpack_require__(10);
var _logger2 = _interopRequireDefault(_logger);
var _module = __webpack_require__(9);
var _module2 = _interopRequireDefault(_module);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var debug = (_logger2.default)('quill:keyboard');
var SHORTKEY = /Mac/i.test(navigator.platform) ? 'metaKey' : 'ctrlKey';
var Keyboard = function (_Module) {
_inherits(Keyboard, _Module);
_createClass(Keyboard, null, [{
key: 'match',
value: function match(evt, binding) {
binding = normalize(binding);
if (['altKey', 'ctrlKey', 'metaKey', 'shiftKey'].some(function (key) {
return !!binding[key] !== evt[key] && binding[key] !== null;
})) {
return false;
}
return binding.key === (evt.which || evt.keyCode);
}
}]);
function Keyboard(quill, options) {
_classCallCheck(this, Keyboard);
var _this = _possibleConstructorReturn(this, (Keyboard.__proto__ || Object.getPrototypeOf(Keyboard)).call(this, quill, options));
_this.bindings = {};
Object.keys(_this.options.bindings).forEach(function (name) {
if (name === 'list autofill' && quill.scroll.whitelist != null && !quill.scroll.whitelist['list']) {
return;
}
if (_this.options.bindings[name]) {
_this.addBinding(_this.options.bindings[name]);
}
});
_this.addBinding({ key: Keyboard.keys.ENTER, shiftKey: null }, handleEnter);
_this.addBinding({ key: Keyboard.keys.ENTER, metaKey: null, ctrlKey: null, altKey: null }, function () {});
if (/Firefox/i.test(navigator.userAgent)) {
// Need to handle delete and backspace for Firefox in the general case #1171
_this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: true }, handleBackspace);
_this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: true }, handleDelete);
} else {
_this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: true, prefix: /^.?$/ }, handleBackspace);
_this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: true, suffix: /^.?$/ }, handleDelete);
}
_this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: false }, handleDeleteRange);
_this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: false }, handleDeleteRange);
_this.addBinding({ key: Keyboard.keys.BACKSPACE, altKey: null, ctrlKey: null, metaKey: null, shiftKey: null }, { collapsed: true, offset: 0 }, handleBackspace);
_this.listen();
return _this;
}
_createClass(Keyboard, [{
key: 'addBinding',
value: function addBinding(key) {
var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var handler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var binding = normalize(key);
if (binding == null || binding.key == null) {
return debug.warn('Attempted to add invalid keyboard binding', binding);
}
if (typeof context === 'function') {
context = { handler: context };
}
if (typeof handler === 'function') {
handler = { handler: handler };
}
binding = (_extend2.default)(binding, context, handler);
this.bindings[binding.key] = this.bindings[binding.key] || [];
this.bindings[binding.key].push(binding);
}
}, {
key: 'listen',
value: function listen() {
var _this2 = this;
this.quill.root.addEventListener('keydown', function (evt) {
if (evt.defaultPrevented) return;
var which = evt.which || evt.keyCode;
var bindings = (_this2.bindings[which] || []).filter(function (binding) {
return Keyboard.match(evt, binding);
});
if (bindings.length === 0) return;
var range = _this2.quill.getSelection();
if (range == null || !_this2.quill.hasFocus()) return;
var _quill$getLine = _this2.quill.getLine(range.index),
_quill$getLine2 = _slicedToArray(_quill$getLine, 2),
line = _quill$getLine2[0],
offset = _quill$getLine2[1];
var _quill$getLeaf = _this2.quill.getLeaf(range.index),
_quill$getLeaf2 = _slicedToArray(_quill$getLeaf, 2),
leafStart = _quill$getLeaf2[0],
offsetStart = _quill$getLeaf2[1];
var _ref = range.length === 0 ? [leafStart, offsetStart] : _this2.quill.getLeaf(range.index + range.length),
_ref2 = _slicedToArray(_ref, 2),
leafEnd = _ref2[0],
offsetEnd = _ref2[1];
var prefixText = leafStart instanceof _parchment2.default.Text ? leafStart.value().slice(0, offsetStart) : '';
var suffixText = leafEnd instanceof _parchment2.default.Text ? leafEnd.value().slice(offsetEnd) : '';
var curContext = {
collapsed: range.length === 0,
empty: range.length === 0 && line.length() <= 1,
format: _this2.quill.getFormat(range),
offset: offset,
prefix: prefixText,
suffix: suffixText
};
var prevented = bindings.some(function (binding) {
if (binding.collapsed != null && binding.collapsed !== curContext.collapsed) return false;
if (binding.empty != null && binding.empty !== curContext.empty) return false;
if (binding.offset != null && binding.offset !== curContext.offset) return false;
if (Array.isArray(binding.format)) {
// any format is present
if (binding.format.every(function (name) {
return curContext.format[name] == null;
})) {
return false;
}
} else if (_typeof(binding.format) === 'object') {
// all formats must match
if (!Object.keys(binding.format).every(function (name) {
if (binding.format[name] === true) return curContext.format[name] != null;
if (binding.format[name] === false) return curContext.format[name] == null;
return (_deepEqual2.default)(binding.format[name], curContext.format[name]);
})) {
return false;
}
}
if (binding.prefix != null && !binding.prefix.test(curContext.prefix)) return false;
if (binding.suffix != null && !binding.suffix.test(curContext.suffix)) return false;
return binding.handler.call(_this2, range, curContext) !== true;
});
if (prevented) {
evt.preventDefault();
}
});
}
}]);
return Keyboard;
}(_module2.default);
Keyboard.keys = {
BACKSPACE: 8,
TAB: 9,
ENTER: 13,
ESCAPE: 27,
LEFT: 37,
UP: 38,
RIGHT: 39,
DOWN: 40,
DELETE: 46
};
Keyboard.DEFAULTS = {
bindings: {
'bold': makeFormatHandler('bold'),
'italic': makeFormatHandler('italic'),
'underline': makeFormatHandler('underline'),
'indent': {
// highlight tab or tab at beginning of list, indent or blockquote
key: Keyboard.keys.TAB,
format: ['blockquote', 'indent', 'list'],
handler: function handler(range, context) {
if (context.collapsed && context.offset !== 0) return true;
this.quill.format('indent', '+1', _quill2.default.sources.USER);
}
},
'outdent': {
key: Keyboard.keys.TAB,
shiftKey: true,
format: ['blockquote', 'indent', 'list'],
// highlight tab or tab at beginning of list, indent or blockquote
handler: function handler(range, context) {
if (context.collapsed && context.offset !== 0) return true;
this.quill.format('indent', '-1', _quill2.default.sources.USER);
}
},
'outdent backspace': {
key: Keyboard.keys.BACKSPACE,
collapsed: true,
shiftKey: null,
metaKey: null,
ctrlKey: null,
altKey: null,
format: ['indent', 'list'],
offset: 0,
handler: function handler(range, context) {
if (context.format.indent != null) {
this.quill.format('indent', '-1', _quill2.default.sources.USER);
} else if (context.format.list != null) {
this.quill.format('list', false, _quill2.default.sources.USER);
}
}
},
'indent code-block': makeCodeBlockHandler(true),
'outdent code-block': makeCodeBlockHandler(false),
'remove tab': {
key: Keyboard.keys.TAB,
shiftKey: true,
collapsed: true,
prefix: /\t$/,
handler: function handler(range) {
this.quill.deleteText(range.index - 1, 1, _quill2.default.sources.USER);
}
},
'tab': {
key: Keyboard.keys.TAB,
handler: function handler(range) {
this.quill.history.cutoff();
var delta = new _quillDelta2.default().retain(range.index).delete(range.length).insert('\t');
this.quill.updateContents(delta, _quill2.default.sources.USER);
this.quill.history.cutoff();
this.quill.setSelection(range.index + 1, _quill2.default.sources.SILENT);
}
},
'list empty enter': {
key: Keyboard.keys.ENTER,
collapsed: true,
format: ['list'],
empty: true,
handler: function handler(range, context) {
this.quill.format('list', false, _quill2.default.sources.USER);
if (context.format.indent) {
this.quill.format('indent', false, _quill2.default.sources.USER);
}
}
},
'checklist enter': {
key: Keyboard.keys.ENTER,
collapsed: true,
format: { list: 'checked' },
handler: function handler(range) {
var _quill$getLine3 = this.quill.getLine(range.index),
_quill$getLine4 = _slicedToArray(_quill$getLine3, 2),
line = _quill$getLine4[0],
offset = _quill$getLine4[1];
var formats = (_extend2.default)({}, line.formats(), { list: 'checked' });
var delta = new _quillDelta2.default().retain(range.index).insert('\n', formats).retain(line.length() - offset - 1).retain(1, { list: 'unchecked' });
this.quill.updateContents(delta, _quill2.default.sources.USER);
this.quill.setSelection(range.index + 1, _quill2.default.sources.SILENT);
this.quill.scrollIntoView();
}
},
'header enter': {
key: Keyboard.keys.ENTER,
collapsed: true,
format: ['header'],
suffix: /^$/,
handler: function handler(range, context) {
var _quill$getLine5 = this.quill.getLine(range.index),
_quill$getLine6 = _slicedToArray(_quill$getLine5, 2),
line = _quill$getLine6[0],
offset = _quill$getLine6[1];
var delta = new _quillDelta2.default().retain(range.index).insert('\n', context.format).retain(line.length() - offset - 1).retain(1, { header: null });
this.quill.updateContents(delta, _quill2.default.sources.USER);
this.quill.setSelection(range.index + 1, _quill2.default.sources.SILENT);
this.quill.scrollIntoView();
}
},
'list autofill': {
key: ' ',
collapsed: true,
format: { list: false },
prefix: /^\s*?(\d+\.|-|\*|\[ ?\]|\[x\])$/,
handler: function handler(range, context) {
var length = context.prefix.length;
var _quill$getLine7 = this.quill.getLine(range.index),
_quill$getLine8 = _slicedToArray(_quill$getLine7, 2),
line = _quill$getLine8[0],
offset = _quill$getLine8[1];
if (offset > length) return true;
var value = void 0;
switch (context.prefix.trim()) {
case '[]':case '[ ]':
value = 'unchecked';
break;
case '[x]':
value = 'checked';
break;
case '-':case '*':
value = 'bullet';
break;
default:
value = 'ordered';
}
this.quill.insertText(range.index, ' ', _quill2.default.sources.USER);
this.quill.history.cutoff();
var delta = new _quillDelta2.default().retain(range.index - offset).delete(length + 1).retain(line.length() - 2 - offset).retain(1, { list: value });
this.quill.updateContents(delta, _quill2.default.sources.USER);
this.quill.history.cutoff();
this.quill.setSelection(range.index - length, _quill2.default.sources.SILENT);
}
},
'code exit': {
key: Keyboard.keys.ENTER,
collapsed: true,
format: ['code-block'],
prefix: /\n\n$/,
suffix: /^\s+$/,
handler: function handler(range) {
var _quill$getLine9 = this.quill.getLine(range.index),
_quill$getLine10 = _slicedToArray(_quill$getLine9, 2),
line = _quill$getLine10[0],
offset = _quill$getLine10[1];
var delta = new _quillDelta2.default().retain(range.index + line.length() - offset - 2).retain(1, { 'code-block': null }).delete(1);
this.quill.updateContents(delta, _quill2.default.sources.USER);
}
},
'embed left': makeEmbedArrowHandler(Keyboard.keys.LEFT, false),
'embed left shift': makeEmbedArrowHandler(Keyboard.keys.LEFT, true),
'embed right': makeEmbedArrowHandler(Keyboard.keys.RIGHT, false),
'embed right shift': makeEmbedArrowHandler(Keyboard.keys.RIGHT, true)
}
};
function makeEmbedArrowHandler(key, shiftKey) {
var _ref3;
var where = key === Keyboard.keys.LEFT ? 'prefix' : 'suffix';
return _ref3 = {
key: key,
shiftKey: shiftKey,
altKey: null
}, _defineProperty(_ref3, where, /^$/), _defineProperty(_ref3, 'handler', function handler(range) {
var index = range.index;
if (key === Keyboard.keys.RIGHT) {
index += range.length + 1;
}
var _quill$getLeaf3 = this.quill.getLeaf(index),
_quill$getLeaf4 = _slicedToArray(_quill$getLeaf3, 1),
leaf = _quill$getLeaf4[0];
if (!(leaf instanceof _parchment2.default.Embed)) return true;
if (key === Keyboard.keys.LEFT) {
if (shiftKey) {
this.quill.setSelection(range.index - 1, range.length + 1, _quill2.default.sources.USER);
} else {
this.quill.setSelection(range.index - 1, _quill2.default.sources.USER);
}
} else {
if (shiftKey) {
this.quill.setSelection(range.index, range.length + 1, _quill2.default.sources.USER);
} else {
this.quill.setSelection(range.index + range.length + 1, _quill2.default.sources.USER);
}
}
return false;
}), _ref3;
}
function handleBackspace(range, context) {
if (range.index === 0 || this.quill.getLength() <= 1) return;
var _quill$getLine11 = this.quill.getLine(range.index),
_quill$getLine12 = _slicedToArray(_quill$getLine11, 1),
line = _quill$getLine12[0];
var formats = {};
if (context.offset === 0) {
var _quill$getLine13 = this.quill.getLine(range.index - 1),
_quill$getLine14 = _slicedToArray(_quill$getLine13, 1),
prev = _quill$getLine14[0];
if (prev != null && prev.length() > 1) {
var curFormats = line.formats();
var prevFormats = this.quill.getFormat(range.index - 1, 1);
formats = _op2.default.attributes.diff(curFormats, prevFormats) || {};
}
}
// Check for astral symbols
var length = /[\uD800-\uDBFF][\uDC00-\uDFFF]$/.test(context.prefix) ? 2 : 1;
this.quill.deleteText(range.index - length, length, _quill2.default.sources.USER);
if (Object.keys(formats).length > 0) {
this.quill.formatLine(range.index - length, length, formats, _quill2.default.sources.USER);
}
this.quill.focus();
}
function handleDelete(range, context) {
// Check for astral symbols
var length = /^[\uD800-\uDBFF][\uDC00-\uDFFF]/.test(context.suffix) ? 2 : 1;
if (range.index >= this.quill.getLength() - length) return;
var formats = {},
nextLength = 0;
var _quill$getLine15 = this.quill.getLine(range.index),
_quill$getLine16 = _slicedToArray(_quill$getLine15, 1),
line = _quill$getLine16[0];
if (context.offset >= line.length() - 1) {
var _quill$getLine17 = this.quill.getLine(range.index + 1),
_quill$getLine18 = _slicedToArray(_quill$getLine17, 1),
next = _quill$getLine18[0];
if (next) {
var curFormats = line.formats();
var nextFormats = this.quill.getFormat(range.index, 1);
formats = _op2.default.attributes.diff(curFormats, nextFormats) || {};
nextLength = next.length();
}
}
this.quill.deleteText(range.index, length, _quill2.default.sources.USER);
if (Object.keys(formats).length > 0) {
this.quill.formatLine(range.index + nextLength - 1, length, formats, _quill2.default.sources.USER);
}
}
function handleDeleteRange(range) {
var lines = this.quill.getLines(range);
var formats = {};
if (lines.length > 1) {
var firstFormats = lines[0].formats();
var lastFormats = lines[lines.length - 1].formats();
formats = _op2.default.attributes.diff(lastFormats, firstFormats) || {};
}
this.quill.deleteText(range, _quill2.default.sources.USER);
if (Object.keys(formats).length > 0) {
this.quill.formatLine(range.index, 1, formats, _quill2.default.sources.USER);
}
this.quill.setSelection(range.index, _quill2.default.sources.SILENT);
this.quill.focus();
}
function handleEnter(range, context) {
var _this3 = this;
if (range.length > 0) {
this.quill.scroll.deleteAt(range.index, range.length); // So we do not trigger text-change
}
var lineFormats = Object.keys(context.format).reduce(function (lineFormats, format) {
if (_parchment2.default.query(format, _parchment2.default.Scope.BLOCK) && !Array.isArray(context.format[format])) {
lineFormats[format] = context.format[format];
}
return lineFormats;
}, {});
this.quill.insertText(range.index, '\n', lineFormats, _quill2.default.sources.USER);
// Earlier scroll.deleteAt might have messed up our selection,
// so insertText's built in selection preservation is not reliable
this.quill.setSelection(range.index + 1, _quill2.default.sources.SILENT);
this.quill.focus();
Object.keys(context.format).forEach(function (name) {
if (lineFormats[name] != null) return;
if (Array.isArray(context.format[name])) return;
if (name === 'link') return;
_this3.quill.format(name, context.format[name], _quill2.default.sources.USER);
});
}
function makeCodeBlockHandler(indent) {
return {
key: Keyboard.keys.TAB,
shiftKey: !indent,
format: { 'code-block': true },
handler: function handler(range) {
var CodeBlock = _parchment2.default.query('code-block');
var index = range.index,
length = range.length;
var _quill$scroll$descend = this.quill.scroll.descendant(CodeBlock, index),
_quill$scroll$descend2 = _slicedToArray(_quill$scroll$descend, 2),
block = _quill$scroll$descend2[0],
offset = _quill$scroll$descend2[1];
if (block == null) return;
var scrollIndex = this.quill.getIndex(block);
var start = block.newlineIndex(offset, true) + 1;
var end = block.newlineIndex(scrollIndex + offset + length);
var lines = block.domNode.textContent.slice(start, end).split('\n');
offset = 0;
lines.forEach(function (line, i) {
if (indent) {
block.insertAt(start + offset, CodeBlock.TAB);
offset += CodeBlock.TAB.length;
if (i === 0) {
index += CodeBlock.TAB.length;
} else {
length += CodeBlock.TAB.length;
}
} else if (line.startsWith(CodeBlock.TAB)) {
block.deleteAt(start + offset, CodeBlock.TAB.length);
offset -= CodeBlock.TAB.length;
if (i === 0) {
index -= CodeBlock.TAB.length;
} else {
length -= CodeBlock.TAB.length;
}
}
offset += line.length + 1;
});
this.quill.update(_quill2.default.sources.USER);
this.quill.setSelection(index, length, _quill2.default.sources.SILENT);
}
};
}
function makeFormatHandler(format) {
return {
key: format[0].toUpperCase(),
shortKey: true,
handler: function handler(range, context) {
this.quill.format(format, !context.format[format], _quill2.default.sources.USER);
}
};
}
function normalize(binding) {
if (typeof binding === 'string' || typeof binding === 'number') {
return normalize({ key: binding });
}
if ((typeof binding === 'undefined' ? 'undefined' : _typeof(binding)) === 'object') {
binding = (_clone2.default)(binding, false);
}
if (typeof binding.key === 'string') {
if (Keyboard.keys[binding.key.toUpperCase()] != null) {
binding.key = Keyboard.keys[binding.key.toUpperCase()];
} else if (binding.key.length === 1) {
binding.key = binding.key.toUpperCase().charCodeAt(0);
} else {
return null;
}
}
if (binding.shortKey) {
binding[SHORTKEY] = binding.shortKey;
delete binding.shortKey;
}
return binding;
}
exports.default = Keyboard;
exports.SHORTKEY = SHORTKEY;
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _text = __webpack_require__(7);
var _text2 = _interopRequireDefault(_text);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Cursor = function (_Parchment$Embed) {
_inherits(Cursor, _Parchment$Embed);
_createClass(Cursor, null, [{
key: 'value',
value: function value() {
return undefined;
}
}]);
function Cursor(domNode, selection) {
_classCallCheck(this, Cursor);
var _this = _possibleConstructorReturn(this, (Cursor.__proto__ || Object.getPrototypeOf(Cursor)).call(this, domNode));
_this.selection = selection;
_this.textNode = document.createTextNode(Cursor.CONTENTS);
_this.domNode.appendChild(_this.textNode);
_this._length = 0;
return _this;
}
_createClass(Cursor, [{
key: 'detach',
value: function detach() {
// super.detach() will also clear domNode.__blot
if (this.parent != null) this.parent.removeChild(this);
}
}, {
key: 'format',
value: function format(name, value) {
if (this._length !== 0) {
return _get(Cursor.prototype.__proto__ || Object.getPrototypeOf(Cursor.prototype), 'format', this).call(this, name, value);
}
var target = this,
index = 0;
while (target != null && target.statics.scope !== _parchment2.default.Scope.BLOCK_BLOT) {
index += target.offset(target.parent);
target = target.parent;
}
if (target != null) {
this._length = Cursor.CONTENTS.length;
target.optimize();
target.formatAt(index, Cursor.CONTENTS.length, name, value);
this._length = 0;
}
}
}, {
key: 'index',
value: function index(node, offset) {
if (node === this.textNode) return 0;
return _get(Cursor.prototype.__proto__ || Object.getPrototypeOf(Cursor.prototype), 'index', this).call(this, node, offset);
}
}, {
key: 'length',
value: function length() {
return this._length;
}
}, {
key: 'position',
value: function position() {
return [this.textNode, this.textNode.data.length];
}
}, {
key: 'remove',
value: function remove() {
_get(Cursor.prototype.__proto__ || Object.getPrototypeOf(Cursor.prototype), 'remove', this).call(this);
this.parent = null;
}
}, {
key: 'restore',
value: function restore() {
if (this.selection.composing || this.parent == null) return;
var textNode = this.textNode;
var range = this.selection.getNativeRange();
var restoreText = void 0,
start = void 0,
end = void 0;
if (range != null && range.start.node === textNode && range.end.node === textNode) {
var _ref = [textNode, range.start.offset, range.end.offset];
restoreText = _ref[0];
start = _ref[1];
end = _ref[2];
}
// Link format will insert text outside of anchor tag
while (this.domNode.lastChild != null && this.domNode.lastChild !== this.textNode) {
this.domNode.parentNode.insertBefore(this.domNode.lastChild, this.domNode);
}
if (this.textNode.data !== Cursor.CONTENTS) {
var text = this.textNode.data.split(Cursor.CONTENTS).join('');
if (this.next instanceof _text2.default) {
restoreText = this.next.domNode;
this.next.insertAt(0, text);
this.textNode.data = Cursor.CONTENTS;
} else {
this.textNode.data = text;
this.parent.insertBefore(_parchment2.default.create(this.textNode), this);
this.textNode = document.createTextNode(Cursor.CONTENTS);
this.domNode.appendChild(this.textNode);
}
}
this.remove();
if (start != null) {
var _map = [start, end].map(function (offset) {
return Math.max(0, Math.min(restoreText.data.length, offset - 1));
});
var _map2 = _slicedToArray(_map, 2);
start = _map2[0];
end = _map2[1];
return {
startNode: restoreText,
startOffset: start,
endNode: restoreText,
endOffset: end
};
}
}
}, {
key: 'update',
value: function update(mutations, context) {
var _this2 = this;
if (mutations.some(function (mutation) {
return mutation.type === 'characterData' && mutation.target === _this2.textNode;
})) {
var range = this.restore();
if (range) context.range = range;
}
}
}, {
key: 'value',
value: function value() {
return '';
}
}]);
return Cursor;
}(_parchment2.default.Embed);
Cursor.blotName = 'cursor';
Cursor.className = 'ql-cursor';
Cursor.tagName = 'span';
Cursor.CONTENTS = '\uFEFF'; // Zero width no break space
exports.default = Cursor;
/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _block = __webpack_require__(4);
var _block2 = _interopRequireDefault(_block);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Container = function (_Parchment$Container) {
_inherits(Container, _Parchment$Container);
function Container() {
_classCallCheck(this, Container);
return _possibleConstructorReturn(this, (Container.__proto__ || Object.getPrototypeOf(Container)).apply(this, arguments));
}
return Container;
}(_parchment2.default.Container);
Container.allowedChildren = [_block2.default, _block.BlockEmbed, Container];
exports.default = Container;
/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ColorStyle = exports.ColorClass = exports.ColorAttributor = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ColorAttributor = function (_Parchment$Attributor) {
_inherits(ColorAttributor, _Parchment$Attributor);
function ColorAttributor() {
_classCallCheck(this, ColorAttributor);
return _possibleConstructorReturn(this, (ColorAttributor.__proto__ || Object.getPrototypeOf(ColorAttributor)).apply(this, arguments));
}
_createClass(ColorAttributor, [{
key: 'value',
value: function value(domNode) {
var value = _get(ColorAttributor.prototype.__proto__ || Object.getPrototypeOf(ColorAttributor.prototype), 'value', this).call(this, domNode);
if (!value.startsWith('rgb(')) return value;
value = value.replace(/^[^\d]+/, '').replace(/[^\d]+$/, '');
return '#' + value.split(',').map(function (component) {
return ('00' + parseInt(component).toString(16)).slice(-2);
}).join('');
}
}]);
return ColorAttributor;
}(_parchment2.default.Attributor.Style);
var ColorClass = new _parchment2.default.Attributor.Class('color', 'ql-color', {
scope: _parchment2.default.Scope.INLINE
});
var ColorStyle = new ColorAttributor('color', 'color', {
scope: _parchment2.default.Scope.INLINE
});
exports.ColorAttributor = ColorAttributor;
exports.ColorClass = ColorClass;
exports.ColorStyle = ColorStyle;
/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.sanitize = exports.default = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _inline = __webpack_require__(6);
var _inline2 = _interopRequireDefault(_inline);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Link = function (_Inline) {
_inherits(Link, _Inline);
function Link() {
_classCallCheck(this, Link);
return _possibleConstructorReturn(this, (Link.__proto__ || Object.getPrototypeOf(Link)).apply(this, arguments));
}
_createClass(Link, [{
key: 'format',
value: function format(name, value) {
if (name !== this.statics.blotName || !value) return _get(Link.prototype.__proto__ || Object.getPrototypeOf(Link.prototype), 'format', this).call(this, name, value);
value = this.constructor.sanitize(value);
this.domNode.setAttribute('href', value);
}
}], [{
key: 'create',
value: function create(value) {
var node = _get(Link.__proto__ || Object.getPrototypeOf(Link), 'create', this).call(this, value);
value = this.sanitize(value);
node.setAttribute('href', value);
node.setAttribute('target', '_blank');
return node;
}
}, {
key: 'formats',
value: function formats(domNode) {
return domNode.getAttribute('href');
}
}, {
key: 'sanitize',
value: function sanitize(url) {
return _sanitize(url, this.PROTOCOL_WHITELIST) ? url : this.SANITIZED_URL;
}
}]);
return Link;
}(_inline2.default);
Link.blotName = 'link';
Link.tagName = 'A';
Link.SANITIZED_URL = 'about:blank';
Link.PROTOCOL_WHITELIST = ['http', 'https', 'mailto', 'tel'];
function _sanitize(url, protocols) {
var anchor = document.createElement('a');
anchor.href = url;
var protocol = anchor.href.slice(0, anchor.href.indexOf(':'));
return protocols.indexOf(protocol) > -1;
}
exports.default = Link;
exports.sanitize = _sanitize;
/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _keyboard = __webpack_require__(23);
var _keyboard2 = _interopRequireDefault(_keyboard);
var _dropdown = __webpack_require__(107);
var _dropdown2 = _interopRequireDefault(_dropdown);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var optionsCounter = 0;
function toggleAriaAttribute(element, attribute) {
element.setAttribute(attribute, !(element.getAttribute(attribute) === 'true'));
}
var Picker = function () {
function Picker(select) {
var _this = this;
_classCallCheck(this, Picker);
this.select = select;
this.container = document.createElement('span');
this.buildPicker();
this.select.style.display = 'none';
this.select.parentNode.insertBefore(this.container, this.select);
this.label.addEventListener('mousedown', function () {
_this.togglePicker();
});
this.label.addEventListener('keydown', function (event) {
switch (event.keyCode) {
// Allows the "Enter" key to open the picker
case _keyboard2.default.keys.ENTER:
_this.togglePicker();
break;
// Allows the "Escape" key to close the picker
case _keyboard2.default.keys.ESCAPE:
_this.escape();
event.preventDefault();
break;
default:
}
});
this.select.addEventListener('change', this.update.bind(this));
}
_createClass(Picker, [{
key: 'togglePicker',
value: function togglePicker() {
this.container.classList.toggle('ql-expanded');
// Toggle aria-expanded and aria-hidden to make the picker accessible
toggleAriaAttribute(this.label, 'aria-expanded');
toggleAriaAttribute(this.options, 'aria-hidden');
}
}, {
key: 'buildItem',
value: function buildItem(option) {
var _this2 = this;
var item = document.createElement('span');
item.tabIndex = '0';
item.setAttribute('role', 'button');
item.classList.add('ql-picker-item');
if (option.hasAttribute('value')) {
item.setAttribute('data-value', option.getAttribute('value'));
}
if (option.textContent) {
item.setAttribute('data-label', option.textContent);
}
item.addEventListener('click', function () {
_this2.selectItem(item, true);
});
item.addEventListener('keydown', function (event) {
switch (event.keyCode) {
// Allows the "Enter" key to select an item
case _keyboard2.default.keys.ENTER:
_this2.selectItem(item, true);
event.preventDefault();
break;
// Allows the "Escape" key to close the picker
case _keyboard2.default.keys.ESCAPE:
_this2.escape();
event.preventDefault();
break;
default:
}
});
return item;
}
}, {
key: 'buildLabel',
value: function buildLabel() {
var label = document.createElement('span');
label.classList.add('ql-picker-label');
label.innerHTML = _dropdown2.default;
label.tabIndex = '0';
label.setAttribute('role', 'button');
label.setAttribute('aria-expanded', 'false');
this.container.appendChild(label);
return label;
}
}, {
key: 'buildOptions',
value: function buildOptions() {
var _this3 = this;
var options = document.createElement('span');
options.classList.add('ql-picker-options');
// Don't want screen readers to read this until options are visible
options.setAttribute('aria-hidden', 'true');
options.tabIndex = '-1';
// Need a unique id for aria-controls
options.id = 'ql-picker-options-' + optionsCounter;
optionsCounter += 1;
this.label.setAttribute('aria-controls', options.id);
this.options = options;
[].slice.call(this.select.options).forEach(function (option) {
var item = _this3.buildItem(option);
options.appendChild(item);
if (option.selected === true) {
_this3.selectItem(item);
}
});
this.container.appendChild(options);
}
}, {
key: 'buildPicker',
value: function buildPicker() {
var _this4 = this;
[].slice.call(this.select.attributes).forEach(function (item) {
_this4.container.setAttribute(item.name, item.value);
});
this.container.classList.add('ql-picker');
this.label = this.buildLabel();
this.buildOptions();
}
}, {
key: 'escape',
value: function escape() {
var _this5 = this;
// Close menu and return focus to trigger label
this.close();
// Need setTimeout for accessibility to ensure that the browser executes
// focus on the next process thread and after any DOM content changes
setTimeout(function () {
return _this5.label.focus();
}, 1);
}
}, {
key: 'close',
value: function close() {
this.container.classList.remove('ql-expanded');
this.label.setAttribute('aria-expanded', 'false');
this.options.setAttribute('aria-hidden', 'true');
}
}, {
key: 'selectItem',
value: function selectItem(item) {
var trigger = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var selected = this.container.querySelector('.ql-selected');
if (item === selected) return;
if (selected != null) {
selected.classList.remove('ql-selected');
}
if (item == null) return;
item.classList.add('ql-selected');
this.select.selectedIndex = [].indexOf.call(item.parentNode.children, item);
if (item.hasAttribute('data-value')) {
this.label.setAttribute('data-value', item.getAttribute('data-value'));
} else {
this.label.removeAttribute('data-value');
}
if (item.hasAttribute('data-label')) {
this.label.setAttribute('data-label', item.getAttribute('data-label'));
} else {
this.label.removeAttribute('data-label');
}
if (trigger) {
if (typeof Event === 'function') {
this.select.dispatchEvent(new Event('change'));
} else if ((typeof Event === 'undefined' ? 'undefined' : _typeof(Event)) === 'object') {
// IE11
var event = document.createEvent('Event');
event.initEvent('change', true, true);
this.select.dispatchEvent(event);
}
this.close();
}
}
}, {
key: 'update',
value: function update() {
var option = void 0;
if (this.select.selectedIndex > -1) {
var item = this.container.querySelector('.ql-picker-options').children[this.select.selectedIndex];
option = this.select.options[this.select.selectedIndex];
this.selectItem(item);
} else {
this.selectItem(null);
}
var isActive = option != null && option !== this.select.querySelector('option[selected]');
this.label.classList.toggle('ql-active', isActive);
}
}]);
return Picker;
}();
exports.default = Picker;
/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _quill = __webpack_require__(5);
var _quill2 = _interopRequireDefault(_quill);
var _block = __webpack_require__(4);
var _block2 = _interopRequireDefault(_block);
var _break = __webpack_require__(16);
var _break2 = _interopRequireDefault(_break);
var _container = __webpack_require__(25);
var _container2 = _interopRequireDefault(_container);
var _cursor = __webpack_require__(24);
var _cursor2 = _interopRequireDefault(_cursor);
var _embed = __webpack_require__(35);
var _embed2 = _interopRequireDefault(_embed);
var _inline = __webpack_require__(6);
var _inline2 = _interopRequireDefault(_inline);
var _scroll = __webpack_require__(22);
var _scroll2 = _interopRequireDefault(_scroll);
var _text = __webpack_require__(7);
var _text2 = _interopRequireDefault(_text);
var _clipboard = __webpack_require__(55);
var _clipboard2 = _interopRequireDefault(_clipboard);
var _history = __webpack_require__(42);
var _history2 = _interopRequireDefault(_history);
var _keyboard = __webpack_require__(23);
var _keyboard2 = _interopRequireDefault(_keyboard);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
_quill2.default.register({
'blots/block': _block2.default,
'blots/block/embed': _block.BlockEmbed,
'blots/break': _break2.default,
'blots/container': _container2.default,
'blots/cursor': _cursor2.default,
'blots/embed': _embed2.default,
'blots/inline': _inline2.default,
'blots/scroll': _scroll2.default,
'blots/text': _text2.default,
'modules/clipboard': _clipboard2.default,
'modules/history': _history2.default,
'modules/keyboard': _keyboard2.default
});
_parchment2.default.register(_block2.default, _break2.default, _cursor2.default, _inline2.default, _scroll2.default, _text2.default);
exports.default = _quill2.default;
/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var Registry = __webpack_require__(1);
var ShadowBlot = /** @class */ (function () {
function ShadowBlot(domNode) {
this.domNode = domNode;
// @ts-ignore
this.domNode[Registry.DATA_KEY] = { blot: this };
}
Object.defineProperty(ShadowBlot.prototype, "statics", {
// Hack for accessing inherited static methods
get: function () {
return this.constructor;
},
enumerable: true,
configurable: true
});
ShadowBlot.create = function (value) {
if (this.tagName == null) {
throw new Registry.ParchmentError('Blot definition missing tagName');
}
var node;
if (Array.isArray(this.tagName)) {
if (typeof value === 'string') {
value = value.toUpperCase();
if (parseInt(value).toString() === value) {
value = parseInt(value);
}
}
if (typeof value === 'number') {
node = document.createElement(this.tagName[value - 1]);
}
else if (this.tagName.indexOf(value) > -1) {
node = document.createElement(value);
}
else {
node = document.createElement(this.tagName[0]);
}
}
else {
node = document.createElement(this.tagName);
}
if (this.className) {
node.classList.add(this.className);
}
return node;
};
ShadowBlot.prototype.attach = function () {
if (this.parent != null) {
this.scroll = this.parent.scroll;
}
};
ShadowBlot.prototype.clone = function () {
var domNode = this.domNode.cloneNode(false);
return Registry.create(domNode);
};
ShadowBlot.prototype.detach = function () {
if (this.parent != null)
this.parent.removeChild(this);
// @ts-ignore
delete this.domNode[Registry.DATA_KEY];
};
ShadowBlot.prototype.deleteAt = function (index, length) {
var blot = this.isolate(index, length);
blot.remove();
};
ShadowBlot.prototype.formatAt = function (index, length, name, value) {
var blot = this.isolate(index, length);
if (Registry.query(name, Registry.Scope.BLOT) != null && value) {
blot.wrap(name, value);
}
else if (Registry.query(name, Registry.Scope.ATTRIBUTE) != null) {
var parent = Registry.create(this.statics.scope);
blot.wrap(parent);
parent.format(name, value);
}
};
ShadowBlot.prototype.insertAt = function (index, value, def) {
var blot = def == null ? Registry.create('text', value) : Registry.create(value, def);
var ref = this.split(index);
this.parent.insertBefore(blot, ref);
};
ShadowBlot.prototype.insertInto = function (parentBlot, refBlot) {
if (refBlot === void 0) { refBlot = null; }
if (this.parent != null) {
this.parent.children.remove(this);
}
var refDomNode = null;
parentBlot.children.insertBefore(this, refBlot);
if (refBlot != null) {
refDomNode = refBlot.domNode;
}
if (this.domNode.parentNode != parentBlot.domNode ||
this.domNode.nextSibling != refDomNode) {
parentBlot.domNode.insertBefore(this.domNode, refDomNode);
}
this.parent = parentBlot;
this.attach();
};
ShadowBlot.prototype.isolate = function (index, length) {
var target = this.split(index);
target.split(length);
return target;
};
ShadowBlot.prototype.length = function () {
return 1;
};
ShadowBlot.prototype.offset = function (root) {
if (root === void 0) { root = this.parent; }
if (this.parent == null || this == root)
return 0;
return this.parent.children.offset(this) + this.parent.offset(root);
};
ShadowBlot.prototype.optimize = function (context) {
// TODO clean up once we use WeakMap
// @ts-ignore
if (this.domNode[Registry.DATA_KEY] != null) {
// @ts-ignore
delete this.domNode[Registry.DATA_KEY].mutations;
}
};
ShadowBlot.prototype.remove = function () {
if (this.domNode.parentNode != null) {
this.domNode.parentNode.removeChild(this.domNode);
}
this.detach();
};
ShadowBlot.prototype.replace = function (target) {
if (target.parent == null)
return;
target.parent.insertBefore(this, target.next);
target.remove();
};
ShadowBlot.prototype.replaceWith = function (name, value) {
var replacement = typeof name === 'string' ? Registry.create(name, value) : name;
replacement.replace(this);
return replacement;
};
ShadowBlot.prototype.split = function (index, force) {
return index === 0 ? this : this.next;
};
ShadowBlot.prototype.update = function (mutations, context) {
// Nothing to do by default
};
ShadowBlot.prototype.wrap = function (name, value) {
var wrapper = typeof name === 'string' ? Registry.create(name, value) : name;
if (this.parent != null) {
this.parent.insertBefore(wrapper, this.next);
}
wrapper.appendChild(this);
return wrapper;
};
ShadowBlot.blotName = 'abstract';
return ShadowBlot;
}());
exports.default = ShadowBlot;
/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var attributor_1 = __webpack_require__(12);
var class_1 = __webpack_require__(32);
var style_1 = __webpack_require__(33);
var Registry = __webpack_require__(1);
var AttributorStore = /** @class */ (function () {
function AttributorStore(domNode) {
this.attributes = {};
this.domNode = domNode;
this.build();
}
AttributorStore.prototype.attribute = function (attribute, value) {
// verb
if (value) {
if (attribute.add(this.domNode, value)) {
if (attribute.value(this.domNode) != null) {
this.attributes[attribute.attrName] = attribute;
}
else {
delete this.attributes[attribute.attrName];
}
}
}
else {
attribute.remove(this.domNode);
delete this.attributes[attribute.attrName];
}
};
AttributorStore.prototype.build = function () {
var _this = this;
this.attributes = {};
var attributes = attributor_1.default.keys(this.domNode);
var classes = class_1.default.keys(this.domNode);
var styles = style_1.default.keys(this.domNode);
attributes
.concat(classes)
.concat(styles)
.forEach(function (name) {
var attr = Registry.query(name, Registry.Scope.ATTRIBUTE);
if (attr instanceof attributor_1.default) {
_this.attributes[attr.attrName] = attr;
}
});
};
AttributorStore.prototype.copy = function (target) {
var _this = this;
Object.keys(this.attributes).forEach(function (key) {
var value = _this.attributes[key].value(_this.domNode);
target.format(key, value);
});
};
AttributorStore.prototype.move = function (target) {
var _this = this;
this.copy(target);
Object.keys(this.attributes).forEach(function (key) {
_this.attributes[key].remove(_this.domNode);
});
this.attributes = {};
};
AttributorStore.prototype.values = function () {
var _this = this;
return Object.keys(this.attributes).reduce(function (attributes, name) {
attributes[name] = _this.attributes[name].value(_this.domNode);
return attributes;
}, {});
};
return AttributorStore;
}());
exports.default = AttributorStore;
/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var attributor_1 = __webpack_require__(12);
function match(node, prefix) {
var className = node.getAttribute('class') || '';
return className.split(/\s+/).filter(function (name) {
return name.indexOf(prefix + "-") === 0;
});
}
var ClassAttributor = /** @class */ (function (_super) {
__extends(ClassAttributor, _super);
function ClassAttributor() {
return _super !== null && _super.apply(this, arguments) || this;
}
ClassAttributor.keys = function (node) {
return (node.getAttribute('class') || '').split(/\s+/).map(function (name) {
return name
.split('-')
.slice(0, -1)
.join('-');
});
};
ClassAttributor.prototype.add = function (node, value) {
if (!this.canAdd(node, value))
return false;
this.remove(node);
node.classList.add(this.keyName + "-" + value);
return true;
};
ClassAttributor.prototype.remove = function (node) {
var matches = match(node, this.keyName);
matches.forEach(function (name) {
node.classList.remove(name);
});
if (node.classList.length === 0) {
node.removeAttribute('class');
}
};
ClassAttributor.prototype.value = function (node) {
var result = match(node, this.keyName)[0] || '';
var value = result.slice(this.keyName.length + 1); // +1 for hyphen
return this.canAdd(node, value) ? value : '';
};
return ClassAttributor;
}(attributor_1.default));
exports.default = ClassAttributor;
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var attributor_1 = __webpack_require__(12);
function camelize(name) {
var parts = name.split('-');
var rest = parts
.slice(1)
.map(function (part) {
return part[0].toUpperCase() + part.slice(1);
})
.join('');
return parts[0] + rest;
}
var StyleAttributor = /** @class */ (function (_super) {
__extends(StyleAttributor, _super);
function StyleAttributor() {
return _super !== null && _super.apply(this, arguments) || this;
}
StyleAttributor.keys = function (node) {
return (node.getAttribute('style') || '').split(';').map(function (value) {
var arr = value.split(':');
return arr[0].trim();
});
};
StyleAttributor.prototype.add = function (node, value) {
if (!this.canAdd(node, value))
return false;
// @ts-ignore
node.style[camelize(this.keyName)] = value;
return true;
};
StyleAttributor.prototype.remove = function (node) {
// @ts-ignore
node.style[camelize(this.keyName)] = '';
if (!node.getAttribute('style')) {
node.removeAttribute('style');
}
};
StyleAttributor.prototype.value = function (node) {
// @ts-ignore
var value = node.style[camelize(this.keyName)];
return this.canAdd(node, value) ? value : '';
};
return StyleAttributor;
}(attributor_1.default));
exports.default = StyleAttributor;
/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Theme = function () {
function Theme(quill, options) {
_classCallCheck(this, Theme);
this.quill = quill;
this.options = options;
this.modules = {};
}
_createClass(Theme, [{
key: 'init',
value: function init() {
var _this = this;
Object.keys(this.options.modules).forEach(function (name) {
if (_this.modules[name] == null) {
_this.addModule(name);
}
});
}
}, {
key: 'addModule',
value: function addModule(name) {
var moduleClass = this.quill.constructor.import('modules/' + name);
this.modules[name] = new moduleClass(this.quill, this.options.modules[name] || {});
return this.modules[name];
}
}]);
return Theme;
}();
Theme.DEFAULTS = {
modules: {}
};
Theme.themes = {
'default': Theme
};
exports.default = Theme;
/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _text = __webpack_require__(7);
var _text2 = _interopRequireDefault(_text);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var GUARD_TEXT = '\uFEFF';
var Embed = function (_Parchment$Embed) {
_inherits(Embed, _Parchment$Embed);
function Embed(node) {
_classCallCheck(this, Embed);
var _this = _possibleConstructorReturn(this, (Embed.__proto__ || Object.getPrototypeOf(Embed)).call(this, node));
_this.contentNode = document.createElement('span');
_this.contentNode.setAttribute('contenteditable', false);
[].slice.call(_this.domNode.childNodes).forEach(function (childNode) {
_this.contentNode.appendChild(childNode);
});
_this.leftGuard = document.createTextNode(GUARD_TEXT);
_this.rightGuard = document.createTextNode(GUARD_TEXT);
_this.domNode.appendChild(_this.leftGuard);
_this.domNode.appendChild(_this.contentNode);
_this.domNode.appendChild(_this.rightGuard);
return _this;
}
_createClass(Embed, [{
key: 'index',
value: function index(node, offset) {
if (node === this.leftGuard) return 0;
if (node === this.rightGuard) return 1;
return _get(Embed.prototype.__proto__ || Object.getPrototypeOf(Embed.prototype), 'index', this).call(this, node, offset);
}
}, {
key: 'restore',
value: function restore(node) {
var range = void 0,
textNode = void 0;
var text = node.data.split(GUARD_TEXT).join('');
if (node === this.leftGuard) {
if (this.prev instanceof _text2.default) {
var prevLength = this.prev.length();
this.prev.insertAt(prevLength, text);
range = {
startNode: this.prev.domNode,
startOffset: prevLength + text.length
};
} else {
textNode = document.createTextNode(text);
this.parent.insertBefore(_parchment2.default.create(textNode), this);
range = {
startNode: textNode,
startOffset: text.length
};
}
} else if (node === this.rightGuard) {
if (this.next instanceof _text2.default) {
this.next.insertAt(0, text);
range = {
startNode: this.next.domNode,
startOffset: text.length
};
} else {
textNode = document.createTextNode(text);
this.parent.insertBefore(_parchment2.default.create(textNode), this.next);
range = {
startNode: textNode,
startOffset: text.length
};
}
}
node.data = GUARD_TEXT;
return range;
}
}, {
key: 'update',
value: function update(mutations, context) {
var _this2 = this;
mutations.forEach(function (mutation) {
if (mutation.type === 'characterData' && (mutation.target === _this2.leftGuard || mutation.target === _this2.rightGuard)) {
var range = _this2.restore(mutation.target);
if (range) context.range = range;
}
});
}
}]);
return Embed;
}(_parchment2.default.Embed);
exports.default = Embed;
/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.AlignStyle = exports.AlignClass = exports.AlignAttribute = undefined;
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var config = {
scope: _parchment2.default.Scope.BLOCK,
whitelist: ['right', 'center', 'justify']
};
var AlignAttribute = new _parchment2.default.Attributor.Attribute('align', 'align', config);
var AlignClass = new _parchment2.default.Attributor.Class('align', 'ql-align', config);
var AlignStyle = new _parchment2.default.Attributor.Style('align', 'text-align', config);
exports.AlignAttribute = AlignAttribute;
exports.AlignClass = AlignClass;
exports.AlignStyle = AlignStyle;
/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.BackgroundStyle = exports.BackgroundClass = undefined;
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _color = __webpack_require__(26);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var BackgroundClass = new _parchment2.default.Attributor.Class('background', 'ql-bg', {
scope: _parchment2.default.Scope.INLINE
});
var BackgroundStyle = new _color.ColorAttributor('background', 'background-color', {
scope: _parchment2.default.Scope.INLINE
});
exports.BackgroundClass = BackgroundClass;
exports.BackgroundStyle = BackgroundStyle;
/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.DirectionStyle = exports.DirectionClass = exports.DirectionAttribute = undefined;
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var config = {
scope: _parchment2.default.Scope.BLOCK,
whitelist: ['rtl']
};
var DirectionAttribute = new _parchment2.default.Attributor.Attribute('direction', 'dir', config);
var DirectionClass = new _parchment2.default.Attributor.Class('direction', 'ql-direction', config);
var DirectionStyle = new _parchment2.default.Attributor.Style('direction', 'direction', config);
exports.DirectionAttribute = DirectionAttribute;
exports.DirectionClass = DirectionClass;
exports.DirectionStyle = DirectionStyle;
/***/ }),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.FontClass = exports.FontStyle = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var config = {
scope: _parchment2.default.Scope.INLINE,
whitelist: ['serif', 'monospace']
};
var FontClass = new _parchment2.default.Attributor.Class('font', 'ql-font', config);
var FontStyleAttributor = function (_Parchment$Attributor) {
_inherits(FontStyleAttributor, _Parchment$Attributor);
function FontStyleAttributor() {
_classCallCheck(this, FontStyleAttributor);
return _possibleConstructorReturn(this, (FontStyleAttributor.__proto__ || Object.getPrototypeOf(FontStyleAttributor)).apply(this, arguments));
}
_createClass(FontStyleAttributor, [{
key: 'value',
value: function value(node) {
return _get(FontStyleAttributor.prototype.__proto__ || Object.getPrototypeOf(FontStyleAttributor.prototype), 'value', this).call(this, node).replace(/["']/g, '');
}
}]);
return FontStyleAttributor;
}(_parchment2.default.Attributor.Style);
var FontStyle = new FontStyleAttributor('font', 'font-family', config);
exports.FontStyle = FontStyle;
exports.FontClass = FontClass;
/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.SizeStyle = exports.SizeClass = undefined;
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var SizeClass = new _parchment2.default.Attributor.Class('size', 'ql-size', {
scope: _parchment2.default.Scope.INLINE,
whitelist: ['small', 'large', 'huge']
});
var SizeStyle = new _parchment2.default.Attributor.Style('size', 'font-size', {
scope: _parchment2.default.Scope.INLINE,
whitelist: ['10px', '18px', '32px']
});
exports.SizeClass = SizeClass;
exports.SizeStyle = SizeStyle;
/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {
module.exports = {
'align': {
'': __webpack_require__(76),
'center': __webpack_require__(77),
'right': __webpack_require__(78),
'justify': __webpack_require__(79)
},
'background': __webpack_require__(80),
'blockquote': __webpack_require__(81),
'bold': __webpack_require__(82),
'clean': __webpack_require__(83),
'code': __webpack_require__(58),
'code-block': __webpack_require__(58),
'color': __webpack_require__(84),
'direction': {
'': __webpack_require__(85),
'rtl': __webpack_require__(86)
},
'float': {
'center': __webpack_require__(87),
'full': __webpack_require__(88),
'left': __webpack_require__(89),
'right': __webpack_require__(90)
},
'formula': __webpack_require__(91),
'header': {
'1': __webpack_require__(92),
'2': __webpack_require__(93)
},
'italic': __webpack_require__(94),
'image': __webpack_require__(95),
'indent': {
'+1': __webpack_require__(96),
'-1': __webpack_require__(97)
},
'link': __webpack_require__(98),
'list': {
'ordered': __webpack_require__(99),
'bullet': __webpack_require__(100),
'check': __webpack_require__(101)
},
'script': {
'sub': __webpack_require__(102),
'super': __webpack_require__(103)
},
'strike': __webpack_require__(104),
'underline': __webpack_require__(105),
'video': __webpack_require__(106)
};
/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getLastChangeIndex = exports.default = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _quill = __webpack_require__(5);
var _quill2 = _interopRequireDefault(_quill);
var _module = __webpack_require__(9);
var _module2 = _interopRequireDefault(_module);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var History = function (_Module) {
_inherits(History, _Module);
function History(quill, options) {
_classCallCheck(this, History);
var _this = _possibleConstructorReturn(this, (History.__proto__ || Object.getPrototypeOf(History)).call(this, quill, options));
_this.lastRecorded = 0;
_this.ignoreChange = false;
_this.clear();
_this.quill.on(_quill2.default.events.EDITOR_CHANGE, function (eventName, delta, oldDelta, source) {
if (eventName !== _quill2.default.events.TEXT_CHANGE || _this.ignoreChange) return;
if (!_this.options.userOnly || source === _quill2.default.sources.USER) {
_this.record(delta, oldDelta);
} else {
_this.transform(delta);
}
});
_this.quill.keyboard.addBinding({ key: 'Z', shortKey: true }, _this.undo.bind(_this));
_this.quill.keyboard.addBinding({ key: 'Z', shortKey: true, shiftKey: true }, _this.redo.bind(_this));
if (/Win/i.test(navigator.platform)) {
_this.quill.keyboard.addBinding({ key: 'Y', shortKey: true }, _this.redo.bind(_this));
}
return _this;
}
_createClass(History, [{
key: 'change',
value: function change(source, dest) {
if (this.stack[source].length === 0) return;
var delta = this.stack[source].pop();
this.stack[dest].push(delta);
this.lastRecorded = 0;
this.ignoreChange = true;
this.quill.updateContents(delta[source], _quill2.default.sources.USER);
this.ignoreChange = false;
var index = getLastChangeIndex(delta[source]);
this.quill.setSelection(index);
}
}, {
key: 'clear',
value: function clear() {
this.stack = { undo: [], redo: [] };
}
}, {
key: 'cutoff',
value: function cutoff() {
this.lastRecorded = 0;
}
}, {
key: 'record',
value: function record(changeDelta, oldDelta) {
if (changeDelta.ops.length === 0) return;
this.stack.redo = [];
var undoDelta = this.quill.getContents().diff(oldDelta);
var timestamp = Date.now();
if (this.lastRecorded + this.options.delay > timestamp && this.stack.undo.length > 0) {
var delta = this.stack.undo.pop();
undoDelta = undoDelta.compose(delta.undo);
changeDelta = delta.redo.compose(changeDelta);
} else {
this.lastRecorded = timestamp;
}
this.stack.undo.push({
redo: changeDelta,
undo: undoDelta
});
if (this.stack.undo.length > this.options.maxStack) {
this.stack.undo.shift();
}
}
}, {
key: 'redo',
value: function redo() {
this.change('redo', 'undo');
}
}, {
key: 'transform',
value: function transform(delta) {
this.stack.undo.forEach(function (change) {
change.undo = delta.transform(change.undo, true);
change.redo = delta.transform(change.redo, true);
});
this.stack.redo.forEach(function (change) {
change.undo = delta.transform(change.undo, true);
change.redo = delta.transform(change.redo, true);
});
}
}, {
key: 'undo',
value: function undo() {
this.change('undo', 'redo');
}
}]);
return History;
}(_module2.default);
History.DEFAULTS = {
delay: 1000,
maxStack: 100,
userOnly: false
};
function endsWithNewlineChange(delta) {
var lastOp = delta.ops[delta.ops.length - 1];
if (lastOp == null) return false;
if (lastOp.insert != null) {
return typeof lastOp.insert === 'string' && lastOp.insert.endsWith('\n');
}
if (lastOp.attributes != null) {
return Object.keys(lastOp.attributes).some(function (attr) {
return _parchment2.default.query(attr, _parchment2.default.Scope.BLOCK) != null;
});
}
return false;
}
function getLastChangeIndex(delta) {
var deleteLength = delta.reduce(function (length, op) {
length += op.delete || 0;
return length;
}, 0);
var changeIndex = delta.length() - deleteLength;
if (endsWithNewlineChange(delta)) {
changeIndex -= 1;
}
return changeIndex;
}
exports.default = History;
exports.getLastChangeIndex = getLastChangeIndex;
/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.BaseTooltip = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _extend = __webpack_require__(3);
var _extend2 = _interopRequireDefault(_extend);
var _quillDelta = __webpack_require__(2);
var _quillDelta2 = _interopRequireDefault(_quillDelta);
var _emitter = __webpack_require__(8);
var _emitter2 = _interopRequireDefault(_emitter);
var _keyboard = __webpack_require__(23);
var _keyboard2 = _interopRequireDefault(_keyboard);
var _theme = __webpack_require__(34);
var _theme2 = _interopRequireDefault(_theme);
var _colorPicker = __webpack_require__(59);
var _colorPicker2 = _interopRequireDefault(_colorPicker);
var _iconPicker = __webpack_require__(60);
var _iconPicker2 = _interopRequireDefault(_iconPicker);
var _picker = __webpack_require__(28);
var _picker2 = _interopRequireDefault(_picker);
var _tooltip = __webpack_require__(61);
var _tooltip2 = _interopRequireDefault(_tooltip);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ALIGNS = [false, 'center', 'right', 'justify'];
var COLORS = ["#000000", "#e60000", "#ff9900", "#ffff00", "#008a00", "#0066cc", "#9933ff", "#ffffff", "#facccc", "#ffebcc", "#ffffcc", "#cce8cc", "#cce0f5", "#ebd6ff", "#bbbbbb", "#f06666", "#ffc266", "#ffff66", "#66b966", "#66a3e0", "#c285ff", "#888888", "#a10000", "#b26b00", "#b2b200", "#006100", "#0047b2", "#6b24b2", "#444444", "#5c0000", "#663d00", "#666600", "#003700", "#002966", "#3d1466"];
var FONTS = [false, 'serif', 'monospace'];
var HEADERS = ['1', '2', '3', false];
var SIZES = ['small', false, 'large', 'huge'];
var BaseTheme = function (_Theme) {
_inherits(BaseTheme, _Theme);
function BaseTheme(quill, options) {
_classCallCheck(this, BaseTheme);
var _this = _possibleConstructorReturn(this, (BaseTheme.__proto__ || Object.getPrototypeOf(BaseTheme)).call(this, quill, options));
var listener = function listener(e) {
if (!document.body.contains(quill.root)) {
return document.body.removeEventListener('click', listener);
}
if (_this.tooltip != null && !_this.tooltip.root.contains(e.target) && document.activeElement !== _this.tooltip.textbox && !_this.quill.hasFocus()) {
_this.tooltip.hide();
}
if (_this.pickers != null) {
_this.pickers.forEach(function (picker) {
if (!picker.container.contains(e.target)) {
picker.close();
}
});
}
};
quill.emitter.listenDOM('click', document.body, listener);
return _this;
}
_createClass(BaseTheme, [{
key: 'addModule',
value: function addModule(name) {
var module = _get(BaseTheme.prototype.__proto__ || Object.getPrototypeOf(BaseTheme.prototype), 'addModule', this).call(this, name);
if (name === 'toolbar') {
this.extendToolbar(module);
}
return module;
}
}, {
key: 'buildButtons',
value: function buildButtons(buttons, icons) {
buttons.forEach(function (button) {
var className = button.getAttribute('class') || '';
className.split(/\s+/).forEach(function (name) {
if (!name.startsWith('ql-')) return;
name = name.slice('ql-'.length);
if (icons[name] == null) return;
if (name === 'direction') {
button.innerHTML = icons[name][''] + icons[name]['rtl'];
} else if (typeof icons[name] === 'string') {
button.innerHTML = icons[name];
} else {
var value = button.value || '';
if (value != null && icons[name][value]) {
button.innerHTML = icons[name][value];
}
}
});
});
}
}, {
key: 'buildPickers',
value: function buildPickers(selects, icons) {
var _this2 = this;
this.pickers = selects.map(function (select) {
if (select.classList.contains('ql-align')) {
if (select.querySelector('option') == null) {
fillSelect(select, ALIGNS);
}
return new _iconPicker2.default(select, icons.align);
} else if (select.classList.contains('ql-background') || select.classList.contains('ql-color')) {
var format = select.classList.contains('ql-background') ? 'background' : 'color';
if (select.querySelector('option') == null) {
fillSelect(select, COLORS, format === 'background' ? '#ffffff' : '#000000');
}
return new _colorPicker2.default(select, icons[format]);
} else {
if (select.querySelector('option') == null) {
if (select.classList.contains('ql-font')) {
fillSelect(select, FONTS);
} else if (select.classList.contains('ql-header')) {
fillSelect(select, HEADERS);
} else if (select.classList.contains('ql-size')) {
fillSelect(select, SIZES);
}
}
return new _picker2.default(select);
}
});
var update = function update() {
_this2.pickers.forEach(function (picker) {
picker.update();
});
};
this.quill.on(_emitter2.default.events.EDITOR_CHANGE, update);
}
}]);
return BaseTheme;
}(_theme2.default);
BaseTheme.DEFAULTS = (_extend2.default)(true, {}, _theme2.default.DEFAULTS, {
modules: {
toolbar: {
handlers: {
formula: function formula() {
this.quill.theme.tooltip.edit('formula');
},
image: function image() {
var _this3 = this;
var fileInput = this.container.querySelector('input.ql-image[type=file]');
if (fileInput == null) {
fileInput = document.createElement('input');
fileInput.setAttribute('type', 'file');
fileInput.setAttribute('accept', 'image/png, image/gif, image/jpeg, image/bmp, image/x-icon');
fileInput.classList.add('ql-image');
fileInput.addEventListener('change', function () {
if (fileInput.files != null && fileInput.files[0] != null) {
var reader = new FileReader();
reader.onload = function (e) {
var range = _this3.quill.getSelection(true);
_this3.quill.updateContents(new _quillDelta2.default().retain(range.index).delete(range.length).insert({ image: e.target.result }), _emitter2.default.sources.USER);
_this3.quill.setSelection(range.index + 1, _emitter2.default.sources.SILENT);
fileInput.value = "";
};
reader.readAsDataURL(fileInput.files[0]);
}
});
this.container.appendChild(fileInput);
}
fileInput.click();
},
video: function video() {
this.quill.theme.tooltip.edit('video');
}
}
}
}
});
var BaseTooltip = function (_Tooltip) {
_inherits(BaseTooltip, _Tooltip);
function BaseTooltip(quill, boundsContainer) {
_classCallCheck(this, BaseTooltip);
var _this4 = _possibleConstructorReturn(this, (BaseTooltip.__proto__ || Object.getPrototypeOf(BaseTooltip)).call(this, quill, boundsContainer));
_this4.textbox = _this4.root.querySelector('input[type="text"]');
_this4.listen();
return _this4;
}
_createClass(BaseTooltip, [{
key: 'listen',
value: function listen() {
var _this5 = this;
this.textbox.addEventListener('keydown', function (event) {
if (_keyboard2.default.match(event, 'enter')) {
_this5.save();
event.preventDefault();
} else if (_keyboard2.default.match(event, 'escape')) {
_this5.cancel();
event.preventDefault();
}
});
}
}, {
key: 'cancel',
value: function cancel() {
this.hide();
}
}, {
key: 'edit',
value: function edit() {
var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'link';
var preview = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
this.root.classList.remove('ql-hidden');
this.root.classList.add('ql-editing');
if (preview != null) {
this.textbox.value = preview;
} else if (mode !== this.root.getAttribute('data-mode')) {
this.textbox.value = '';
}
this.position(this.quill.getBounds(this.quill.selection.savedRange));
this.textbox.select();
this.textbox.setAttribute('placeholder', this.textbox.getAttribute('data-' + mode) || '');
this.root.setAttribute('data-mode', mode);
}
}, {
key: 'restoreFocus',
value: function restoreFocus() {
var scrollTop = this.quill.scrollingContainer.scrollTop;
this.quill.focus();
this.quill.scrollingContainer.scrollTop = scrollTop;
}
}, {
key: 'save',
value: function save() {
var value = this.textbox.value;
switch (this.root.getAttribute('data-mode')) {
case 'link':
{
var scrollTop = this.quill.root.scrollTop;
if (this.linkRange) {
this.quill.formatText(this.linkRange, 'link', value, _emitter2.default.sources.USER);
delete this.linkRange;
} else {
this.restoreFocus();
this.quill.format('link', value, _emitter2.default.sources.USER);
}
this.quill.root.scrollTop = scrollTop;
break;
}
case 'video':
{
value = extractVideoUrl(value);
} // eslint-disable-next-line no-fallthrough
case 'formula':
{
if (!value) break;
var range = this.quill.getSelection(true);
if (range != null) {
var index = range.index + range.length;
this.quill.insertEmbed(index, this.root.getAttribute('data-mode'), value, _emitter2.default.sources.USER);
if (this.root.getAttribute('data-mode') === 'formula') {
this.quill.insertText(index + 1, ' ', _emitter2.default.sources.USER);
}
this.quill.setSelection(index + 2, _emitter2.default.sources.USER);
}
break;
}
default:
}
this.textbox.value = '';
this.hide();
}
}]);
return BaseTooltip;
}(_tooltip2.default);
function extractVideoUrl(url) {
var match = url.match(/^(?:(https?):\/\/)?(?:(?:www|m)\.)?youtube\.com\/watch.*v=([a-zA-Z0-9_-]+)/) || url.match(/^(?:(https?):\/\/)?(?:(?:www|m)\.)?youtu\.be\/([a-zA-Z0-9_-]+)/);
if (match) {
return (match[1] || 'https') + '://www.youtube.com/embed/' + match[2] + '?showinfo=0';
}
if (match = url.match(/^(?:(https?):\/\/)?(?:www\.)?vimeo\.com\/(\d+)/)) {
// eslint-disable-line no-cond-assign
return (match[1] || 'https') + '://player.vimeo.com/video/' + match[2] + '/';
}
return url;
}
function fillSelect(select, values) {
var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
values.forEach(function (value) {
var option = document.createElement('option');
if (value === defaultValue) {
option.setAttribute('selected', 'selected');
} else {
option.setAttribute('value', value);
}
select.appendChild(option);
});
}
exports.BaseTooltip = BaseTooltip;
exports.default = BaseTheme;
/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", { value: true });
var LinkedList = /** @class */ (function () {
function LinkedList() {
this.head = this.tail = null;
this.length = 0;
}
LinkedList.prototype.append = function () {
var nodes = [];
for (var _i = 0; _i < arguments.length; _i++) {
nodes[_i] = arguments[_i];
}
this.insertBefore(nodes[0], null);
if (nodes.length > 1) {
this.append.apply(this, nodes.slice(1));
}
};
LinkedList.prototype.contains = function (node) {
var cur, next = this.iterator();
while ((cur = next())) {
if (cur === node)
return true;
}
return false;
};
LinkedList.prototype.insertBefore = function (node, refNode) {
if (!node)
return;
node.next = refNode;
if (refNode != null) {
node.prev = refNode.prev;
if (refNode.prev != null) {
refNode.prev.next = node;
}
refNode.prev = node;
if (refNode === this.head) {
this.head = node;
}
}
else if (this.tail != null) {
this.tail.next = node;
node.prev = this.tail;
this.tail = node;
}
else {
node.prev = null;
this.head = this.tail = node;
}
this.length += 1;
};
LinkedList.prototype.offset = function (target) {
var index = 0, cur = this.head;
while (cur != null) {
if (cur === target)
return index;
index += cur.length();
cur = cur.next;
}
return -1;
};
LinkedList.prototype.remove = function (node) {
if (!this.contains(node))
return;
if (node.prev != null)
node.prev.next = node.next;
if (node.next != null)
node.next.prev = node.prev;
if (node === this.head)
this.head = node.next;
if (node === this.tail)
this.tail = node.prev;
this.length -= 1;
};
LinkedList.prototype.iterator = function (curNode) {
if (curNode === void 0) { curNode = this.head; }
// TODO use yield when we can
return function () {
var ret = curNode;
if (curNode != null)
curNode = curNode.next;
return ret;
};
};
LinkedList.prototype.find = function (index, inclusive) {
if (inclusive === void 0) { inclusive = false; }
var cur, next = this.iterator();
while ((cur = next())) {
var length = cur.length();
if (index < length ||
(inclusive && index === length && (cur.next == null || cur.next.length() !== 0))) {
return [cur, index];
}
index -= length;
}
return [null, 0];
};
LinkedList.prototype.forEach = function (callback) {
var cur, next = this.iterator();
while ((cur = next())) {
callback(cur);
}
};
LinkedList.prototype.forEachAt = function (index, length, callback) {
if (length <= 0)
return;
var _a = this.find(index), startNode = _a[0], offset = _a[1];
var cur, curIndex = index - offset, next = this.iterator(startNode);
while ((cur = next()) && curIndex < index + length) {
var curLength = cur.length();
if (index > curIndex) {
callback(cur, index - curIndex, Math.min(length, curIndex + curLength - index));
}
else {
callback(cur, 0, Math.min(curLength, index + length - curIndex));
}
curIndex += curLength;
}
};
LinkedList.prototype.map = function (callback) {
return this.reduce(function (memo, cur) {
memo.push(callback(cur));
return memo;
}, []);
};
LinkedList.prototype.reduce = function (callback, memo) {
var cur, next = this.iterator();
while ((cur = next())) {
memo = callback(memo, cur);
}
return memo;
};
return LinkedList;
}());
exports.default = LinkedList;
/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var container_1 = __webpack_require__(17);
var Registry = __webpack_require__(1);
var OBSERVER_CONFIG = {
attributes: true,
characterData: true,
characterDataOldValue: true,
childList: true,
subtree: true,
};
var MAX_OPTIMIZE_ITERATIONS = 100;
var ScrollBlot = /** @class */ (function (_super) {
__extends(ScrollBlot, _super);
function ScrollBlot(node) {
var _this = _super.call(this, node) || this;
_this.scroll = _this;
_this.observer = new MutationObserver(function (mutations) {
_this.update(mutations);
});
_this.observer.observe(_this.domNode, OBSERVER_CONFIG);
_this.attach();
return _this;
}
ScrollBlot.prototype.detach = function () {
_super.prototype.detach.call(this);
this.observer.disconnect();
};
ScrollBlot.prototype.deleteAt = function (index, length) {
this.update();
if (index === 0 && length === this.length()) {
this.children.forEach(function (child) {
child.remove();
});
}
else {
_super.prototype.deleteAt.call(this, index, length);
}
};
ScrollBlot.prototype.formatAt = function (index, length, name, value) {
this.update();
_super.prototype.formatAt.call(this, index, length, name, value);
};
ScrollBlot.prototype.insertAt = function (index, value, def) {
this.update();
_super.prototype.insertAt.call(this, index, value, def);
};
ScrollBlot.prototype.optimize = function (mutations, context) {
var _this = this;
if (mutations === void 0) { mutations = []; }
if (context === void 0) { context = {}; }
_super.prototype.optimize.call(this, context);
// We must modify mutations directly, cannot make copy and then modify
var records = [].slice.call(this.observer.takeRecords());
// Array.push currently seems to be implemented by a non-tail recursive function
// so we cannot just mutations.push.apply(mutations, this.observer.takeRecords());
while (records.length > 0)
mutations.push(records.pop());
// TODO use WeakMap
var mark = function (blot, markParent) {
if (markParent === void 0) { markParent = true; }
if (blot == null || blot === _this)
return;
if (blot.domNode.parentNode == null)
return;
// @ts-ignore
if (blot.domNode[Registry.DATA_KEY].mutations == null) {
// @ts-ignore
blot.domNode[Registry.DATA_KEY].mutations = [];
}
if (markParent)
mark(blot.parent);
};
var optimize = function (blot) {
// Post-order traversal
if (
// @ts-ignore
blot.domNode[Registry.DATA_KEY] == null ||
// @ts-ignore
blot.domNode[Registry.DATA_KEY].mutations == null) {
return;
}
if (blot instanceof container_1.default) {
blot.children.forEach(optimize);
}
blot.optimize(context);
};
var remaining = mutations;
for (var i = 0; remaining.length > 0; i += 1) {
if (i >= MAX_OPTIMIZE_ITERATIONS) {
throw new Error('[Parchment] Maximum optimize iterations reached');
}
remaining.forEach(function (mutation) {
var blot = Registry.find(mutation.target, true);
if (blot == null)
return;
if (blot.domNode === mutation.target) {
if (mutation.type === 'childList') {
mark(Registry.find(mutation.previousSibling, false));
[].forEach.call(mutation.addedNodes, function (node) {
var child = Registry.find(node, false);
mark(child, false);
if (child instanceof container_1.default) {
child.children.forEach(function (grandChild) {
mark(grandChild, false);
});
}
});
}
else if (mutation.type === 'attributes') {
mark(blot.prev);
}
}
mark(blot);
});
this.children.forEach(optimize);
remaining = [].slice.call(this.observer.takeRecords());
records = remaining.slice();
while (records.length > 0)
mutations.push(records.pop());
}
};
ScrollBlot.prototype.update = function (mutations, context) {
var _this = this;
if (context === void 0) { context = {}; }
mutations = mutations || this.observer.takeRecords();
// TODO use WeakMap
mutations
.map(function (mutation) {
var blot = Registry.find(mutation.target, true);
if (blot == null)
return null;
// @ts-ignore
if (blot.domNode[Registry.DATA_KEY].mutations == null) {
// @ts-ignore
blot.domNode[Registry.DATA_KEY].mutations = [mutation];
return blot;
}
else {
// @ts-ignore
blot.domNode[Registry.DATA_KEY].mutations.push(mutation);
return null;
}
})
.forEach(function (blot) {
if (blot == null ||
blot === _this ||
//@ts-ignore
blot.domNode[Registry.DATA_KEY] == null)
return;
// @ts-ignore
blot.update(blot.domNode[Registry.DATA_KEY].mutations || [], context);
});
// @ts-ignore
if (this.domNode[Registry.DATA_KEY].mutations != null) {
// @ts-ignore
_super.prototype.update.call(this, this.domNode[Registry.DATA_KEY].mutations, context);
}
this.optimize(mutations, context);
};
ScrollBlot.blotName = 'scroll';
ScrollBlot.defaultChild = 'block';
ScrollBlot.scope = Registry.Scope.BLOCK_BLOT;
ScrollBlot.tagName = 'DIV';
return ScrollBlot;
}(container_1.default));
exports.default = ScrollBlot;
/***/ }),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var format_1 = __webpack_require__(18);
var Registry = __webpack_require__(1);
// Shallow object comparison
function isEqual(obj1, obj2) {
if (Object.keys(obj1).length !== Object.keys(obj2).length)
return false;
// @ts-ignore
for (var prop in obj1) {
// @ts-ignore
if (obj1[prop] !== obj2[prop])
return false;
}
return true;
}
var InlineBlot = /** @class */ (function (_super) {
__extends(InlineBlot, _super);
function InlineBlot() {
return _super !== null && _super.apply(this, arguments) || this;
}
InlineBlot.formats = function (domNode) {
if (domNode.tagName === InlineBlot.tagName)
return undefined;
return _super.formats.call(this, domNode);
};
InlineBlot.prototype.format = function (name, value) {
var _this = this;
if (name === this.statics.blotName && !value) {
this.children.forEach(function (child) {
if (!(child instanceof format_1.default)) {
child = child.wrap(InlineBlot.blotName, true);
}
_this.attributes.copy(child);
});
this.unwrap();
}
else {
_super.prototype.format.call(this, name, value);
}
};
InlineBlot.prototype.formatAt = function (index, length, name, value) {
if (this.formats()[name] != null || Registry.query(name, Registry.Scope.ATTRIBUTE)) {
var blot = this.isolate(index, length);
blot.format(name, value);
}
else {
_super.prototype.formatAt.call(this, index, length, name, value);
}
};
InlineBlot.prototype.optimize = function (context) {
_super.prototype.optimize.call(this, context);
var formats = this.formats();
if (Object.keys(formats).length === 0) {
return this.unwrap(); // unformatted span
}
var next = this.next;
if (next instanceof InlineBlot && next.prev === this && isEqual(formats, next.formats())) {
next.moveChildren(this);
next.remove();
}
};
InlineBlot.blotName = 'inline';
InlineBlot.scope = Registry.Scope.INLINE_BLOT;
InlineBlot.tagName = 'SPAN';
return InlineBlot;
}(format_1.default));
exports.default = InlineBlot;
/***/ }),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var format_1 = __webpack_require__(18);
var Registry = __webpack_require__(1);
var BlockBlot = /** @class */ (function (_super) {
__extends(BlockBlot, _super);
function BlockBlot() {
return _super !== null && _super.apply(this, arguments) || this;
}
BlockBlot.formats = function (domNode) {
var tagName = Registry.query(BlockBlot.blotName).tagName;
if (domNode.tagName === tagName)
return undefined;
return _super.formats.call(this, domNode);
};
BlockBlot.prototype.format = function (name, value) {
if (Registry.query(name, Registry.Scope.BLOCK) == null) {
return;
}
else if (name === this.statics.blotName && !value) {
this.replaceWith(BlockBlot.blotName);
}
else {
_super.prototype.format.call(this, name, value);
}
};
BlockBlot.prototype.formatAt = function (index, length, name, value) {
if (Registry.query(name, Registry.Scope.BLOCK) != null) {
this.format(name, value);
}
else {
_super.prototype.formatAt.call(this, index, length, name, value);
}
};
BlockBlot.prototype.insertAt = function (index, value, def) {
if (def == null || Registry.query(value, Registry.Scope.INLINE) != null) {
// Insert text or inline
_super.prototype.insertAt.call(this, index, value, def);
}
else {
var after = this.split(index);
var blot = Registry.create(value, def);
after.parent.insertBefore(blot, after);
}
};
BlockBlot.prototype.update = function (mutations, context) {
if (navigator.userAgent.match(/Trident/)) {
this.build();
}
else {
_super.prototype.update.call(this, mutations, context);
}
};
BlockBlot.blotName = 'block';
BlockBlot.scope = Registry.Scope.BLOCK_BLOT;
BlockBlot.tagName = 'P';
return BlockBlot;
}(format_1.default));
exports.default = BlockBlot;
/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var leaf_1 = __webpack_require__(19);
var EmbedBlot = /** @class */ (function (_super) {
__extends(EmbedBlot, _super);
function EmbedBlot() {
return _super !== null && _super.apply(this, arguments) || this;
}
EmbedBlot.formats = function (domNode) {
return undefined;
};
EmbedBlot.prototype.format = function (name, value) {
// super.formatAt wraps, which is what we want in general,
// but this allows subclasses to overwrite for formats
// that just apply to particular embeds
_super.prototype.formatAt.call(this, 0, this.length(), name, value);
};
EmbedBlot.prototype.formatAt = function (index, length, name, value) {
if (index === 0 && length === this.length()) {
this.format(name, value);
}
else {
_super.prototype.formatAt.call(this, index, length, name, value);
}
};
EmbedBlot.prototype.formats = function () {
return this.statics.formats(this.domNode);
};
return EmbedBlot;
}(leaf_1.default));
exports.default = EmbedBlot;
/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var leaf_1 = __webpack_require__(19);
var Registry = __webpack_require__(1);
var TextBlot = /** @class */ (function (_super) {
__extends(TextBlot, _super);
function TextBlot(node) {
var _this = _super.call(this, node) || this;
_this.text = _this.statics.value(_this.domNode);
return _this;
}
TextBlot.create = function (value) {
return document.createTextNode(value);
};
TextBlot.value = function (domNode) {
var text = domNode.data;
// @ts-ignore
if (text['normalize'])
text = text['normalize']();
return text;
};
TextBlot.prototype.deleteAt = function (index, length) {
this.domNode.data = this.text = this.text.slice(0, index) + this.text.slice(index + length);
};
TextBlot.prototype.index = function (node, offset) {
if (this.domNode === node) {
return offset;
}
return -1;
};
TextBlot.prototype.insertAt = function (index, value, def) {
if (def == null) {
this.text = this.text.slice(0, index) + value + this.text.slice(index);
this.domNode.data = this.text;
}
else {
_super.prototype.insertAt.call(this, index, value, def);
}
};
TextBlot.prototype.length = function () {
return this.text.length;
};
TextBlot.prototype.optimize = function (context) {
_super.prototype.optimize.call(this, context);
this.text = this.statics.value(this.domNode);
if (this.text.length === 0) {
this.remove();
}
else if (this.next instanceof TextBlot && this.next.prev === this) {
this.insertAt(this.length(), this.next.value());
this.next.remove();
}
};
TextBlot.prototype.position = function (index, inclusive) {
if (inclusive === void 0) { inclusive = false; }
return [this.domNode, index];
};
TextBlot.prototype.split = function (index, force) {
if (force === void 0) { force = false; }
if (!force) {
if (index === 0)
return this;
if (index === this.length())
return this.next;
}
var after = Registry.create(this.domNode.splitText(index));
this.parent.insertBefore(after, this.next);
this.text = this.statics.value(this.domNode);
return after;
};
TextBlot.prototype.update = function (mutations, context) {
var _this = this;
if (mutations.some(function (mutation) {
return mutation.type === 'characterData' && mutation.target === _this.domNode;
})) {
this.text = this.statics.value(this.domNode);
}
};
TextBlot.prototype.value = function () {
return this.text;
};
TextBlot.blotName = 'text';
TextBlot.scope = Registry.Scope.INLINE_BLOT;
return TextBlot;
}(leaf_1.default));
exports.default = TextBlot;
/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {
var elem = document.createElement('div');
elem.classList.toggle('test-class', false);
if (elem.classList.contains('test-class')) {
var _toggle = DOMTokenList.prototype.toggle;
DOMTokenList.prototype.toggle = function (token, force) {
if (arguments.length > 1 && !this.contains(token) === !force) {
return force;
} else {
return _toggle.call(this, token);
}
};
}
if (!String.prototype.startsWith) {
String.prototype.startsWith = function (searchString, position) {
position = position || 0;
return this.substr(position, searchString.length) === searchString;
};
}
if (!String.prototype.endsWith) {
String.prototype.endsWith = function (searchString, position) {
var subjectString = this.toString();
if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {
position = subjectString.length;
}
position -= searchString.length;
var lastIndex = subjectString.indexOf(searchString, position);
return lastIndex !== -1 && lastIndex === position;
};
}
if (!Array.prototype.find) {
Object.defineProperty(Array.prototype, "find", {
value: function value(predicate) {
if (this === null) {
throw new TypeError('Array.prototype.find called on null or undefined');
}
if (typeof predicate !== 'function') {
throw new TypeError('predicate must be a function');
}
var list = Object(this);
var length = list.length >>> 0;
var thisArg = arguments[1];
var value;
for (var i = 0; i < length; i++) {
value = list[i];
if (predicate.call(thisArg, value, i, list)) {
return value;
}
}
return undefined;
}
});
}
document.addEventListener("DOMContentLoaded", function () {
// Disable resizing in Firefox
document.execCommand("enableObjectResizing", false, false);
// Disable automatic linkifying in IE11
document.execCommand("autoUrlDetect", false, false);
});
/***/ }),
/* 51 */
/***/ (function(module, exports) {
/**
* This library modifies the diff-patch-match library by Neil Fraser
* by removing the patch and match functionality and certain advanced
* options in the diff function. The original license is as follows:
*
* ===
*
* Diff Match and Patch
*
* Copyright 2006 Google Inc.
* http://code.google.com/p/google-diff-match-patch/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* The data structure representing a diff is an array of tuples:
* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
* which means: delete 'Hello', add 'Goodbye' and keep ' world.'
*/
var DIFF_DELETE = -1;
var DIFF_INSERT = 1;
var DIFF_EQUAL = 0;
/**
* Find the differences between two texts. Simplifies the problem by stripping
* any common prefix or suffix off the texts before diffing.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @param {Int} cursor_pos Expected edit position in text1 (optional)
* @return {Array} Array of diff tuples.
*/
function diff_main(text1, text2, cursor_pos) {
// Check for equality (speedup).
if (text1 == text2) {
if (text1) {
return [[DIFF_EQUAL, text1]];
}
return [];
}
// Check cursor_pos within bounds
if (cursor_pos < 0 || text1.length < cursor_pos) {
cursor_pos = null;
}
// Trim off common prefix (speedup).
var commonlength = diff_commonPrefix(text1, text2);
var commonprefix = text1.substring(0, commonlength);
text1 = text1.substring(commonlength);
text2 = text2.substring(commonlength);
// Trim off common suffix (speedup).
commonlength = diff_commonSuffix(text1, text2);
var commonsuffix = text1.substring(text1.length - commonlength);
text1 = text1.substring(0, text1.length - commonlength);
text2 = text2.substring(0, text2.length - commonlength);
// Compute the diff on the middle block.
var diffs = diff_compute_(text1, text2);
// Restore the prefix and suffix.
if (commonprefix) {
diffs.unshift([DIFF_EQUAL, commonprefix]);
}
if (commonsuffix) {
diffs.push([DIFF_EQUAL, commonsuffix]);
}
diff_cleanupMerge(diffs);
if (cursor_pos != null) {
diffs = fix_cursor(diffs, cursor_pos);
}
diffs = fix_emoji(diffs);
return diffs;
}
/**
* Find the differences between two texts. Assumes that the texts do not
* have any common prefix or suffix.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @return {Array} Array of diff tuples.
*/
function diff_compute_(text1, text2) {
var diffs;
if (!text1) {
// Just add some text (speedup).
return [[DIFF_INSERT, text2]];
}
if (!text2) {
// Just delete some text (speedup).
return [[DIFF_DELETE, text1]];
}
var longtext = text1.length > text2.length ? text1 : text2;
var shorttext = text1.length > text2.length ? text2 : text1;
var i = longtext.indexOf(shorttext);
if (i != -1) {
// Shorter text is inside the longer text (speedup).
diffs = [[DIFF_INSERT, longtext.substring(0, i)],
[DIFF_EQUAL, shorttext],
[DIFF_INSERT, longtext.substring(i + shorttext.length)]];
// Swap insertions for deletions if diff is reversed.
if (text1.length > text2.length) {
diffs[0][0] = diffs[2][0] = DIFF_DELETE;
}
return diffs;
}
if (shorttext.length == 1) {
// Single character string.
// After the previous speedup, the character can't be an equality.
return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
}
// Check to see if the problem can be split in two.
var hm = diff_halfMatch_(text1, text2);
if (hm) {
// A half-match was found, sort out the return data.
var text1_a = hm[0];
var text1_b = hm[1];
var text2_a = hm[2];
var text2_b = hm[3];
var mid_common = hm[4];
// Send both pairs off for separate processing.
var diffs_a = diff_main(text1_a, text2_a);
var diffs_b = diff_main(text1_b, text2_b);
// Merge the results.
return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);
}
return diff_bisect_(text1, text2);
}
/**
* Find the 'middle snake' of a diff, split the problem in two
* and return the recursively constructed diff.
* See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @return {Array} Array of diff tuples.
* @private
*/
function diff_bisect_(text1, text2) {
// Cache the text lengths to prevent multiple calls.
var text1_length = text1.length;
var text2_length = text2.length;
var max_d = Math.ceil((text1_length + text2_length) / 2);
var v_offset = max_d;
var v_length = 2 * max_d;
var v1 = new Array(v_length);
var v2 = new Array(v_length);
// Setting all elements to -1 is faster in Chrome & Firefox than mixing
// integers and undefined.
for (var x = 0; x < v_length; x++) {
v1[x] = -1;
v2[x] = -1;
}
v1[v_offset + 1] = 0;
v2[v_offset + 1] = 0;
var delta = text1_length - text2_length;
// If the total number of characters is odd, then the front path will collide
// with the reverse path.
var front = (delta % 2 != 0);
// Offsets for start and end of k loop.
// Prevents mapping of space beyond the grid.
var k1start = 0;
var k1end = 0;
var k2start = 0;
var k2end = 0;
for (var d = 0; d < max_d; d++) {
// Walk the front path one step.
for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
var k1_offset = v_offset + k1;
var x1;
if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {
x1 = v1[k1_offset + 1];
} else {
x1 = v1[k1_offset - 1] + 1;
}
var y1 = x1 - k1;
while (x1 < text1_length && y1 < text2_length &&
text1.charAt(x1) == text2.charAt(y1)) {
x1++;
y1++;
}
v1[k1_offset] = x1;
if (x1 > text1_length) {
// Ran off the right of the graph.
k1end += 2;
} else if (y1 > text2_length) {
// Ran off the bottom of the graph.
k1start += 2;
} else if (front) {
var k2_offset = v_offset + delta - k1;
if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {
// Mirror x2 onto top-left coordinate system.
var x2 = text1_length - v2[k2_offset];
if (x1 >= x2) {
// Overlap detected.
return diff_bisectSplit_(text1, text2, x1, y1);
}
}
}
}
// Walk the reverse path one step.
for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
var k2_offset = v_offset + k2;
var x2;
if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {
x2 = v2[k2_offset + 1];
} else {
x2 = v2[k2_offset - 1] + 1;
}
var y2 = x2 - k2;
while (x2 < text1_length && y2 < text2_length &&
text1.charAt(text1_length - x2 - 1) ==
text2.charAt(text2_length - y2 - 1)) {
x2++;
y2++;
}
v2[k2_offset] = x2;
if (x2 > text1_length) {
// Ran off the left of the graph.
k2end += 2;
} else if (y2 > text2_length) {
// Ran off the top of the graph.
k2start += 2;
} else if (!front) {
var k1_offset = v_offset + delta - k2;
if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {
var x1 = v1[k1_offset];
var y1 = v_offset + x1 - k1_offset;
// Mirror x2 onto top-left coordinate system.
x2 = text1_length - x2;
if (x1 >= x2) {
// Overlap detected.
return diff_bisectSplit_(text1, text2, x1, y1);
}
}
}
}
}
// Diff took too long and hit the deadline or
// number of diffs equals number of characters, no commonality at all.
return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
}
/**
* Given the location of the 'middle snake', split the diff in two parts
* and recurse.
* @param {string} text1 Old string to be diffed.
* @param {string} text2 New string to be diffed.
* @param {number} x Index of split point in text1.
* @param {number} y Index of split point in text2.
* @return {Array} Array of diff tuples.
*/
function diff_bisectSplit_(text1, text2, x, y) {
var text1a = text1.substring(0, x);
var text2a = text2.substring(0, y);
var text1b = text1.substring(x);
var text2b = text2.substring(y);
// Compute both diffs serially.
var diffs = diff_main(text1a, text2a);
var diffsb = diff_main(text1b, text2b);
return diffs.concat(diffsb);
}
/**
* Determine the common prefix of two strings.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {number} The number of characters common to the start of each
* string.
*/
function diff_commonPrefix(text1, text2) {
// Quick check for common null cases.
if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {
return 0;
}
// Binary search.
// Performance analysis: http://neil.fraser.name/news/2007/10/09/
var pointermin = 0;
var pointermax = Math.min(text1.length, text2.length);
var pointermid = pointermax;
var pointerstart = 0;
while (pointermin < pointermid) {
if (text1.substring(pointerstart, pointermid) ==
text2.substring(pointerstart, pointermid)) {
pointermin = pointermid;
pointerstart = pointermin;
} else {
pointermax = pointermid;
}
pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
}
return pointermid;
}
/**
* Determine the common suffix of two strings.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {number} The number of characters common to the end of each string.
*/
function diff_commonSuffix(text1, text2) {
// Quick check for common null cases.
if (!text1 || !text2 ||
text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {
return 0;
}
// Binary search.
// Performance analysis: http://neil.fraser.name/news/2007/10/09/
var pointermin = 0;
var pointermax = Math.min(text1.length, text2.length);
var pointermid = pointermax;
var pointerend = 0;
while (pointermin < pointermid) {
if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==
text2.substring(text2.length - pointermid, text2.length - pointerend)) {
pointermin = pointermid;
pointerend = pointermin;
} else {
pointermax = pointermid;
}
pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
}
return pointermid;
}
/**
* Do the two texts share a substring which is at least half the length of the
* longer text?
* This speedup can produce non-minimal diffs.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {Array.<string>} Five element Array, containing the prefix of
* text1, the suffix of text1, the prefix of text2, the suffix of
* text2 and the common middle. Or null if there was no match.
*/
function diff_halfMatch_(text1, text2) {
var longtext = text1.length > text2.length ? text1 : text2;
var shorttext = text1.length > text2.length ? text2 : text1;
if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {
return null; // Pointless.
}
/**
* Does a substring of shorttext exist within longtext such that the substring
* is at least half the length of longtext?
* Closure, but does not reference any external variables.
* @param {string} longtext Longer string.
* @param {string} shorttext Shorter string.
* @param {number} i Start index of quarter length substring within longtext.
* @return {Array.<string>} Five element Array, containing the prefix of
* longtext, the suffix of longtext, the prefix of shorttext, the suffix
* of shorttext and the common middle. Or null if there was no match.
* @private
*/
function diff_halfMatchI_(longtext, shorttext, i) {
// Start with a 1/4 length substring at position i as a seed.
var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));
var j = -1;
var best_common = '';
var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;
while ((j = shorttext.indexOf(seed, j + 1)) != -1) {
var prefixLength = diff_commonPrefix(longtext.substring(i),
shorttext.substring(j));
var suffixLength = diff_commonSuffix(longtext.substring(0, i),
shorttext.substring(0, j));
if (best_common.length < suffixLength + prefixLength) {
best_common = shorttext.substring(j - suffixLength, j) +
shorttext.substring(j, j + prefixLength);
best_longtext_a = longtext.substring(0, i - suffixLength);
best_longtext_b = longtext.substring(i + prefixLength);
best_shorttext_a = shorttext.substring(0, j - suffixLength);
best_shorttext_b = shorttext.substring(j + prefixLength);
}
}
if (best_common.length * 2 >= longtext.length) {
return [best_longtext_a, best_longtext_b,
best_shorttext_a, best_shorttext_b, best_common];
} else {
return null;
}
}
// First check if the second quarter is the seed for a half-match.
var hm1 = diff_halfMatchI_(longtext, shorttext,
Math.ceil(longtext.length / 4));
// Check again based on the third quarter.
var hm2 = diff_halfMatchI_(longtext, shorttext,
Math.ceil(longtext.length / 2));
var hm;
if (!hm1 && !hm2) {
return null;
} else if (!hm2) {
hm = hm1;
} else if (!hm1) {
hm = hm2;
} else {
// Both matched. Select the longest.
hm = hm1[4].length > hm2[4].length ? hm1 : hm2;
}
// A half-match was found, sort out the return data.
var text1_a, text1_b, text2_a, text2_b;
if (text1.length > text2.length) {
text1_a = hm[0];
text1_b = hm[1];
text2_a = hm[2];
text2_b = hm[3];
} else {
text2_a = hm[0];
text2_b = hm[1];
text1_a = hm[2];
text1_b = hm[3];
}
var mid_common = hm[4];
return [text1_a, text1_b, text2_a, text2_b, mid_common];
}
/**
* Reorder and merge like edit sections. Merge equalities.
* Any edit section can move as long as it doesn't cross an equality.
* @param {Array} diffs Array of diff tuples.
*/
function diff_cleanupMerge(diffs) {
diffs.push([DIFF_EQUAL, '']); // Add a dummy entry at the end.
var pointer = 0;
var count_delete = 0;
var count_insert = 0;
var text_delete = '';
var text_insert = '';
var commonlength;
while (pointer < diffs.length) {
switch (diffs[pointer][0]) {
case DIFF_INSERT:
count_insert++;
text_insert += diffs[pointer][1];
pointer++;
break;
case DIFF_DELETE:
count_delete++;
text_delete += diffs[pointer][1];
pointer++;
break;
case DIFF_EQUAL:
// Upon reaching an equality, check for prior redundancies.
if (count_delete + count_insert > 1) {
if (count_delete !== 0 && count_insert !== 0) {
// Factor out any common prefixies.
commonlength = diff_commonPrefix(text_insert, text_delete);
if (commonlength !== 0) {
if ((pointer - count_delete - count_insert) > 0 &&
diffs[pointer - count_delete - count_insert - 1][0] ==
DIFF_EQUAL) {
diffs[pointer - count_delete - count_insert - 1][1] +=
text_insert.substring(0, commonlength);
} else {
diffs.splice(0, 0, [DIFF_EQUAL,
text_insert.substring(0, commonlength)]);
pointer++;
}
text_insert = text_insert.substring(commonlength);
text_delete = text_delete.substring(commonlength);
}
// Factor out any common suffixies.
commonlength = diff_commonSuffix(text_insert, text_delete);
if (commonlength !== 0) {
diffs[pointer][1] = text_insert.substring(text_insert.length -
commonlength) + diffs[pointer][1];
text_insert = text_insert.substring(0, text_insert.length -
commonlength);
text_delete = text_delete.substring(0, text_delete.length -
commonlength);
}
}
// Delete the offending records and add the merged ones.
if (count_delete === 0) {
diffs.splice(pointer - count_insert,
count_delete + count_insert, [DIFF_INSERT, text_insert]);
} else if (count_insert === 0) {
diffs.splice(pointer - count_delete,
count_delete + count_insert, [DIFF_DELETE, text_delete]);
} else {
diffs.splice(pointer - count_delete - count_insert,
count_delete + count_insert, [DIFF_DELETE, text_delete],
[DIFF_INSERT, text_insert]);
}
pointer = pointer - count_delete - count_insert +
(count_delete ? 1 : 0) + (count_insert ? 1 : 0) + 1;
} else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {
// Merge this equality with the previous one.
diffs[pointer - 1][1] += diffs[pointer][1];
diffs.splice(pointer, 1);
} else {
pointer++;
}
count_insert = 0;
count_delete = 0;
text_delete = '';
text_insert = '';
break;
}
}
if (diffs[diffs.length - 1][1] === '') {
diffs.pop(); // Remove the dummy entry at the end.
}
// Second pass: look for single edits surrounded on both sides by equalities
// which can be shifted sideways to eliminate an equality.
// e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
var changes = false;
pointer = 1;
// Intentionally ignore the first and last element (don't need checking).
while (pointer < diffs.length - 1) {
if (diffs[pointer - 1][0] == DIFF_EQUAL &&
diffs[pointer + 1][0] == DIFF_EQUAL) {
// This is a single edit surrounded by equalities.
if (diffs[pointer][1].substring(diffs[pointer][1].length -
diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {
// Shift the edit over the previous equality.
diffs[pointer][1] = diffs[pointer - 1][1] +
diffs[pointer][1].substring(0, diffs[pointer][1].length -
diffs[pointer - 1][1].length);
diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
diffs.splice(pointer - 1, 1);
changes = true;
} else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==
diffs[pointer + 1][1]) {
// Shift the edit over the next equality.
diffs[pointer - 1][1] += diffs[pointer + 1][1];
diffs[pointer][1] =
diffs[pointer][1].substring(diffs[pointer + 1][1].length) +
diffs[pointer + 1][1];
diffs.splice(pointer + 1, 1);
changes = true;
}
}
pointer++;
}
// If shifts were made, the diff needs reordering and another shift sweep.
if (changes) {
diff_cleanupMerge(diffs);
}
}
var diff = diff_main;
diff.INSERT = DIFF_INSERT;
diff.DELETE = DIFF_DELETE;
diff.EQUAL = DIFF_EQUAL;
module.exports = diff;
/*
* Modify a diff such that the cursor position points to the start of a change:
* E.g.
* cursor_normalize_diff([[DIFF_EQUAL, 'abc']], 1)
* => [1, [[DIFF_EQUAL, 'a'], [DIFF_EQUAL, 'bc']]]
* cursor_normalize_diff([[DIFF_INSERT, 'new'], [DIFF_DELETE, 'xyz']], 2)
* => [2, [[DIFF_INSERT, 'new'], [DIFF_DELETE, 'xy'], [DIFF_DELETE, 'z']]]
*
* @param {Array} diffs Array of diff tuples
* @param {Int} cursor_pos Suggested edit position. Must not be out of bounds!
* @return {Array} A tuple [cursor location in the modified diff, modified diff]
*/
function cursor_normalize_diff (diffs, cursor_pos) {
if (cursor_pos === 0) {
return [DIFF_EQUAL, diffs];
}
for (var current_pos = 0, i = 0; i < diffs.length; i++) {
var d = diffs[i];
if (d[0] === DIFF_DELETE || d[0] === DIFF_EQUAL) {
var next_pos = current_pos + d[1].length;
if (cursor_pos === next_pos) {
return [i + 1, diffs];
} else if (cursor_pos < next_pos) {
// copy to prevent side effects
diffs = diffs.slice();
// split d into two diff changes
var split_pos = cursor_pos - current_pos;
var d_left = [d[0], d[1].slice(0, split_pos)];
var d_right = [d[0], d[1].slice(split_pos)];
diffs.splice(i, 1, d_left, d_right);
return [i + 1, diffs];
} else {
current_pos = next_pos;
}
}
}
throw new Error('cursor_pos is out of bounds!')
}
/*
* Modify a diff such that the edit position is "shifted" to the proposed edit location (cursor_position).
*
* Case 1)
* Check if a naive shift is possible:
* [0, X], [ 1, Y] -> [ 1, Y], [0, X] (if X + Y === Y + X)
* [0, X], [-1, Y] -> [-1, Y], [0, X] (if X + Y === Y + X) - holds same result
* Case 2)
* Check if the following shifts are possible:
* [0, 'pre'], [ 1, 'prefix'] -> [ 1, 'pre'], [0, 'pre'], [ 1, 'fix']
* [0, 'pre'], [-1, 'prefix'] -> [-1, 'pre'], [0, 'pre'], [-1, 'fix']
* ^ ^
* d d_next
*
* @param {Array} diffs Array of diff tuples
* @param {Int} cursor_pos Suggested edit position. Must not be out of bounds!
* @return {Array} Array of diff tuples
*/
function fix_cursor (diffs, cursor_pos) {
var norm = cursor_normalize_diff(diffs, cursor_pos);
var ndiffs = norm[1];
var cursor_pointer = norm[0];
var d = ndiffs[cursor_pointer];
var d_next = ndiffs[cursor_pointer + 1];
if (d == null) {
// Text was deleted from end of original string,
// cursor is now out of bounds in new string
return diffs;
} else if (d[0] !== DIFF_EQUAL) {
// A modification happened at the cursor location.
// This is the expected outcome, so we can return the original diff.
return diffs;
} else {
if (d_next != null && d[1] + d_next[1] === d_next[1] + d[1]) {
// Case 1)
// It is possible to perform a naive shift
ndiffs.splice(cursor_pointer, 2, d_next, d);
return merge_tuples(ndiffs, cursor_pointer, 2)
} else if (d_next != null && d_next[1].indexOf(d[1]) === 0) {
// Case 2)
// d[1] is a prefix of d_next[1]
// We can assume that d_next[0] !== 0, since d[0] === 0
// Shift edit locations..
ndiffs.splice(cursor_pointer, 2, [d_next[0], d[1]], [0, d[1]]);
var suffix = d_next[1].slice(d[1].length);
if (suffix.length > 0) {
ndiffs.splice(cursor_pointer + 2, 0, [d_next[0], suffix]);
}
return merge_tuples(ndiffs, cursor_pointer, 3)
} else {
// Not possible to perform any modification
return diffs;
}
}
}
/*
* Check diff did not split surrogate pairs.
* Ex. [0, '\uD83D'], [-1, '\uDC36'], [1, '\uDC2F'] -> [-1, '\uD83D\uDC36'], [1, '\uD83D\uDC2F']
* '\uD83D\uDC36' === '🐶', '\uD83D\uDC2F' === '🐯'
*
* @param {Array} diffs Array of diff tuples
* @return {Array} Array of diff tuples
*/
function fix_emoji (diffs) {
var compact = false;
var starts_with_pair_end = function(str) {
return str.charCodeAt(0) >= 0xDC00 && str.charCodeAt(0) <= 0xDFFF;
};
var ends_with_pair_start = function(str) {
return str.charCodeAt(str.length-1) >= 0xD800 && str.charCodeAt(str.length-1) <= 0xDBFF;
};
for (var i = 2; i < diffs.length; i += 1) {
if (diffs[i-2][0] === DIFF_EQUAL && ends_with_pair_start(diffs[i-2][1]) &&
diffs[i-1][0] === DIFF_DELETE && starts_with_pair_end(diffs[i-1][1]) &&
diffs[i][0] === DIFF_INSERT && starts_with_pair_end(diffs[i][1])) {
compact = true;
diffs[i-1][1] = diffs[i-2][1].slice(-1) + diffs[i-1][1];
diffs[i][1] = diffs[i-2][1].slice(-1) + diffs[i][1];
diffs[i-2][1] = diffs[i-2][1].slice(0, -1);
}
}
if (!compact) {
return diffs;
}
var fixed_diffs = [];
for (var i = 0; i < diffs.length; i += 1) {
if (diffs[i][1].length > 0) {
fixed_diffs.push(diffs[i]);
}
}
return fixed_diffs;
}
/*
* Try to merge tuples with their neigbors in a given range.
* E.g. [0, 'a'], [0, 'b'] -> [0, 'ab']
*
* @param {Array} diffs Array of diff tuples.
* @param {Int} start Position of the first element to merge (diffs[start] is also merged with diffs[start - 1]).
* @param {Int} length Number of consecutive elements to check.
* @return {Array} Array of merged diff tuples.
*/
function merge_tuples (diffs, start, length) {
// Check from (start-1) to (start+length).
for (var i = start + length - 1; i >= 0 && i >= start - 1; i--) {
if (i + 1 < diffs.length) {
var left_d = diffs[i];
var right_d = diffs[i+1];
if (left_d[0] === right_d[1]) {
diffs.splice(i, 2, [left_d[0], left_d[1] + right_d[1]]);
}
}
}
return diffs;
}
/***/ }),
/* 52 */
/***/ (function(module, exports) {
exports = module.exports = typeof Object.keys === 'function'
? Object.keys : shim;
exports.shim = shim;
function shim (obj) {
var keys = [];
for (var key in obj) keys.push(key);
return keys;
}
/***/ }),
/* 53 */
/***/ (function(module, exports) {
var supportsArgumentsClass = (function(){
return Object.prototype.toString.call(arguments)
})() == '[object Arguments]';
exports = module.exports = supportsArgumentsClass ? supported : unsupported;
exports.supported = supported;
function supported(object) {
return Object.prototype.toString.call(object) == '[object Arguments]';
}
exports.unsupported = unsupported;
function unsupported(object){
return object &&
typeof object == 'object' &&
typeof object.length == 'number' &&
Object.prototype.hasOwnProperty.call(object, 'callee') &&
!Object.prototype.propertyIsEnumerable.call(object, 'callee') ||
false;
}
/***/ }),
/* 54 */
/***/ (function(module, exports) {
var has = Object.prototype.hasOwnProperty
, prefix = '~';
/**
* Constructor to create a storage for our `EE` objects.
* An `Events` instance is a plain object whose properties are event names.
*
* @constructor
* @api private
*/
function Events() {}
//
// We try to not inherit from `Object.prototype`. In some engines creating an
// instance in this way is faster than calling `Object.create(null)` directly.
// If `Object.create(null)` is not supported we prefix the event names with a
// character to make sure that the built-in object properties are not
// overridden or used as an attack vector.
//
if (Object.create) {
Events.prototype = Object.create(null);
//
// This hack is needed because the `__proto__` property is still inherited in
// some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
//
if (!new Events().__proto__) prefix = false;
}
/**
* Representation of a single event listener.
*
* @param {Function} fn The listener function.
* @param {Mixed} context The context to invoke the listener with.
* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
* @constructor
* @api private
*/
function EE(fn, context, once) {
this.fn = fn;
this.context = context;
this.once = once || false;
}
/**
* Minimal `EventEmitter` interface that is molded against the Node.js
* `EventEmitter` interface.
*
* @constructor
* @api public
*/
function EventEmitter() {
this._events = new Events();
this._eventsCount = 0;
}
/**
* Return an array listing the events for which the emitter has registered
* listeners.
*
* @returns {Array}
* @api public
*/
EventEmitter.prototype.eventNames = function eventNames() {
var names = []
, events
, name;
if (this._eventsCount === 0) return names;
for (name in (events = this._events)) {
if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
}
if (Object.getOwnPropertySymbols) {
return names.concat(Object.getOwnPropertySymbols(events));
}
return names;
};
/**
* Return the listeners registered for a given event.
*
* @param {String|Symbol} event The event name.
* @param {Boolean} exists Only check if there are listeners.
* @returns {Array|Boolean}
* @api public
*/
EventEmitter.prototype.listeners = function listeners(event, exists) {
var evt = prefix ? prefix + event : event
, available = this._events[evt];
if (exists) return !!available;
if (!available) return [];
if (available.fn) return [available.fn];
for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) {
ee[i] = available[i].fn;
}
return ee;
};
/**
* Calls each of the listeners registered for a given event.
*
* @param {String|Symbol} event The event name.
* @returns {Boolean} `true` if the event had listeners, else `false`.
* @api public
*/
EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
var evt = prefix ? prefix + event : event;
if (!this._events[evt]) return false;
var listeners = this._events[evt]
, len = arguments.length
, args
, i;
if (listeners.fn) {
if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
switch (len) {
case 1: return listeners.fn.call(listeners.context), true;
case 2: return listeners.fn.call(listeners.context, a1), true;
case 3: return listeners.fn.call(listeners.context, a1, a2), true;
case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
}
for (i = 1, args = new Array(len -1); i < len; i++) {
args[i - 1] = arguments[i];
}
listeners.fn.apply(listeners.context, args);
} else {
var length = listeners.length
, j;
for (i = 0; i < length; i++) {
if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
switch (len) {
case 1: listeners[i].fn.call(listeners[i].context); break;
case 2: listeners[i].fn.call(listeners[i].context, a1); break;
case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
default:
if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
args[j - 1] = arguments[j];
}
listeners[i].fn.apply(listeners[i].context, args);
}
}
}
return true;
};
/**
* Add a listener for a given event.
*
* @param {String|Symbol} event The event name.
* @param {Function} fn The listener function.
* @param {Mixed} [context=this] The context to invoke the listener with.
* @returns {EventEmitter} `this`.
* @api public
*/
EventEmitter.prototype.on = function on(event, fn, context) {
var listener = new EE(fn, context || this)
, evt = prefix ? prefix + event : event;
if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;
else if (!this._events[evt].fn) this._events[evt].push(listener);
else this._events[evt] = [this._events[evt], listener];
return this;
};
/**
* Add a one-time listener for a given event.
*
* @param {String|Symbol} event The event name.
* @param {Function} fn The listener function.
* @param {Mixed} [context=this] The context to invoke the listener with.
* @returns {EventEmitter} `this`.
* @api public
*/
EventEmitter.prototype.once = function once(event, fn, context) {
var listener = new EE(fn, context || this, true)
, evt = prefix ? prefix + event : event;
if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;
else if (!this._events[evt].fn) this._events[evt].push(listener);
else this._events[evt] = [this._events[evt], listener];
return this;
};
/**
* Remove the listeners of a given event.
*
* @param {String|Symbol} event The event name.
* @param {Function} fn Only remove the listeners that match this function.
* @param {Mixed} context Only remove the listeners that have this context.
* @param {Boolean} once Only remove one-time listeners.
* @returns {EventEmitter} `this`.
* @api public
*/
EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
var evt = prefix ? prefix + event : event;
if (!this._events[evt]) return this;
if (!fn) {
if (--this._eventsCount === 0) this._events = new Events();
else delete this._events[evt];
return this;
}
var listeners = this._events[evt];
if (listeners.fn) {
if (
listeners.fn === fn
&& (!once || listeners.once)
&& (!context || listeners.context === context)
) {
if (--this._eventsCount === 0) this._events = new Events();
else delete this._events[evt];
}
} else {
for (var i = 0, events = [], length = listeners.length; i < length; i++) {
if (
listeners[i].fn !== fn
|| (once && !listeners[i].once)
|| (context && listeners[i].context !== context)
) {
events.push(listeners[i]);
}
}
//
// Reset the array, or remove it completely if we have no more listeners.
//
if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
else if (--this._eventsCount === 0) this._events = new Events();
else delete this._events[evt];
}
return this;
};
/**
* Remove all listeners, or those of the specified event.
*
* @param {String|Symbol} [event] The event name.
* @returns {EventEmitter} `this`.
* @api public
*/
EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
var evt;
if (event) {
evt = prefix ? prefix + event : event;
if (this._events[evt]) {
if (--this._eventsCount === 0) this._events = new Events();
else delete this._events[evt];
}
} else {
this._events = new Events();
this._eventsCount = 0;
}
return this;
};
//
// Alias methods names because people roll like that.
//
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.addListener = EventEmitter.prototype.on;
//
// This function doesn't apply anymore.
//
EventEmitter.prototype.setMaxListeners = function setMaxListeners() {
return this;
};
//
// Expose the prefix.
//
EventEmitter.prefixed = prefix;
//
// Allow `EventEmitter` to be imported as module namespace.
//
EventEmitter.EventEmitter = EventEmitter;
//
// Expose the module.
//
if ('undefined' !== typeof module) {
module.exports = EventEmitter;
}
/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.matchText = exports.matchSpacing = exports.matchNewline = exports.matchBlot = exports.matchAttributor = exports.default = undefined;
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _extend2 = __webpack_require__(3);
var _extend3 = _interopRequireDefault(_extend2);
var _quillDelta = __webpack_require__(2);
var _quillDelta2 = _interopRequireDefault(_quillDelta);
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _quill = __webpack_require__(5);
var _quill2 = _interopRequireDefault(_quill);
var _logger = __webpack_require__(10);
var _logger2 = _interopRequireDefault(_logger);
var _module = __webpack_require__(9);
var _module2 = _interopRequireDefault(_module);
var _align = __webpack_require__(36);
var _background = __webpack_require__(37);
var _code = __webpack_require__(13);
var _code2 = _interopRequireDefault(_code);
var _color = __webpack_require__(26);
var _direction = __webpack_require__(38);
var _font = __webpack_require__(39);
var _size = __webpack_require__(40);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var debug = (_logger2.default)('quill:clipboard');
var DOM_KEY = '__ql-matcher';
var CLIPBOARD_CONFIG = [[Node.TEXT_NODE, matchText], [Node.TEXT_NODE, matchNewline], ['br', matchBreak], [Node.ELEMENT_NODE, matchNewline], [Node.ELEMENT_NODE, matchBlot], [Node.ELEMENT_NODE, matchSpacing], [Node.ELEMENT_NODE, matchAttributor], [Node.ELEMENT_NODE, matchStyles], ['li', matchIndent], ['b', matchAlias.bind(matchAlias, 'bold')], ['i', matchAlias.bind(matchAlias, 'italic')], ['style', matchIgnore]];
var ATTRIBUTE_ATTRIBUTORS = [_align.AlignAttribute, _direction.DirectionAttribute].reduce(function (memo, attr) {
memo[attr.keyName] = attr;
return memo;
}, {});
var STYLE_ATTRIBUTORS = [_align.AlignStyle, _background.BackgroundStyle, _color.ColorStyle, _direction.DirectionStyle, _font.FontStyle, _size.SizeStyle].reduce(function (memo, attr) {
memo[attr.keyName] = attr;
return memo;
}, {});
var Clipboard = function (_Module) {
_inherits(Clipboard, _Module);
function Clipboard(quill, options) {
_classCallCheck(this, Clipboard);
var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this, quill, options));
_this.quill.root.addEventListener('paste', _this.onPaste.bind(_this));
_this.container = _this.quill.addContainer('ql-clipboard');
_this.container.setAttribute('contenteditable', true);
_this.container.setAttribute('tabindex', -1);
_this.matchers = [];
CLIPBOARD_CONFIG.concat(_this.options.matchers).forEach(function (_ref) {
var _ref2 = _slicedToArray(_ref, 2),
selector = _ref2[0],
matcher = _ref2[1];
if (!options.matchVisual && matcher === matchSpacing) return;
_this.addMatcher(selector, matcher);
});
return _this;
}
_createClass(Clipboard, [{
key: 'addMatcher',
value: function addMatcher(selector, matcher) {
this.matchers.push([selector, matcher]);
}
}, {
key: 'convert',
value: function convert(html) {
if (typeof html === 'string') {
this.container.innerHTML = html.replace(/\>\r?\n +\</g, '><'); // Remove spaces between tags
return this.convert();
}
var formats = this.quill.getFormat(this.quill.selection.savedRange.index);
if (formats[_code2.default.blotName]) {
var text = this.container.innerText;
this.container.innerHTML = '';
return new _quillDelta2.default().insert(text, _defineProperty({}, _code2.default.blotName, formats[_code2.default.blotName]));
}
var _prepareMatching = this.prepareMatching(),
_prepareMatching2 = _slicedToArray(_prepareMatching, 2),
elementMatchers = _prepareMatching2[0],
textMatchers = _prepareMatching2[1];
var delta = traverse(this.container, elementMatchers, textMatchers);
// Remove trailing newline
if (deltaEndsWith(delta, '\n') && delta.ops[delta.ops.length - 1].attributes == null) {
delta = delta.compose(new _quillDelta2.default().retain(delta.length() - 1).delete(1));
}
debug.log('convert', this.container.innerHTML, delta);
this.container.innerHTML = '';
return delta;
}
}, {
key: 'dangerouslyPasteHTML',
value: function dangerouslyPasteHTML(index, html) {
var source = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _quill2.default.sources.API;
if (typeof index === 'string') {
this.quill.setContents(this.convert(index), html);
this.quill.setSelection(0, _quill2.default.sources.SILENT);
} else {
var paste = this.convert(html);
this.quill.updateContents(new _quillDelta2.default().retain(index).concat(paste), source);
this.quill.setSelection(index + paste.length(), _quill2.default.sources.SILENT);
}
}
}, {
key: 'onPaste',
value: function onPaste(e) {
var _this2 = this;
if (e.defaultPrevented || !this.quill.isEnabled()) return;
var range = this.quill.getSelection();
var delta = new _quillDelta2.default().retain(range.index);
var scrollTop = this.quill.scrollingContainer.scrollTop;
this.container.focus();
this.quill.selection.update(_quill2.default.sources.SILENT);
setTimeout(function () {
delta = delta.concat(_this2.convert()).delete(range.length);
_this2.quill.updateContents(delta, _quill2.default.sources.USER);
// range.length contributes to delta.length()
_this2.quill.setSelection(delta.length() - range.length, _quill2.default.sources.SILENT);
_this2.quill.scrollingContainer.scrollTop = scrollTop;
_this2.quill.focus();
}, 1);
}
}, {
key: 'prepareMatching',
value: function prepareMatching() {
var _this3 = this;
var elementMatchers = [],
textMatchers = [];
this.matchers.forEach(function (pair) {
var _pair = _slicedToArray(pair, 2),
selector = _pair[0],
matcher = _pair[1];
switch (selector) {
case Node.TEXT_NODE:
textMatchers.push(matcher);
break;
case Node.ELEMENT_NODE:
elementMatchers.push(matcher);
break;
default:
[].forEach.call(_this3.container.querySelectorAll(selector), function (node) {
// TODO use weakmap
node[DOM_KEY] = node[DOM_KEY] || [];
node[DOM_KEY].push(matcher);
});
break;
}
});
return [elementMatchers, textMatchers];
}
}]);
return Clipboard;
}(_module2.default);
Clipboard.DEFAULTS = {
matchers: [],
matchVisual: true
};
function applyFormat(delta, format, value) {
if ((typeof format === 'undefined' ? 'undefined' : _typeof(format)) === 'object') {
return Object.keys(format).reduce(function (delta, key) {
return applyFormat(delta, key, format[key]);
}, delta);
} else {
return delta.reduce(function (delta, op) {
if (op.attributes && op.attributes[format]) {
return delta.push(op);
} else {
return delta.insert(op.insert, (_extend3.default)({}, _defineProperty({}, format, value), op.attributes));
}
}, new _quillDelta2.default());
}
}
function computeStyle(node) {
if (node.nodeType !== Node.ELEMENT_NODE) return {};
var DOM_KEY = '__ql-computed-style';
return node[DOM_KEY] || (node[DOM_KEY] = window.getComputedStyle(node));
}
function deltaEndsWith(delta, text) {
var endText = "";
for (var i = delta.ops.length - 1; i >= 0 && endText.length < text.length; --i) {
var op = delta.ops[i];
if (typeof op.insert !== 'string') break;
endText = op.insert + endText;
}
return endText.slice(-1 * text.length) === text;
}
function isLine(node) {
if (node.childNodes.length === 0) return false; // Exclude embed blocks
var style = computeStyle(node);
return ['block', 'list-item'].indexOf(style.display) > -1;
}
function traverse(node, elementMatchers, textMatchers) {
// Post-order
if (node.nodeType === node.TEXT_NODE) {
return textMatchers.reduce(function (delta, matcher) {
return matcher(node, delta);
}, new _quillDelta2.default());
} else if (node.nodeType === node.ELEMENT_NODE) {
return [].reduce.call(node.childNodes || [], function (delta, childNode) {
var childrenDelta = traverse(childNode, elementMatchers, textMatchers);
if (childNode.nodeType === node.ELEMENT_NODE) {
childrenDelta = elementMatchers.reduce(function (childrenDelta, matcher) {
return matcher(childNode, childrenDelta);
}, childrenDelta);
childrenDelta = (childNode[DOM_KEY] || []).reduce(function (childrenDelta, matcher) {
return matcher(childNode, childrenDelta);
}, childrenDelta);
}
return delta.concat(childrenDelta);
}, new _quillDelta2.default());
} else {
return new _quillDelta2.default();
}
}
function matchAlias(format, node, delta) {
return applyFormat(delta, format, true);
}
function matchAttributor(node, delta) {
var attributes = _parchment2.default.Attributor.Attribute.keys(node);
var classes = _parchment2.default.Attributor.Class.keys(node);
var styles = _parchment2.default.Attributor.Style.keys(node);
var formats = {};
attributes.concat(classes).concat(styles).forEach(function (name) {
var attr = _parchment2.default.query(name, _parchment2.default.Scope.ATTRIBUTE);
if (attr != null) {
formats[attr.attrName] = attr.value(node);
if (formats[attr.attrName]) return;
}
attr = ATTRIBUTE_ATTRIBUTORS[name];
if (attr != null && (attr.attrName === name || attr.keyName === name)) {
formats[attr.attrName] = attr.value(node) || undefined;
}
attr = STYLE_ATTRIBUTORS[name];
if (attr != null && (attr.attrName === name || attr.keyName === name)) {
attr = STYLE_ATTRIBUTORS[name];
formats[attr.attrName] = attr.value(node) || undefined;
}
});
if (Object.keys(formats).length > 0) {
delta = applyFormat(delta, formats);
}
return delta;
}
function matchBlot(node, delta) {
var match = _parchment2.default.query(node);
if (match == null) return delta;
if (match.prototype instanceof _parchment2.default.Embed) {
var embed = {};
var value = match.value(node);
if (value != null) {
embed[match.blotName] = value;
delta = new _quillDelta2.default().insert(embed, match.formats(node));
}
} else if (typeof match.formats === 'function') {
delta = applyFormat(delta, match.blotName, match.formats(node));
}
return delta;
}
function matchBreak(node, delta) {
if (!deltaEndsWith(delta, '\n')) {
delta.insert('\n');
}
return delta;
}
function matchIgnore() {
return new _quillDelta2.default();
}
function matchIndent(node, delta) {
var match = _parchment2.default.query(node);
if (match == null || match.blotName !== 'list-item' || !deltaEndsWith(delta, '\n')) {
return delta;
}
var indent = -1,
parent = node.parentNode;
while (!parent.classList.contains('ql-clipboard')) {
if ((_parchment2.default.query(parent) || {}).blotName === 'list') {
indent += 1;
}
parent = parent.parentNode;
}
if (indent <= 0) return delta;
return delta.compose(new _quillDelta2.default().retain(delta.length() - 1).retain(1, { indent: indent }));
}
function matchNewline(node, delta) {
if (!deltaEndsWith(delta, '\n')) {
if (isLine(node) || delta.length() > 0 && node.nextSibling && isLine(node.nextSibling)) {
delta.insert('\n');
}
}
return delta;
}
function matchSpacing(node, delta) {
if (isLine(node) && node.nextElementSibling != null && !deltaEndsWith(delta, '\n\n')) {
var nodeHeight = node.offsetHeight + parseFloat(computeStyle(node).marginTop) + parseFloat(computeStyle(node).marginBottom);
if (node.nextElementSibling.offsetTop > node.offsetTop + nodeHeight * 1.5) {
delta.insert('\n');
}
}
return delta;
}
function matchStyles(node, delta) {
var formats = {};
var style = node.style || {};
if (style.fontStyle && computeStyle(node).fontStyle === 'italic') {
formats.italic = true;
}
if (style.fontWeight && (computeStyle(node).fontWeight.startsWith('bold') || parseInt(computeStyle(node).fontWeight) >= 700)) {
formats.bold = true;
}
if (Object.keys(formats).length > 0) {
delta = applyFormat(delta, formats);
}
if (parseFloat(style.textIndent || 0) > 0) {
// Could be 0.5in
delta = new _quillDelta2.default().insert('\t').concat(delta);
}
return delta;
}
function matchText(node, delta) {
var text = node.data;
// Word represents empty line with <o:p>&nbsp;</o:p>
if (node.parentNode.tagName === 'O:P') {
return delta.insert(text.trim());
}
if (text.trim().length === 0 && node.parentNode.classList.contains('ql-clipboard')) {
return delta;
}
if (!computeStyle(node.parentNode).whiteSpace.startsWith('pre')) {
// eslint-disable-next-line func-style
var replacer = function replacer(collapse, match) {
match = match.replace(/[^\u00a0]/g, ''); // \u00a0 is nbsp;
return match.length < 1 && collapse ? ' ' : match;
};
text = text.replace(/\r\n/g, ' ').replace(/\n/g, ' ');
text = text.replace(/\s\s+/g, replacer.bind(replacer, true)); // collapse whitespace
if (node.previousSibling == null && isLine(node.parentNode) || node.previousSibling != null && isLine(node.previousSibling)) {
text = text.replace(/^\s+/, replacer.bind(replacer, false));
}
if (node.nextSibling == null && isLine(node.parentNode) || node.nextSibling != null && isLine(node.nextSibling)) {
text = text.replace(/\s+$/, replacer.bind(replacer, false));
}
}
return delta.insert(text);
}
exports.default = Clipboard;
exports.matchAttributor = matchAttributor;
exports.matchBlot = matchBlot;
exports.matchNewline = matchNewline;
exports.matchSpacing = matchSpacing;
exports.matchText = matchText;
/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _inline = __webpack_require__(6);
var _inline2 = _interopRequireDefault(_inline);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Bold = function (_Inline) {
_inherits(Bold, _Inline);
function Bold() {
_classCallCheck(this, Bold);
return _possibleConstructorReturn(this, (Bold.__proto__ || Object.getPrototypeOf(Bold)).apply(this, arguments));
}
_createClass(Bold, [{
key: 'optimize',
value: function optimize(context) {
_get(Bold.prototype.__proto__ || Object.getPrototypeOf(Bold.prototype), 'optimize', this).call(this, context);
if (this.domNode.tagName !== this.statics.tagName[0]) {
this.replaceWith(this.statics.blotName);
}
}
}], [{
key: 'create',
value: function create() {
return _get(Bold.__proto__ || Object.getPrototypeOf(Bold), 'create', this).call(this);
}
}, {
key: 'formats',
value: function formats() {
return true;
}
}]);
return Bold;
}(_inline2.default);
Bold.blotName = 'bold';
Bold.tagName = ['STRONG', 'B'];
exports.default = Bold;
/***/ }),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.addControls = exports.default = undefined;
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _quillDelta = __webpack_require__(2);
var _quillDelta2 = _interopRequireDefault(_quillDelta);
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _quill = __webpack_require__(5);
var _quill2 = _interopRequireDefault(_quill);
var _logger = __webpack_require__(10);
var _logger2 = _interopRequireDefault(_logger);
var _module = __webpack_require__(9);
var _module2 = _interopRequireDefault(_module);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var debug = (_logger2.default)('quill:toolbar');
var Toolbar = function (_Module) {
_inherits(Toolbar, _Module);
function Toolbar(quill, options) {
_classCallCheck(this, Toolbar);
var _this = _possibleConstructorReturn(this, (Toolbar.__proto__ || Object.getPrototypeOf(Toolbar)).call(this, quill, options));
if (Array.isArray(_this.options.container)) {
var container = document.createElement('div');
addControls(container, _this.options.container);
quill.container.parentNode.insertBefore(container, quill.container);
_this.container = container;
} else if (typeof _this.options.container === 'string') {
_this.container = document.querySelector(_this.options.container);
} else {
_this.container = _this.options.container;
}
if (!(_this.container instanceof HTMLElement)) {
var _ret;
return _ret = debug.error('Container required for toolbar', _this.options), _possibleConstructorReturn(_this, _ret);
}
_this.container.classList.add('ql-toolbar');
_this.controls = [];
_this.handlers = {};
Object.keys(_this.options.handlers).forEach(function (format) {
_this.addHandler(format, _this.options.handlers[format]);
});
[].forEach.call(_this.container.querySelectorAll('button, select'), function (input) {
_this.attach(input);
});
_this.quill.on(_quill2.default.events.EDITOR_CHANGE, function (type, range) {
if (type === _quill2.default.events.SELECTION_CHANGE) {
_this.update(range);
}
});
_this.quill.on(_quill2.default.events.SCROLL_OPTIMIZE, function () {
var _this$quill$selection = _this.quill.selection.getRange(),
_this$quill$selection2 = _slicedToArray(_this$quill$selection, 1),
range = _this$quill$selection2[0]; // quill.getSelection triggers update
_this.update(range);
});
return _this;
}
_createClass(Toolbar, [{
key: 'addHandler',
value: function addHandler(format, handler) {
this.handlers[format] = handler;
}
}, {
key: 'attach',
value: function attach(input) {
var _this2 = this;
var format = [].find.call(input.classList, function (className) {
return className.indexOf('ql-') === 0;
});
if (!format) return;
format = format.slice('ql-'.length);
if (input.tagName === 'BUTTON') {
input.setAttribute('type', 'button');
}
if (this.handlers[format] == null) {
if (this.quill.scroll.whitelist != null && this.quill.scroll.whitelist[format] == null) {
debug.warn('ignoring attaching to disabled format', format, input);
return;
}
if (_parchment2.default.query(format) == null) {
debug.warn('ignoring attaching to nonexistent format', format, input);
return;
}
}
var eventName = input.tagName === 'SELECT' ? 'change' : 'click';
input.addEventListener(eventName, function (e) {
var value = void 0;
if (input.tagName === 'SELECT') {
if (input.selectedIndex < 0) return;
var selected = input.options[input.selectedIndex];
if (selected.hasAttribute('selected')) {
value = false;
} else {
value = selected.value || false;
}
} else {
if (input.classList.contains('ql-active')) {
value = false;
} else {
value = input.value || !input.hasAttribute('value');
}
e.preventDefault();
}
_this2.quill.focus();
var _quill$selection$getR = _this2.quill.selection.getRange(),
_quill$selection$getR2 = _slicedToArray(_quill$selection$getR, 1),
range = _quill$selection$getR2[0];
if (_this2.handlers[format] != null) {
_this2.handlers[format].call(_this2, value);
} else if (_parchment2.default.query(format).prototype instanceof _parchment2.default.Embed) {
value = prompt('Enter ' + format);
if (!value) return;
_this2.quill.updateContents(new _quillDelta2.default().retain(range.index).delete(range.length).insert(_defineProperty({}, format, value)), _quill2.default.sources.USER);
} else {
_this2.quill.format(format, value, _quill2.default.sources.USER);
}
_this2.update(range);
});
// TODO use weakmap
this.controls.push([format, input]);
}
}, {
key: 'update',
value: function update(range) {
var formats = range == null ? {} : this.quill.getFormat(range);
this.controls.forEach(function (pair) {
var _pair = _slicedToArray(pair, 2),
format = _pair[0],
input = _pair[1];
if (input.tagName === 'SELECT') {
var option = void 0;
if (range == null) {
option = null;
} else if (formats[format] == null) {
option = input.querySelector('option[selected]');
} else if (!Array.isArray(formats[format])) {
var value = formats[format];
if (typeof value === 'string') {
value = value.replace(/\"/g, '\\"');
}
option = input.querySelector('option[value="' + value + '"]');
}
if (option == null) {
input.value = ''; // TODO make configurable?
input.selectedIndex = -1;
} else {
option.selected = true;
}
} else {
if (range == null) {
input.classList.remove('ql-active');
} else if (input.hasAttribute('value')) {
// both being null should match (default values)
// '1' should match with 1 (headers)
var isActive = formats[format] === input.getAttribute('value') || formats[format] != null && formats[format].toString() === input.getAttribute('value') || formats[format] == null && !input.getAttribute('value');
input.classList.toggle('ql-active', isActive);
} else {
input.classList.toggle('ql-active', formats[format] != null);
}
}
});
}
}]);
return Toolbar;
}(_module2.default);
Toolbar.DEFAULTS = {};
function addButton(container, format, value) {
var input = document.createElement('button');
input.setAttribute('type', 'button');
input.classList.add('ql-' + format);
if (value != null) {
input.value = value;
}
container.appendChild(input);
}
function addControls(container, groups) {
if (!Array.isArray(groups[0])) {
groups = [groups];
}
groups.forEach(function (controls) {
var group = document.createElement('span');
group.classList.add('ql-formats');
controls.forEach(function (control) {
if (typeof control === 'string') {
addButton(group, control);
} else {
var format = Object.keys(control)[0];
var value = control[format];
if (Array.isArray(value)) {
addSelect(group, format, value);
} else {
addButton(group, format, value);
}
}
});
container.appendChild(group);
});
}
function addSelect(container, format, values) {
var input = document.createElement('select');
input.classList.add('ql-' + format);
values.forEach(function (value) {
var option = document.createElement('option');
if (value !== false) {
option.setAttribute('value', value);
} else {
option.setAttribute('selected', 'selected');
}
input.appendChild(option);
});
container.appendChild(input);
}
Toolbar.DEFAULTS = {
container: null,
handlers: {
clean: function clean() {
var _this3 = this;
var range = this.quill.getSelection();
if (range == null) return;
if (range.length == 0) {
var formats = this.quill.getFormat();
Object.keys(formats).forEach(function (name) {
// Clean functionality in existing apps only clean inline formats
if (_parchment2.default.query(name, _parchment2.default.Scope.INLINE) != null) {
_this3.quill.format(name, false);
}
});
} else {
this.quill.removeFormat(range, _quill2.default.sources.USER);
}
},
direction: function direction(value) {
var align = this.quill.getFormat()['align'];
if (value === 'rtl' && align == null) {
this.quill.format('align', 'right', _quill2.default.sources.USER);
} else if (!value && align === 'right') {
this.quill.format('align', false, _quill2.default.sources.USER);
}
this.quill.format('direction', value, _quill2.default.sources.USER);
},
indent: function indent(value) {
var range = this.quill.getSelection();
var formats = this.quill.getFormat(range);
var indent = parseInt(formats.indent || 0);
if (value === '+1' || value === '-1') {
var modifier = value === '+1' ? 1 : -1;
if (formats.direction === 'rtl') modifier *= -1;
this.quill.format('indent', indent + modifier, _quill2.default.sources.USER);
}
},
link: function link(value) {
if (value === true) {
value = prompt('Enter link URL:');
}
this.quill.format('link', value, _quill2.default.sources.USER);
},
list: function list(value) {
var range = this.quill.getSelection();
var formats = this.quill.getFormat(range);
if (value === 'check') {
if (formats['list'] === 'checked' || formats['list'] === 'unchecked') {
this.quill.format('list', false, _quill2.default.sources.USER);
} else {
this.quill.format('list', 'unchecked', _quill2.default.sources.USER);
}
} else {
this.quill.format('list', value, _quill2.default.sources.USER);
}
}
}
};
exports.default = Toolbar;
exports.addControls = addControls;
/***/ }),
/* 58 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <polyline class=\"ql-even ql-stroke\" points=\"5 7 3 9 5 11\"></polyline> <polyline class=\"ql-even ql-stroke\" points=\"13 7 15 9 13 11\"></polyline> <line class=ql-stroke x1=10 x2=8 y1=5 y2=13></line> </svg>";
/***/ }),
/* 59 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _picker = __webpack_require__(28);
var _picker2 = _interopRequireDefault(_picker);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ColorPicker = function (_Picker) {
_inherits(ColorPicker, _Picker);
function ColorPicker(select, label) {
_classCallCheck(this, ColorPicker);
var _this = _possibleConstructorReturn(this, (ColorPicker.__proto__ || Object.getPrototypeOf(ColorPicker)).call(this, select));
_this.label.innerHTML = label;
_this.container.classList.add('ql-color-picker');
[].slice.call(_this.container.querySelectorAll('.ql-picker-item'), 0, 7).forEach(function (item) {
item.classList.add('ql-primary');
});
return _this;
}
_createClass(ColorPicker, [{
key: 'buildItem',
value: function buildItem(option) {
var item = _get(ColorPicker.prototype.__proto__ || Object.getPrototypeOf(ColorPicker.prototype), 'buildItem', this).call(this, option);
item.style.backgroundColor = option.getAttribute('value') || '';
return item;
}
}, {
key: 'selectItem',
value: function selectItem(item, trigger) {
_get(ColorPicker.prototype.__proto__ || Object.getPrototypeOf(ColorPicker.prototype), 'selectItem', this).call(this, item, trigger);
var colorLabel = this.label.querySelector('.ql-color-label');
var value = item ? item.getAttribute('data-value') || '' : '';
if (colorLabel) {
if (colorLabel.tagName === 'line') {
colorLabel.style.stroke = value;
} else {
colorLabel.style.fill = value;
}
}
}
}]);
return ColorPicker;
}(_picker2.default);
exports.default = ColorPicker;
/***/ }),
/* 60 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _picker = __webpack_require__(28);
var _picker2 = _interopRequireDefault(_picker);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var IconPicker = function (_Picker) {
_inherits(IconPicker, _Picker);
function IconPicker(select, icons) {
_classCallCheck(this, IconPicker);
var _this = _possibleConstructorReturn(this, (IconPicker.__proto__ || Object.getPrototypeOf(IconPicker)).call(this, select));
_this.container.classList.add('ql-icon-picker');
[].forEach.call(_this.container.querySelectorAll('.ql-picker-item'), function (item) {
item.innerHTML = icons[item.getAttribute('data-value') || ''];
});
_this.defaultItem = _this.container.querySelector('.ql-selected');
_this.selectItem(_this.defaultItem);
return _this;
}
_createClass(IconPicker, [{
key: 'selectItem',
value: function selectItem(item, trigger) {
_get(IconPicker.prototype.__proto__ || Object.getPrototypeOf(IconPicker.prototype), 'selectItem', this).call(this, item, trigger);
item = item || this.defaultItem;
this.label.innerHTML = item.innerHTML;
}
}]);
return IconPicker;
}(_picker2.default);
exports.default = IconPicker;
/***/ }),
/* 61 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Tooltip = function () {
function Tooltip(quill, boundsContainer) {
var _this = this;
_classCallCheck(this, Tooltip);
this.quill = quill;
this.boundsContainer = boundsContainer || document.body;
this.root = quill.addContainer('ql-tooltip');
this.root.innerHTML = this.constructor.TEMPLATE;
if (this.quill.root === this.quill.scrollingContainer) {
this.quill.root.addEventListener('scroll', function () {
_this.root.style.marginTop = -1 * _this.quill.root.scrollTop + 'px';
});
}
this.hide();
}
_createClass(Tooltip, [{
key: 'hide',
value: function hide() {
this.root.classList.add('ql-hidden');
}
}, {
key: 'position',
value: function position(reference) {
var left = reference.left + reference.width / 2 - this.root.offsetWidth / 2;
// root.scrollTop should be 0 if scrollContainer !== root
var top = reference.bottom + this.quill.root.scrollTop;
this.root.style.left = left + 'px';
this.root.style.top = top + 'px';
this.root.classList.remove('ql-flip');
var containerBounds = this.boundsContainer.getBoundingClientRect();
var rootBounds = this.root.getBoundingClientRect();
var shift = 0;
if (rootBounds.right > containerBounds.right) {
shift = containerBounds.right - rootBounds.right;
this.root.style.left = left + shift + 'px';
}
if (rootBounds.left < containerBounds.left) {
shift = containerBounds.left - rootBounds.left;
this.root.style.left = left + shift + 'px';
}
if (rootBounds.bottom > containerBounds.bottom) {
var height = rootBounds.bottom - rootBounds.top;
var verticalShift = reference.bottom - reference.top + height;
this.root.style.top = top - verticalShift + 'px';
this.root.classList.add('ql-flip');
}
return shift;
}
}, {
key: 'show',
value: function show() {
this.root.classList.remove('ql-editing');
this.root.classList.remove('ql-hidden');
}
}]);
return Tooltip;
}();
exports.default = Tooltip;
/***/ }),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _extend = __webpack_require__(3);
var _extend2 = _interopRequireDefault(_extend);
var _emitter = __webpack_require__(8);
var _emitter2 = _interopRequireDefault(_emitter);
var _base = __webpack_require__(43);
var _base2 = _interopRequireDefault(_base);
var _link = __webpack_require__(27);
var _link2 = _interopRequireDefault(_link);
var _selection = __webpack_require__(15);
var _icons = __webpack_require__(41);
var _icons2 = _interopRequireDefault(_icons);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var TOOLBAR_CONFIG = [[{ header: ['1', '2', '3', false] }], ['bold', 'italic', 'underline', 'link'], [{ list: 'ordered' }, { list: 'bullet' }], ['clean']];
var SnowTheme = function (_BaseTheme) {
_inherits(SnowTheme, _BaseTheme);
function SnowTheme(quill, options) {
_classCallCheck(this, SnowTheme);
if (options.modules.toolbar != null && options.modules.toolbar.container == null) {
options.modules.toolbar.container = TOOLBAR_CONFIG;
}
var _this = _possibleConstructorReturn(this, (SnowTheme.__proto__ || Object.getPrototypeOf(SnowTheme)).call(this, quill, options));
_this.quill.container.classList.add('ql-snow');
return _this;
}
_createClass(SnowTheme, [{
key: 'extendToolbar',
value: function extendToolbar(toolbar) {
toolbar.container.classList.add('ql-snow');
this.buildButtons([].slice.call(toolbar.container.querySelectorAll('button')), _icons2.default);
this.buildPickers([].slice.call(toolbar.container.querySelectorAll('select')), _icons2.default);
this.tooltip = new SnowTooltip(this.quill, this.options.bounds);
if (toolbar.container.querySelector('.ql-link')) {
this.quill.keyboard.addBinding({ key: 'K', shortKey: true }, function (range, context) {
toolbar.handlers['link'].call(toolbar, !context.format.link);
});
}
}
}]);
return SnowTheme;
}(_base2.default);
SnowTheme.DEFAULTS = (_extend2.default)(true, {}, _base2.default.DEFAULTS, {
modules: {
toolbar: {
handlers: {
link: function link(value) {
if (value) {
var range = this.quill.getSelection();
if (range == null || range.length == 0) return;
var preview = this.quill.getText(range);
if (/^\S+@\S+\.\S+$/.test(preview) && preview.indexOf('mailto:') !== 0) {
preview = 'mailto:' + preview;
}
var tooltip = this.quill.theme.tooltip;
tooltip.edit('link', preview);
} else {
this.quill.format('link', false);
}
}
}
}
}
});
var SnowTooltip = function (_BaseTooltip) {
_inherits(SnowTooltip, _BaseTooltip);
function SnowTooltip(quill, bounds) {
_classCallCheck(this, SnowTooltip);
var _this2 = _possibleConstructorReturn(this, (SnowTooltip.__proto__ || Object.getPrototypeOf(SnowTooltip)).call(this, quill, bounds));
_this2.preview = _this2.root.querySelector('a.ql-preview');
return _this2;
}
_createClass(SnowTooltip, [{
key: 'listen',
value: function listen() {
var _this3 = this;
_get(SnowTooltip.prototype.__proto__ || Object.getPrototypeOf(SnowTooltip.prototype), 'listen', this).call(this);
this.root.querySelector('a.ql-action').addEventListener('click', function (event) {
if (_this3.root.classList.contains('ql-editing')) {
_this3.save();
} else {
_this3.edit('link', _this3.preview.textContent);
}
event.preventDefault();
});
this.root.querySelector('a.ql-remove').addEventListener('click', function (event) {
if (_this3.linkRange != null) {
var range = _this3.linkRange;
_this3.restoreFocus();
_this3.quill.formatText(range, 'link', false, _emitter2.default.sources.USER);
delete _this3.linkRange;
}
event.preventDefault();
_this3.hide();
});
this.quill.on(_emitter2.default.events.SELECTION_CHANGE, function (range, oldRange, source) {
if (range == null) return;
if (range.length === 0 && source === _emitter2.default.sources.USER) {
var _quill$scroll$descend = _this3.quill.scroll.descendant(_link2.default, range.index),
_quill$scroll$descend2 = _slicedToArray(_quill$scroll$descend, 2),
link = _quill$scroll$descend2[0],
offset = _quill$scroll$descend2[1];
if (link != null) {
_this3.linkRange = new _selection.Range(range.index - offset, link.length());
var preview = _link2.default.formats(link.domNode);
_this3.preview.textContent = preview;
_this3.preview.setAttribute('href', preview);
_this3.show();
_this3.position(_this3.quill.getBounds(_this3.linkRange));
return;
}
} else {
delete _this3.linkRange;
}
_this3.hide();
});
}
}, {
key: 'show',
value: function show() {
_get(SnowTooltip.prototype.__proto__ || Object.getPrototypeOf(SnowTooltip.prototype), 'show', this).call(this);
this.root.removeAttribute('data-mode');
}
}]);
return SnowTooltip;
}(_base.BaseTooltip);
SnowTooltip.TEMPLATE = ['<a class="ql-preview" target="_blank" href="about:blank"></a>', '<input type="text" data-formula="e=mc^2" data-link="https://quilljs.com" data-video="Embed URL">', '<a class="ql-action"></a>', '<a class="ql-remove"></a>'].join('');
exports.default = SnowTheme;
/***/ }),
/* 63 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _core = __webpack_require__(29);
var _core2 = _interopRequireDefault(_core);
var _align = __webpack_require__(36);
var _direction = __webpack_require__(38);
var _indent = __webpack_require__(64);
var _blockquote = __webpack_require__(65);
var _blockquote2 = _interopRequireDefault(_blockquote);
var _header = __webpack_require__(66);
var _header2 = _interopRequireDefault(_header);
var _list = __webpack_require__(67);
var _list2 = _interopRequireDefault(_list);
var _background = __webpack_require__(37);
var _color = __webpack_require__(26);
var _font = __webpack_require__(39);
var _size = __webpack_require__(40);
var _bold = __webpack_require__(56);
var _bold2 = _interopRequireDefault(_bold);
var _italic = __webpack_require__(68);
var _italic2 = _interopRequireDefault(_italic);
var _link = __webpack_require__(27);
var _link2 = _interopRequireDefault(_link);
var _script = __webpack_require__(69);
var _script2 = _interopRequireDefault(_script);
var _strike = __webpack_require__(70);
var _strike2 = _interopRequireDefault(_strike);
var _underline = __webpack_require__(71);
var _underline2 = _interopRequireDefault(_underline);
var _image = __webpack_require__(72);
var _image2 = _interopRequireDefault(_image);
var _video = __webpack_require__(73);
var _video2 = _interopRequireDefault(_video);
var _code = __webpack_require__(13);
var _code2 = _interopRequireDefault(_code);
var _formula = __webpack_require__(74);
var _formula2 = _interopRequireDefault(_formula);
var _syntax = __webpack_require__(75);
var _syntax2 = _interopRequireDefault(_syntax);
var _toolbar = __webpack_require__(57);
var _toolbar2 = _interopRequireDefault(_toolbar);
var _icons = __webpack_require__(41);
var _icons2 = _interopRequireDefault(_icons);
var _picker = __webpack_require__(28);
var _picker2 = _interopRequireDefault(_picker);
var _colorPicker = __webpack_require__(59);
var _colorPicker2 = _interopRequireDefault(_colorPicker);
var _iconPicker = __webpack_require__(60);
var _iconPicker2 = _interopRequireDefault(_iconPicker);
var _tooltip = __webpack_require__(61);
var _tooltip2 = _interopRequireDefault(_tooltip);
var _bubble = __webpack_require__(108);
var _bubble2 = _interopRequireDefault(_bubble);
var _snow = __webpack_require__(62);
var _snow2 = _interopRequireDefault(_snow);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
_core2.default.register({
'attributors/attribute/direction': _direction.DirectionAttribute,
'attributors/class/align': _align.AlignClass,
'attributors/class/background': _background.BackgroundClass,
'attributors/class/color': _color.ColorClass,
'attributors/class/direction': _direction.DirectionClass,
'attributors/class/font': _font.FontClass,
'attributors/class/size': _size.SizeClass,
'attributors/style/align': _align.AlignStyle,
'attributors/style/background': _background.BackgroundStyle,
'attributors/style/color': _color.ColorStyle,
'attributors/style/direction': _direction.DirectionStyle,
'attributors/style/font': _font.FontStyle,
'attributors/style/size': _size.SizeStyle
}, true);
_core2.default.register({
'formats/align': _align.AlignClass,
'formats/direction': _direction.DirectionClass,
'formats/indent': _indent.IndentClass,
'formats/background': _background.BackgroundStyle,
'formats/color': _color.ColorStyle,
'formats/font': _font.FontClass,
'formats/size': _size.SizeClass,
'formats/blockquote': _blockquote2.default,
'formats/code-block': _code2.default,
'formats/header': _header2.default,
'formats/list': _list2.default,
'formats/bold': _bold2.default,
'formats/code': _code.Code,
'formats/italic': _italic2.default,
'formats/link': _link2.default,
'formats/script': _script2.default,
'formats/strike': _strike2.default,
'formats/underline': _underline2.default,
'formats/image': _image2.default,
'formats/video': _video2.default,
'formats/list/item': _list.ListItem,
'modules/formula': _formula2.default,
'modules/syntax': _syntax2.default,
'modules/toolbar': _toolbar2.default,
'themes/bubble': _bubble2.default,
'themes/snow': _snow2.default,
'ui/icons': _icons2.default,
'ui/picker': _picker2.default,
'ui/icon-picker': _iconPicker2.default,
'ui/color-picker': _colorPicker2.default,
'ui/tooltip': _tooltip2.default
}, true);
exports.default = _core2.default;
/***/ }),
/* 64 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.IndentClass = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var IdentAttributor = function (_Parchment$Attributor) {
_inherits(IdentAttributor, _Parchment$Attributor);
function IdentAttributor() {
_classCallCheck(this, IdentAttributor);
return _possibleConstructorReturn(this, (IdentAttributor.__proto__ || Object.getPrototypeOf(IdentAttributor)).apply(this, arguments));
}
_createClass(IdentAttributor, [{
key: 'add',
value: function add(node, value) {
if (value === '+1' || value === '-1') {
var indent = this.value(node) || 0;
value = value === '+1' ? indent + 1 : indent - 1;
}
if (value === 0) {
this.remove(node);
return true;
} else {
return _get(IdentAttributor.prototype.__proto__ || Object.getPrototypeOf(IdentAttributor.prototype), 'add', this).call(this, node, value);
}
}
}, {
key: 'canAdd',
value: function canAdd(node, value) {
return _get(IdentAttributor.prototype.__proto__ || Object.getPrototypeOf(IdentAttributor.prototype), 'canAdd', this).call(this, node, value) || _get(IdentAttributor.prototype.__proto__ || Object.getPrototypeOf(IdentAttributor.prototype), 'canAdd', this).call(this, node, parseInt(value));
}
}, {
key: 'value',
value: function value(node) {
return parseInt(_get(IdentAttributor.prototype.__proto__ || Object.getPrototypeOf(IdentAttributor.prototype), 'value', this).call(this, node)) || undefined; // Don't return NaN
}
}]);
return IdentAttributor;
}(_parchment2.default.Attributor.Class);
var IndentClass = new IdentAttributor('indent', 'ql-indent', {
scope: _parchment2.default.Scope.BLOCK,
whitelist: [1, 2, 3, 4, 5, 6, 7, 8]
});
exports.IndentClass = IndentClass;
/***/ }),
/* 65 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _block = __webpack_require__(4);
var _block2 = _interopRequireDefault(_block);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Blockquote = function (_Block) {
_inherits(Blockquote, _Block);
function Blockquote() {
_classCallCheck(this, Blockquote);
return _possibleConstructorReturn(this, (Blockquote.__proto__ || Object.getPrototypeOf(Blockquote)).apply(this, arguments));
}
return Blockquote;
}(_block2.default);
Blockquote.blotName = 'blockquote';
Blockquote.tagName = 'blockquote';
exports.default = Blockquote;
/***/ }),
/* 66 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _block = __webpack_require__(4);
var _block2 = _interopRequireDefault(_block);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Header = function (_Block) {
_inherits(Header, _Block);
function Header() {
_classCallCheck(this, Header);
return _possibleConstructorReturn(this, (Header.__proto__ || Object.getPrototypeOf(Header)).apply(this, arguments));
}
_createClass(Header, null, [{
key: 'formats',
value: function formats(domNode) {
return this.tagName.indexOf(domNode.tagName) + 1;
}
}]);
return Header;
}(_block2.default);
Header.blotName = 'header';
Header.tagName = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'];
exports.default = Header;
/***/ }),
/* 67 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.ListItem = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _block = __webpack_require__(4);
var _block2 = _interopRequireDefault(_block);
var _container = __webpack_require__(25);
var _container2 = _interopRequireDefault(_container);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ListItem = function (_Block) {
_inherits(ListItem, _Block);
function ListItem() {
_classCallCheck(this, ListItem);
return _possibleConstructorReturn(this, (ListItem.__proto__ || Object.getPrototypeOf(ListItem)).apply(this, arguments));
}
_createClass(ListItem, [{
key: 'format',
value: function format(name, value) {
if (name === List.blotName && !value) {
this.replaceWith(_parchment2.default.create(this.statics.scope));
} else {
_get(ListItem.prototype.__proto__ || Object.getPrototypeOf(ListItem.prototype), 'format', this).call(this, name, value);
}
}
}, {
key: 'remove',
value: function remove() {
if (this.prev == null && this.next == null) {
this.parent.remove();
} else {
_get(ListItem.prototype.__proto__ || Object.getPrototypeOf(ListItem.prototype), 'remove', this).call(this);
}
}
}, {
key: 'replaceWith',
value: function replaceWith(name, value) {
this.parent.isolate(this.offset(this.parent), this.length());
if (name === this.parent.statics.blotName) {
this.parent.replaceWith(name, value);
return this;
} else {
this.parent.unwrap();
return _get(ListItem.prototype.__proto__ || Object.getPrototypeOf(ListItem.prototype), 'replaceWith', this).call(this, name, value);
}
}
}], [{
key: 'formats',
value: function formats(domNode) {
return domNode.tagName === this.tagName ? undefined : _get(ListItem.__proto__ || Object.getPrototypeOf(ListItem), 'formats', this).call(this, domNode);
}
}]);
return ListItem;
}(_block2.default);
ListItem.blotName = 'list-item';
ListItem.tagName = 'LI';
var List = function (_Container) {
_inherits(List, _Container);
_createClass(List, null, [{
key: 'create',
value: function create(value) {
var tagName = value === 'ordered' ? 'OL' : 'UL';
var node = _get(List.__proto__ || Object.getPrototypeOf(List), 'create', this).call(this, tagName);
if (value === 'checked' || value === 'unchecked') {
node.setAttribute('data-checked', value === 'checked');
}
return node;
}
}, {
key: 'formats',
value: function formats(domNode) {
if (domNode.tagName === 'OL') return 'ordered';
if (domNode.tagName === 'UL') {
if (domNode.hasAttribute('data-checked')) {
return domNode.getAttribute('data-checked') === 'true' ? 'checked' : 'unchecked';
} else {
return 'bullet';
}
}
return undefined;
}
}]);
function List(domNode) {
_classCallCheck(this, List);
var _this2 = _possibleConstructorReturn(this, (List.__proto__ || Object.getPrototypeOf(List)).call(this, domNode));
var listEventHandler = function listEventHandler(e) {
if (e.target.parentNode !== domNode) return;
var format = _this2.statics.formats(domNode);
var blot = _parchment2.default.find(e.target);
if (format === 'checked') {
blot.format('list', 'unchecked');
} else if (format === 'unchecked') {
blot.format('list', 'checked');
}
};
domNode.addEventListener('touchstart', listEventHandler);
domNode.addEventListener('mousedown', listEventHandler);
return _this2;
}
_createClass(List, [{
key: 'format',
value: function format(name, value) {
if (this.children.length > 0) {
this.children.tail.format(name, value);
}
}
}, {
key: 'formats',
value: function formats() {
// We don't inherit from FormatBlot
return _defineProperty({}, this.statics.blotName, this.statics.formats(this.domNode));
}
}, {
key: 'insertBefore',
value: function insertBefore(blot, ref) {
if (blot instanceof ListItem) {
_get(List.prototype.__proto__ || Object.getPrototypeOf(List.prototype), 'insertBefore', this).call(this, blot, ref);
} else {
var index = ref == null ? this.length() : ref.offset(this);
var after = this.split(index);
after.parent.insertBefore(blot, after);
}
}
}, {
key: 'optimize',
value: function optimize(context) {
_get(List.prototype.__proto__ || Object.getPrototypeOf(List.prototype), 'optimize', this).call(this, context);
var next = this.next;
if (next != null && next.prev === this && next.statics.blotName === this.statics.blotName && next.domNode.tagName === this.domNode.tagName && next.domNode.getAttribute('data-checked') === this.domNode.getAttribute('data-checked')) {
next.moveChildren(this);
next.remove();
}
}
}, {
key: 'replace',
value: function replace(target) {
if (target.statics.blotName !== this.statics.blotName) {
var item = _parchment2.default.create(this.statics.defaultChild);
target.moveChildren(item);
this.appendChild(item);
}
_get(List.prototype.__proto__ || Object.getPrototypeOf(List.prototype), 'replace', this).call(this, target);
}
}]);
return List;
}(_container2.default);
List.blotName = 'list';
List.scope = _parchment2.default.Scope.BLOCK_BLOT;
List.tagName = ['OL', 'UL'];
List.defaultChild = 'list-item';
List.allowedChildren = [ListItem];
exports.ListItem = ListItem;
exports.default = List;
/***/ }),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _bold = __webpack_require__(56);
var _bold2 = _interopRequireDefault(_bold);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Italic = function (_Bold) {
_inherits(Italic, _Bold);
function Italic() {
_classCallCheck(this, Italic);
return _possibleConstructorReturn(this, (Italic.__proto__ || Object.getPrototypeOf(Italic)).apply(this, arguments));
}
return Italic;
}(_bold2.default);
Italic.blotName = 'italic';
Italic.tagName = ['EM', 'I'];
exports.default = Italic;
/***/ }),
/* 69 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _inline = __webpack_require__(6);
var _inline2 = _interopRequireDefault(_inline);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Script = function (_Inline) {
_inherits(Script, _Inline);
function Script() {
_classCallCheck(this, Script);
return _possibleConstructorReturn(this, (Script.__proto__ || Object.getPrototypeOf(Script)).apply(this, arguments));
}
_createClass(Script, null, [{
key: 'create',
value: function create(value) {
if (value === 'super') {
return document.createElement('sup');
} else if (value === 'sub') {
return document.createElement('sub');
} else {
return _get(Script.__proto__ || Object.getPrototypeOf(Script), 'create', this).call(this, value);
}
}
}, {
key: 'formats',
value: function formats(domNode) {
if (domNode.tagName === 'SUB') return 'sub';
if (domNode.tagName === 'SUP') return 'super';
return undefined;
}
}]);
return Script;
}(_inline2.default);
Script.blotName = 'script';
Script.tagName = ['SUB', 'SUP'];
exports.default = Script;
/***/ }),
/* 70 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _inline = __webpack_require__(6);
var _inline2 = _interopRequireDefault(_inline);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Strike = function (_Inline) {
_inherits(Strike, _Inline);
function Strike() {
_classCallCheck(this, Strike);
return _possibleConstructorReturn(this, (Strike.__proto__ || Object.getPrototypeOf(Strike)).apply(this, arguments));
}
return Strike;
}(_inline2.default);
Strike.blotName = 'strike';
Strike.tagName = 'S';
exports.default = Strike;
/***/ }),
/* 71 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _inline = __webpack_require__(6);
var _inline2 = _interopRequireDefault(_inline);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Underline = function (_Inline) {
_inherits(Underline, _Inline);
function Underline() {
_classCallCheck(this, Underline);
return _possibleConstructorReturn(this, (Underline.__proto__ || Object.getPrototypeOf(Underline)).apply(this, arguments));
}
return Underline;
}(_inline2.default);
Underline.blotName = 'underline';
Underline.tagName = 'U';
exports.default = Underline;
/***/ }),
/* 72 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _link = __webpack_require__(27);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ATTRIBUTES = ['alt', 'height', 'width'];
var Image = function (_Parchment$Embed) {
_inherits(Image, _Parchment$Embed);
function Image() {
_classCallCheck(this, Image);
return _possibleConstructorReturn(this, (Image.__proto__ || Object.getPrototypeOf(Image)).apply(this, arguments));
}
_createClass(Image, [{
key: 'format',
value: function format(name, value) {
if (ATTRIBUTES.indexOf(name) > -1) {
if (value) {
this.domNode.setAttribute(name, value);
} else {
this.domNode.removeAttribute(name);
}
} else {
_get(Image.prototype.__proto__ || Object.getPrototypeOf(Image.prototype), 'format', this).call(this, name, value);
}
}
}], [{
key: 'create',
value: function create(value) {
var node = _get(Image.__proto__ || Object.getPrototypeOf(Image), 'create', this).call(this, value);
if (typeof value === 'string') {
node.setAttribute('src', this.sanitize(value));
}
return node;
}
}, {
key: 'formats',
value: function formats(domNode) {
return ATTRIBUTES.reduce(function (formats, attribute) {
if (domNode.hasAttribute(attribute)) {
formats[attribute] = domNode.getAttribute(attribute);
}
return formats;
}, {});
}
}, {
key: 'match',
value: function match(url) {
return (/\.(jpe?g|gif|png)$/.test(url) || /^data:image\/.+;base64/.test(url)
);
}
}, {
key: 'sanitize',
value: function sanitize(url) {
return (_link.sanitize)(url, ['http', 'https', 'data']) ? url : '//:0';
}
}, {
key: 'value',
value: function value(domNode) {
return domNode.getAttribute('src');
}
}]);
return Image;
}(_parchment2.default.Embed);
Image.blotName = 'image';
Image.tagName = 'IMG';
exports.default = Image;
/***/ }),
/* 73 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _block = __webpack_require__(4);
var _link = __webpack_require__(27);
var _link2 = _interopRequireDefault(_link);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var ATTRIBUTES = ['height', 'width'];
var Video = function (_BlockEmbed) {
_inherits(Video, _BlockEmbed);
function Video() {
_classCallCheck(this, Video);
return _possibleConstructorReturn(this, (Video.__proto__ || Object.getPrototypeOf(Video)).apply(this, arguments));
}
_createClass(Video, [{
key: 'format',
value: function format(name, value) {
if (ATTRIBUTES.indexOf(name) > -1) {
if (value) {
this.domNode.setAttribute(name, value);
} else {
this.domNode.removeAttribute(name);
}
} else {
_get(Video.prototype.__proto__ || Object.getPrototypeOf(Video.prototype), 'format', this).call(this, name, value);
}
}
}], [{
key: 'create',
value: function create(value) {
var node = _get(Video.__proto__ || Object.getPrototypeOf(Video), 'create', this).call(this, value);
node.setAttribute('frameborder', '0');
node.setAttribute('allowfullscreen', true);
node.setAttribute('src', this.sanitize(value));
return node;
}
}, {
key: 'formats',
value: function formats(domNode) {
return ATTRIBUTES.reduce(function (formats, attribute) {
if (domNode.hasAttribute(attribute)) {
formats[attribute] = domNode.getAttribute(attribute);
}
return formats;
}, {});
}
}, {
key: 'sanitize',
value: function sanitize(url) {
return _link2.default.sanitize(url);
}
}, {
key: 'value',
value: function value(domNode) {
return domNode.getAttribute('src');
}
}]);
return Video;
}(_block.BlockEmbed);
Video.blotName = 'video';
Video.className = 'ql-video';
Video.tagName = 'IFRAME';
exports.default = Video;
/***/ }),
/* 74 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.FormulaBlot = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _embed = __webpack_require__(35);
var _embed2 = _interopRequireDefault(_embed);
var _quill = __webpack_require__(5);
var _quill2 = _interopRequireDefault(_quill);
var _module = __webpack_require__(9);
var _module2 = _interopRequireDefault(_module);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var FormulaBlot = function (_Embed) {
_inherits(FormulaBlot, _Embed);
function FormulaBlot() {
_classCallCheck(this, FormulaBlot);
return _possibleConstructorReturn(this, (FormulaBlot.__proto__ || Object.getPrototypeOf(FormulaBlot)).apply(this, arguments));
}
_createClass(FormulaBlot, null, [{
key: 'create',
value: function create(value) {
var node = _get(FormulaBlot.__proto__ || Object.getPrototypeOf(FormulaBlot), 'create', this).call(this, value);
if (typeof value === 'string') {
window.katex.render(value, node, {
throwOnError: false,
errorColor: '#f00'
});
node.setAttribute('data-value', value);
}
return node;
}
}, {
key: 'value',
value: function value(domNode) {
return domNode.getAttribute('data-value');
}
}]);
return FormulaBlot;
}(_embed2.default);
FormulaBlot.blotName = 'formula';
FormulaBlot.className = 'ql-formula';
FormulaBlot.tagName = 'SPAN';
var Formula = function (_Module) {
_inherits(Formula, _Module);
_createClass(Formula, null, [{
key: 'register',
value: function register() {
_quill2.default.register(FormulaBlot, true);
}
}]);
function Formula() {
_classCallCheck(this, Formula);
var _this2 = _possibleConstructorReturn(this, (Formula.__proto__ || Object.getPrototypeOf(Formula)).call(this));
if (window.katex == null) {
throw new Error('Formula module requires KaTeX.');
}
return _this2;
}
return Formula;
}(_module2.default);
exports.FormulaBlot = FormulaBlot;
exports.default = Formula;
/***/ }),
/* 75 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.CodeToken = exports.CodeBlock = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _parchment = __webpack_require__(0);
var _parchment2 = _interopRequireDefault(_parchment);
var _quill = __webpack_require__(5);
var _quill2 = _interopRequireDefault(_quill);
var _module = __webpack_require__(9);
var _module2 = _interopRequireDefault(_module);
var _code = __webpack_require__(13);
var _code2 = _interopRequireDefault(_code);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var SyntaxCodeBlock = function (_CodeBlock) {
_inherits(SyntaxCodeBlock, _CodeBlock);
function SyntaxCodeBlock() {
_classCallCheck(this, SyntaxCodeBlock);
return _possibleConstructorReturn(this, (SyntaxCodeBlock.__proto__ || Object.getPrototypeOf(SyntaxCodeBlock)).apply(this, arguments));
}
_createClass(SyntaxCodeBlock, [{
key: 'replaceWith',
value: function replaceWith(block) {
this.domNode.textContent = this.domNode.textContent;
this.attach();
_get(SyntaxCodeBlock.prototype.__proto__ || Object.getPrototypeOf(SyntaxCodeBlock.prototype), 'replaceWith', this).call(this, block);
}
}, {
key: 'highlight',
value: function highlight(_highlight) {
var text = this.domNode.textContent;
if (this.cachedText !== text) {
if (text.trim().length > 0 || this.cachedText == null) {
this.domNode.innerHTML = _highlight(text);
this.domNode.normalize();
this.attach();
}
this.cachedText = text;
}
}
}]);
return SyntaxCodeBlock;
}(_code2.default);
SyntaxCodeBlock.className = 'ql-syntax';
var CodeToken = new _parchment2.default.Attributor.Class('token', 'hljs', {
scope: _parchment2.default.Scope.INLINE
});
var Syntax = function (_Module) {
_inherits(Syntax, _Module);
_createClass(Syntax, null, [{
key: 'register',
value: function register() {
_quill2.default.register(CodeToken, true);
_quill2.default.register(SyntaxCodeBlock, true);
}
}]);
function Syntax(quill, options) {
_classCallCheck(this, Syntax);
var _this2 = _possibleConstructorReturn(this, (Syntax.__proto__ || Object.getPrototypeOf(Syntax)).call(this, quill, options));
if (typeof _this2.options.highlight !== 'function') {
throw new Error('Syntax module requires highlight.js. Please include the library on the page before Quill.');
}
var timer = null;
_this2.quill.on(_quill2.default.events.SCROLL_OPTIMIZE, function () {
clearTimeout(timer);
timer = setTimeout(function () {
_this2.highlight();
timer = null;
}, _this2.options.interval);
});
_this2.highlight();
return _this2;
}
_createClass(Syntax, [{
key: 'highlight',
value: function highlight() {
var _this3 = this;
if (this.quill.selection.composing) return;
this.quill.update(_quill2.default.sources.USER);
var range = this.quill.getSelection();
this.quill.scroll.descendants(SyntaxCodeBlock).forEach(function (code) {
code.highlight(_this3.options.highlight);
});
this.quill.update(_quill2.default.sources.SILENT);
if (range != null) {
this.quill.setSelection(range, _quill2.default.sources.SILENT);
}
}
}]);
return Syntax;
}(_module2.default);
Syntax.DEFAULTS = {
highlight: function () {
if (window.hljs == null) return null;
return function (text) {
var result = window.hljs.highlightAuto(text);
return result.value;
};
}(),
interval: 1000
};
exports.CodeBlock = SyntaxCodeBlock;
exports.CodeToken = CodeToken;
exports.default = Syntax;
/***/ }),
/* 76 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=3 x2=15 y1=9 y2=9></line> <line class=ql-stroke x1=3 x2=13 y1=14 y2=14></line> <line class=ql-stroke x1=3 x2=9 y1=4 y2=4></line> </svg>";
/***/ }),
/* 77 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=15 x2=3 y1=9 y2=9></line> <line class=ql-stroke x1=14 x2=4 y1=14 y2=14></line> <line class=ql-stroke x1=12 x2=6 y1=4 y2=4></line> </svg>";
/***/ }),
/* 78 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=15 x2=3 y1=9 y2=9></line> <line class=ql-stroke x1=15 x2=5 y1=14 y2=14></line> <line class=ql-stroke x1=15 x2=9 y1=4 y2=4></line> </svg>";
/***/ }),
/* 79 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=15 x2=3 y1=9 y2=9></line> <line class=ql-stroke x1=15 x2=3 y1=14 y2=14></line> <line class=ql-stroke x1=15 x2=3 y1=4 y2=4></line> </svg>";
/***/ }),
/* 80 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <g class=\"ql-fill ql-color-label\"> <polygon points=\"6 6.868 6 6 5 6 5 7 5.942 7 6 6.868\"></polygon> <rect height=1 width=1 x=4 y=4></rect> <polygon points=\"6.817 5 6 5 6 6 6.38 6 6.817 5\"></polygon> <rect height=1 width=1 x=2 y=6></rect> <rect height=1 width=1 x=3 y=5></rect> <rect height=1 width=1 x=4 y=7></rect> <polygon points=\"4 11.439 4 11 3 11 3 12 3.755 12 4 11.439\"></polygon> <rect height=1 width=1 x=2 y=12></rect> <rect height=1 width=1 x=2 y=9></rect> <rect height=1 width=1 x=2 y=15></rect> <polygon points=\"4.63 10 4 10 4 11 4.192 11 4.63 10\"></polygon> <rect height=1 width=1 x=3 y=8></rect> <path d=M10.832,4.2L11,4.582V4H10.708A1.948,1.948,0,0,1,10.832,4.2Z></path> <path d=M7,4.582L7.168,4.2A1.929,1.929,0,0,1,7.292,4H7V4.582Z></path> <path d=M8,13H7.683l-0.351.8a1.933,1.933,0,0,1-.124.2H8V13Z></path> <rect height=1 width=1 x=12 y=2></rect> <rect height=1 width=1 x=11 y=3></rect> <path d=M9,3H8V3.282A1.985,1.985,0,0,1,9,3Z></path> <rect height=1 width=1 x=2 y=3></rect> <rect height=1 width=1 x=6 y=2></rect> <rect height=1 width=1 x=3 y=2></rect> <rect height=1 width=1 x=5 y=3></rect> <rect height=1 width=1 x=9 y=2></rect> <rect height=1 width=1 x=15 y=14></rect> <polygon points=\"13.447 10.174 13.469 10.225 13.472 10.232 13.808 11 14 11 14 10 13.37 10 13.447 10.174\"></polygon> <rect height=1 width=1 x=13 y=7></rect> <rect height=1 width=1 x=15 y=5></rect> <rect height=1 width=1 x=14 y=6></rect> <rect height=1 width=1 x=15 y=8></rect> <rect height=1 width=1 x=14 y=9></rect> <path d=M3.775,14H3v1H4V14.314A1.97,1.97,0,0,1,3.775,14Z></path> <rect height=1 width=1 x=14 y=3></rect> <polygon points=\"12 6.868 12 6 11.62 6 12 6.868\"></polygon> <rect height=1 width=1 x=15 y=2></rect> <rect height=1 width=1 x=12 y=5></rect> <rect height=1 width=1 x=13 y=4></rect> <polygon points=\"12.933 9 13 9 13 8 12.495 8 12.933 9\"></polygon> <rect height=1 width=1 x=9 y=14></rect> <rect height=1 width=1 x=8 y=15></rect> <path d=M6,14.926V15H7V14.316A1.993,1.993,0,0,1,6,14.926Z></path> <rect height=1 width=1 x=5 y=15></rect> <path d=M10.668,13.8L10.317,13H10v1h0.792A1.947,1.947,0,0,1,10.668,13.8Z></path> <rect height=1 width=1 x=11 y=15></rect> <path d=M14.332,12.2a1.99,1.99,0,0,1,.166.8H15V12H14.245Z></path> <rect height=1 width=1 x=14 y=15></rect> <rect height=1 width=1 x=15 y=11></rect> </g> <polyline class=ql-stroke points=\"5.5 13 9 5 12.5 13\"></polyline> <line class=ql-stroke x1=11.63 x2=6.38 y1=11 y2=11></line> </svg>";
/***/ }),
/* 81 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <rect class=\"ql-fill ql-stroke\" height=3 width=3 x=4 y=5></rect> <rect class=\"ql-fill ql-stroke\" height=3 width=3 x=11 y=5></rect> <path class=\"ql-even ql-fill ql-stroke\" d=M7,8c0,4.031-3,5-3,5></path> <path class=\"ql-even ql-fill ql-stroke\" d=M14,8c0,4.031-3,5-3,5></path> </svg>";
/***/ }),
/* 82 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-stroke d=M5,4H9.5A2.5,2.5,0,0,1,12,6.5v0A2.5,2.5,0,0,1,9.5,9H5A0,0,0,0,1,5,9V4A0,0,0,0,1,5,4Z></path> <path class=ql-stroke d=M5,9h5.5A2.5,2.5,0,0,1,13,11.5v0A2.5,2.5,0,0,1,10.5,14H5a0,0,0,0,1,0,0V9A0,0,0,0,1,5,9Z></path> </svg>";
/***/ }),
/* 83 */
/***/ (function(module, exports) {
module.exports = "<svg class=\"\" viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=5 x2=13 y1=3 y2=3></line> <line class=ql-stroke x1=6 x2=9.35 y1=12 y2=3></line> <line class=ql-stroke x1=11 x2=15 y1=11 y2=15></line> <line class=ql-stroke x1=15 x2=11 y1=11 y2=15></line> <rect class=ql-fill height=1 rx=0.5 ry=0.5 width=7 x=2 y=14></rect> </svg>";
/***/ }),
/* 84 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=\"ql-color-label ql-stroke ql-transparent\" x1=3 x2=15 y1=15 y2=15></line> <polyline class=ql-stroke points=\"5.5 11 9 3 12.5 11\"></polyline> <line class=ql-stroke x1=11.63 x2=6.38 y1=9 y2=9></line> </svg>";
/***/ }),
/* 85 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <polygon class=\"ql-stroke ql-fill\" points=\"3 11 5 9 3 7 3 11\"></polygon> <line class=\"ql-stroke ql-fill\" x1=15 x2=11 y1=4 y2=4></line> <path class=ql-fill d=M11,3a3,3,0,0,0,0,6h1V3H11Z></path> <rect class=ql-fill height=11 width=1 x=11 y=4></rect> <rect class=ql-fill height=11 width=1 x=13 y=4></rect> </svg>";
/***/ }),
/* 86 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <polygon class=\"ql-stroke ql-fill\" points=\"15 12 13 10 15 8 15 12\"></polygon> <line class=\"ql-stroke ql-fill\" x1=9 x2=5 y1=4 y2=4></line> <path class=ql-fill d=M5,3A3,3,0,0,0,5,9H6V3H5Z></path> <rect class=ql-fill height=11 width=1 x=5 y=4></rect> <rect class=ql-fill height=11 width=1 x=7 y=4></rect> </svg>";
/***/ }),
/* 87 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M14,16H4a1,1,0,0,1,0-2H14A1,1,0,0,1,14,16Z /> <path class=ql-fill d=M14,4H4A1,1,0,0,1,4,2H14A1,1,0,0,1,14,4Z /> <rect class=ql-fill x=3 y=6 width=12 height=6 rx=1 ry=1 /> </svg>";
/***/ }),
/* 88 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M13,16H5a1,1,0,0,1,0-2h8A1,1,0,0,1,13,16Z /> <path class=ql-fill d=M13,4H5A1,1,0,0,1,5,2h8A1,1,0,0,1,13,4Z /> <rect class=ql-fill x=2 y=6 width=14 height=6 rx=1 ry=1 /> </svg>";
/***/ }),
/* 89 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M15,8H13a1,1,0,0,1,0-2h2A1,1,0,0,1,15,8Z /> <path class=ql-fill d=M15,12H13a1,1,0,0,1,0-2h2A1,1,0,0,1,15,12Z /> <path class=ql-fill d=M15,16H5a1,1,0,0,1,0-2H15A1,1,0,0,1,15,16Z /> <path class=ql-fill d=M15,4H5A1,1,0,0,1,5,2H15A1,1,0,0,1,15,4Z /> <rect class=ql-fill x=2 y=6 width=8 height=6 rx=1 ry=1 /> </svg>";
/***/ }),
/* 90 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M5,8H3A1,1,0,0,1,3,6H5A1,1,0,0,1,5,8Z /> <path class=ql-fill d=M5,12H3a1,1,0,0,1,0-2H5A1,1,0,0,1,5,12Z /> <path class=ql-fill d=M13,16H3a1,1,0,0,1,0-2H13A1,1,0,0,1,13,16Z /> <path class=ql-fill d=M13,4H3A1,1,0,0,1,3,2H13A1,1,0,0,1,13,4Z /> <rect class=ql-fill x=8 y=6 width=8 height=6 rx=1 ry=1 transform=\"translate(24 18) rotate(-180)\"/> </svg>";
/***/ }),
/* 91 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M11.759,2.482a2.561,2.561,0,0,0-3.53.607A7.656,7.656,0,0,0,6.8,6.2C6.109,9.188,5.275,14.677,4.15,14.927a1.545,1.545,0,0,0-1.3-.933A0.922,0.922,0,0,0,2,15.036S1.954,16,4.119,16s3.091-2.691,3.7-5.553c0.177-.826.36-1.726,0.554-2.6L8.775,6.2c0.381-1.421.807-2.521,1.306-2.676a1.014,1.014,0,0,0,1.02.56A0.966,0.966,0,0,0,11.759,2.482Z></path> <rect class=ql-fill height=1.6 rx=0.8 ry=0.8 width=5 x=5.15 y=6.2></rect> <path class=ql-fill d=M13.663,12.027a1.662,1.662,0,0,1,.266-0.276q0.193,0.069.456,0.138a2.1,2.1,0,0,0,.535.069,1.075,1.075,0,0,0,.767-0.3,1.044,1.044,0,0,0,.314-0.8,0.84,0.84,0,0,0-.238-0.619,0.8,0.8,0,0,0-.594-0.239,1.154,1.154,0,0,0-.781.3,4.607,4.607,0,0,0-.781,1q-0.091.15-.218,0.346l-0.246.38c-0.068-.288-0.137-0.582-0.212-0.885-0.459-1.847-2.494-.984-2.941-0.8-0.482.2-.353,0.647-0.094,0.529a0.869,0.869,0,0,1,1.281.585c0.217,0.751.377,1.436,0.527,2.038a5.688,5.688,0,0,1-.362.467,2.69,2.69,0,0,1-.264.271q-0.221-.08-0.471-0.147a2.029,2.029,0,0,0-.522-0.066,1.079,1.079,0,0,0-.768.3A1.058,1.058,0,0,0,9,15.131a0.82,0.82,0,0,0,.832.852,1.134,1.134,0,0,0,.787-0.3,5.11,5.11,0,0,0,.776-0.993q0.141-.219.215-0.34c0.046-.076.122-0.194,0.223-0.346a2.786,2.786,0,0,0,.918,1.726,2.582,2.582,0,0,0,2.376-.185c0.317-.181.212-0.565,0-0.494A0.807,0.807,0,0,1,14.176,15a5.159,5.159,0,0,1-.913-2.446l0,0Q13.487,12.24,13.663,12.027Z></path> </svg>";
/***/ }),
/* 92 */
/***/ (function(module, exports) {
module.exports = "<svg viewBox=\"0 0 18 18\"> <path class=ql-fill d=M10,4V14a1,1,0,0,1-2,0V10H3v4a1,1,0,0,1-2,0V4A1,1,0,0,1,3,4V8H8V4a1,1,0,0,1,2,0Zm6.06787,9.209H14.98975V7.59863a.54085.54085,0,0,0-.605-.60547h-.62744a1.01119,1.01119,0,0,0-.748.29688L11.645,8.56641a.5435.5435,0,0,0-.022.8584l.28613.30762a.53861.53861,0,0,0,.84717.0332l.09912-.08789a1.2137,1.2137,0,0,0,.2417-.35254h.02246s-.01123.30859-.01123.60547V13.209H12.041a.54085.54085,0,0,0-.605.60547v.43945a.54085.54085,0,0,0,.605.60547h4.02686a.54085.54085,0,0,0,.605-.60547v-.43945A.54085.54085,0,0,0,16.06787,13.209Z /> </svg>";
/***/ }),
/* 93 */
/***/ (function(module, exports) {
module.exports = "<svg viewBox=\"0 0 18 18\"> <path class=ql-fill d=M16.73975,13.81445v.43945a.54085.54085,0,0,1-.605.60547H11.855a.58392.58392,0,0,1-.64893-.60547V14.0127c0-2.90527,3.39941-3.42187,3.39941-4.55469a.77675.77675,0,0,0-.84717-.78125,1.17684,1.17684,0,0,0-.83594.38477c-.2749.26367-.561.374-.85791.13184l-.4292-.34082c-.30811-.24219-.38525-.51758-.1543-.81445a2.97155,2.97155,0,0,1,2.45361-1.17676,2.45393,2.45393,0,0,1,2.68408,2.40918c0,2.45312-3.1792,2.92676-3.27832,3.93848h2.79443A.54085.54085,0,0,1,16.73975,13.81445ZM9,3A.99974.99974,0,0,0,8,4V8H3V4A1,1,0,0,0,1,4V14a1,1,0,0,0,2,0V10H8v4a1,1,0,0,0,2,0V4A.99974.99974,0,0,0,9,3Z /> </svg>";
/***/ }),
/* 94 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=7 x2=13 y1=4 y2=4></line> <line class=ql-stroke x1=5 x2=11 y1=14 y2=14></line> <line class=ql-stroke x1=8 x2=10 y1=14 y2=4></line> </svg>";
/***/ }),
/* 95 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <rect class=ql-stroke height=10 width=12 x=3 y=4></rect> <circle class=ql-fill cx=6 cy=7 r=1></circle> <polyline class=\"ql-even ql-fill\" points=\"5 12 5 11 7 9 8 10 11 7 13 9 13 12 5 12\"></polyline> </svg>";
/***/ }),
/* 96 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=3 x2=15 y1=14 y2=14></line> <line class=ql-stroke x1=3 x2=15 y1=4 y2=4></line> <line class=ql-stroke x1=9 x2=15 y1=9 y2=9></line> <polyline class=\"ql-fill ql-stroke\" points=\"3 7 3 11 5 9 3 7\"></polyline> </svg>";
/***/ }),
/* 97 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=3 x2=15 y1=14 y2=14></line> <line class=ql-stroke x1=3 x2=15 y1=4 y2=4></line> <line class=ql-stroke x1=9 x2=15 y1=9 y2=9></line> <polyline class=ql-stroke points=\"5 7 5 11 3 9 5 7\"></polyline> </svg>";
/***/ }),
/* 98 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=7 x2=11 y1=7 y2=11></line> <path class=\"ql-even ql-stroke\" d=M8.9,4.577a3.476,3.476,0,0,1,.36,4.679A3.476,3.476,0,0,1,4.577,8.9C3.185,7.5,2.035,6.4,4.217,4.217S7.5,3.185,8.9,4.577Z></path> <path class=\"ql-even ql-stroke\" d=M13.423,9.1a3.476,3.476,0,0,0-4.679-.36,3.476,3.476,0,0,0,.36,4.679c1.392,1.392,2.5,2.542,4.679.36S14.815,10.5,13.423,9.1Z></path> </svg>";
/***/ }),
/* 99 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=7 x2=15 y1=4 y2=4></line> <line class=ql-stroke x1=7 x2=15 y1=9 y2=9></line> <line class=ql-stroke x1=7 x2=15 y1=14 y2=14></line> <line class=\"ql-stroke ql-thin\" x1=2.5 x2=4.5 y1=5.5 y2=5.5></line> <path class=ql-fill d=M3.5,6A0.5,0.5,0,0,1,3,5.5V3.085l-0.276.138A0.5,0.5,0,0,1,2.053,3c-0.124-.247-0.023-0.324.224-0.447l1-.5A0.5,0.5,0,0,1,4,2.5v3A0.5,0.5,0,0,1,3.5,6Z></path> <path class=\"ql-stroke ql-thin\" d=M4.5,10.5h-2c0-.234,1.85-1.076,1.85-2.234A0.959,0.959,0,0,0,2.5,8.156></path> <path class=\"ql-stroke ql-thin\" d=M2.5,14.846a0.959,0.959,0,0,0,1.85-.109A0.7,0.7,0,0,0,3.75,14a0.688,0.688,0,0,0,.6-0.736,0.959,0.959,0,0,0-1.85-.109></path> </svg>";
/***/ }),
/* 100 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=6 x2=15 y1=4 y2=4></line> <line class=ql-stroke x1=6 x2=15 y1=9 y2=9></line> <line class=ql-stroke x1=6 x2=15 y1=14 y2=14></line> <line class=ql-stroke x1=3 x2=3 y1=4 y2=4></line> <line class=ql-stroke x1=3 x2=3 y1=9 y2=9></line> <line class=ql-stroke x1=3 x2=3 y1=14 y2=14></line> </svg>";
/***/ }),
/* 101 */
/***/ (function(module, exports) {
module.exports = "<svg class=\"\" viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=9 x2=15 y1=4 y2=4></line> <polyline class=ql-stroke points=\"3 4 4 5 6 3\"></polyline> <line class=ql-stroke x1=9 x2=15 y1=14 y2=14></line> <polyline class=ql-stroke points=\"3 14 4 15 6 13\"></polyline> <line class=ql-stroke x1=9 x2=15 y1=9 y2=9></line> <polyline class=ql-stroke points=\"3 9 4 10 6 8\"></polyline> </svg>";
/***/ }),
/* 102 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M15.5,15H13.861a3.858,3.858,0,0,0,1.914-2.975,1.8,1.8,0,0,0-1.6-1.751A1.921,1.921,0,0,0,12.021,11.7a0.50013,0.50013,0,1,0,.957.291h0a0.914,0.914,0,0,1,1.053-.725,0.81,0.81,0,0,1,.744.762c0,1.076-1.16971,1.86982-1.93971,2.43082A1.45639,1.45639,0,0,0,12,15.5a0.5,0.5,0,0,0,.5.5h3A0.5,0.5,0,0,0,15.5,15Z /> <path class=ql-fill d=M9.65,5.241a1,1,0,0,0-1.409.108L6,7.964,3.759,5.349A1,1,0,0,0,2.192,6.59178Q2.21541,6.6213,2.241,6.649L4.684,9.5,2.241,12.35A1,1,0,0,0,3.71,13.70722q0.02557-.02768.049-0.05722L6,11.036,8.241,13.65a1,1,0,1,0,1.567-1.24277Q9.78459,12.3777,9.759,12.35L7.316,9.5,9.759,6.651A1,1,0,0,0,9.65,5.241Z /> </svg>";
/***/ }),
/* 103 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M15.5,7H13.861a4.015,4.015,0,0,0,1.914-2.975,1.8,1.8,0,0,0-1.6-1.751A1.922,1.922,0,0,0,12.021,3.7a0.5,0.5,0,1,0,.957.291,0.917,0.917,0,0,1,1.053-.725,0.81,0.81,0,0,1,.744.762c0,1.077-1.164,1.925-1.934,2.486A1.423,1.423,0,0,0,12,7.5a0.5,0.5,0,0,0,.5.5h3A0.5,0.5,0,0,0,15.5,7Z /> <path class=ql-fill d=M9.651,5.241a1,1,0,0,0-1.41.108L6,7.964,3.759,5.349a1,1,0,1,0-1.519,1.3L4.683,9.5,2.241,12.35a1,1,0,1,0,1.519,1.3L6,11.036,8.241,13.65a1,1,0,0,0,1.519-1.3L7.317,9.5,9.759,6.651A1,1,0,0,0,9.651,5.241Z /> </svg>";
/***/ }),
/* 104 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=\"ql-stroke ql-thin\" x1=15.5 x2=2.5 y1=8.5 y2=9.5></line> <path class=ql-fill d=M9.007,8C6.542,7.791,6,7.519,6,6.5,6,5.792,7.283,5,9,5c1.571,0,2.765.679,2.969,1.309a1,1,0,0,0,1.9-.617C13.356,4.106,11.354,3,9,3,6.2,3,4,4.538,4,6.5a3.2,3.2,0,0,0,.5,1.843Z></path> <path class=ql-fill d=M8.984,10C11.457,10.208,12,10.479,12,11.5c0,0.708-1.283,1.5-3,1.5-1.571,0-2.765-.679-2.969-1.309a1,1,0,1,0-1.9.617C4.644,13.894,6.646,15,9,15c2.8,0,5-1.538,5-3.5a3.2,3.2,0,0,0-.5-1.843Z></path> </svg>";
/***/ }),
/* 105 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-stroke d=M5,3V9a4.012,4.012,0,0,0,4,4H9a4.012,4.012,0,0,0,4-4V3></path> <rect class=ql-fill height=1 rx=0.5 ry=0.5 width=12 x=3 y=15></rect> </svg>";
/***/ }),
/* 106 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <rect class=ql-stroke height=12 width=12 x=3 y=3></rect> <rect class=ql-fill height=12 width=1 x=5 y=3></rect> <rect class=ql-fill height=12 width=1 x=12 y=3></rect> <rect class=ql-fill height=2 width=8 x=5 y=8></rect> <rect class=ql-fill height=1 width=3 x=3 y=5></rect> <rect class=ql-fill height=1 width=3 x=3 y=7></rect> <rect class=ql-fill height=1 width=3 x=3 y=10></rect> <rect class=ql-fill height=1 width=3 x=3 y=12></rect> <rect class=ql-fill height=1 width=3 x=12 y=5></rect> <rect class=ql-fill height=1 width=3 x=12 y=7></rect> <rect class=ql-fill height=1 width=3 x=12 y=10></rect> <rect class=ql-fill height=1 width=3 x=12 y=12></rect> </svg>";
/***/ }),
/* 107 */
/***/ (function(module, exports) {
module.exports = "<svg viewbox=\"0 0 18 18\"> <polygon class=ql-stroke points=\"7 11 9 13 11 11 7 11\"></polygon> <polygon class=ql-stroke points=\"7 7 9 5 11 7 7 7\"></polygon> </svg>";
/***/ }),
/* 108 */
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.BubbleTooltip = undefined;
var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _extend = __webpack_require__(3);
var _extend2 = _interopRequireDefault(_extend);
var _emitter = __webpack_require__(8);
var _emitter2 = _interopRequireDefault(_emitter);
var _base = __webpack_require__(43);
var _base2 = _interopRequireDefault(_base);
var _selection = __webpack_require__(15);
var _icons = __webpack_require__(41);
var _icons2 = _interopRequireDefault(_icons);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var TOOLBAR_CONFIG = [['bold', 'italic', 'link'], [{ header: 1 }, { header: 2 }, 'blockquote']];
var BubbleTheme = function (_BaseTheme) {
_inherits(BubbleTheme, _BaseTheme);
function BubbleTheme(quill, options) {
_classCallCheck(this, BubbleTheme);
if (options.modules.toolbar != null && options.modules.toolbar.container == null) {
options.modules.toolbar.container = TOOLBAR_CONFIG;
}
var _this = _possibleConstructorReturn(this, (BubbleTheme.__proto__ || Object.getPrototypeOf(BubbleTheme)).call(this, quill, options));
_this.quill.container.classList.add('ql-bubble');
return _this;
}
_createClass(BubbleTheme, [{
key: 'extendToolbar',
value: function extendToolbar(toolbar) {
this.tooltip = new BubbleTooltip(this.quill, this.options.bounds);
this.tooltip.root.appendChild(toolbar.container);
this.buildButtons([].slice.call(toolbar.container.querySelectorAll('button')), _icons2.default);
this.buildPickers([].slice.call(toolbar.container.querySelectorAll('select')), _icons2.default);
}
}]);
return BubbleTheme;
}(_base2.default);
BubbleTheme.DEFAULTS = (_extend2.default)(true, {}, _base2.default.DEFAULTS, {
modules: {
toolbar: {
handlers: {
link: function link(value) {
if (!value) {
this.quill.format('link', false);
} else {
this.quill.theme.tooltip.edit();
}
}
}
}
}
});
var BubbleTooltip = function (_BaseTooltip) {
_inherits(BubbleTooltip, _BaseTooltip);
function BubbleTooltip(quill, bounds) {
_classCallCheck(this, BubbleTooltip);
var _this2 = _possibleConstructorReturn(this, (BubbleTooltip.__proto__ || Object.getPrototypeOf(BubbleTooltip)).call(this, quill, bounds));
_this2.quill.on(_emitter2.default.events.EDITOR_CHANGE, function (type, range, oldRange, source) {
if (type !== _emitter2.default.events.SELECTION_CHANGE) return;
if (range != null && range.length > 0 && source === _emitter2.default.sources.USER) {
_this2.show();
// Lock our width so we will expand beyond our offsetParent boundaries
_this2.root.style.left = '0px';
_this2.root.style.width = '';
_this2.root.style.width = _this2.root.offsetWidth + 'px';
var lines = _this2.quill.getLines(range.index, range.length);
if (lines.length === 1) {
_this2.position(_this2.quill.getBounds(range));
} else {
var lastLine = lines[lines.length - 1];
var index = _this2.quill.getIndex(lastLine);
var length = Math.min(lastLine.length() - 1, range.index + range.length - index);
var _bounds = _this2.quill.getBounds(new _selection.Range(index, length));
_this2.position(_bounds);
}
} else if (document.activeElement !== _this2.textbox && _this2.quill.hasFocus()) {
_this2.hide();
}
});
return _this2;
}
_createClass(BubbleTooltip, [{
key: 'listen',
value: function listen() {
var _this3 = this;
_get(BubbleTooltip.prototype.__proto__ || Object.getPrototypeOf(BubbleTooltip.prototype), 'listen', this).call(this);
this.root.querySelector('.ql-close').addEventListener('click', function () {
_this3.root.classList.remove('ql-editing');
});
this.quill.on(_emitter2.default.events.SCROLL_OPTIMIZE, function () {
// Let selection be restored by toolbar handlers before repositioning
setTimeout(function () {
if (_this3.root.classList.contains('ql-hidden')) return;
var range = _this3.quill.getSelection();
if (range != null) {
_this3.position(_this3.quill.getBounds(range));
}
}, 1);
});
}
}, {
key: 'cancel',
value: function cancel() {
this.show();
}
}, {
key: 'position',
value: function position(reference) {
var shift = _get(BubbleTooltip.prototype.__proto__ || Object.getPrototypeOf(BubbleTooltip.prototype), 'position', this).call(this, reference);
var arrow = this.root.querySelector('.ql-tooltip-arrow');
arrow.style.marginLeft = '';
if (shift === 0) return shift;
arrow.style.marginLeft = -1 * shift - arrow.offsetWidth / 2 + 'px';
}
}]);
return BubbleTooltip;
}(_base.BaseTooltip);
BubbleTooltip.TEMPLATE = ['<span class="ql-tooltip-arrow"></span>', '<div class="ql-tooltip-editor">', '<input type="text" data-formula="e=mc^2" data-link="https://quilljs.com" data-video="Embed URL">', '<a class="ql-close"></a>', '</div>'].join('');
exports.BubbleTooltip = BubbleTooltip;
exports.default = BubbleTheme;
/***/ }),
/* 109 */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(63);
/***/ })
/******/ ])["default"];
});
});
var Quill = unwrapExports(quill);
const Y$$1 = Y$1;
const connector = { name: 'test', url: 'http://localhost:1234' };
Y$$1.test = TestConnector;
function getStateSet (y) {
let ss = {};
for (let [user, clock] of y.ss.state) {
ss[user] = clock;
}
return ss
}
function getDeleteSet (y) {
var ds = {};
y.ds.iterate(null, null, function (n) {
var user = n._id.user;
var counter = n._id.clock;
var len = n.len;
var gc = n.gc;
var dv = ds[user];
if (dv === void 0) {
dv = [];
ds[user] = dv;
}
dv.push([counter, len, gc]);
});
return ds
}
/*
* 1. reconnect and flush all
* 2. user 0 gc
* 3. get type content
* 4. disconnect & reconnect all (so gc is propagated)
* 5. compare os, ds, ss
*/
async function compareUsers (t, users) {
await Promise.all(users.map(u => u.reconnect()));
if (users[0].connector.testRoom == null) {
await wait(100);
}
await flushAll(t, users);
await wait();
await flushAll(t, users);
await wait();
await flushAll(t, users);
await wait();
await flushAll(t, users);
var userArrayValues = users.map(u => u.define('array', Y$$1.Array).toJSON().map(val => JSON.stringify(val)));
var userMapValues = users.map(u => u.define('map', Y$$1.Map).toJSON());
var userXmlValues = users.map(u => u.define('xml', Y$$1.Xml).toString());
var userTextValues = users.map(u => u.define('text', Y$$1.Text).toDelta());
var userQuillValues = users.map(u => {
u.quill.update('yjs'); // get latest changes
return u.quill.getContents().ops
});
var data = users.map(u => {
defragmentItemContent(u);
var data = {};
let ops = [];
u.os.iterate(null, null, function (op) {
let json;
if (op.constructor === GC) {
json = {
type: 'GC',
id: op._id,
length: op._length
};
} else {
json = {
id: op._id,
left: op._left === null ? null : op._left._lastId,
right: op._right === null ? null : op._right._id,
length: op._length,
deleted: op._deleted,
parent: op._parent._id
};
}
if (op instanceof ItemJSON || op instanceof ItemString) {
json.content = op._content;
}
ops.push(json);
});
data.os = ops;
data.ds = getDeleteSet(u);
data.ss = getStateSet(u);
return data
});
for (var i = 0; i < data.length - 1; i++) {
await t.asyncGroup(async () => {
t.compare(userArrayValues[i], userArrayValues[i + 1], 'array types');
t.compare(userMapValues[i], userMapValues[i + 1], 'map types');
t.compare(userXmlValues[i], userXmlValues[i + 1], 'xml types');
t.compare(userTextValues[i], userTextValues[i + 1], 'text types');
t.compare(userQuillValues[i], userQuillValues[i + 1], 'quill delta content');
t.compare(data[i].os, data[i + 1].os, 'os');
t.compare(data[i].ds, data[i + 1].ds, 'ds');
t.compare(data[i].ss, data[i + 1].ss, 'ss');
}, `Compare user${i} with user${i + 1}`);
}
users.map(u => u.destroy());
}
function domFilter (nodeName, attrs) {
if (nodeName === 'HIDDEN') {
return null
}
attrs.delete('hidden');
return attrs
}
async function initArrays (t, opts) {
var result = {
users: []
};
var chance = opts.chance || new chance_1(t.getSeed() * 1000000000);
var conn = Object.assign({ room: 'debugging_' + t.name, testContext: t, chance }, connector);
for (let i = 0; i < opts.users; i++) {
let connOpts;
if (i === 0) {
connOpts = Object.assign({ role: 'master' }, conn);
} else {
connOpts = Object.assign({ role: 'slave' }, conn);
}
let y = new Y$$1(connOpts.room, {
userID: i, // evil hackery, don't try this at home
connector: connOpts
});
result.users.push(y);
result['array' + i] = y.define('array', Y$$1.Array);
result['map' + i] = y.define('map', Y$$1.Map);
const yxml = y.define('xml', Y$$1.XmlElement);
result['xml' + i] = yxml;
const dom = document.createElement('my-dom');
const domBinding = new DomBinding(yxml, dom, { domFilter });
result['domBinding' + i] = domBinding;
result['dom' + i] = dom;
const textType = y.define('text', Y$$1.Text);
result['text' + i] = textType;
const quill$$1 = new Quill(document.createElement('div'));
result['quillBinding' + i] = new Y$$1.QuillBinding(textType, quill$$1);
result['quill' + i] = quill$$1;
y.quill = quill$$1; // put quill on the y object (so we can use it later)
y.dom = dom;
y.on('afterTransaction', function () {
for (let missing of y._missingStructs.values()) {
if (missing.size > 0) {
console.error(new Error('Test check in "afterTransaction": missing should be empty!'));
}
}
});
}
result.array0.delete(0, result.array0.length);
if (result.users[0].connector.testRoom != null) {
// flush for sync if test-connector
await result.users[0].connector.testRoom.flushAll(result.users);
}
await Promise.all(result.users.map(u => {
return new Promise(function (resolve) {
u.connector.whenSynced(resolve);
})
}));
await flushAll(t, result.users);
return result
}
async function flushAll (t, users) {
// users = users.filter(u => u.connector.isSynced)
if (users.length === 0) {
return
}
await wait(10);
if (users[0].connector.testRoom != null) {
// use flushAll method specified in Test Connector
await users[0].connector.testRoom.flushAll(users);
} else {
var flushCounter = users[0].get('flushHelper', Y$$1.Map).get('0') || 0;
flushCounter++;
await Promise.all(users.map(async (u, i) => {
// wait for all users to set the flush counter to the same value
await new Promise(resolve => {
function observer () {
var allUsersReceivedUpdate = true;
for (var i = 0; i < users.length; i++) {
if (u.get('flushHelper', Y$$1.Map).get(i + '') !== flushCounter) {
allUsersReceivedUpdate = false;
break
}
}
if (allUsersReceivedUpdate) {
resolve();
}
}
u.get('flushHelper', Y$$1.Map).observe(observer);
u.get('flushHelper').set(i + '', flushCounter);
});
}));
}
}
async function flushSome (t, users) {
if (users[0].connector.testRoom == null) {
// if not test-connector, wait for some time for operations to arrive
await wait(100);
}
}
function wait (t) {
return new Promise(function (resolve) {
setTimeout(resolve, t != null ? t : 100);
})
}
async function applyRandomTests (t, mods, iterations) {
const chance = new chance_1(t.getSeed() * 1000000000);
var initInformation = await initArrays(t, { users: 5, chance: chance });
let { users } = initInformation;
for (var i = 0; i < iterations; i++) {
if (chance.bool({likelihood: 10})) {
// 10% chance to disconnect/reconnect a user
// we make sure that the first users always is connected
let user = chance.pickone(users.slice(1));
if (user.connector.isSynced) {
if (users.filter(u => u.connector.isSynced).length > 1) {
// make sure that at least one user remains in the room
await user.disconnect();
if (users[0].connector.testRoom == null) {
await wait(100);
}
}
} else {
await user.reconnect();
if (users[0].connector.testRoom == null) {
await wait(100);
}
await new Promise(function (resolve) {
user.connector.whenSynced(resolve);
});
}
} else if (chance.bool({likelihood: 5})) {
// 20%*!prev chance to flush all & garbagecollect
// TODO: We do not gc all users as this does not work yet
// await garbageCollectUsers(t, users)
await flushAll(t, users);
// await users[0].db.emptyGarbageCollector()
await flushAll(t, users);
} else if (chance.bool({likelihood: 10})) {
// 20%*!prev chance to flush some operations
await flushSome(t, users);
}
let user = chance.pickone(users);
var test = chance.pickone(mods);
test(t, user, chance);
}
await compareUsers(t, users);
return initInformation
}
proxyConsole();
test('basic spec', async function array0 (t) {
let { users, array0 } = await initArrays(t, { users: 2 });
array0.delete(0, 0);
t.assert(true, 'Does not throw when deleting zero elements with position 0');
let throwInvalidPosition = false;
try {
array0.delete(1, 1);
} catch (e) {
throwInvalidPosition = true;
}
t.assert(throwInvalidPosition, 'Throws when deleting with an invalid position');
array0.insert(0, ['A']);
array0.delete(1, 0);
t.assert(true, 'Does not throw when deleting zero elements with valid position 1');
await compareUsers(t, users);
});
test('insert three elements, try re-get property', async function array1 (t) {
var { users, array0, array1 } = await initArrays(t, { users: 2 });
array0.insert(0, [1, 2, 3]);
t.compare(array0.toJSON(), [1, 2, 3], '.toJSON() works');
await flushAll(t, users);
t.compare(array1.toJSON(), [1, 2, 3], '.toJSON() works after sync');
await compareUsers(t, users);
});
test('concurrent insert (handle three conflicts)', async function array2 (t) {
var { users, array0, array1, array2 } = await initArrays(t, { users: 3 });
array0.insert(0, [0]);
array1.insert(0, [1]);
array2.insert(0, [2]);
await compareUsers(t, users);
});
test('concurrent insert&delete (handle three conflicts)', async function array3 (t) {
var { users, array0, array1, array2 } = await initArrays(t, { users: 3 });
array0.insert(0, ['x', 'y', 'z']);
await flushAll(t, users);
array0.insert(1, [0]);
array1.delete(0);
array1.delete(1, 1);
array2.insert(1, [2]);
await compareUsers(t, users);
});
test('insertions work in late sync', async function array4 (t) {
var { users, array0, array1, array2 } = await initArrays(t, { users: 3 });
array0.insert(0, ['x', 'y']);
await flushAll(t, users);
users[1].disconnect();
users[2].disconnect();
array0.insert(1, ['user0']);
array1.insert(1, ['user1']);
array2.insert(1, ['user2']);
await users[1].reconnect();
await users[2].reconnect();
await compareUsers(t, users);
});
test('disconnect really prevents sending messages', async function array5 (t) {
var { users, array0, array1 } = await initArrays(t, { users: 3 });
array0.insert(0, ['x', 'y']);
await flushAll(t, users);
users[1].disconnect();
users[2].disconnect();
array0.insert(1, ['user0']);
array1.insert(1, ['user1']);
await wait(1000);
t.compare(array0.toJSON(), ['x', 'user0', 'y']);
t.compare(array1.toJSON(), ['x', 'user1', 'y']);
await users[1].reconnect();
await users[2].reconnect();
await compareUsers(t, users);
});
test('deletions in late sync', async function array6 (t) {
var { users, array0, array1 } = await initArrays(t, { users: 2 });
array0.insert(0, ['x', 'y']);
await flushAll(t, users);
await users[1].disconnect();
array1.delete(1, 1);
array0.delete(0, 2);
await wait();
await users[1].reconnect();
await compareUsers(t, users);
});
test('insert, then marge delete on sync', async function array7 (t) {
var { users, array0, array1 } = await initArrays(t, { users: 2 });
array0.insert(0, ['x', 'y', 'z']);
await flushAll(t, users);
await wait();
await users[0].disconnect();
array1.delete(0, 3);
await wait();
await users[0].reconnect();
await compareUsers(t, users);
});
function compareEvent (t, is, should) {
for (var key in should) {
t.assert(
should[key] === is[key] ||
JSON.stringify(should[key]) === JSON.stringify(is[key])
, 'event works as expected'
);
}
}
test('insert & delete events', async function array8 (t) {
var { array0, users } = await initArrays(t, { users: 2 });
var event;
array0.observe(function (e) {
event = e;
});
array0.insert(0, [0, 1, 2]);
compareEvent(t, event, {
remote: false
});
array0.delete(0);
compareEvent(t, event, {
remote: false
});
array0.delete(0, 2);
compareEvent(t, event, {
remote: false
});
await compareUsers(t, users);
});
test('insert & delete events for types', async function array9 (t) {
var { array0, users } = await initArrays(t, { users: 2 });
var event;
array0.observe(function (e) {
event = e;
});
array0.insert(0, [Y$$1.Array]);
compareEvent(t, event, {
remote: false
});
array0.delete(0);
compareEvent(t, event, {
remote: false
});
await compareUsers(t, users);
});
test('insert & delete events for types (2)', async function array10 (t) {
var { array0, users } = await initArrays(t, { users: 2 });
var events = [];
array0.observe(function (e) {
events.push(e);
});
array0.insert(0, ['hi', Y$$1.Map]);
compareEvent(t, events[0], {
remote: false
});
t.assert(events.length === 1, 'Event is triggered exactly once for insertion of two elements');
array0.delete(1);
compareEvent(t, events[1], {
remote: false
});
t.assert(events.length === 2, 'Event is triggered exactly once for deletion');
await compareUsers(t, users);
});
test('garbage collector', async function gc1 (t) {
var { users, array0 } = await initArrays(t, { users: 3 });
array0.insert(0, ['x', 'y', 'z']);
await flushAll(t, users);
users[0].disconnect();
array0.delete(0, 3);
await wait();
await users[0].reconnect();
await flushAll(t, users);
await compareUsers(t, users);
});
test('event target is set correctly (local)', async function array11 (t) {
let { array0, users } = await initArrays(t, { users: 3 });
var event;
array0.observe(function (e) {
event = e;
});
array0.insert(0, ['stuff']);
t.assert(event.target === array0, '"target" property is set correctly');
await compareUsers(t, users);
});
test('event target is set correctly (remote user)', async function array12 (t) {
let { array0, array1, users } = await initArrays(t, { users: 3 });
var event;
array0.observe(function (e) {
event = e;
});
array1.insert(0, ['stuff']);
await flushAll(t, users);
compareEvent(t, event, {
remote: true
});
t.assert(event.target === array0, '"target" property is set correctly');
await compareUsers(t, users);
});
var _uniqueNumber = 0;
function getUniqueNumber () {
return _uniqueNumber++
}
var arrayTransactions = [
function insert (t, user, chance) {
const yarray = user.get('array', Y$$1.Array);
var uniqueNumber = getUniqueNumber();
var content = [];
var len = chance.integer({ min: 1, max: 4 });
for (var i = 0; i < len; i++) {
content.push(uniqueNumber);
}
var pos = chance.integer({ min: 0, max: yarray.length });
yarray.insert(pos, content);
},
function insertTypeArray (t, user, chance) {
const yarray = user.get('array', Y$$1.Array);
var pos = chance.integer({ min: 0, max: yarray.length });
yarray.insert(pos, [Y$$1.Array]);
var array2 = yarray.get(pos);
array2.insert(0, [1, 2, 3, 4]);
},
function insertTypeMap (t, user, chance) {
const yarray = user.get('array', Y$$1.Array);
var pos = chance.integer({ min: 0, max: yarray.length });
yarray.insert(pos, [Y$$1.Map]);
var map = yarray.get(pos);
map.set('someprop', 42);
map.set('someprop', 43);
map.set('someprop', 44);
},
function _delete (t, user, chance) {
const yarray = user.get('array', Y$$1.Array);
var length = yarray.length;
if (length > 0) {
var somePos = chance.integer({ min: 0, max: length - 1 });
var delLength = chance.integer({ min: 1, max: Math.min(2, length - somePos) });
if (yarray instanceof Y$$1.Array) {
if (chance.bool()) {
var type = yarray.get(somePos);
if (type.length > 0) {
somePos = chance.integer({ min: 0, max: type.length - 1 });
delLength = chance.integer({ min: 0, max: Math.min(2, type.length - somePos) });
type.delete(somePos, delLength);
}
} else {
yarray.delete(somePos, delLength);
}
} else {
yarray.delete(somePos, delLength);
}
}
}
];
test('y-array: Random tests (20)', async function randomArray20 (t) {
await applyRandomTests(t, arrayTransactions, 20);
});
test('y-array: Random tests (42)', async function randomArray42 (t) {
await applyRandomTests(t, arrayTransactions, 42);
});
test('y-array: Random tests (43)', async function randomArray43 (t) {
await applyRandomTests(t, arrayTransactions, 43);
});
test('y-array: Random tests (44)', async function randomArray44 (t) {
await applyRandomTests(t, arrayTransactions, 44);
});
test('y-array: Random tests (45)', async function randomArray45 (t) {
await applyRandomTests(t, arrayTransactions, 45);
});
test('y-array: Random tests (46)', async function randomArray46 (t) {
await applyRandomTests(t, arrayTransactions, 46);
});
test('y-array: Random tests (47)', async function randomArray47 (t) {
await applyRandomTests(t, arrayTransactions, 47);
});
test('y-array: Random tests (300)', async function randomArray300 (t) {
await applyRandomTests(t, arrayTransactions, 200);
});
test('y-array: Random tests (500)', async function randomArray500 (t) {
await applyRandomTests(t, arrayTransactions, 300);
});
test('y-array: Random tests (600)', async function randomArray600 (t) {
await applyRandomTests(t, arrayTransactions, 400);
});
test('y-array: Random tests (700)', async function randomArray700 (t) {
await applyRandomTests(t, arrayTransactions, 500);
});
test('y-array: Random tests (1000)', async function randomArray1000 (t) {
await applyRandomTests(t, arrayTransactions, 1000);
});
test('y-array: Random tests (1800)', async function randomArray1800 (t) {
await applyRandomTests(t, arrayTransactions, 2000);
});
proxyConsole();
test('basic insert delete', async function text0 (t) {
let { users, text0 } = await initArrays(t, { users: 2 });
let delta;
text0.observe(function (event) {
delta = event.delta;
});
text0.delete(0, 0);
t.assert(true, 'Does not throw when deleting zero elements with position 0');
text0.insert(0, 'abc');
t.assert(text0.toString() === 'abc', 'Basic insert works');
t.compare(delta, [{ insert: 'abc' }]);
text0.delete(0, 1);
t.assert(text0.toString() === 'bc', 'Basic delete works (position 0)');
t.compare(delta, [{ delete: 1 }]);
text0.delete(1, 1);
t.assert(text0.toString() === 'b', 'Basic delete works (position 1)');
t.compare(delta, [{ retain: 1 }, { delete: 1 }]);
await compareUsers(t, users);
});
test('basic format', async function text1 (t) {
let { users, text0 } = await initArrays(t, { users: 2 });
let delta;
text0.observe(function (event) {
delta = event.delta;
});
text0.insert(0, 'abc', { bold: true });
t.assert(text0.toString() === 'abc', 'Basic insert with attributes works');
t.compare(text0.toDelta(), [{ insert: 'abc', attributes: { bold: true } }]);
t.compare(delta, [{ insert: 'abc', attributes: { bold: true } }]);
text0.delete(0, 1);
t.assert(text0.toString() === 'bc', 'Basic delete on formatted works (position 0)');
t.compare(text0.toDelta(), [{ insert: 'bc', attributes: { bold: true } }]);
t.compare(delta, [{ delete: 1 }]);
text0.delete(1, 1);
t.assert(text0.toString() === 'b', 'Basic delete works (position 1)');
t.compare(text0.toDelta(), [{ insert: 'b', attributes: { bold: true } }]);
t.compare(delta, [{ retain: 1 }, { delete: 1 }]);
text0.insert(0, 'z', {bold: true});
t.assert(text0.toString() === 'zb');
t.compare(text0.toDelta(), [{ insert: 'zb', attributes: { bold: true } }]);
t.compare(delta, [{ insert: 'z', attributes: { bold: true } }]);
t.assert(text0._start._right._right._right._content === 'b', 'Does not insert duplicate attribute marker');
text0.insert(0, 'y');
t.assert(text0.toString() === 'yzb');
t.compare(text0.toDelta(), [{ insert: 'y' }, { insert: 'zb', attributes: { bold: true } }]);
t.compare(delta, [{ insert: 'y' }]);
text0.format(0, 2, { bold: null });
t.assert(text0.toString() === 'yzb');
t.compare(text0.toDelta(), [{ insert: 'yz' }, { insert: 'b', attributes: { bold: true } }]);
t.compare(delta, [{ retain: 1 }, { retain: 1, attributes: { bold: null } }]);
await compareUsers(t, users);
});
test('quill issue 1', async function quill1 (t) {
let { users, quill0 } = await initArrays(t, { users: 2 });
quill0.insertText(0, 'x');
await flushAll(t, users);
quill0.insertText(1, '\n', 'list', 'ordered');
await flushAll(t, users);
quill0.insertText(1, '\n', 'list', 'ordered');
await compareUsers(t, users);
});
test('quill issue 2', async function quill2 (t) {
let { users, quill0, text0 } = await initArrays(t, { users: 2 });
let delta;
text0.observe(function (event) {
delta = event.delta;
});
quill0.insertText(0, 'abc', 'bold', true);
await flushAll(t, users);
quill0.insertText(1, 'x');
quill0.update();
t.compare(delta, [{ retain: 1 }, { insert: 'x', attributes: { bold: true } }]);
await compareUsers(t, users);
});
test('quill issue 3', async function quill3 (t) {
let { users, quill0, text0 } = await initArrays(t, { users: 2 });
quill0.insertText(0, 'a');
quill0.insertText(1, '\n\n', 'list', 'ordered');
quill0.insertText(2, 'b');
t.compare(text0.toDelta(), [
{ insert: 'a' },
{ insert: '\n', attributes: { list: 'ordered' } },
{ insert: 'b' },
{ insert: '\n', attributes: { list: 'ordered' } }
]);
await compareUsers(t, users);
});
proxyConsole();
test('basic map tests', async function map0 (t) {
let { users, map0, map1, map2 } = await initArrays(t, { users: 3 });
users[2].disconnect();
map0.set('number', 1);
map0.set('string', 'hello Y');
map0.set('object', { key: { key2: 'value' } });
map0.set('y-map', new Y$$1.Map());
let map = map0.get('y-map');
map.set('y-array', new Y$$1.Array());
let array = map.get('y-array');
array.insert(0, [0]);
array.insert(0, [-1]);
t.assert(map0.get('number') === 1, 'client 0 computed the change (number)');
t.assert(map0.get('string') === 'hello Y', 'client 0 computed the change (string)');
t.compare(map0.get('object'), { key: { key2: 'value' } }, 'client 0 computed the change (object)');
t.assert(map0.get('y-map').get('y-array').get(0) === -1, 'client 0 computed the change (type)');
await users[2].reconnect();
await flushAll(t, users);
t.assert(map1.get('number') === 1, 'client 1 received the update (number)');
t.assert(map1.get('string') === 'hello Y', 'client 1 received the update (string)');
t.compare(map1.get('object'), { key: { key2: 'value' } }, 'client 1 received the update (object)');
t.assert(map1.get('y-map').get('y-array').get(0) === -1, 'client 1 received the update (type)');
// compare disconnected user
t.assert(map2.get('number') === 1, 'client 2 received the update (number) - was disconnected');
t.assert(map2.get('string') === 'hello Y', 'client 2 received the update (string) - was disconnected');
t.compare(map2.get('object'), { key: { key2: 'value' } }, 'client 2 received the update (object) - was disconnected');
t.assert(map2.get('y-map').get('y-array').get(0) === -1, 'client 2 received the update (type) - was disconnected');
await compareUsers(t, users);
});
test('Basic get&set of Map property (converge via sync)', async function map1 (t) {
let { users, map0 } = await initArrays(t, { users: 2 });
map0.set('stuff', 'stuffy');
map0.set('undefined', undefined);
map0.set('null', null);
t.compare(map0.get('stuff'), 'stuffy');
await flushAll(t, users);
for (let user of users) {
var u = user.get('map', Y$$1.Map);
t.compare(u.get('stuff'), 'stuffy');
t.assert(u.get('undefined') === undefined, 'undefined');
t.compare(u.get('null'), null, 'null');
}
await compareUsers(t, users);
});
test('Map can set custom types (Map)', async function map2 (t) {
let { users, map0 } = await initArrays(t, { users: 2 });
var map = map0.set('Map', new Y$$1.Map());
map.set('one', 1);
map = map0.get('Map');
t.compare(map.get('one'), 1);
await compareUsers(t, users);
});
test('Map can set custom types (Map) - get also returns the type', async function map3 (t) {
let { users, map0 } = await initArrays(t, { users: 2 });
map0.set('Map', new Y$$1.Map());
var map = map0.get('Map');
map.set('one', 1);
map = map0.get('Map');
t.compare(map.get('one'), 1);
await compareUsers(t, users);
});
test('Map can set custom types (Array)', async function map4 (t) {
let { users, map0 } = await initArrays(t, { users: 2 });
var array = map0.set('Array', new Y$$1.Array());
array.insert(0, [1, 2, 3]);
array = map0.get('Array');
t.compare(array.toArray(), [1, 2, 3]);
await compareUsers(t, users);
});
test('Basic get&set of Map property (converge via update)', async function map5 (t) {
let { users, map0 } = await initArrays(t, { users: 2 });
map0.set('stuff', 'stuffy');
t.compare(map0.get('stuff'), 'stuffy');
await flushAll(t, users);
for (let user of users) {
var u = user.get('map', Y$$1.Map);
t.compare(u.get('stuff'), 'stuffy');
}
await compareUsers(t, users);
});
test('Basic get&set of Map property (handle conflict)', async function map6 (t) {
let { users, map0, map1 } = await initArrays(t, { users: 3 });
map0.set('stuff', 'c0');
map1.set('stuff', 'c1');
await flushAll(t, users);
for (let user of users) {
var u = user.get('map', Y$$1.Map);
t.compare(u.get('stuff'), 'c0');
}
await compareUsers(t, users);
});
test('Basic get&set&delete of Map property (handle conflict)', async function map7 (t) {
let { users, map0, map1 } = await initArrays(t, { users: 3 });
map0.set('stuff', 'c0');
map0.delete('stuff');
map1.set('stuff', 'c1');
await flushAll(t, users);
for (let user of users) {
var u = user.get('map', Y$$1.Map);
t.assert(u.get('stuff') === undefined);
}
await compareUsers(t, users);
});
test('Basic get&set of Map property (handle three conflicts)', async function map8 (t) {
let { users, map0, map1, map2 } = await initArrays(t, { users: 3 });
map0.set('stuff', 'c0');
map1.set('stuff', 'c1');
map1.set('stuff', 'c2');
map2.set('stuff', 'c3');
await flushAll(t, users);
for (let user of users) {
var u = user.get('map', Y$$1.Map);
t.compare(u.get('stuff'), 'c0');
}
await compareUsers(t, users);
});
test('Basic get&set&delete of Map property (handle three conflicts)', async function map9 (t) {
let { users, map0, map1, map2, map3 } = await initArrays(t, { users: 4 });
map0.set('stuff', 'c0');
map1.set('stuff', 'c1');
map1.set('stuff', 'c2');
map2.set('stuff', 'c3');
await flushAll(t, users);
map0.set('stuff', 'deleteme');
map0.delete('stuff');
map1.set('stuff', 'c1');
map2.set('stuff', 'c2');
map3.set('stuff', 'c3');
await flushAll(t, users);
for (let user of users) {
var u = user.get('map', Y$$1.Map);
t.assert(u.get('stuff') === undefined);
}
await compareUsers(t, users);
});
/* TODO reimplement observePath
test('observePath properties', async function map10 (t) {
let { users, map0, map1, map2 } = await initArrays(t, { users: 3 })
let map
map0.observePath(['map'], function (map) {
if (map != null) {
map.set('yay', 4)
}
})
map1.set('map', new Y.Map())
await flushAll(t, users)
map = map2.get('map')
t.compare(map.get('yay'), 4)
await compareUsers(t, users)
})
*/
test('observe deep properties', async function map11 (t) {
let { users, map1, map2, map3 } = await initArrays(t, { users: 4 });
var _map1 = map1.set('map', new Y$$1.Map());
var calls = 0;
var dmapid;
map1.observeDeep(function (events) {
events.forEach(event => {
calls++;
t.assert(event.keysChanged.has('deepmap'));
t.assert(event.path.length === 1);
t.assert(event.path[0] === 'map');
dmapid = event.target.get('deepmap')._id;
});
});
await flushAll(t, users);
await flushAll(t, users);
var _map3 = map3.get('map');
_map3.set('deepmap', new Y$$1.Map());
await flushAll(t, users);
var _map2 = map2.get('map');
_map2.set('deepmap', new Y$$1.Map());
await flushAll(t, users);
await flushAll(t, users);
var dmap1 = _map1.get('deepmap');
var dmap2 = _map2.get('deepmap');
var dmap3 = _map3.get('deepmap');
t.assert(calls > 0);
t.assert(dmap1._id.equals(dmap2._id));
t.assert(dmap1._id.equals(dmap3._id));
t.assert(dmap1._id.equals(dmapid));
await compareUsers(t, users);
});
test('observes using observeDeep', async function map12 (t) {
let { users, map0 } = await initArrays(t, { users: 2 });
var pathes = [];
var calls = 0;
map0.observeDeep(function (events) {
events.forEach(event => {
pathes.push(event.path);
});
calls++;
});
map0.set('map', new Y$$1.Map());
map0.get('map').set('array', new Y$$1.Array());
map0.get('map').get('array').insert(0, ['content']);
t.assert(calls === 3);
t.compare(pathes, [[], ['map'], ['map', 'array']]);
await compareUsers(t, users);
});
/* TODO: Test events in Y.Map
function compareEvent (t, is, should) {
for (var key in should) {
t.assert(should[key] === is[key])
}
}
test('throws add & update & delete events (with type and primitive content)', async function map13 (t) {
let { users, map0 } = await initArrays(t, { users: 2 })
var event
await flushAll(t, users)
map0.observe(function (e) {
event = e // just put it on event, should be thrown synchronously anyway
})
map0.set('stuff', 4)
compareEvent(t, event, {
type: 'add',
object: map0,
name: 'stuff'
})
// update, oldValue is in contents
map0.set('stuff', new Y.Array())
compareEvent(t, event, {
type: 'update',
object: map0,
name: 'stuff',
oldValue: 4
})
var replacedArray = map0.get('stuff')
// update, oldValue is in opContents
map0.set('stuff', 5)
var array = event.oldValue
t.compare(array._model, replacedArray._model)
// delete
map0.delete('stuff')
compareEvent(t, event, {
type: 'delete',
name: 'stuff',
object: map0,
oldValue: 5
})
await compareUsers(t, users)
})
*/
/* reimplement event.value somehow (probably with ss vector)
test('event has correct value when setting a primitive on a YMap (same user)', async function map14 (t) {
let { users, map0 } = await initArrays(t, { users: 3 })
var event
await flushAll(t, users)
map0.observe(function (e) {
event = e
})
map0.set('stuff', 2)
t.compare(event.value, event.target.get(event.name))
await compareUsers(t, users)
})
test('event has correct value when setting a primitive on a YMap (received from another user)', async function map15 (t) {
let { users, map0, map1 } = await initArrays(t, { users: 3 })
var event
await flushAll(t, users)
map0.observe(function (e) {
event = e
})
map1.set('stuff', 2)
await flushAll(t, users)
t.compare(event.value, event.target.get(event.name))
await compareUsers(t, users)
})
*/
var mapTransactions = [
function set (t, user, chance) {
let key = chance.pickone(['one', 'two']);
var value = chance.string();
user.get('map', Y$$1.Map).set(key, value);
},
function setType (t, user, chance) {
let key = chance.pickone(['one', 'two']);
var type = chance.pickone([new Y$$1.Array(), new Y$$1.Map()]);
user.get('map', Y$$1.Map).set(key, type);
if (type instanceof Y$$1.Array) {
type.insert(0, [1, 2, 3, 4]);
} else {
type.set('deepkey', 'deepvalue');
}
},
function _delete (t, user, chance) {
let key = chance.pickone(['one', 'two']);
user.get('map', Y$$1.Map).delete(key);
}
];
test('y-map: Random tests (42)', async function randomMap42 (t) {
await applyRandomTests(t, mapTransactions, 42);
});
test('y-map: Random tests (43)', async function randomMap43 (t) {
await applyRandomTests(t, mapTransactions, 43);
});
test('y-map: Random tests (44)', async function randomMap44 (t) {
await applyRandomTests(t, mapTransactions, 44);
});
test('y-map: Random tests (45)', async function randomMap45 (t) {
await applyRandomTests(t, mapTransactions, 45);
});
test('y-map: Random tests (46)', async function randomMap46 (t) {
await applyRandomTests(t, mapTransactions, 46);
});
test('y-map: Random tests (47)', async function randomMap47 (t) {
await applyRandomTests(t, mapTransactions, 47);
});
test('y-map: Random tests (200)', async function randomMap200 (t) {
await applyRandomTests(t, mapTransactions, 200);
});
test('y-map: Random tests (300)', async function randomMap300 (t) {
await applyRandomTests(t, mapTransactions, 300);
});
test('y-map: Random tests (500)', async function randomMap500 (t) {
await applyRandomTests(t, mapTransactions, 500);
});
test('y-map: Random tests (1000)', async function randomMap1000 (t) {
await applyRandomTests(t, mapTransactions, 1000);
});
test('y-map: Random tests (1800)', async function randomMap1800 (t) {
await applyRandomTests(t, mapTransactions, 1800);
});
test('set property', async function xml0 (t) {
var { users, xml0, xml1 } = await initArrays(t, { users: 2 });
xml0.setAttribute('height', '10');
t.assert(xml0.getAttribute('height') === '10', 'Simple set+get works');
await flushAll(t, users);
t.assert(xml1.getAttribute('height') === '10', 'Simple set+get works (remote)');
await compareUsers(t, users);
});
test('events', async function xml1 (t) {
var { users, xml0, xml1 } = await initArrays(t, { users: 2 });
var event;
var remoteEvent;
xml0.observe(function (e) {
delete e._content;
delete e.nodes;
delete e.values;
event = e;
});
xml1.observe(function (e) {
delete e._content;
delete e.nodes;
delete e.values;
remoteEvent = e;
});
xml0.setAttribute('key', 'value');
t.assert(event.attributesChanged.has('key'), 'YXmlEvent.attributesChanged on updated key');
await flushAll(t, users);
t.assert(remoteEvent.attributesChanged.has('key'), 'YXmlEvent.attributesChanged on updated key (remote)');
// check attributeRemoved
xml0.removeAttribute('key');
t.assert(event.attributesChanged.has('key'), 'YXmlEvent.attributesChanged on removed attribute');
await flushAll(t, users);
t.assert(remoteEvent.attributesChanged.has('key'), 'YXmlEvent.attributesChanged on removed attribute (remote)');
xml0.insert(0, [new Y$$1.XmlText('some text')]);
t.assert(event.childListChanged, 'YXmlEvent.childListChanged on inserted element');
await flushAll(t, users);
t.assert(remoteEvent.childListChanged, 'YXmlEvent.childListChanged on inserted element (remote)');
// test childRemoved
xml0.delete(0);
t.assert(event.childListChanged, 'YXmlEvent.childListChanged on deleted element');
await flushAll(t, users);
t.assert(remoteEvent.childListChanged, 'YXmlEvent.childListChanged on deleted element (remote)');
await compareUsers(t, users);
});
test('attribute modifications (y -> dom)', async function xml2 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
xml0.setAttribute('height', '100px');
await wait();
t.assert(dom0.getAttribute('height') === '100px', 'setAttribute');
xml0.removeAttribute('height');
await wait();
t.assert(dom0.getAttribute('height') == null, 'removeAttribute');
xml0.setAttribute('class', 'stuffy stuff');
await wait();
t.assert(dom0.getAttribute('class') === 'stuffy stuff', 'set class attribute');
await compareUsers(t, users);
});
test('attribute modifications (dom -> y)', async function xml3 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
dom0.setAttribute('height', '100px');
await wait();
t.assert(xml0.getAttribute('height') === '100px', 'setAttribute');
dom0.removeAttribute('height');
await wait();
t.assert(xml0.getAttribute('height') == null, 'removeAttribute');
dom0.setAttribute('class', 'stuffy stuff');
await wait();
t.assert(xml0.getAttribute('class') === 'stuffy stuff', 'set class attribute');
await compareUsers(t, users);
});
test('element insert (dom -> y)', async function xml4 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
dom0.insertBefore(document.createTextNode('some text'), null);
dom0.insertBefore(document.createElement('p'), null);
await wait();
t.assert(xml0.get(0).toString() === 'some text', 'Retrieve Text Node');
t.assert(xml0.get(1).nodeName === 'P', 'Retrieve Element node');
await compareUsers(t, users);
});
test('element insert (y -> dom)', async function xml5 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
xml0.insert(0, [new Y$$1.XmlText('some text')]);
xml0.insert(1, [new Y$$1.XmlElement('p')]);
t.assert(dom0.childNodes[0].textContent === 'some text', 'Retrieve Text node');
t.assert(dom0.childNodes[1].nodeName === 'P', 'Retrieve Element node');
await compareUsers(t, users);
});
test('y on insert, then delete (dom -> y)', async function xml6 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
dom0.insertBefore(document.createElement('p'), null);
await wait();
t.assert(xml0.length === 1, 'one node present');
dom0.childNodes[0].remove();
await wait();
t.assert(xml0.length === 0, 'no node present after delete');
await compareUsers(t, users);
});
test('y on insert, then delete (y -> dom)', async function xml7 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
xml0.insert(0, [new Y$$1.XmlElement('p')]);
t.assert(dom0.childNodes[0].nodeName === 'P', 'Get inserted element from dom');
xml0.delete(0, 1);
t.assert(dom0.childNodes.length === 0, '#childNodes is empty after delete');
await compareUsers(t, users);
});
test('delete consecutive (1) (Text)', async function xml8 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
xml0.insert(0, [new Y$$1.XmlText('1'), new Y$$1.XmlText('2'), new Y$$1.XmlText('3')]);
await wait();
xml0.delete(1, 2);
await wait();
t.assert(xml0.length === 1, 'check length (y)');
t.assert(dom0.childNodes.length === 1, 'check length (dom)');
t.assert(dom0.childNodes[0].textContent === '1', 'check content');
await compareUsers(t, users);
});
test('delete consecutive (2) (Text)', async function xml9 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
xml0.insert(0, [new Y$$1.XmlText('1'), new Y$$1.XmlText('2'), new Y$$1.XmlText('3')]);
await wait();
xml0.delete(0, 1);
xml0.delete(1, 1);
await wait();
t.assert(xml0.length === 1, 'check length (y)');
t.assert(dom0.childNodes.length === 1, 'check length (dom)');
t.assert(dom0.childNodes[0].textContent === '2', 'check content');
await compareUsers(t, users);
});
test('delete consecutive (1) (Element)', async function xml10 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
xml0.insert(0, [new Y$$1.XmlElement('A'), new Y$$1.XmlElement('B'), new Y$$1.XmlElement('C')]);
await wait();
xml0.delete(1, 2);
await wait();
t.assert(xml0.length === 1, 'check length (y)');
t.assert(dom0.childNodes.length === 1, 'check length (dom)');
t.assert(dom0.childNodes[0].nodeName === 'A', 'check content');
await compareUsers(t, users);
});
test('delete consecutive (2) (Element)', async function xml11 (t) {
var { users, xml0, dom0 } = await initArrays(t, { users: 3 });
xml0.insert(0, [new Y$$1.XmlElement('A'), new Y$$1.XmlElement('B'), new Y$$1.XmlElement('C')]);
await wait();
xml0.delete(0, 1);
xml0.delete(1, 1);
await wait();
t.assert(xml0.length === 1, 'check length (y)');
t.assert(dom0.childNodes.length === 1, 'check length (dom)');
t.assert(dom0.childNodes[0].nodeName === 'B', 'check content');
await compareUsers(t, users);
});
test('Receive a bunch of elements (with disconnect)', async function xml12 (t) {
var { users, xml0, xml1, dom0, dom1 } = await initArrays(t, { users: 3 });
users[1].disconnect();
xml0.insert(0, [new Y$$1.XmlElement('A'), new Y$$1.XmlElement('B'), new Y$$1.XmlElement('C')]);
xml0.insert(0, [new Y$$1.XmlElement('X'), new Y$$1.XmlElement('Y'), new Y$$1.XmlElement('Z')]);
await users[1].reconnect();
await flushAll(t, users);
t.assert(xml0.length === 6, 'check length (y)');
t.assert(xml1.length === 6, 'check length (y) (reconnected user)');
t.assert(dom0.childNodes.length === 6, 'check length (dom)');
t.assert(dom1.childNodes.length === 6, 'check length (dom) (reconnected user)');
await compareUsers(t, users);
});
test('move element to a different position', async function xml13 (t) {
var { users, dom0, dom1 } = await initArrays(t, { users: 3 });
dom0.append(document.createElement('div'));
dom0.append(document.createElement('h1'));
await flushAll(t, users);
dom1.insertBefore(dom1.childNodes[0], null);
t.assert(dom1.childNodes[0].nodeName === 'H1', 'div was deleted (user 0)');
t.assert(dom1.childNodes[1].nodeName === 'DIV', 'div was moved to the correct position (user 0)');
t.assert(dom1.childNodes[0].nodeName === 'H1', 'div was deleted (user 1)');
t.assert(dom1.childNodes[1].nodeName === 'DIV', 'div was moved to the correct position (user 1)');
await compareUsers(t, users);
});
test('filter node', async function xml14 (t) {
var { users, dom0, dom1, domBinding0, domBinding1 } = await initArrays(t, { users: 3 });
let domFilter = (nodeName, attrs) => {
if (nodeName === 'H1') {
return null
} else {
return attrs
}
};
domBinding0.setFilter(domFilter);
domBinding1.setFilter(domFilter);
dom0.append(document.createElement('div'));
dom0.append(document.createElement('h1'));
await flushAll(t, users);
t.assert(dom1.childNodes.length === 1, 'Only one node was not transmitted');
t.assert(dom1.childNodes[0].nodeName === 'DIV', 'div node was transmitted');
await compareUsers(t, users);
});
test('filter attribute', async function xml15 (t) {
var { users, dom0, dom1, domBinding0, domBinding1 } = await initArrays(t, { users: 3 });
let domFilter = (nodeName, attrs) => {
attrs.delete('hidden');
return attrs
};
domBinding0.setFilter(domFilter);
domBinding1.setFilter(domFilter);
dom0.setAttribute('hidden', 'true');
dom0.setAttribute('style', 'height: 30px');
dom0.setAttribute('data-me', '77');
await flushAll(t, users);
t.assert(dom0.getAttribute('hidden') === 'true', 'User 0 still has the attribute');
t.assert(dom1.getAttribute('hidden') == null, 'User 1 did not receive update');
t.assert(dom1.getAttribute('style') === 'height: 30px', 'User 1 received style update');
t.assert(dom1.getAttribute('data-me') === '77', 'User 1 received data update');
await compareUsers(t, users);
});
test('deep element insert', async function xml16 (t) {
var { users, dom0, dom1 } = await initArrays(t, { users: 3 });
let deepElement = document.createElement('p');
let boldElement = document.createElement('b');
let attrElement = document.createElement('img');
attrElement.setAttribute('src', 'http:localhost:8080/nowhere');
boldElement.append(document.createTextNode('hi'));
deepElement.append(boldElement);
deepElement.append(attrElement);
dom0.append(deepElement);
let str0 = dom0.outerHTML;
await flushAll(t, users);
let str1 = dom1.outerHTML;
t.compare(str0, str1, 'Dom string representation matches');
await compareUsers(t, users);
});
test('treeWalker', async function xml17 (t) {
var { users, xml0 } = await initArrays(t, { users: 3 });
let paragraph1 = new Y$$1.XmlElement('p');
let paragraph2 = new Y$$1.XmlElement('p');
let text1 = new Y$$1.XmlText('init');
let text2 = new Y$$1.XmlText('text');
paragraph1.insert(0, [text1, text2]);
xml0.insert(0, [paragraph1, paragraph2, new Y$$1.XmlElement('img')]);
let allParagraphs = xml0.querySelectorAll('p');
t.assert(allParagraphs.length === 2, 'found exactly two paragraphs');
t.assert(allParagraphs[0] === paragraph1, 'querySelectorAll found paragraph1');
t.assert(allParagraphs[1] === paragraph2, 'querySelectorAll found paragraph2');
t.assert(xml0.querySelector('p') === paragraph1, 'querySelector found paragraph1');
await compareUsers(t, users);
});
/**
* The expected behavior is that changes on your own dom (e.g. malicious attributes) persist.
* Yjs should just ignore them, never propagate those attributes.
* Incoming changes that contain malicious attributes should be deleted.
*/
test('Filtering remote changes', async function xmlFilteringRemote (t) {
var { users, xml0, xml1, domBinding0 } = await initArrays(t, { users: 3 });
domBinding0.setFilter(function (nodeName, attributes) {
attributes.delete('malicious');
if (nodeName === 'HIDEME') {
return null
} else if (attributes.has('isHidden')) {
return null
} else {
return attributes
}
});
let paragraph = new Y$$1.XmlElement('p');
let hideMe = new Y$$1.XmlElement('hideMe');
let span = new Y$$1.XmlElement('span');
span.setAttribute('malicious', 'alert("give me money")');
let tag = new Y$$1.XmlElement('tag');
tag.setAttribute('isHidden', 'true');
paragraph.insert(0, [hideMe, span, tag]);
xml0.insert(0, [paragraph]);
let tag2 = new Y$$1.XmlElement('tag');
tag2.setAttribute('isHidden', 'true');
paragraph.insert(0, [tag2]);
await flushAll(t, users);
// check dom
domBinding0.typeToDom.get(paragraph).setAttribute('malicious', 'true');
domBinding0.typeToDom.get(span).setAttribute('malicious', 'true');
// check incoming attributes
xml1.get(0).get(0).setAttribute('malicious', 'true');
xml1.insert(0, [new Y$$1.XmlElement('hideMe')]);
await flushAll(t, users);
await compareUsers(t, users);
});
// TODO: move elements
var xmlTransactions = [
function attributeChange (t, user, chance) {
user.dom.setAttribute(chance.word(), chance.word());
},
function attributeChangeHidden (t, user, chance) {
user.dom.setAttribute('hidden', chance.word());
},
function insertText (t, user, chance) {
let dom = user.dom;
var succ = dom.children.length > 0 ? chance.pickone(dom.children) : null;
dom.insertBefore(document.createTextNode(chance.word()), succ);
},
function insertHiddenDom (t, user, chance) {
let dom = user.dom;
var succ = dom.children.length > 0 ? chance.pickone(dom.children) : null;
dom.insertBefore(document.createElement('hidden'), succ);
},
function insertDom (t, user, chance) {
let dom = user.dom;
var succ = dom.children.length > 0 ? chance.pickone(dom.children) : null;
dom.insertBefore(document.createElement(chance.word()), succ);
},
function deleteChild (t, user, chance) {
let dom = user.dom;
if (dom.childNodes.length > 0) {
var d = chance.pickone(dom.childNodes);
d.remove();
}
},
function insertTextSecondLayer (t, user, chance) {
let dom = user.dom;
if (dom.children.length > 0) {
let dom2 = chance.pickone(dom.children);
let succ = dom2.childNodes.length > 0 ? chance.pickone(dom2.childNodes) : null;
dom2.insertBefore(document.createTextNode(chance.word()), succ);
}
},
function insertDomSecondLayer (t, user, chance) {
let dom = user.dom;
if (dom.children.length > 0) {
let dom2 = chance.pickone(dom.children);
let succ = dom2.childNodes.length > 0 ? chance.pickone(dom2.childNodes) : null;
dom2.insertBefore(document.createElement(chance.word()), succ);
}
},
function deleteChildSecondLayer (t, user, chance) {
let dom = user.dom;
if (dom.children.length > 0) {
let dom2 = chance.pickone(dom.children);
if (dom2.childNodes.length > 0) {
let d = chance.pickone(dom2.childNodes);
d.remove();
}
}
}
];
test('y-xml: Random tests (10)', async function xmlRandom10 (t) {
await applyRandomTests(t, xmlTransactions, 10);
});
test('y-xml: Random tests (42)', async function xmlRandom42 (t) {
await applyRandomTests(t, xmlTransactions, 42);
});
test('y-xml: Random tests (43)', async function xmlRandom43 (t) {
await applyRandomTests(t, xmlTransactions, 43);
});
test('y-xml: Random tests (44)', async function xmlRandom44 (t) {
await applyRandomTests(t, xmlTransactions, 44);
});
test('y-xml: Random tests (45)', async function xmlRandom45 (t) {
await applyRandomTests(t, xmlTransactions, 45);
});
test('y-xml: Random tests (46)', async function xmlRandom46 (t) {
await applyRandomTests(t, xmlTransactions, 46);
});
test('y-xml: Random tests (47)', async function xmlRandom47 (t) {
await applyRandomTests(t, xmlTransactions, 47);
});
test('y-xml: Random tests (100)', async function xmlRandom100 (t) {
await applyRandomTests(t, xmlTransactions, 100);
});
test('y-xml: Random tests (200)', async function xmlRandom200 (t) {
await applyRandomTests(t, xmlTransactions, 200);
});
test('y-xml: Random tests (500)', async function xmlRandom500 (t) {
await applyRandomTests(t, xmlTransactions, 500);
});
test('y-xml: Random tests (1000)', async function xmlRandom1000 (t) {
await applyRandomTests(t, xmlTransactions, 1000);
});
function testEncoding (t, write, read, val) {
let encoder = new BinaryEncoder();
write(encoder, val);
let reader = new BinaryDecoder(encoder.createBuffer());
let result = read(reader);
t.log(`string encode: ${JSON.stringify(val).length} bytes / binary encode: ${encoder.data.length} bytes`);
t.compare(val, result, 'Compare results');
}
const writeVarUint = (encoder, val) => encoder.writeVarUint(val);
const readVarUint = decoder => decoder.readVarUint();
test('varUint 1 byte', async function varUint1 (t) {
testEncoding(t, writeVarUint, readVarUint, 42);
});
test('varUint 2 bytes', async function varUint2 (t) {
testEncoding(t, writeVarUint, readVarUint, 1 << 9 | 3);
testEncoding(t, writeVarUint, readVarUint, 1 << 9 | 3);
});
test('varUint 3 bytes', async function varUint3 (t) {
testEncoding(t, writeVarUint, readVarUint, 1 << 17 | 1 << 9 | 3);
});
test('varUint 4 bytes', async function varUint4 (t) {
testEncoding(t, writeVarUint, readVarUint, 1 << 25 | 1 << 17 | 1 << 9 | 3);
});
test('varUint of 2839012934', async function varUint2839012934 (t) {
testEncoding(t, writeVarUint, readVarUint, 2839012934);
});
test('varUint random', async function varUintRandom (t) {
const chance = new chance_1(t.getSeed() * Math.pow(Number.MAX_SAFE_INTEGER));
testEncoding(t, writeVarUint, readVarUint, chance.integer({min: 0, max: (1 << 28) - 1}));
});
test('varUint random user id', async function varUintRandomUserId (t) {
t.getSeed(); // enforces that this test is repeated
testEncoding(t, writeVarUint, readVarUint, generateRandomUint32());
});
const writeVarString = (encoder, val) => encoder.writeVarString(val);
const readVarString = decoder => decoder.readVarString();
test('varString', async function varString (t) {
testEncoding(t, writeVarString, readVarString, 'hello');
testEncoding(t, writeVarString, readVarString, 'test!');
testEncoding(t, writeVarString, readVarString, '☺☺☺');
testEncoding(t, writeVarString, readVarString, '1234');
testEncoding(t, writeVarString, readVarString, '쾟');
testEncoding(t, writeVarString, readVarString, '龟'); // surrogate length 3
testEncoding(t, writeVarString, readVarString, '😝'); // surrogate length 4
});
test('varString random', async function varStringRandom (t) {
const chance = new chance_1(t.getSeed() * 1000000000);
testEncoding(t, writeVarString, readVarString, chance.string());
});
function runDiffTest (t, a, b, expected) {
let result = simpleDiff(a, b);
t.compare(result, expected, `Compare "${a}" with "${b}"`);
}
test('diff tests', async function diff1 (t) {
runDiffTest(t, 'abc', 'axc', { pos: 1, remove: 1, insert: 'x' });
runDiffTest(t, 'bc', 'xc', { pos: 0, remove: 1, insert: 'x' });
runDiffTest(t, 'ab', 'ax', { pos: 1, remove: 1, insert: 'x' });
runDiffTest(t, 'b', 'x', { pos: 0, remove: 1, insert: 'x' });
runDiffTest(t, '', 'abc', { pos: 0, remove: 0, insert: 'abc' });
runDiffTest(t, 'abc', 'xyz', { pos: 0, remove: 3, insert: 'xyz' });
runDiffTest(t, 'axz', 'au', { pos: 1, remove: 2, insert: 'u' });
runDiffTest(t, 'ax', 'axy', { pos: 2, remove: 0, insert: 'y' });
});
test('random diff tests', async function randomDiff (t) {
const chance = new chance_1(t.getSeed() * 1000000000);
let a = chance.word();
let b = chance.word();
let change = simpleDiff(a, b);
let arr = Array.from(a);
arr.splice(change.pos, change.remove, ...Array.from(change.insert));
t.assert(arr.join('') === b, 'Applying change information is correct');
});
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=y.test.js.map
View Git Blame Copy Permalink