text:
<!--
@license
Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
--><link rel="import" href="polymer-micro.html">

<script>Polymer.Base._addFeature({
_prepTemplate: function () {
this._template = this._template || Polymer.DomModule.import(this.is, 'template');
if (this._template && this._template.hasAttribute('is')) {
this._warn(this._logf('_prepTemplate', 'top-level Polymer template ' + 'must not be a type-extension, found', this._template, 'Move inside simple <template>.'));
}
if (this._template && !this._template.content && HTMLTemplateElement.bootstrap) {
HTMLTemplateElement.decorate(this._template);
HTMLTemplateElement.bootstrap(this._template.content);
}
},
_stampTemplate: function () {
if (this._template) {
this.root = this.instanceTemplate(this._template);
}
},
instanceTemplate: function (template) {
var dom = document.importNode(template._content || template.content, true);
return dom;
}
});
(function () {
var baseAttachedCallback = Polymer.Base.attachedCallback;
Polymer.Base._addFeature({
_hostStack: [],
ready: function () {
},
_pushHost: function (host) {
this.dataHost = host = host || Polymer.Base._hostStack[Polymer.Base._hostStack.length - 1];
if (host && host._clients) {
host._clients.push(this);
}
this._beginHost();
},
_beginHost: function () {
Polymer.Base._hostStack.push(this);
if (!this._clients) {
this._clients = [];
}
},
_popHost: function () {
Polymer.Base._hostStack.pop();
},
_tryReady: function () {
if (this._canReady()) {
this._ready();
}
},
_canReady: function () {
return !this.dataHost || this.dataHost._clientsReadied;
},
_ready: function () {
this._beforeClientsReady();
this._setupRoot();
this._readyClients();
this._afterClientsReady();
this._readySelf();
},
_readyClients: function () {
this._beginDistribute();
var c$ = this._clients;
for (var i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
c._ready();
}
this._finishDistribute();
this._clientsReadied = true;
this._clients = null;
},
_readySelf: function () {
this._doBehavior('ready');
this._readied = true;
if (this._attachedPending) {
this._attachedPending = false;
this.attachedCallback();
}
},
_beforeClientsReady: function () {
},
_afterClientsReady: function () {
},
_beforeAttached: function () {
},
attachedCallback: function () {
if (this._readied) {
this._beforeAttached();
baseAttachedCallback.call(this);
} else {
this._attachedPending = true;
}
}
});
}());
Polymer.ArraySplice = function () {
function newSplice(index, removed, addedCount) {
return {
index: index,
removed: removed,
addedCount: addedCount
};
}
var EDIT_LEAVE = 0;
var EDIT_UPDATE = 1;
var EDIT_ADD = 2;
var EDIT_DELETE = 3;
function ArraySplice() {
}
ArraySplice.prototype = {
calcEditDistances: function (current, currentStart, currentEnd, old, oldStart, oldEnd) {
var rowCount = oldEnd - oldStart + 1;
var columnCount = currentEnd - currentStart + 1;
var distances = new Array(rowCount);
for (var i = 0; i < rowCount; i++) {
distances[i] = new Array(columnCount);
distances[i][0] = i;
}
for (var j = 0; j < columnCount; j++)
distances[0][j] = j;
for (var i = 1; i < rowCount; i++) {
for (var j = 1; j < columnCount; j++) {
if (this.equals(current[currentStart + j - 1], old[oldStart + i - 1]))
distances[i][j] = distances[i - 1][j - 1];
else {
var north = distances[i - 1][j] + 1;
var west = distances[i][j - 1] + 1;
distances[i][j] = north < west ? north : west;
}
}
}
return distances;
},
spliceOperationsFromEditDistances: function (distances) {
var i = distances.length - 1;
var j = distances[0].length - 1;
var current = distances[i][j];
var edits = [];
while (i > 0 || j > 0) {
if (i == 0) {
edits.push(EDIT_ADD);
j--;
continue;
}
if (j == 0) {
edits.push(EDIT_DELETE);
i--;
continue;
}
var northWest = distances[i - 1][j - 1];
var west = distances[i - 1][j];
var north = distances[i][j - 1];
var min;
if (west < north)
min = west < northWest ? west : northWest;
else
min = north < northWest ? north : northWest;
if (min == northWest) {
if (northWest == current) {
edits.push(EDIT_LEAVE);
} else {
edits.push(EDIT_UPDATE);
current = northWest;
}
i--;
j--;
} else if (min == west) {
edits.push(EDIT_DELETE);
i--;
current = west;
} else {
edits.push(EDIT_ADD);
j--;
current = north;
}
}
edits.reverse();
return edits;
},
calcSplices: function (current, currentStart, currentEnd, old, oldStart, oldEnd) {
var prefixCount = 0;
var suffixCount = 0;
var minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);
if (currentStart == 0 && oldStart == 0)
prefixCount = this.sharedPrefix(current, old, minLength);
if (currentEnd == current.length && oldEnd == old.length)
suffixCount = this.sharedSuffix(current, old, minLength - prefixCount);
currentStart += prefixCount;
oldStart += prefixCount;
currentEnd -= suffixCount;
oldEnd -= suffixCount;
if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)
return [];
if (currentStart == currentEnd) {
var splice = newSplice(currentStart, [], 0);
while (oldStart < oldEnd)
splice.removed.push(old[oldStart++]);
return [splice];
} else if (oldStart == oldEnd)
return [newSplice(currentStart, [], currentEnd - currentStart)];
var ops = this.spliceOperationsFromEditDistances(this.calcEditDistances(current, currentStart, currentEnd, old, oldStart, oldEnd));
var splice = undefined;
var splices = [];
var index = currentStart;
var oldIndex = oldStart;
for (var i = 0; i < ops.length; i++) {
switch (ops[i]) {
case EDIT_LEAVE:
if (splice) {
splices.push(splice);
splice = undefined;
}
index++;
oldIndex++;
break;
case EDIT_UPDATE:
if (!splice)
splice = newSplice(index, [], 0);
splice.addedCount++;
index++;
splice.removed.push(old[oldIndex]);
oldIndex++;
break;
case EDIT_ADD:
if (!splice)
splice = newSplice(index, [], 0);
splice.addedCount++;
index++;
break;
case EDIT_DELETE:
if (!splice)
splice = newSplice(index, [], 0);
splice.removed.push(old[oldIndex]);
oldIndex++;
break;
}
}
if (splice) {
splices.push(splice);
}
return splices;
},
sharedPrefix: function (current, old, searchLength) {
for (var i = 0; i < searchLength; i++)
if (!this.equals(current[i], old[i]))
return i;
return searchLength;
},
sharedSuffix: function (current, old, searchLength) {
var index1 = current.length;
var index2 = old.length;
var count = 0;
while (count < searchLength && this.equals(current[--index1], old[--index2]))
count++;
return count;
},
calculateSplices: function (current, previous) {
return this.calcSplices(current, 0, current.length, previous, 0, previous.length);
},
equals: function (currentValue, previousValue) {
return currentValue === previousValue;
}
};
return new ArraySplice();
}();
Polymer.domInnerHTML = function () {
var escapeAttrRegExp = /[&\u00A0"]/g;
var escapeDataRegExp = /[&\u00A0<>]/g;
function escapeReplace(c) {
switch (c) {
case '&':
return '&';
case '<':
return '<';
case '>':
return '>';
case '"':
return '"';
case '\xA0':
return ' ';
}
}
function escapeAttr(s) {
return s.replace(escapeAttrRegExp, escapeReplace);
}
function escapeData(s) {
return s.replace(escapeDataRegExp, escapeReplace);
}
function makeSet(arr) {
var set = {};
for (var i = 0; i < arr.length; i++) {
set[arr[i]] = true;
}
return set;
}
var voidElements = makeSet([
'area',
'base',
'br',
'col',
'command',
'embed',
'hr',
'img',
'input',
'keygen',
'link',
'meta',
'param',
'source',
'track',
'wbr'
]);
var plaintextParents = makeSet([
'style',
'script',
'xmp',
'iframe',
'noembed',
'noframes',
'plaintext',
'noscript'
]);
function getOuterHTML(node, parentNode, composed) {
switch (node.nodeType) {
case Node.ELEMENT_NODE:
var tagName = node.localName;
var s = '<' + tagName;
var attrs = node.attributes;
for (var i = 0, attr; attr = attrs[i]; i++) {
s += ' ' + attr.name + '="' + escapeAttr(attr.value) + '"';
}
s += '>';
if (voidElements[tagName]) {
return s;
}
return s + getInnerHTML(node, composed) + '</' + tagName + '>';
case Node.TEXT_NODE:
var data = node.data;
if (parentNode && plaintextParents[parentNode.localName]) {
return data;
}
return escapeData(data);
case Node.COMMENT_NODE:
return '<!--' + node.data + '-->';
default:
console.error(node);
throw new Error('not implemented');
}
}
function getInnerHTML(node, composed) {
if (node instanceof HTMLTemplateElement)
node = node.content;
var s = '';
var c$ = Polymer.dom(node).childNodes;
c$ = composed ? node._composedChildren : c$;
for (var i = 0, l = c$.length, child; i < l && (child = c$[i]); i++) {
s += getOuterHTML(child, node, composed);
}
return s;
}
return { getInnerHTML: getInnerHTML };
}();
Polymer.DomApi = function () {
'use strict';
var Settings = Polymer.Settings;
var getInnerHTML = Polymer.domInnerHTML.getInnerHTML;
var nativeInsertBefore = Element.prototype.insertBefore;
var nativeRemoveChild = Element.prototype.removeChild;
var nativeAppendChild = Element.prototype.appendChild;
var nativeCloneNode = Element.prototype.cloneNode;
var nativeImportNode = Document.prototype.importNode;
var DomApi = function (node) {
this.node = node;
if (this.patch) {
this.patch();
}
};
if (window.wrap && Settings.useShadow && !Settings.useNativeShadow) {
DomApi = function (node) {
this.node = wrap(node);
if (this.patch) {
this.patch();
}
};
}
DomApi.prototype = {
flush: function () {
Polymer.dom.flush();
},
_lazyDistribute: function (host) {
if (host.shadyRoot && host.shadyRoot._distributionClean) {
host.shadyRoot._distributionClean = false;
Polymer.dom.addDebouncer(host.debounce('_distribute', host._distributeContent));
}
},
appendChild: function (node) {
return this._addNode(node);
},
insertBefore: function (node, ref_node) {
return this._addNode(node, ref_node);
},
_addNode: function (node, ref_node) {
this._removeNodeFromParent(node);
var addedInsertionPoint;
var root = this.getOwnerRoot();
if (root) {
addedInsertionPoint = this._maybeAddInsertionPoint(node, this.node);
}
if (this._nodeHasLogicalChildren(this.node)) {
if (ref_node) {
var children = this.childNodes;
var index = children.indexOf(ref_node);
if (index < 0) {
throw Error('The ref_node to be inserted before is not a child ' + 'of this node');
}
}
this._addLogicalInfo(node, this.node, index);
}
this._addNodeToHost(node);
if (!this._maybeDistribute(node, this.node) && !this._tryRemoveUndistributedNode(node)) {
if (ref_node) {
ref_node = ref_node.localName === CONTENT ? this._firstComposedNode(ref_node) : ref_node;
}
var container = this.node._isShadyRoot ? this.node.host : this.node;
addToComposedParent(container, node, ref_node);
if (ref_node) {
nativeInsertBefore.call(container, node, ref_node);
} else {
nativeAppendChild.call(container, node);
}
}
if (addedInsertionPoint) {
this._updateInsertionPoints(root.host);
}
this.notifyObserver();
return node;
},
removeChild: function (node) {
if (factory(node).parentNode !== this.node) {
console.warn('The node to be removed is not a child of this node', node);
}
this._removeNodeFromHost(node);
if (!this._maybeDistribute(node, this.node)) {
var container = this.node._isShadyRoot ? this.node.host : this.node;
if (container === node.parentNode) {
removeFromComposedParent(container, node);
nativeRemoveChild.call(container, node);
}
}
this.notifyObserver();
return node;
},
replaceChild: function (node, ref_node) {
this.insertBefore(node, ref_node);
this.removeChild(ref_node);
return node;
},
_hasCachedOwnerRoot: function (node) {
return Boolean(node._ownerShadyRoot !== undefined);
},
getOwnerRoot: function () {
return this._ownerShadyRootForNode(this.node);
},
_ownerShadyRootForNode: function (node) {
if (!node) {
return;
}
if (node._ownerShadyRoot === undefined) {
var root;
if (node._isShadyRoot) {
root = node;
} else {
var parent = Polymer.dom(node).parentNode;
if (parent) {
root = parent._isShadyRoot ? parent : this._ownerShadyRootForNode(parent);
} else {
root = null;
}
}
node._ownerShadyRoot = root;
}
return node._ownerShadyRoot;
},
_maybeDistribute: function (node, parent) {
var fragContent = node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && !node.__noContent && Polymer.dom(node).querySelector(CONTENT);
var wrappedContent = fragContent && Polymer.dom(fragContent).parentNode.nodeType !== Node.DOCUMENT_FRAGMENT_NODE;
var hasContent = fragContent || node.localName === CONTENT;
if (hasContent) {
var root = this._ownerShadyRootForNode(parent);
if (root) {
var host = root.host;
this._lazyDistribute(host);
}
}
var parentNeedsDist = this._parentNeedsDistribution(parent);
if (parentNeedsDist) {
this._lazyDistribute(parent);
}
return parentNeedsDist || hasContent && !wrappedContent;
},
_maybeAddInsertionPoint: function (node, parent) {
var added;
if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && !node.__noContent) {
var c$ = factory(node).querySelectorAll(CONTENT);
for (var i = 0, n, np, na; i < c$.length && (n = c$[i]); i++) {
np = factory(n).parentNode;
if (np === node) {
np = parent;
}
na = this._maybeAddInsertionPoint(n, np);
added = added || na;
}
} else if (node.localName === CONTENT) {
saveLightChildrenIfNeeded(parent);
saveLightChildrenIfNeeded(node);
added = true;
}
return added;
},
_tryRemoveUndistributedNode: function (node) {
if (this.node.shadyRoot) {
var parent = getComposedParent(node);
if (parent) {
nativeRemoveChild.call(parent, node);
}
return true;
}
},
_updateInsertionPoints: function (host) {
var i$ = host.shadyRoot._insertionPoints = factory(host.shadyRoot).querySelectorAll(CONTENT);
for (var i = 0, c; i < i$.length; i++) {
c = i$[i];
saveLightChildrenIfNeeded(c);
saveLightChildrenIfNeeded(factory(c).parentNode);
}
},
_nodeHasLogicalChildren: function (node) {
return Boolean(node._lightChildren !== undefined);
},
_parentNeedsDistribution: function (parent) {
return parent && parent.shadyRoot && hasInsertionPoint(parent.shadyRoot);
},
_removeNodeFromParent: function (node) {
var parent = node._lightParent || node.parentNode;
if (parent && hasDomApi(parent)) {
factory(parent).notifyObserver();
}
this._removeNodeFromHost(node, true);
},
_removeNodeFromHost: function (node, ensureComposedRemoval) {
var hostNeedsDist;
var root;
var parent = node._lightParent;
if (parent) {
factory(node)._distributeParent();
root = this._ownerShadyRootForNode(node);
if (root) {
root.host._elementRemove(node);
hostNeedsDist = this._removeDistributedChildren(root, node);
}
this._removeLogicalInfo(node, parent);
}
this._removeOwnerShadyRoot(node);
if (root && hostNeedsDist) {
this._updateInsertionPoints(root.host);
this._lazyDistribute(root.host);
} else if (ensureComposedRemoval) {
removeFromComposedParent(getComposedParent(node), node);
}
},
_removeDistributedChildren: function (root, container) {
var hostNeedsDist;
var ip$ = root._insertionPoints;
for (var i = 0; i < ip$.length; i++) {
var content = ip$[i];
if (this._contains(container, content)) {
var dc$ = factory(content).getDistributedNodes();
for (var j = 0; j < dc$.length; j++) {
hostNeedsDist = true;
var node = dc$[j];
var parent = node.parentNode;
if (parent) {
removeFromComposedParent(parent, node);
nativeRemoveChild.call(parent, node);
}
}
}
}
return hostNeedsDist;
},
_contains: function (container, node) {
while (node) {
if (node == container) {
return true;
}
node = factory(node).parentNode;
}
},
_addNodeToHost: function (node) {
var root = this.getOwnerRoot();
if (root) {
root.host._elementAdd(node);
}
},
_addLogicalInfo: function (node, container, index) {
var children = factory(container).childNodes;
index = index === undefined ? children.length : index;
if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
var c$ = Array.prototype.slice.call(node.childNodes);
for (var i = 0, n; i < c$.length && (n = c$[i]); i++) {
children.splice(index++, 0, n);
n._lightParent = container;
}
} else {
children.splice(index, 0, node);
node._lightParent = container;
}
},
_removeLogicalInfo: function (node, container) {
var children = factory(container).childNodes;
var index = children.indexOf(node);
if (index < 0 || container !== node._lightParent) {
throw Error('The node to be removed is not a child of this node');
}
children.splice(index, 1);
node._lightParent = null;
},
_removeOwnerShadyRoot: function (node) {
if (this._hasCachedOwnerRoot(node)) {
var c$ = factory(node).childNodes;
for (var i = 0, l = c$.length, n; i < l && (n = c$[i]); i++) {
this._removeOwnerShadyRoot(n);
}
}
node._ownerShadyRoot = undefined;
},
_firstComposedNode: function (content) {
var n$ = factory(content).getDistributedNodes();
for (var i = 0, l = n$.length, n, p$; i < l && (n = n$[i]); i++) {
p$ = factory(n).getDestinationInsertionPoints();
if (p$[p$.length - 1] === content) {
return n;
}
}
},
querySelector: function (selector) {
return this.querySelectorAll(selector)[0];
},
querySelectorAll: function (selector) {
return this._query(function (n) {
return matchesSelector.call(n, selector);
}, this.node);
},
_query: function (matcher, node) {
node = node || this.node;
var list = [];
this._queryElements(factory(node).childNodes, matcher, list);
return list;
},
_queryElements: function (elements, matcher, list) {
for (var i = 0, l = elements.length, c; i < l && (c = elements[i]); i++) {
if (c.nodeType === Node.ELEMENT_NODE) {
this._queryElement(c, matcher, list);
}
}
},
_queryElement: function (node, matcher, list) {
if (matcher(node)) {
list.push(node);
}
this._queryElements(factory(node).childNodes, matcher, list);
},
getDestinationInsertionPoints: function () {
return this.node._destinationInsertionPoints || [];
},
getDistributedNodes: function () {
return this.node._distributedNodes || [];
},
queryDistributedElements: function (selector) {
var c$ = this.getEffectiveChildNodes();
var list = [];
for (var i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
if (c.nodeType === Node.ELEMENT_NODE && matchesSelector.call(c, selector)) {
list.push(c);
}
}
return list;
},
getEffectiveChildNodes: function () {
var list = [];
var c$ = this.childNodes;
for (var i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
if (c.localName === CONTENT) {
var d$ = factory(c).getDistributedNodes();
for (var j = 0; j < d$.length; j++) {
list.push(d$[j]);
}
} else {
list.push(c);
}
}
return list;
},
_clear: function () {
while (this.childNodes.length) {
this.removeChild(this.childNodes[0]);
}
},
setAttribute: function (name, value) {
this.node.setAttribute(name, value);
this._distributeParent();
},
removeAttribute: function (name) {
this.node.removeAttribute(name);
this._distributeParent();
},
_distributeParent: function () {
if (this._parentNeedsDistribution(this.parentNode)) {
this._lazyDistribute(this.parentNode);
}
},
cloneNode: function (deep) {
var n = nativeCloneNode.call(this.node, false);
if (deep) {
var c$ = this.childNodes;
var d = factory(n);
for (var i = 0, nc; i < c$.length; i++) {
nc = factory(c$[i]).cloneNode(true);
d.appendChild(nc);
}
}
return n;
},
importNode: function (externalNode, deep) {
var doc = this.node instanceof Document ? this.node : this.node.ownerDocument;
var n = nativeImportNode.call(doc, externalNode, false);
if (deep) {
var c$ = factory(externalNode).childNodes;
var d = factory(n);
for (var i = 0, nc; i < c$.length; i++) {
nc = factory(doc).importNode(c$[i], true);
d.appendChild(nc);
}
}
return n;
},
observeNodes: function (callback) {
if (callback) {
if (!this.observer) {
this.observer = this.node.localName === CONTENT ? new DomApi.DistributedNodesObserver(this) : new DomApi.EffectiveNodesObserver(this);
}
return this.observer.addListener(callback);
}
},
unobserveNodes: function (handle) {
if (this.observer) {
this.observer.removeListener(handle);
}
},
notifyObserver: function () {
if (this.observer) {
this.observer.notify();
}
}
};
if (!Settings.useShadow) {
Object.defineProperties(DomApi.prototype, {
childNodes: {
get: function () {
var c$ = getLightChildren(this.node);
return Array.isArray(c$) ? c$ : Array.prototype.slice.call(c$);
},
configurable: true
},
children: {
get: function () {
return Array.prototype.filter.call(this.childNodes, function (n) {
return n.nodeType === Node.ELEMENT_NODE;
});
},
configurable: true
},
parentNode: {
get: function () {
return this.node._lightParent || getComposedParent(this.node);
},
configurable: true
},
firstChild: {
get: function () {
return this.childNodes[0];
},
configurable: true
},
lastChild: {
get: function () {
var c$ = this.childNodes;
return c$[c$.length - 1];
},
configurable: true
},
nextSibling: {
get: function () {
var c$ = this.parentNode && factory(this.parentNode).childNodes;
if (c$) {
return c$[Array.prototype.indexOf.call(c$, this.node) + 1];
}
},
configurable: true
},
previousSibling: {
get: function () {
var c$ = this.parentNode && factory(this.parentNode).childNodes;
if (c$) {
return c$[Array.prototype.indexOf.call(c$, this.node) - 1];
}
},
configurable: true
},
firstElementChild: {
get: function () {
return this.children[0];
},
configurable: true
},
lastElementChild: {
get: function () {
var c$ = this.children;
return c$[c$.length - 1];
},
configurable: true
},
nextElementSibling: {
get: function () {
var c$ = this.parentNode && factory(this.parentNode).children;
if (c$) {
return c$[Array.prototype.indexOf.call(c$, this.node) + 1];
}
},
configurable: true
},
previousElementSibling: {
get: function () {
var c$ = this.parentNode && factory(this.parentNode).children;
if (c$) {
return c$[Array.prototype.indexOf.call(c$, this.node) - 1];
}
},
configurable: true
},
textContent: {
get: function () {
var nt = this.node.nodeType;
if (nt === Node.TEXT_NODE || nt === Node.COMMENT_NODE) {
return this.node.textContent;
} else {
var tc = [];
for (var i = 0, cn = this.childNodes, c; c = cn[i]; i++) {
if (c.nodeType !== Node.COMMENT_NODE) {
tc.push(c.textContent);
}
}
return tc.join('');
}
},
set: function (text) {
var nt = this.node.nodeType;
if (nt === Node.TEXT_NODE || nt === Node.COMMENT_NODE) {
this.node.textContent = text;
} else {
this._clear();
if (text) {
this.appendChild(document.createTextNode(text));
}
}
},
configurable: true
},
innerHTML: {
get: function () {
var nt = this.node.nodeType;
if (nt === Node.TEXT_NODE || nt === Node.COMMENT_NODE) {
return null;
} else {
return getInnerHTML(this.node);
}
},
set: function (text) {
var nt = this.node.nodeType;
if (nt !== Node.TEXT_NODE || nt !== Node.COMMENT_NODE) {
this._clear();
var d = document.createElement('div');
d.innerHTML = text;
var c$ = Array.prototype.slice.call(d.childNodes);
for (var i = 0; i < c$.length; i++) {
this.appendChild(c$[i]);
}
}
},
configurable: true
}
});
DomApi.prototype._getComposedInnerHTML = function () {
return getInnerHTML(this.node, true);
};
} else {
var forwardMethods = [
'cloneNode',
'appendChild',
'insertBefore',
'removeChild',
'replaceChild'
];
forwardMethods.forEach(function (name) {
DomApi.prototype[name] = function () {
return this.node[name].apply(this.node, arguments);
};
});
DomApi.prototype.querySelectorAll = function (selector) {
return Array.prototype.slice.call(this.node.querySelectorAll(selector));
};
DomApi.prototype.getOwnerRoot = function () {
var n = this.node;
while (n) {
if (n.nodeType === Node.DOCUMENT_FRAGMENT_NODE && n.host) {
return n;
}
n = n.parentNode;
}
};
DomApi.prototype.importNode = function (externalNode, deep) {
var doc = this.node instanceof Document ? this.node : this.node.ownerDocument;
return doc.importNode(externalNode, deep);
};
DomApi.prototype.getDestinationInsertionPoints = function () {
var n$ = this.node.getDestinationInsertionPoints && this.node.getDestinationInsertionPoints();
return n$ ? Array.prototype.slice.call(n$) : [];
};
DomApi.prototype.getDistributedNodes = function () {
var n$ = this.node.getDistributedNodes && this.node.getDistributedNodes();
return n$ ? Array.prototype.slice.call(n$) : [];
};
DomApi.prototype._distributeParent = function () {
};
var nativeForwards = [
'appendChild',
'insertBefore',
'removeChild',
'replaceChild'
];
nativeForwards.forEach(function (forward) {
DomApi.prototype[forward] = function () {
return this.node[forward].apply(this.node, arguments);
};
});
Object.defineProperties(DomApi.prototype, {
childNodes: {
get: function () {
return Array.prototype.slice.call(this.node.childNodes);
},
configurable: true
},
children: {
get: function () {
return Array.prototype.slice.call(this.node.children);
},
configurable: true
},
textContent: {
get: function () {
return this.node.textContent;
},
set: function (value) {
return this.node.textContent = value;
},
configurable: true
},
innerHTML: {
get: function () {
return this.node.innerHTML;
},
set: function (value) {
return this.node.innerHTML = value;
},
configurable: true
}
});
var forwardProperties = [
'parentNode',
'firstChild',
'lastChild',
'nextSibling',
'previousSibling',
'firstElementChild',
'lastElementChild',
'nextElementSibling',
'previousElementSibling'
];
forwardProperties.forEach(function (name) {
Object.defineProperty(DomApi.prototype, name, {
get: function () {
return this.node[name];
},
configurable: true
});
});
}
var CONTENT = 'content';
function factory(node, patch) {
node = node || document;
if (!node.__domApi) {
node.__domApi = new DomApi(node, patch);
}
return node.__domApi;
}
;
function hasDomApi(node) {
return Boolean(node.__domApi);
}
Polymer.dom = function (obj, patch) {
if (obj instanceof Event) {
return Polymer.EventApi.factory(obj);
} else {
return factory(obj, patch);
}
};
function getLightChildren(node) {
var children = node._lightChildren;
return children ? children : node.childNodes;
}
function getComposedChildren(node) {
if (!node._composedChildren) {
node._composedChildren = Array.prototype.slice.call(node.childNodes);
}
return node._composedChildren;
}
function addToComposedParent(parent, node, ref_node) {
var children = getComposedChildren(parent);
var i = ref_node ? children.indexOf(ref_node) : -1;
if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
var fragChildren = getComposedChildren(node);
for (var j = 0; j < fragChildren.length; j++) {
addNodeToComposedChildren(fragChildren[j], parent, children, i + j);
}
node._composedChildren = null;
} else {
addNodeToComposedChildren(node, parent, children, i);
}
}
function getComposedParent(node) {
return node.__patched ? node._composedParent : node.parentNode;
}
function addNodeToComposedChildren(node, parent, children, i) {
node._composedParent = parent;
children.splice(i >= 0 ? i : children.length, 0, node);
}
function removeFromComposedParent(parent, node) {
node._composedParent = null;
if (parent) {
var children = getComposedChildren(parent);
var i = children.indexOf(node);
if (i >= 0) {
children.splice(i, 1);
}
}
}
function saveLightChildrenIfNeeded(node) {
if (!node._lightChildren) {
var c$ = Array.prototype.slice.call(node.childNodes);
for (var i = 0, l = c$.length, child; i < l && (child = c$[i]); i++) {
child._lightParent = child._lightParent || node;
}
node._lightChildren = c$;
}
}
function hasInsertionPoint(root) {
return Boolean(root && root._insertionPoints.length);
}
var p = Element.prototype;
var matchesSelector = p.matches || p.matchesSelector || p.mozMatchesSelector || p.msMatchesSelector || p.oMatchesSelector || p.webkitMatchesSelector;
return {
getLightChildren: getLightChildren,
getComposedParent: getComposedParent,
getComposedChildren: getComposedChildren,
removeFromComposedParent: removeFromComposedParent,
saveLightChildrenIfNeeded: saveLightChildrenIfNeeded,
matchesSelector: matchesSelector,
hasInsertionPoint: hasInsertionPoint,
ctor: DomApi,
factory: factory,
hasDomApi: hasDomApi
};
}();
Polymer.Base.extend(Polymer.dom, {
_flushGuard: 0,
_FLUSH_MAX: 100,
_needsTakeRecords: !Polymer.Settings.useNativeCustomElements,
_debouncers: [],
_staticFlushList: [],
_finishDebouncer: null,
flush: function () {
this._flushGuard = 0;
this._prepareFlush();
while (this._debouncers.length && this._flushGuard < this._FLUSH_MAX) {
for (var i = 0; i < this._debouncers.length; i++) {
this._debouncers[i].complete();
}
if (this._finishDebouncer) {
this._finishDebouncer.complete();
}
this._prepareFlush();
this._flushGuard++;
}
if (this._flushGuard >= this._FLUSH_MAX) {
console.warn('Polymer.dom.flush aborted. Flush may not be complete.');
}
},
_prepareFlush: function () {
if (this._needsTakeRecords) {
CustomElements.takeRecords();
}
for (var i = 0; i < this._staticFlushList.length; i++) {
this._staticFlushList[i]();
}
},
addStaticFlush: function (fn) {
this._staticFlushList.push(fn);
},
removeStaticFlush: function (fn) {
var i = this._staticFlushList.indexOf(fn);
if (i >= 0) {
this._staticFlushList.splice(i, 1);
}
},
addDebouncer: function (debouncer) {
this._debouncers.push(debouncer);
this._finishDebouncer = Polymer.Debounce(this._finishDebouncer, this._finishFlush);
},
_finishFlush: function () {
Polymer.dom._debouncers = [];
}
});
Polymer.EventApi = function () {
'use strict';
var DomApi = Polymer.DomApi.ctor;
var Settings = Polymer.Settings;
DomApi.Event = function (event) {
this.event = event;
};
if (Settings.useShadow) {
DomApi.Event.prototype = {
get rootTarget() {
return this.event.path[0];
},
get localTarget() {
return this.event.target;
},
get path() {
return this.event.path;
}
};
} else {
DomApi.Event.prototype = {
get rootTarget() {
return this.event.target;
},
get localTarget() {
var current = this.event.currentTarget;
var currentRoot = current && Polymer.dom(current).getOwnerRoot();
var p$ = this.path;
for (var i = 0; i < p$.length; i++) {
if (Polymer.dom(p$[i]).getOwnerRoot() === currentRoot) {
return p$[i];
}
}
},
get path() {
if (!this.event._path) {
var path = [];
var o = this.rootTarget;
while (o) {
path.push(o);
o = Polymer.dom(o).parentNode || o.host;
}
path.push(window);
this.event._path = path;
}
return this.event._path;
}
};
}
var factory = function (event) {
if (!event.__eventApi) {
event.__eventApi = new DomApi.Event(event);
}
return event.__eventApi;
};
return { factory: factory };
}();
(function () {
'use strict';
var DomApi = Polymer.DomApi.ctor;
Object.defineProperty(DomApi.prototype, 'classList', {
get: function () {
if (!this._classList) {
this._classList = new DomApi.ClassList(this);
}
return this._classList;
},
configurable: true
});
DomApi.ClassList = function (host) {
this.domApi = host;
this.node = host.node;
};
DomApi.ClassList.prototype = {
add: function () {
this.node.classList.add.apply(this.node.classList, arguments);
this.domApi._distributeParent();
},
remove: function () {
this.node.classList.remove.apply(this.node.classList, arguments);
this.domApi._distributeParent();
},
toggle: function () {
this.node.classList.toggle.apply(this.node.classList, arguments);
this.domApi._distributeParent();
},
contains: function () {
return this.node.classList.contains.apply(this.node.classList, arguments);
}
};
}());
(function () {
'use strict';
var DomApi = Polymer.DomApi.ctor;
var Settings = Polymer.Settings;
var hasDomApi = Polymer.DomApi.hasDomApi;
DomApi.EffectiveNodesObserver = function (domApi) {
this.domApi = domApi;
this.node = this.domApi.node;
this._listeners = [];
};
DomApi.EffectiveNodesObserver.prototype = {
addListener: function (callback) {
if (!this._isSetup) {
this._setup();
this._isSetup = true;
}
var listener = {
fn: callback,
_nodes: []
};
this._listeners.push(listener);
this._scheduleNotify();
return listener;
},
removeListener: function (handle) {
var i = this._listeners.indexOf(handle);
if (i >= 0) {
this._listeners.splice(i, 1);
handle._nodes = [];
}
if (!this._hasListeners()) {
this._cleanup();
this._isSetup = false;
}
},
_setup: function () {
this._observeContentElements(this.domApi.childNodes);
},
_cleanup: function () {
this._unobserveContentElements(this.domApi.childNodes);
},
_hasListeners: function () {
return Boolean(this._listeners.length);
},
_scheduleNotify: function () {
if (this._debouncer) {
this._debouncer.stop();
}
this._debouncer = Polymer.Debounce(this._debouncer, this._notify);
this._debouncer.context = this;
Polymer.dom.addDebouncer(this._debouncer);
},
notify: function () {
if (this._hasListeners()) {
this._scheduleNotify();
}
},
_notify: function (mxns) {
this._beforeCallListeners();
this._callListeners();
},
_beforeCallListeners: function () {
this._updateContentElements();
},
_updateContentElements: function () {
this._observeContentElements(this.domApi.childNodes);
},
_observeContentElements: function (elements) {
for (var i = 0, n; i < elements.length && (n = elements[i]); i++) {
if (this._isContent(n)) {
n.__observeNodesMap = n.__observeNodesMap || new WeakMap();
if (!n.__observeNodesMap.has(this)) {
n.__observeNodesMap.set(this, this._observeContent(n));
}
}
}
},
_observeContent: function (content) {
var h = Polymer.dom(content).observeNodes(this._scheduleNotify.bind(this));
h._avoidChangeCalculation = true;
return h;
},
_unobserveContentElements: function (elements) {
for (var i = 0, n, h; i < elements.length && (n = elements[i]); i++) {
if (this._isContent(n)) {
h = n.__observeNodesMap.get(this);
if (h) {
Polymer.dom(n).unobserveNodes(h);
n.__observeNodesMap.delete(this);
}
}
}
},
_isContent: function (node) {
return node.localName === 'content';
},
_callListeners: function () {
var o$ = this._listeners;
var nodes = this._getEffectiveNodes();
for (var i = 0, o; i < o$.length && (o = o$[i]); i++) {
var info = this._generateListenerInfo(o, nodes);
if (info || o._alwaysNotify) {
this._callListener(o, info);
}
}
},
_getEffectiveNodes: function () {
return this.domApi.getEffectiveChildNodes();
},
_generateListenerInfo: function (listener, newNodes) {
if (listener._avoidChangeCalculation) {
return true;
}
var oldNodes = listener._nodes;
var info = {
target: this.node,
addedNodes: [],
removedNodes: []
};
var splices = Polymer.ArraySplice.calculateSplices(newNodes, oldNodes);
for (var i = 0, s; i < splices.length && (s = splices[i]); i++) {
for (var j = 0, n; j < s.removed.length && (n = s.removed[j]); j++) {
info.removedNodes.push(n);
}
}
for (var i = 0, s; i < splices.length && (s = splices[i]); i++) {
for (var j = s.index; j < s.index + s.addedCount; j++) {
info.addedNodes.push(newNodes[j]);
}
}
listener._nodes = newNodes;
if (info.addedNodes.length || info.removedNodes.length) {
return info;
}
},
_callListener: function (listener, info) {
return listener.fn.call(this.node, info);
},
enableShadowAttributeTracking: function () {
}
};
if (Settings.useShadow) {
var baseSetup = DomApi.EffectiveNodesObserver.prototype._setup;
var baseCleanup = DomApi.EffectiveNodesObserver.prototype._cleanup;
var beforeCallListeners = DomApi.EffectiveNodesObserver.prototype._beforeCallListeners;
Polymer.Base.extend(DomApi.EffectiveNodesObserver.prototype, {
_setup: function () {
if (!this._observer) {
var self = this;
this._mutationHandler = function (mxns) {
if (mxns && mxns.length) {
self._scheduleNotify();
}
};
this._observer = new MutationObserver(this._mutationHandler);
this._boundFlush = this._flush.bind(this);
Polymer.dom.addStaticFlush(this._boundFlush);
this._observer.observe(this.node, { childList: true });
}
baseSetup.call(this);
},
_cleanup: function () {
this._observer.disconnect();
this._observer = null;
this._mutationHandler = null;
Polymer.dom.removeStaticFlush(this._boundFlush);
baseCleanup.call(this);
},
_flush: function () {
if (this._observer) {
this._mutationHandler(this._observer.takeRecords());
}
},
enableShadowAttributeTracking: function () {
if (this._observer) {
this._makeContentListenersAlwaysNotify();
this._observer.disconnect();
this._observer.observe(this.node, {
childList: true,
attributes: true,
subtree: true
});
var root = this.domApi.getOwnerRoot();
var host = root && root.host;
if (host && Polymer.dom(host).observer) {
Polymer.dom(host).observer.enableShadowAttributeTracking();
}
}
},
_makeContentListenersAlwaysNotify: function () {
for (var i = 0, h; i < this._listeners.length; i++) {
h = this._listeners[i];
h._alwaysNotify = h._isContentListener;
}
}
});
}
}());
(function () {
'use strict';
var DomApi = Polymer.DomApi.ctor;
var Settings = Polymer.Settings;
DomApi.DistributedNodesObserver = function (domApi) {
DomApi.EffectiveNodesObserver.call(this, domApi);
};
DomApi.DistributedNodesObserver.prototype = Object.create(DomApi.EffectiveNodesObserver.prototype);
Polymer.Base.extend(DomApi.DistributedNodesObserver.prototype, {
_setup: function () {
},
_cleanup: function () {
},
_beforeCallListeners: function () {
},
_getEffectiveNodes: function () {
return this.domApi.getDistributedNodes();
}
});
if (Settings.useShadow) {
Polymer.Base.extend(DomApi.DistributedNodesObserver.prototype, {
_setup: function () {
if (!this._observer) {
var root = this.domApi.getOwnerRoot();
var host = root && root.host;
if (host) {
this._observer = Polymer.dom(host).observeNodes(this._scheduleNotify.bind(this));
this._observer._isContentListener = true;
if (this._hasAttrSelect()) {
Polymer.dom(host).observer.enableShadowAttributeTracking();
}
}
}
},
_hasAttrSelect: function () {
var select = this.node.getAttribute('select');
return select && select.match(/[[.]+/);
},
_cleanup: function () {
var root = this.domApi.getOwnerRoot();
var host = root && root.host;
if (host) {
Polymer.dom(host).unobserveNodes(this._observer);
}
this._observer = null;
}
});
}
}());
(function () {
var hasDomApi = Polymer.DomApi.hasDomApi;
Polymer.Base._addFeature({
_prepShady: function () {
this._useContent = this._useContent || Boolean(this._template);
},
_poolContent: function () {
if (this._useContent) {
saveLightChildrenIfNeeded(this);
}
},
_setupRoot: function () {
if (this._useContent) {
this._createLocalRoot();
if (!this.dataHost) {
upgradeLightChildren(this._lightChildren);
}
}
},
_createLocalRoot: function () {
this.shadyRoot = this.root;
this.shadyRoot._distributionClean = false;
this.shadyRoot._isShadyRoot = true;
this.shadyRoot._dirtyRoots = [];
var i$ = this.shadyRoot._insertionPoints = !this._notes || this._notes._hasContent ? this.shadyRoot.querySelectorAll('content') : [];
saveLightChildrenIfNeeded(this.shadyRoot);
for (var i = 0, c; i < i$.length; i++) {
c = i$[i];
saveLightChildrenIfNeeded(c);
saveLightChildrenIfNeeded(c.parentNode);
}
this.shadyRoot.host = this;
},
get domHost() {
var root = Polymer.dom(this).getOwnerRoot();
return root && root.host;
},
distributeContent: function (updateInsertionPoints) {
if (this.shadyRoot) {
var dom = Polymer.dom(this);
if (updateInsertionPoints) {
dom._updateInsertionPoints(this);
}
var host = getTopDistributingHost(this);
dom._lazyDistribute(host);
}
},
_distributeContent: function () {
if (this._useContent && !this.shadyRoot._distributionClean) {
this._beginDistribute();
this._distributeDirtyRoots();
this._finishDistribute();
}
},
_beginDistribute: function () {
if (this._useContent && hasInsertionPoint(this.shadyRoot)) {
this._resetDistribution();
this._distributePool(this.shadyRoot, this._collectPool());
}
},
_distributeDirtyRoots: function () {
var c$ = this.shadyRoot._dirtyRoots;
for (var i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
c._distributeContent();
}
this.shadyRoot._dirtyRoots = [];
},
_finishDistribute: function () {
if (this._useContent) {
this.shadyRoot._distributionClean = true;
if (hasInsertionPoint(this.shadyRoot)) {
this._composeTree();
notifyContentObservers(this.shadyRoot);
} else {
if (!this.shadyRoot._hasDistributed) {
this.textContent = '';
this._composedChildren = null;
this.appendChild(this.shadyRoot);
} else {
var children = this._composeNode(this);
this._updateChildNodes(this, children);
}
}
if (!this.shadyRoot._hasDistributed) {
notifyInitialDistribution(this);
}
this.shadyRoot._hasDistributed = true;
}
},
elementMatches: function (selector, node) {
node = node || this;
return matchesSelector.call(node, selector);
},
_resetDistribution: function () {
var children = getLightChildren(this);
for (var i = 0; i < children.length; i++) {
var child = children[i];
if (child._destinationInsertionPoints) {
child._destinationInsertionPoints = undefined;
}
if (isInsertionPoint(child)) {
clearDistributedDestinationInsertionPoints(child);
}
}
var root = this.shadyRoot;
var p$ = root._insertionPoints;
for (var j = 0; j < p$.length; j++) {
p$[j]._distributedNodes = [];
}
},
_collectPool: function () {
var pool = [];
var children = getLightChildren(this);
for (var i = 0; i < children.length; i++) {
var child = children[i];
if (isInsertionPoint(child)) {
pool.push.apply(pool, child._distributedNodes);
} else {
pool.push(child);
}
}
return pool;
},
_distributePool: function (node, pool) {
var p$ = node._insertionPoints;
for (var i = 0, l = p$.length, p; i < l && (p = p$[i]); i++) {
this._distributeInsertionPoint(p, pool);
maybeRedistributeParent(p, this);
}
},
_distributeInsertionPoint: function (content, pool) {
var anyDistributed = false;
for (var i = 0, l = pool.length, node; i < l; i++) {
node = pool[i];
if (!node) {
continue;
}
if (this._matchesContentSelect(node, content)) {
distributeNodeInto(node, content);
pool[i] = undefined;
anyDistributed = true;
}
}
if (!anyDistributed) {
var children = getLightChildren(content);
for (var j = 0; j < children.length; j++) {
distributeNodeInto(children[j], content);
}
}
},
_composeTree: function () {
this._updateChildNodes(this, this._composeNode(this));
var p$ = this.shadyRoot._insertionPoints;
for (var i = 0, l = p$.length, p, parent; i < l && (p = p$[i]); i++) {
parent = p._lightParent || p.parentNode;
if (!parent._useContent && parent !== this && parent !== this.shadyRoot) {
this._updateChildNodes(parent, this._composeNode(parent));
}
}
},
_composeNode: function (node) {
var children = [];
var c$ = getLightChildren(node.shadyRoot || node);
for (var i = 0; i < c$.length; i++) {
var child = c$[i];
if (isInsertionPoint(child)) {
var distributedNodes = child._distributedNodes;
for (var j = 0; j < distributedNodes.length; j++) {
var distributedNode = distributedNodes[j];
if (isFinalDestination(child, distributedNode)) {
children.push(distributedNode);
}
}
} else {
children.push(child);
}
}
return children;
},
_updateChildNodes: function (container, children) {
var composed = getComposedChildren(container);
var splices = Polymer.ArraySplice.calculateSplices(children, composed);
for (var i = 0, d = 0, s; i < splices.length && (s = splices[i]); i++) {
for (var j = 0, n; j < s.removed.length && (n = s.removed[j]); j++) {
if (getComposedParent(n) === container) {
remove(n);
}
composed.splice(s.index + d, 1);
}
d -= s.addedCount;
}
for (var i = 0, s, next; i < splices.length && (s = splices[i]); i++) {
next = composed[s.index];
for (var j = s.index, n; j < s.index + s.addedCount; j++) {
n = children[j];
insertBefore(container, n, next);
composed.splice(j, 0, n);
}
}
ensureComposedParent(container, children);
},
_matchesContentSelect: function (node, contentElement) {
var select = contentElement.getAttribute('select');
if (!select) {
return true;
}
select = select.trim();
if (!select) {
return true;
}
if (!(node instanceof Element)) {
return false;
}
var validSelectors = /^(:not\()?[*.#[a-zA-Z_|]/;
if (!validSelectors.test(select)) {
return false;
}
return this.elementMatches(select, node);
},
_elementAdd: function () {
},
_elementRemove: function () {
}
});
var saveLightChildrenIfNeeded = Polymer.DomApi.saveLightChildrenIfNeeded;
var getLightChildren = Polymer.DomApi.getLightChildren;
var matchesSelector = Polymer.DomApi.matchesSelector;
var hasInsertionPoint = Polymer.DomApi.hasInsertionPoint;
var getComposedChildren = Polymer.DomApi.getComposedChildren;
var getComposedParent = Polymer.DomApi.getComposedParent;
var removeFromComposedParent = Polymer.DomApi.removeFromComposedParent;
function distributeNodeInto(child, insertionPoint) {
insertionPoint._distributedNodes.push(child);
var points = child._destinationInsertionPoints;
if (!points) {
child._destinationInsertionPoints = [insertionPoint];
} else {
points.push(insertionPoint);
}
}
function clearDistributedDestinationInsertionPoints(content) {
var e$ = content._distributedNodes;
if (e$) {
for (var i = 0; i < e$.length; i++) {
var d = e$[i]._destinationInsertionPoints;
if (d) {
d.splice(d.indexOf(content) + 1, d.length);
}
}
}
}
function maybeRedistributeParent(content, host) {
var parent = content._lightParent;
if (parent && parent.shadyRoot && hasInsertionPoint(parent.shadyRoot) && parent.shadyRoot._distributionClean) {
parent.shadyRoot._distributionClean = false;
host.shadyRoot._dirtyRoots.push(parent);
}
}
function isFinalDestination(insertionPoint, node) {
var points = node._destinationInsertionPoints;
return points && points[points.length - 1] === insertionPoint;
}
function isInsertionPoint(node) {
return node.localName == 'content';
}
var nativeInsertBefore = Element.prototype.insertBefore;
var nativeRemoveChild = Element.prototype.removeChild;
function insertBefore(parentNode, newChild, refChild) {
var newChildParent = getComposedParent(newChild);
if (newChildParent !== parentNode) {
removeFromComposedParent(newChildParent, newChild);
}
remove(newChild);
nativeInsertBefore.call(parentNode, newChild, refChild || null);
newChild._composedParent = parentNode;
}
function remove(node) {
var parentNode = getComposedParent(node);
if (parentNode) {
node._composedParent = null;
nativeRemoveChild.call(parentNode, node);
}
}
function ensureComposedParent(parent, children) {
for (var i = 0, n; i < children.length; i++) {
children[i]._composedParent = parent;
}
}
function getTopDistributingHost(host) {
while (host && hostNeedsRedistribution(host)) {
host = host.domHost;
}
return host;
}
function hostNeedsRedistribution(host) {
var c$ = Polymer.dom(host).children;
for (var i = 0, c; i < c$.length; i++) {
c = c$[i];
if (c.localName === 'content') {
return host.domHost;
}
}
}
function notifyContentObservers(root) {
for (var i = 0, c; i < root._insertionPoints.length; i++) {
c = root._insertionPoints[i];
if (hasDomApi(c)) {
Polymer.dom(c).notifyObserver();
}
}
}
function notifyInitialDistribution(host) {
if (hasDomApi(host)) {
Polymer.dom(host).notifyObserver();
}
}
var needsUpgrade = window.CustomElements && !CustomElements.useNative;
function upgradeLightChildren(children) {
if (needsUpgrade && children) {
for (var i = 0; i < children.length; i++) {
CustomElements.upgrade(children[i]);
}
}
}
}());
if (Polymer.Settings.useShadow) {
Polymer.Base._addFeature({
_poolContent: function () {
},
_beginDistribute: function () {
},
distributeContent: function () {
},
_distributeContent: function () {
},
_finishDistribute: function () {
},
_createLocalRoot: function () {
this.createShadowRoot();
this.shadowRoot.appendChild(this.root);
this.root = this.shadowRoot;
}
});
}
Polymer.DomModule = document.createElement('dom-module');
Polymer.Base._addFeature({
_registerFeatures: function () {
this._prepIs();
this._prepAttributes();
this._prepBehaviors();
this._prepConstructor();
this._prepTemplate();
this._prepShady();
},
_prepBehavior: function (b) {
this._addHostAttributes(b.hostAttributes);
},
_initFeatures: function () {
this._poolContent();
this._pushHost();
this._stampTemplate();
this._popHost();
this._marshalHostAttributes();
this._setupDebouncers();
this._marshalBehaviors();
this._tryReady();
},
_marshalBehavior: function (b) {
}
});</script>


text:
from sqlalchemy.dialects.postgresql import UUID
from podhub.website import db
from . import Base

class User(Base, db.Model):
    __tablename__ = 'user'
    profile = db.relationship('Profile', backref='user', lazy='dynamic',
                              uselist=False)

class Profile(Base, db.Model):
    __tablename__ = 'profile'
    username = db.Column(db.String(80), index=True, unique=True)
    email = db.Column(db.String(120), index=True, unique=True)
    display_name = db.Column(db.String(80), index=True, unique=True)
    first_name = db.Column(db.String(80), index=True)
    last_name = db.Column(db.String(80), index=True)
    user_id = db.Column(UUID, db.ForeignKey('user.id'))
    author_id = db.Column(UUID, db.ForeignKey('author.id'))

    def __init__(self, username, email, first_name=None, last_name=None,
                 display_name=None, user_id=None, author_id=None):
        self.username = username
        self.email = email
        if not display_name:
            self.display_name = username
        else:
            self.display_name = display_name
        self.first_name = first_name
        self.last_name = last_name

        self.user_id = user_id
        self.author_id = author_id

class Author(Base, db.Model):
    __tablename__ = 'author'
    name = db.Column(db.String(80), index=True)
    profile = db.relationship('Profile', backref='author', lazy='dynamic',
                              uselist=False)

    def __init__(self, name):
        self.name = name

class Publisher(Base, db.Model):
    __tablename__ = 'publisher'
    name = db.Column(db.String(80), index=True)
    profile = db.relationship('Profile', backref='publisher', lazy='dynamic',
                              uselist=False)

    def __init__(self, name):
        self.name = name

redpajama_set_name: RedPajamaGithub


text:
(function() {
    'use strict';

    angular.module('blackjack.game', []);

})();


text:
import unittest
from programy.parser.template.nodes import *
from test.parser.template.graph.test_graph_client import TemplateGraphTestClient

class TemplateGraphSraixTests(TemplateGraphTestClient):

    def test_sraix_template_params_as_attribs(self):
        template = ET.fromstring("""
            <template>
                <sraix host="hostname" botid="testbot" hint="test query" apikey="1234567890" service="/ask">
                    Ask this question
                </sraix>
            </template>
            """)
        ast = self.parser.parse_template_expression(template)

    def test_sraix_template_params_as_children(self):
        template = ET.fromstring("""
            <template>
                <sraix>
                    <host>hostname</host>
                    <botid>testbot</botid>
                    <hint>test query</hint>
                    <apikey>1234567890</apikey>
                    <service>/ask</service>
                    Ask this question
                </sraix>
            </template>
            """)
        ast = self.parser.parse_template_expression(template)

if __name__ == '__main__':
    unittest.main()


text:
/*
    to use import instead of these lets
      need babel
*/
let express = require('express');
let path = require('path');
let open = require('open');

const port = 2222;
const app = express();

app.use('/', express.static(path.join(__dirname, '../dist/')));

app.listen(port, function(err) {
  if (err) {
    console.log(err);
  }
  else {
    open('http://localhost:' + port);
  }
});


text:
"""Tests for the type libraries collector."""

import unittest

from dfwinreg import definitions as dfwinreg_definitions
from dfwinreg import fake as dfwinreg_fake
from dfwinreg import registry as dfwinreg_registry

from winregrc import type_libraries

from tests import test_lib

class TypeLibraryTest(test_lib.BaseTestCase):
  """Tests for the type library."""

  _DESCRIPTION = 'Microsoft Office List 14.0'
  _FILENAME = 'C:\\PROGRA~1\\MICROS~2\\Office14\\STSLIST.DLL'
  _GUID = '{edcd5812-6a06-43c3-afac-46ef5d14e22c}'
  _VERSION = '3.0'

  def testInitialize(self):
    """Tests the initialize function."""
    type_library = type_libraries.TypeLibrary(
        self._GUID, self._VERSION, self._DESCRIPTION, self._FILENAME)
    self.assertIsNotNone(type_library)

class TypeLibraryCollectorTest(test_lib.BaseTestCase):
  """Tests for the type libraries collector."""

  _DESCRIPTION1 = 'Microsoft Office List 14.0'
  _FILENAME1 = 'C:\\PROGRA~1\\MICROS~2\\Office14\\STSLIST.DLL'
  _GUID1 = '{edcd5812-6a06-43c3-afac-46ef5d14e22c}'
  _VERSION1 = '3.0'

  _DESCRIPTION2 = 'IAS SDO Helper 1.0 Type Library'
  _FILENAME2 = '%SystemRoot%\\system32\\sdohlp.dll\\1'
  _GUID2 = '{e9970f91-b6aa-11d9-b032-000d56c25c27}'
  _VERSION2 = '1.0'

  def _CreateTestRegistry(self):
    """Creates Registry keys and values for testing.

    Returns:
      dfwinreg.WinRegistry: Windows Registry for testing.
    """
    key_path_prefix = 'HKEY_LOCAL_MACHINE\\Software'

    registry_file = dfwinreg_fake.FakeWinRegistryFile(
        key_path_prefix=key_path_prefix)

    registry_key = dfwinreg_fake.FakeWinRegistryKey(self._GUID1)
    registry_file.AddKeyByPath('\\Classes\\TypeLib', registry_key)

    subkey = dfwinreg_fake.FakeWinRegistryKey(self._VERSION1)
    registry_key.AddSubkey(self._VERSION1, subkey)

    value_data = self._DESCRIPTION1.encode('utf-16-le')
    registry_value = dfwinreg_fake.FakeWinRegistryValue(
        '', data=value_data, data_type=dfwinreg_definitions.REG_SZ)
    subkey.AddValue(registry_value)

    language_key = dfwinreg_fake.FakeWinRegistryKey('409')
    subkey.AddSubkey('409', language_key)

    platform_key = dfwinreg_fake.FakeWinRegistryKey('Win32')
    language_key.AddSubkey('Win32', platform_key)

    value_data = self._FILENAME1.encode('utf-16-le')
    registry_value = dfwinreg_fake.FakeWinRegistryValue(
        '', data=value_data, data_type=dfwinreg_definitions.REG_SZ)
    platform_key.AddValue(registry_value)

    registry_key = dfwinreg_fake.FakeWinRegistryKey(self._GUID2)
    registry_file.AddKeyByPath('\\Classes\\TypeLib', registry_key)

    subkey = dfwinreg_fake.FakeWinRegistryKey(self._VERSION2)
    registry_key.AddSubkey(self._VERSION2, subkey)

    value_data = self._DESCRIPTION1.encode('utf-16-le')
    registry_value = dfwinreg_fake.FakeWinRegistryValue(
        '', data=value_data, data_type=dfwinreg_definitions.REG_SZ)
    subkey.AddValue(registry_value)

    language_key = dfwinreg_fake.FakeWinRegistryKey('0')
    subkey.AddSubkey('0', language_key)

    platform_key = dfwinreg_fake.FakeWinRegistryKey('x64')
    language_key.AddSubkey('x64', platform_key)

    value_data = self._FILENAME1.encode('utf-16-le')
    registry_value = dfwinreg_fake.FakeWinRegistryValue(
        '', data=value_data, data_type=dfwinreg_definitions.REG_SZ)
    platform_key.AddValue(registry_value)

    registry_file.Open(None)

    registry = dfwinreg_registry.WinRegistry()
    registry.MapFile(key_path_prefix, registry_file)
    return registry

  def testCollect(self):
    """Tests the Collect function."""
    registry = self._CreateTestRegistry()

    test_output_writer = test_lib.TestOutputWriter()
    collector_object = type_libraries.TypeLibrariesCollector(
        output_writer=test_output_writer)

    result = collector_object.Collect(registry)
    self.assertTrue(result)

    self.assertEqual(len(collector_object.type_libraries), 2)

    type_library = collector_object.type_libraries[0]

    self.assertIsNotNone(type_library)
    self.assertEqual(type_library.description, self._DESCRIPTION1)
    self.assertEqual(type_library.guid, self._GUID1)
    self.assertEqual(type_library.typelib_filename, self._FILENAME1)
    self.assertEqual(type_library.version, self._VERSION1)

  def testCollectEmpty(self):
    """Tests the Collect function on an empty Registry."""
    registry = dfwinreg_registry.WinRegistry()

    test_output_writer = test_lib.TestOutputWriter()
    collector_object = type_libraries.TypeLibrariesCollector(
        output_writer=test_output_writer)

    result = collector_object.Collect(registry)
    self.assertFalse(result)

    self.assertEqual(len(collector_object.type_libraries), 0)

if __name__ == '__main__':
  unittest.main()


text:
(async function(testRunner) {
  var {page, session, dp} = await testRunner.startBlank(
      'Verifies that requests made for service worker main scripts get Network.*ExtraInfo events for them.');
  const swHelper = (await testRunner.loadScript('resources/service-worker-helper.js'))(dp, session);

  await dp.Target.setAutoAttach(
    {autoAttach: true, waitForDebuggerOnStart: true, flatten: true});

  await session.navigate('resources/repeat-fetch-service-worker.html');

  const attachedPromise = dp.Target.onceAttachedToTarget();
  swHelper.installSWAndWaitForActivated('/inspector-protocol/service-worker/resources/repeat-fetch-service-worker.js');
  const attachedToTarget = await attachedPromise;

  const swdp = session.createChild(attachedToTarget.params.sessionId).protocol;

  const networkEvents = [
    swdp.Network.onceRequestWillBeSent(),
    swdp.Network.onceRequestWillBeSentExtraInfo(),
    swdp.Network.onceResponseReceived(),
    swdp.Network.onceResponseReceivedExtraInfo()
  ];

  await Promise.all([
    swdp.Network.enable(),
    swdp.Runtime.runIfWaitingForDebugger(),
  ]);

  const [
    requestWillBeSent,
    requestWillBeSentExtraInfo,
    responseReceived,
    responseReceivedExtraInfo
  ] = await Promise.all(networkEvents);

  const idsMatch = requestWillBeSent.params.requestId === requestWillBeSentExtraInfo.params.requestId
    && requestWillBeSent.params.requestId === responseReceived.params.requestId
    && requestWillBeSent.params.requestId === responseReceivedExtraInfo.params.requestId;
  testRunner.log('requestWillBeSent url: ' + requestWillBeSent.params.request.url);
  testRunner.log('requestIds match: ' + idsMatch);
  testRunner.completeTest();
});


text:
<?xml version="1.0" encoding="utf-8"?>
<MapData>
<Details>
<FileName>[222]M10_S01_B10.rmd</FileName>
<FileType>Red Stone Scenario File 6.0 beta</FileType>
<MapName>スウェブタワー B10</MapName>
<SysWidth>190</SysWidth>
<SysHeight>190</SysHeight>
<TgaWidth>380</TgaWidth>
<TgaHeight>190</TgaHeight>
<MapType>1</MapType>
<isPremiumMap>0</isPremiumMap>
<isPvPMap>0</isPvPMap>
<MapView_Lv>7</MapView_Lv>
<isLocationStrage>1</isLocationStrage>
<P_SubElement1>24</P_SubElement1>
<P_SubElement2>23</P_SubElement2>
<P_SubElement3>24</P_SubElement3>
<P_SubElement4>24</P_SubElement4>
<P_SubElement5>23</P_SubElement5>
<P_SubElement6>28</P_SubElement6>
<M_AddElement1>0</M_AddElement1>
<M_AddElement2>0</M_AddElement2>
<M_AddElement3>0</M_AddElement3>
<M_AddElement4>0</M_AddElement4>
<M_AddElement5>0</M_AddElement5>
<M_AddElement6>0</M_AddElement6>
</Details>
<CharacterData>
<Character id="cUid0">
<CharacterUID>0</CharacterUID>
<CharacterName>ファイアデビル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>3</InternalID>
<PopSpeed>120</PopSpeed>
<PopPoint_X>179.78</PopPoint_X>
<PopPoint_Y>48.41</PopPoint_Y>
</Character>
<Character id="cUid1">
<CharacterUID>1</CharacterUID>
<CharacterName>ファイアデビル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>3</InternalID>
<PopSpeed>120</PopSpeed>
<PopPoint_X>208.91</PopPoint_X>
<PopPoint_Y>37.94</PopPoint_Y>
</Character>
<Character id="cUid2">
<CharacterUID>2</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>97.38</PopPoint_X>
<PopPoint_Y>138.84</PopPoint_Y>
</Character>
<Character id="cUid3">
<CharacterUID>3</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>290.97</PopPoint_X>
<PopPoint_Y>68.22</PopPoint_Y>
</Character>
<Character id="cUid4">
<CharacterUID>4</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>229.41</PopPoint_X>
<PopPoint_Y>97.91</PopPoint_Y>
</Character>
<Character id="cUid5">
<CharacterUID>5</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>123.72</PopPoint_X>
<PopPoint_Y>149.53</PopPoint_Y>
</Character>
<Character id="cUid7">
<CharacterUID>7</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>105.56</PopPoint_X>
<PopPoint_Y>138.50</PopPoint_Y>
</Character>
<Character id="cUid8">
<CharacterUID>8</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>97.25</PopPoint_X>
<PopPoint_Y>143.75</PopPoint_Y>
</Character>
<Character id="cUid9">
<CharacterUID>9</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>119.66</PopPoint_X>
<PopPoint_Y>151.00</PopPoint_Y>
</Character>
<Character id="cUid11">
<CharacterUID>11</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>116.88</PopPoint_X>
<PopPoint_Y>153.84</PopPoint_Y>
</Character>
<Character id="cUid12">
<CharacterUID>12</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>50.31</PopPoint_X>
<PopPoint_Y>104.00</PopPoint_Y>
</Character>
<Character id="cUid13">
<CharacterUID>13</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>57.69</PopPoint_X>
<PopPoint_Y>102.28</PopPoint_Y>
</Character>
<Character id="cUid14">
<CharacterUID>14</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>47.84</PopPoint_X>
<PopPoint_Y>108.56</PopPoint_Y>
</Character>
<Character id="cUid15">
<CharacterUID>15</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>40.69</PopPoint_X>
<PopPoint_Y>104.72</PopPoint_Y>
</Character>
<Character id="cUid16">
<CharacterUID>16</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>66.75</PopPoint_X>
<PopPoint_Y>104.50</PopPoint_Y>
</Character>
<Character id="cUid17">
<CharacterUID>17</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>63.16</PopPoint_X>
<PopPoint_Y>110.09</PopPoint_Y>
</Character>
<Character id="cUid18">
<CharacterUID>18</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>184.16</PopPoint_X>
<PopPoint_Y>128.41</PopPoint_Y>
</Character>
<Character id="cUid19">
<CharacterUID>19</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>191.53</PopPoint_X>
<PopPoint_Y>126.69</PopPoint_Y>
</Character>
<Character id="cUid20">
<CharacterUID>20</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>181.69</PopPoint_X>
<PopPoint_Y>132.97</PopPoint_Y>
</Character>
<Character id="cUid21">
<CharacterUID>21</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>174.53</PopPoint_X>
<PopPoint_Y>129.13</PopPoint_Y>
</Character>
<Character id="cUid22">
<CharacterUID>22</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>200.59</PopPoint_X>
<PopPoint_Y>128.91</PopPoint_Y>
</Character>
<Character id="cUid23">
<CharacterUID>23</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>197.00</PopPoint_X>
<PopPoint_Y>134.50</PopPoint_Y>
</Character>
<Character id="cUid24">
<CharacterUID>24</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>270.97</PopPoint_X>
<PopPoint_Y>116.19</PopPoint_Y>
</Character>
<Character id="cUid25">
<CharacterUID>25</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>278.34</PopPoint_X>
<PopPoint_Y>114.47</PopPoint_Y>
</Character>
<Character id="cUid26">
<CharacterUID>26</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>268.50</PopPoint_X>
<PopPoint_Y>120.75</PopPoint_Y>
</Character>
<Character id="cUid27">
<CharacterUID>27</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>261.34</PopPoint_X>
<PopPoint_Y>116.91</PopPoint_Y>
</Character>
<Character id="cUid28">
<CharacterUID>28</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>287.41</PopPoint_X>
<PopPoint_Y>116.69</PopPoint_Y>
</Character>
<Character id="cUid29">
<CharacterUID>29</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>283.81</PopPoint_X>
<PopPoint_Y>122.28</PopPoint_Y>
</Character>
<Character id="cUid30">
<CharacterUID>30</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>234.44</PopPoint_X>
<PopPoint_Y>101.56</PopPoint_Y>
</Character>
<Character id="cUid31">
<CharacterUID>31</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>237.94</PopPoint_X>
<PopPoint_Y>104.34</PopPoint_Y>
</Character>
<Character id="cUid32">
<CharacterUID>32</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>235.63</PopPoint_X>
<PopPoint_Y>105.81</PopPoint_Y>
</Character>
<Character id="cUid33">
<CharacterUID>33</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>239.19</PopPoint_X>
<PopPoint_Y>98.53</PopPoint_Y>
</Character>
<Character id="cUid34">
<CharacterUID>34</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>232.84</PopPoint_X>
<PopPoint_Y>108.66</PopPoint_Y>
</Character>
<Character id="cUid35">
<CharacterUID>35</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>297.84</PopPoint_X>
<PopPoint_Y>69.38</PopPoint_Y>
</Character>
<Character id="cUid36">
<CharacterUID>36</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>304.09</PopPoint_X>
<PopPoint_Y>72.16</PopPoint_Y>
</Character>
<Character id="cUid37">
<CharacterUID>37</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>299.03</PopPoint_X>
<PopPoint_Y>73.63</PopPoint_Y>
</Character>
<Character id="cUid38">
<CharacterUID>38</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>302.59</PopPoint_X>
<PopPoint_Y>66.34</PopPoint_Y>
</Character>
<Character id="cUid39">
<CharacterUID>39</CharacterUID>
<CharacterName>リプリートマーキ</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>4</InternalID>
<PopSpeed>15</PopSpeed>
<PopPoint_X>289.84</PopPoint_X>
<PopPoint_Y>75.88</PopPoint_Y>
</Character>
<Character id="cUid40">
<CharacterUID>40</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>13</PopSpeed>
<PopPoint_X>212.75</PopPoint_X>
<PopPoint_Y>84.16</PopPoint_Y>
</Character>
<Character id="cUid41">
<CharacterUID>41</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>13</PopSpeed>
<PopPoint_X>194.13</PopPoint_X>
<PopPoint_Y>82.56</PopPoint_Y>
</Character>
<Character id="cUid43">
<CharacterUID>43</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>13</PopSpeed>
<PopPoint_X>207.03</PopPoint_X>
<PopPoint_Y>78.13</PopPoint_Y>
</Character>
<Character id="cUid44">
<CharacterUID>44</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>274.53</PopPoint_X>
<PopPoint_Y>57.59</PopPoint_Y>
</Character>
<Character id="cUid45">
<CharacterUID>45</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>13</PopSpeed>
<PopPoint_X>213.34</PopPoint_X>
<PopPoint_Y>79.84</PopPoint_Y>
</Character>
<Character id="cUid46">
<CharacterUID>46</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>13</PopSpeed>
<PopPoint_X>198.84</PopPoint_X>
<PopPoint_Y>78.31</PopPoint_Y>
</Character>
<Character id="cUid47">
<CharacterUID>47</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>258.28</PopPoint_X>
<PopPoint_Y>56.41</PopPoint_Y>
</Character>
<Character id="cUid49">
<CharacterUID>49</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>258.47</PopPoint_X>
<PopPoint_Y>52.16</PopPoint_Y>
</Character>
<Character id="cUid50">
<CharacterUID>50</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>277.50</PopPoint_X>
<PopPoint_Y>53.69</PopPoint_Y>
</Character>
<Character id="cUid51">
<CharacterUID>51</CharacterUID>
<CharacterName>デビルスカラー</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>2</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>272.81</PopPoint_X>
<PopPoint_Y>54.25</PopPoint_Y>
</Character>
<Character id="cUid52">
<CharacterUID>52</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>132.50</PopPoint_X>
<PopPoint_Y>109.47</PopPoint_Y>
</Character>
<Character id="cUid53">
<CharacterUID>53</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>149.25</PopPoint_X>
<PopPoint_Y>106.69</PopPoint_Y>
</Character>
<Character id="cUid54">
<CharacterUID>54</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>133.56</PopPoint_X>
<PopPoint_Y>104.25</PopPoint_Y>
</Character>
<Character id="cUid55">
<CharacterUID>55</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>140.69</PopPoint_X>
<PopPoint_Y>108.88</PopPoint_Y>
</Character>
<Character id="cUid56">
<CharacterUID>56</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>154.03</PopPoint_X>
<PopPoint_Y>115.28</PopPoint_Y>
</Character>
<Character id="cUid57">
<CharacterUID>57</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>156.88</PopPoint_X>
<PopPoint_Y>112.97</PopPoint_Y>
</Character>
<Character id="cUid58">
<CharacterUID>58</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>325.88</PopPoint_X>
<PopPoint_Y>90.88</PopPoint_Y>
</Character>
<Character id="cUid59">
<CharacterUID>59</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>342.63</PopPoint_X>
<PopPoint_Y>88.09</PopPoint_Y>
</Character>
<Character id="cUid60">
<CharacterUID>60</CharacterUID>
<CharacterName>マーブルガゴイル</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>0</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>326.94</PopPoint_X>
<PopPoint_Y>85.66</PopPoint_Y>
</Character>
<Character id="cUid61">
<CharacterUID>61</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>334.06</PopPoint_X>
<PopPoint_Y>90.28</PopPoint_Y>
</Character>
<Character id="cUid62">
<CharacterUID>62</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>341.91</PopPoint_X>
<PopPoint_Y>93.00</PopPoint_Y>
</Character>
<Character id="cUid63">
<CharacterUID>63</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>344.75</PopPoint_X>
<PopPoint_Y>90.69</PopPoint_Y>
</Character>
<Character id="cUid64">
<CharacterUID>64</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>137.06</PopPoint_X>
<PopPoint_Y>110.53</PopPoint_Y>
</Character>
<Character id="cUid65">
<CharacterUID>65</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>14</PopSpeed>
<PopPoint_X>330.44</PopPoint_X>
<PopPoint_Y>91.94</PopPoint_Y>
</Character>
<Character id="cUid66">
<CharacterUID>66</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>13</PopSpeed>
<PopPoint_X>198.59</PopPoint_X>
<PopPoint_Y>84.28</PopPoint_Y>
</Character>
<Character id="cUid67">
<CharacterUID>67</CharacterUID>
<CharacterName>アイウィング</CharacterName>
<CharacterType>2</CharacterType>
<InternalID>1</InternalID>
<PopSpeed>20</PopSpeed>
<PopPoint_X>262.75</PopPoint_X>
<PopPoint_Y>58.13</PopPoint_Y>
</Character>
</CharacterData>
<AreaData>
<Area id="aUid0">
<AreaUID>0</AreaUID>
<AreaName>_필드 전체</AreaName>
<AreaType>0</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>0.00</AreaPos_X>
<AreaPos_X2>0.00</AreaPos_X2>
<AreaPos_Y>0.00</AreaPos_Y>
<AreaPos_Y2>0.00</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid1">
<AreaUID>1</AreaUID>
<AreaName>_화면</AreaName>
<AreaType>0</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>0.00</AreaPos_X>
<AreaPos_X2>0.00</AreaPos_X2>
<AreaPos_Y>0.00</AreaPos_Y>
<AreaPos_Y2>0.00</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid2">
<AreaUID>2</AreaUID>
<AreaName>ㅁ1</AreaName>
<AreaType>3</AreaType>
<AccessMap>[222]M10_S01_B10.rmd</AccessMap>
<AccessMapName>スウェブタワー B10</AccessMapName>
<AreaPos_X>107.53</AreaPos_X>
<AreaPos_X2>111.78</AreaPos_X2>
<AreaPos_Y>75.59</AreaPos_Y>
<AreaPos_Y2>79.16</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid3">
<AreaUID>3</AreaUID>
<AreaName>ㅁ2</AreaName>
<AreaType>3</AreaType>
<AccessMap>[222]M10_S01_B10.rmd</AccessMap>
<AccessMapName>スウェブタワー B10</AccessMapName>
<AreaPos_X>151.53</AreaPos_X>
<AreaPos_X2>154.91</AreaPos_X2>
<AreaPos_Y>159.63</AreaPos_Y>
<AreaPos_Y2>162.19</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid4">
<AreaUID>4</AreaUID>
<AreaName>A1</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>89.47</AreaPos_X>
<AreaPos_X2>110.13</AreaPos_X2>
<AreaPos_Y>131.03</AreaPos_Y>
<AreaPos_Y2>147.63</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid5">
<AreaUID>5</AreaUID>
<AreaName>A2</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>110.75</AreaPos_X>
<AreaPos_X2>131.28</AreaPos_X2>
<AreaPos_Y>141.53</AreaPos_Y>
<AreaPos_Y2>158.66</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid6">
<AreaUID>6</AreaUID>
<AreaName>B1</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>30.94</AreaPos_X>
<AreaPos_X2>54.47</AreaPos_X2>
<AreaPos_Y>97.22</AreaPos_Y>
<AreaPos_Y2>112.88</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid7">
<AreaUID>7</AreaUID>
<AreaName>B2</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>54.47</AreaPos_X>
<AreaPos_X2>82.16</AreaPos_X2>
<AreaPos_Y>97.22</AreaPos_Y>
<AreaPos_Y2>112.88</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid8">
<AreaUID>8</AreaUID>
<AreaName>9층으로</AreaName>
<AreaType>3</AreaType>
<AccessMap>[223]M10_S01_B09.rmd</AccessMap>
<AccessMapName>スウェブタワー B9</AccessMapName>
<AreaPos_X>39.81</AreaPos_X>
<AreaPos_X2>43.56</AreaPos_X2>
<AreaPos_Y>21.22</AreaPos_Y>
<AreaPos_Y2>23.94</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid9">
<AreaUID>9</AreaUID>
<AreaName>11층으로</AreaName>
<AreaType>3</AreaType>
<AccessMap>[221]M10_S01_B11.rmd</AccessMap>
<AccessMapName>スウェブタワー B11</AccessMapName>
<AreaPos_X>89.63</AreaPos_X>
<AreaPos_X2>93.38</AreaPos_X2>
<AreaPos_Y>41.75</AreaPos_Y>
<AreaPos_Y2>44.47</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid10">
<AreaUID>10</AreaUID>
<AreaName>C1</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>122.03</AreaPos_X>
<AreaPos_X2>143.72</AreaPos_X2>
<AreaPos_Y>98.97</AreaPos_Y>
<AreaPos_Y2>117.50</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid11">
<AreaUID>11</AreaUID>
<AreaName>C2</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>143.72</AreaPos_X>
<AreaPos_X2>164.56</AreaPos_X2>
<AreaPos_Y>98.97</AreaPos_Y>
<AreaPos_Y2>117.50</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid12">
<AreaUID>12</AreaUID>
<AreaName>B3</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>168.09</AreaPos_X>
<AreaPos_X2>187.66</AreaPos_X2>
<AreaPos_Y>122.53</AreaPos_Y>
<AreaPos_Y2>138.22</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid13">
<AreaUID>13</AreaUID>
<AreaName>B4</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>187.66</AreaPos_X>
<AreaPos_X2>207.31</AreaPos_X2>
<AreaPos_Y>122.50</AreaPos_Y>
<AreaPos_Y2>138.22</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid14">
<AreaUID>14</AreaUID>
<AreaName>A3</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>225.56</AreaPos_X>
<AreaPos_X2>254.94</AreaPos_X2>
<AreaPos_Y>91.81</AreaPos_Y>
<AreaPos_Y2>111.69</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid15">
<AreaUID>15</AreaUID>
<AreaName>A4</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>294.00</AreaPos_X>
<AreaPos_X2>321.19</AreaPos_X2>
<AreaPos_Y>57.88</AreaPos_Y>
<AreaPos_Y2>78.34</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid16">
<AreaUID>16</AreaUID>
<AreaName>B5</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>254.56</AreaPos_X>
<AreaPos_X2>274.16</AreaPos_X2>
<AreaPos_Y>110.06</AreaPos_Y>
<AreaPos_Y2>125.75</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid17">
<AreaUID>17</AreaUID>
<AreaName>B6</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>274.16</AreaPos_X>
<AreaPos_X2>297.75</AreaPos_X2>
<AreaPos_Y>110.06</AreaPos_Y>
<AreaPos_Y2>125.75</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid18">
<AreaUID>18</AreaUID>
<AreaName>C3</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>314.28</AreaPos_X>
<AreaPos_X2>337.44</AreaPos_X2>
<AreaPos_Y>79.97</AreaPos_Y>
<AreaPos_Y2>99.09</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid19">
<AreaUID>19</AreaUID>
<AreaName>C4</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>337.47</AreaPos_X>
<AreaPos_X2>362.59</AreaPos_X2>
<AreaPos_Y>83.03</AreaPos_Y>
<AreaPos_Y2>105.50</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid20">
<AreaUID>20</AreaUID>
<AreaName>D1</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>182.53</AreaPos_X>
<AreaPos_X2>203.59</AreaPos_X2>
<AreaPos_Y>73.84</AreaPos_Y>
<AreaPos_Y2>88.91</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid21">
<AreaUID>21</AreaUID>
<AreaName>D2</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>203.59</AreaPos_X>
<AreaPos_X2>224.63</AreaPos_X2>
<AreaPos_Y>73.84</AreaPos_Y>
<AreaPos_Y2>88.91</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid22">
<AreaUID>22</AreaUID>
<AreaName>D3</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>265.44</AreaPos_X>
<AreaPos_X2>284.44</AreaPos_X2>
<AreaPos_Y>40.22</AreaPos_Y>
<AreaPos_Y2>63.28</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid23">
<AreaUID>23</AreaUID>
<AreaName>D4</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>243.75</AreaPos_X>
<AreaPos_X2>265.47</AreaPos_X2>
<AreaPos_Y>40.13</AreaPos_Y>
<AreaPos_Y2>63.28</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid24">
<AreaUID>24</AreaUID>
<AreaName>보스몹1</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>171.97</AreaPos_X>
<AreaPos_X2>187.56</AreaPos_X2>
<AreaPos_Y>42.81</AreaPos_Y>
<AreaPos_Y2>58.50</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid25">
<AreaUID>25</AreaUID>
<AreaName>보스몹2</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>201.72</AreaPos_X>
<AreaPos_X2>217.31</AreaPos_X2>
<AreaPos_Y>30.91</AreaPos_Y>
<AreaPos_Y2>46.59</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
<Area id="aUid26">
<AreaUID>26</AreaUID>
<AreaName>Area 25</AreaName>
<AreaType>2</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>210.97</AreaPos_X>
<AreaPos_X2>220.56</AreaPos_X2>
<AreaPos_Y>50.19</AreaPos_Y>
<AreaPos_Y2>58.16</AreaPos_Y2>
<AreaExpansion>
<Door_Endurance>1000</Door_Endurance>
<DetectSecretDoor_Lv>0</DetectSecretDoor_Lv>
<UnlockDoor_Lv>1</UnlockDoor_Lv>
<RecoveryTime>30</RecoveryTime>
<isMortalObject>1</isMortalObject>
<DisarmTrap_Lv>1</DisarmTrap_Lv>
<DetectTrap_Lv>1</DetectTrap_Lv>
<TrapID1>0</TrapID1>
<TrapID2>6</TrapID2>
<isSecretDungeonEntrance>0</isSecretDungeonEntrance>
</AreaExpansion>
</Area>
<Area id="aUid27">
<AreaUID>27</AreaUID>
<AreaName>Area 26</AreaName>
<AreaType>2</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>163.22</AreaPos_X>
<AreaPos_X2>172.81</AreaPos_X2>
<AreaPos_Y>113.94</AreaPos_Y>
<AreaPos_Y2>122.06</AreaPos_Y2>
<AreaExpansion>
<Door_Endurance>1000</Door_Endurance>
<DetectSecretDoor_Lv>0</DetectSecretDoor_Lv>
<UnlockDoor_Lv>1</UnlockDoor_Lv>
<RecoveryTime>30</RecoveryTime>
<isMortalObject>1</isMortalObject>
<DisarmTrap_Lv>1</DisarmTrap_Lv>
<DetectTrap_Lv>1</DetectTrap_Lv>
<TrapID1>0</TrapID1>
<TrapID2>6</TrapID2>
<isSecretDungeonEntrance>0</isSecretDungeonEntrance>
</AreaExpansion>
</Area>
<Area id="aUid28">
<AreaUID>28</AreaUID>
<AreaName>Area 27</AreaName>
<AreaType>2</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>204.78</AreaPos_X>
<AreaPos_X2>212.34</AreaPos_X2>
<AreaPos_Y>134.72</AreaPos_Y>
<AreaPos_Y2>141.56</AreaPos_Y2>
<AreaExpansion>
<Door_Endurance>1000</Door_Endurance>
<DetectSecretDoor_Lv>0</DetectSecretDoor_Lv>
<UnlockDoor_Lv>1</UnlockDoor_Lv>
<RecoveryTime>30</RecoveryTime>
<isMortalObject>1</isMortalObject>
<DisarmTrap_Lv>1</DisarmTrap_Lv>
<DetectTrap_Lv>1</DetectTrap_Lv>
<TrapID1>0</TrapID1>
<TrapID2>6</TrapID2>
<isSecretDungeonEntrance>0</isSecretDungeonEntrance>
</AreaExpansion>
</Area>
<Area id="aUid29">
<AreaUID>29</AreaUID>
<AreaName>Area 28</AreaName>
<AreaType>2</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>215.19</AreaPos_X>
<AreaPos_X2>223.22</AreaPos_X2>
<AreaPos_Y>140.31</AreaPos_Y>
<AreaPos_Y2>147.72</AreaPos_Y2>
<AreaExpansion>
<Door_Endurance>1000</Door_Endurance>
<DetectSecretDoor_Lv>0</DetectSecretDoor_Lv>
<UnlockDoor_Lv>1</UnlockDoor_Lv>
<RecoveryTime>30</RecoveryTime>
<isMortalObject>1</isMortalObject>
<DisarmTrap_Lv>1</DisarmTrap_Lv>
<DetectTrap_Lv>1</DetectTrap_Lv>
<TrapID1>0</TrapID1>
<TrapID2>6</TrapID2>
<isSecretDungeonEntrance>0</isSecretDungeonEntrance>
</AreaExpansion>
</Area>
<Area id="aUid30">
<AreaUID>30</AreaUID>
<AreaName>Area 29</AreaName>
<AreaType>4</AreaType>
<AccessMap></AccessMap>
<AccessMapName></AccessMapName>
<AreaPos_X>280.69</AreaPos_X>
<AreaPos_X2>294.00</AreaPos_X2>
<AreaPos_Y>63.88</AreaPos_Y>
<AreaPos_Y2>78.28</AreaPos_Y2>
<AreaExpansion>
</AreaExpansion>
</Area>
</AreaData>
</MapData>


text:
CREATE OR REPLACE FUNCTION mtp_get_schema(i_json json)
  RETURNS json AS
$BODY$
sql_select = "select column_name, udt_name,
    character_maximum_length ,
    is_nullable,
    column_default,
    data_type
    from information_schema.columns
    where table_catalog = $1 and table_schema = $2 and table_name = $3
    and column_name not in ('id','seq', 'active', 'referenceid', 'lastupdateon', 'lastupdatedby', 'rowversionstamp', 'createdon', 'createdby', 'modifiedon', 'modifiedby', 'rowversion')
    order by ordinal_position
"

rtn = plv8.execute(sql_select, [i_json.catalog, i_json.schema, i_json.table_name])

if rtn.length>0
    return {"data":rtn}
else
    return {}

$BODY$
  LANGUAGE plcoffee VOLATILE


text:
using UnityEngine;
using UnityEngine.UI;

namespace Assets.ScreenSpace.RocketLeague.Scripts {

    [RequireComponent(typeof(Toggle))]
    [AddComponentMenu("Scripts/Rocket League/Show Sub Menu")]
    public class ShowSubMenu : MonoBehaviour {

        [SerializeField]
        private Transform backButtonTransform;

        private bool menuOpen;

        [SerializeField]
        private Transform submenuGameTransform;

        public void OnMouseEnter() {
            if (!gameObject.GetComponent<ShowSubMenu>().enabled || submenuGameTransform == null) {
                return;
            }

            submenuGameTransform.gameObject.SetActive(true);
        }

        public void OnMouseExit() {
            if (!gameObject.GetComponent<ShowSubMenu>().enabled || menuOpen || submenuGameTransform == null) {
                return;
            }

            submenuGameTransform.gameObject.SetActive(false);
        }

        public void ToggleChange() {
            if (GetComponent<Toggle>().isOn) {
                menuOpen = true;

                backButtonTransform.gameObject.SetActive(true);
                backButtonTransform.GetComponent<BackButton>().SubMenuGameObject = submenuGameTransform.gameObject;

                transform.parent.GetComponent<Animation>().Play();
                submenuGameTransform.GetComponent<Animation>().Play();
            } else {
                menuOpen = false;

                backButtonTransform.gameObject.SetActive(false);
                backButtonTransform.GetComponent<BackButton>().SubMenuGameObject = null;

                submenuGameTransform.gameObject.SetActive(false);
                submenuGameTransform.GetComponent<CanvasGroup>().alpha = 0.3f;
            }
        }

        // Use this for initialization
        private void Start() {
            if (submenuGameTransform == null) {
                Debug.LogWarning("Submenu has not been assigned.");
            }
        }
    }

}


text:
package org.technbolts.jbehave.eclipse.editors.story.outline;

import java.util.ArrayList;
import java.util.List;

import org.technbolts.jbehave.support.JBKeyword;
import org.technbolts.jbehave.support.JBPartition;

public class OutlineModel {

    private final JBPartition partition;
    private JBKeyword keyword;
    private String content;
    private int offset, length;
    private List<OutlineModel> children = new ArrayList<OutlineModel>();

    public OutlineModel(JBKeyword keyword, String content, int offset, int length) {
        super();
        this.keyword = keyword;
        this.partition = JBPartition.partitionOf(keyword);
        this.content = extractSingleLine(content);
        this.offset = offset;
        this.length = length;
    }

    private static String extractSingleLine(String content) {
        String[] lines = content.split("[\r\n]+");
        for(String line : lines) {
            if(!line.trim().isEmpty())
                return line;
        }
        return null;
    }

    public JBKeyword getKeyword() {
        return keyword;
    }

    public boolean hasChildren() {
        return !children.isEmpty();
    }

    public List<OutlineModel> getChildren() {
        return children;
    }

    boolean merge(OutlineModel model) {
        if(partition==model.partition) {
            // make sure there is no hole: otherwise the model must be emitted
            if(this.offset+this.length == model.offset) {
                appendChild(model);
                this.length += model.length;
                return true;
            }
        }
        return false;
    }

    private void appendChild(OutlineModel model) {
        if(children.isEmpty()) {
            // add self as child
            // children.add(copy());
        }
        children.add(model);
    }

    public JBPartition getPartition() {
        return partition;
    }

    public String getContent() {
        return content;
    }

    public int getOffset() {
        return offset;
    }

    public int getLength() {
        return length;
    }

}


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
J. Bot. , London 5: 3 (1846)

#### Original name
Thelephora subhepatica Berk., 1846

### Remarks
null


text:
package ru.sdroman.bank;

import java.time.LocalTime;

/**
 * Class DateParam.
 *
 * @author sdroman
 * @version 0.1
 * @since 04.17
 */
public class DateParam {

    /**
     * Return date in LocalTime.
     *
     * @param date String
     * @return LocalTime
     */
    public LocalTime stringToLocalTime(String date) {
        return LocalTime.parse(date);
    }
}


text:
#ifndef AVUTIL_VERSION_H
#define AVUTIL_VERSION_H

#include "macros.h"

/**
 * @addtogroup version_utils
 *
 * Useful to check and match library version in order to maintain
 * backward compatibility.
 *
 * @{
 */

#define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c)
#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)

/**
 * @}
 */

/**
 * @file
 * @ingroup lavu
 * Libavutil version macros
 */

/**
 * @defgroup lavu_ver Version and Build diagnostics
 *
 * Macros and function useful to check at compiletime and at runtime
 * which version of libavutil is in use.
 *
 * @{
 */

#define LIBAVUTIL_VERSION_MAJOR  54
#define LIBAVUTIL_VERSION_MINOR  15
#define LIBAVUTIL_VERSION_MICRO 100

#define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                               LIBAVUTIL_VERSION_MINOR, \
                                               LIBAVUTIL_VERSION_MICRO)
#define LIBAVUTIL_VERSION       AV_VERSION(LIBAVUTIL_VERSION_MAJOR,     \
                                           LIBAVUTIL_VERSION_MINOR,     \
                                           LIBAVUTIL_VERSION_MICRO)
#define LIBAVUTIL_BUILD         LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_IDENT         "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)

/**
 * @}
 *
 * @defgroup depr_guards Deprecation guards
 * FF_API_* defines may be placed below to indicate public API that will be
 * dropped at a future version bump. The defines themselves are not part of
 * the public API and may change, break or disappear at any time.
 *
 * @{
 */

#ifndef FF_API_OLD_AVOPTIONS
#define FF_API_OLD_AVOPTIONS            (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_PIX_FMT
#define FF_API_PIX_FMT                  (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_CONTEXT_SIZE
#define FF_API_CONTEXT_SIZE             (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_PIX_FMT_DESC
#define FF_API_PIX_FMT_DESC             (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_AV_REVERSE
#define FF_API_AV_REVERSE               (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_AUDIOCONVERT
#define FF_API_AUDIOCONVERT             (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_CPU_FLAG_MMX2
#define FF_API_CPU_FLAG_MMX2            (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_LLS_PRIVATE
#define FF_API_LLS_PRIVATE              (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_AVFRAME_LAVC
#define FF_API_AVFRAME_LAVC             (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_VDPAU
#define FF_API_VDPAU                    (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_GET_CHANNEL_LAYOUT_COMPAT
#define FF_API_GET_CHANNEL_LAYOUT_COMPAT (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_XVMC
#define FF_API_XVMC                     (LIBAVUTIL_VERSION_MAJOR < 55)
#endif
#ifndef FF_API_OPT_TYPE_METADATA
#define FF_API_OPT_TYPE_METADATA        (LIBAVUTIL_VERSION_MAJOR < 55)
#endif

#ifndef FF_CONST_AVUTIL55
#if LIBAVUTIL_VERSION_MAJOR >= 55
#define FF_CONST_AVUTIL55 const
#else
#define FF_CONST_AVUTIL55
#endif
#endif

/**
 * @}
 */

#endif /* AVUTIL_VERSION_H */


text:
import { setPropertiesFromJSON } from '../../json-helper';

/**
 * Generated class for shr.entity.Ingredient.
 */
class Ingredient {

  /**
   * Get the choice value; one of: shr.core.CodeableConcept, shr.entity.Substance reference.
   * @returns {(CodeableConcept|Reference)} The choice value; one of: shr.core.CodeableConcept, shr.entity.Substance reference
   */
  get value() {
    return this._value;
  }

  /**
   * Set the choice value; one of: shr.core.CodeableConcept, shr.entity.Substance reference.
   * @param {(CodeableConcept|Reference)} value - The choice value; one of: shr.core.CodeableConcept, shr.entity.Substance reference
   */
  set value(value) {
    this._value = value;
  }

  /**
   * Get the IngredientAmount.
   * @returns {IngredientAmount} The shr.entity.IngredientAmount
   */
  get ingredientAmount() {
    return this._ingredientAmount;
  }

  /**
   * Set the IngredientAmount.
   * @param {IngredientAmount} ingredientAmount - The shr.entity.IngredientAmount
   */
  set ingredientAmount(ingredientAmount) {
    this._ingredientAmount = ingredientAmount;
  }

  /**
   * Deserializes JSON data to an instance of the Ingredient class.
   * The JSON must be valid against the Ingredient JSON schema, although this is not validated by the function.
   * @param {object} json - the JSON data to deserialize
   * @returns {Ingredient} An instance of Ingredient populated with the JSON data
   */
  static fromJSON(json={}) {
    const inst = new Ingredient();
    setPropertiesFromJSON(inst, json);
    return inst;
  }
}
export default Ingredient;


text:
<?php
/**
 * @type CallCombo
 *
 * created to provide
 * simple, 'from' and 'to' arrays
 */
namespace Catapult;
/**
 *
 * CallCombo should be accessible
 * by bridge. This is conviniece
 * and be used instead of passing each
 * call individualy
 */
final class CallCombo extends Types {
  public function Make($args /* polymorphic */)
	{
    $calls = func_get_args();
    $call_ids = array();

    foreach ($calls as $call) {
      if (is_object($call)) {
        $call_ids[] = $call->id;
      } else {
        $call_ids[] = $call;
      }
    }

    return $call_ids;
	}
  public function __toString() {
    return implode(",", $this->$call_ids);
  }
}
?>


text:
import JSONEditor, {JSONEditorMode, JSONEditorNode, JSONEditorOptions} from 'jsoneditor';

let options: JSONEditorOptions;
options = {
    ace: ace,
    //ajv: Ajv({allErrors: true, verbose: true})
    onChange() {},
    onEditable(node: JSONEditorNode) {
        return true;
    },
    onError(error: Error) {},
    onModeChange(newMode: JSONEditorMode, oldMode: JSONEditorMode) {},
    escapeUnicode: false,
    sortObjectKeys: true,
    history: true,
    mode: 'tree',
    modes: ['tree', 'view', 'form', 'code', 'text'],
    name: 'foo',
    schema: {},
    search: false,
    indentation: 2,
    theme: 'default'
};
options = {
    onEditable(node: JSONEditorNode) {
        return {field: true, value: false};
    }
};

let jsonEditor: JSONEditor;
jsonEditor = new JSONEditor(document.body);
jsonEditor = new JSONEditor(document.body, {});
jsonEditor = new JSONEditor(document.body, options, {foo: 'bar'});

jsonEditor.collapseAll();
jsonEditor.destroy();
jsonEditor.expandAll();
jsonEditor.focus();
jsonEditor.set({foo: 'bar'});
jsonEditor.setMode('text');
jsonEditor.setName('foo');
jsonEditor.setName();
jsonEditor.setSchema({});
jsonEditor.setText('{foo: 1}');

const json: any = jsonEditor.get();
const name: string = jsonEditor.getName();
const jsonString: string = jsonEditor.getText();


text:
package org.brackit.server.tx.locking.services;

import java.util.ArrayList;
import java.util.List;

import org.brackit.server.tx.Tx;
import org.brackit.server.tx.TxException;
import org.brackit.server.tx.TxState;
import org.brackit.server.tx.TxMgr;
import org.brackit.server.tx.locking.LockClass;
import org.brackit.server.tx.locking.LockName;
import org.brackit.server.tx.locking.protocol.URIX;
import org.brackit.server.tx.locking.protocol.URIX.Mode;
import org.brackit.server.tx.locking.table.TreeLockNameFactory;
import org.brackit.xquery.util.Cfg;

/**
 * Simple lock service that serializes txs directly.
 *
 * @author Sebastian Baechle
 *
 */
public class SimpleLockService<E> extends GenericLockServiceImpl<URIX.Mode> {
	private class ObjectLockName<F> implements LockName {
		private final F obj;

		public ObjectLockName(F string) {
			this.obj = string;
		}

		@Override
		public boolean equals(Object obj) {
			return ((obj instanceof ObjectLockName) && (((ObjectLockName<F>) obj).obj
					.equals(this.obj)));
		}

		@Override
		public int hashCode() {
			return obj.hashCode();
		}

		@Override
		public String toString() {
			return obj.toString();
		}
	}

	public List<E> getLockedResources() {
		List<LockName> resources = table.getLockedResources();
		List<E> objects = new ArrayList<E>(resources.size());

		for (LockName name : resources) {
			objects.add(((ObjectLockName<E>) name).obj);
		}

		return objects;
	}

	public void lock(Tx tx, E object, LockClass lockClass, boolean shared)
			throws TxException {
		LockName lockName = new ObjectLockName<E>(object);
		Mode mode = (shared) ? Mode.R : Mode.X;
		processResult(tx, lockName, mode, getClient(tx).request(lockName,
				lockClass, mode, false), false);
	}

	protected URIX.Mode processResult(Tx tx, TreeLockNameFactory lockNames,
			Mode requested, Mode result, boolean conditional)
			throws TxException {
		if (result != null) {
			return result;
		} else if (conditional) {
			return null;
		} else {
			String reason = (tx.getState() == TxState.ABORTED) ? "Kill"
					: "Timeout";
			throw new TxException("Lock request %s for %s (%s) failed: %s",
					requested, lockNames
							.getLockName(lockNames.getTargetLevel()),
					conditional ? "conditional" : "unconditional", reason);
		}
	}

	public SimpleLockService(String name) {
		this(name, Cfg.asInt(TxMgr.MAX_LOCKS, 200000), Cfg.asInt(TxMgr.MAX_TX,
				100));
	}

	public SimpleLockService(String name, int maxLocks, int maxTransactions) {
		super(name, maxLocks, maxTransactions);
	}
}