8b4ec79d4f · samitouri/QOS-React-2

@@ -1,6379 +0,0 @@

1 -/**

2 - * @license

4 - * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt

5 - * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt

6 - * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt

7 - * Code distributed by Google as part of the polymer project is also

8 - * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt

9 - * @providesModule WebComponents

10 - */

11 -// @version 0.5.1

12 -window.WebComponents = window.WebComponents || {};

13 -

14 -(function(scope) {

15 - var flags = scope.flags || {};

16 - var file = "webcomponents.js";

17 - var script = document.querySelector('script[src*="' + file + '"]');

18 - var flags = {};

19 - if (!flags.noOpts) {

20 - location.search.slice(1).split("&").forEach(function(o) {

21 - o = o.split("=");

22 - o[0] && (flags[o[0]] = o[1] || true);

23 - });

24 - if (script) {

25 - for (var i = 0, a; a = script.attributes[i]; i++) {

26 - if (a.name !== "src") {

27 - flags[a.name] = a.value || true;

28 - }

29 - }

30 - }

31 - if (flags.log) {

32 - var parts = flags.log.split(",");

33 - flags.log = {};

34 - parts.forEach(function(f) {

35 - flags.log[f] = true;

36 - });

37 - } else {

38 - flags.log = {};

39 - }

40 - }

41 - flags.shadow = flags.shadow || flags.shadowdom || flags.polyfill;

42 - if (flags.shadow === "native") {

43 - flags.shadow = false;

44 - } else {

45 - flags.shadow = flags.shadow || !HTMLElement.prototype.createShadowRoot;

46 - }

47 - if (flags.register) {

48 - window.CustomElements = window.CustomElements || {

49 - flags: {}

50 - };

51 - window.CustomElements.flags.register = flags.register;

52 - }

53 - scope.flags = flags;

54 -})(WebComponents);

55 -

56 -if (WebComponents.flags.shadow) {

57 - if (typeof WeakMap === "undefined") {

58 - (function() {

59 - var defineProperty = Object.defineProperty;

60 - var counter = Date.now() % 1e9;

61 - var WeakMap = function() {

62 - this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__");

63 - };

64 - WeakMap.prototype = {

65 - set: function(key, value) {

66 - var entry = key[this.name];

67 - if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {

68 - value: [ key, value ],

69 - writable: true

70 - });

71 - return this;

72 - },

73 - get: function(key) {

74 - var entry;

75 - return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;

76 - },

77 - "delete": function(key) {

78 - var entry = key[this.name];

79 - if (!entry || entry[0] !== key) return false;

80 - entry[0] = entry[1] = undefined;

81 - return true;

82 - },

83 - has: function(key) {

84 - var entry = key[this.name];

85 - if (!entry) return false;

86 - return entry[0] === key;

87 - }

88 - };

89 - window.WeakMap = WeakMap;

90 - })();

91 - }

92 - window.ShadowDOMPolyfill = {};

93 - (function(scope) {

94 - "use strict";

95 - var constructorTable = new WeakMap();

96 - var nativePrototypeTable = new WeakMap();

97 - var wrappers = Object.create(null);

98 - function detectEval() {

99 - if (typeof chrome !== "undefined" && chrome.app && chrome.app.runtime) {

100 - return false;

101 - }

102 - if (navigator.getDeviceStorage) {

103 - return false;

104 - }

105 - try {

106 - var f = new Function("return true;");

107 - return f();

108 - } catch (ex) {

109 - return false;

110 - }

111 - }

112 - var hasEval = detectEval();

113 - function assert(b) {

114 - if (!b) throw new Error("Assertion failed");

115 - }

116 - var defineProperty = Object.defineProperty;

117 - var getOwnPropertyNames = Object.getOwnPropertyNames;

118 - var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;

119 - function mixin(to, from) {

120 - var names = getOwnPropertyNames(from);

121 - for (var i = 0; i < names.length; i++) {

122 - var name = names[i];

123 - defineProperty(to, name, getOwnPropertyDescriptor(from, name));

124 - }

125 - return to;

126 - }

127 - function mixinStatics(to, from) {

128 - var names = getOwnPropertyNames(from);

129 - for (var i = 0; i < names.length; i++) {

130 - var name = names[i];

131 - switch (name) {

132 - case "arguments":

133 - case "caller":

134 - case "length":

135 - case "name":

136 - case "prototype":

137 - case "toString":

138 - continue;

139 - }

140 - defineProperty(to, name, getOwnPropertyDescriptor(from, name));

141 - }

142 - return to;

143 - }

144 - function oneOf(object, propertyNames) {

145 - for (var i = 0; i < propertyNames.length; i++) {

146 - if (propertyNames[i] in object) return propertyNames[i];

147 - }

148 - }

149 - var nonEnumerableDataDescriptor = {

150 - value: undefined,

151 - configurable: true,

152 - enumerable: false,

153 - writable: true

154 - };

155 - function defineNonEnumerableDataProperty(object, name, value) {

156 - nonEnumerableDataDescriptor.value = value;

157 - defineProperty(object, name, nonEnumerableDataDescriptor);

158 - }

159 - getOwnPropertyNames(window);

160 - function getWrapperConstructor(node) {

161 - var nativePrototype = node.__proto__ || Object.getPrototypeOf(node);

162 - var wrapperConstructor = constructorTable.get(nativePrototype);

163 - if (wrapperConstructor) return wrapperConstructor;

164 - var parentWrapperConstructor = getWrapperConstructor(nativePrototype);

165 - var GeneratedWrapper = createWrapperConstructor(parentWrapperConstructor);

166 - registerInternal(nativePrototype, GeneratedWrapper, node);

167 - return GeneratedWrapper;

168 - }

169 - function addForwardingProperties(nativePrototype, wrapperPrototype) {

170 - installProperty(nativePrototype, wrapperPrototype, true);

171 - }

172 - function registerInstanceProperties(wrapperPrototype, instanceObject) {

173 - installProperty(instanceObject, wrapperPrototype, false);

174 - }

175 - var isFirefox = /Firefox/.test(navigator.userAgent);

176 - var dummyDescriptor = {

177 - get: function() {},

178 - set: function(v) {},

179 - configurable: true,

180 - enumerable: true

181 - };

182 - function isEventHandlerName(name) {

183 - return /^on[a-z]+$/.test(name);

184 - }

185 - function isIdentifierName(name) {

186 - return /^\w[a-zA-Z_0-9]*$/.test(name);

187 - }

188 - function getGetter(name) {

189 - return hasEval && isIdentifierName(name) ? new Function("return this.__impl4cf1e782hg__." + name) : function() {

190 - return this.__impl4cf1e782hg__[name];

191 - };

192 - }

193 - function getSetter(name) {

194 - return hasEval && isIdentifierName(name) ? new Function("v", "this.__impl4cf1e782hg__." + name + " = v") : function(v) {

195 - this.__impl4cf1e782hg__[name] = v;

196 - };

197 - }

198 - function getMethod(name) {

199 - return hasEval && isIdentifierName(name) ? new Function("return this.__impl4cf1e782hg__." + name + ".apply(this.__impl4cf1e782hg__, arguments)") : function() {

200 - return this.__impl4cf1e782hg__[name].apply(this.__impl4cf1e782hg__, arguments);

201 - };

202 - }

203 - function getDescriptor(source, name) {

204 - try {

205 - return Object.getOwnPropertyDescriptor(source, name);

206 - } catch (ex) {

207 - return dummyDescriptor;

208 - }

209 - }

210 - var isBrokenSafari = function() {

211 - var descr = Object.getOwnPropertyDescriptor(Node.prototype, "nodeType");

212 - return descr && !descr.get && !descr.set;

213 - }();

214 - function installProperty(source, target, allowMethod, opt_blacklist) {

215 - var names = getOwnPropertyNames(source);

216 - for (var i = 0; i < names.length; i++) {

217 - var name = names[i];

218 - if (name === "polymerBlackList_") continue;

219 - if (name in target) continue;

220 - if (source.polymerBlackList_ && source.polymerBlackList_[name]) continue;

221 - if (isFirefox) {

222 - source.__lookupGetter__(name);

223 - }

224 - var descriptor = getDescriptor(source, name);

225 - var getter, setter;

226 - if (allowMethod && typeof descriptor.value === "function") {

227 - target[name] = getMethod(name);

228 - continue;

229 - }

230 - var isEvent = isEventHandlerName(name);

231 - if (isEvent) getter = scope.getEventHandlerGetter(name); else getter = getGetter(name);

232 - if (descriptor.writable || descriptor.set || isBrokenSafari) {

233 - if (isEvent) setter = scope.getEventHandlerSetter(name); else setter = getSetter(name);

234 - }

235 - defineProperty(target, name, {

236 - get: getter,

237 - set: setter,

238 - configurable: descriptor.configurable,

239 - enumerable: descriptor.enumerable

240 - });

241 - }

242 - }

243 - function register(nativeConstructor, wrapperConstructor, opt_instance) {

244 - var nativePrototype = nativeConstructor.prototype;

245 - registerInternal(nativePrototype, wrapperConstructor, opt_instance);

246 - mixinStatics(wrapperConstructor, nativeConstructor);

247 - }

248 - function registerInternal(nativePrototype, wrapperConstructor, opt_instance) {

249 - var wrapperPrototype = wrapperConstructor.prototype;

250 - assert(constructorTable.get(nativePrototype) === undefined);

251 - constructorTable.set(nativePrototype, wrapperConstructor);

252 - nativePrototypeTable.set(wrapperPrototype, nativePrototype);

253 - addForwardingProperties(nativePrototype, wrapperPrototype);

254 - if (opt_instance) registerInstanceProperties(wrapperPrototype, opt_instance);

255 - defineNonEnumerableDataProperty(wrapperPrototype, "constructor", wrapperConstructor);

256 - wrapperConstructor.prototype = wrapperPrototype;

257 - }

258 - function isWrapperFor(wrapperConstructor, nativeConstructor) {

259 - return constructorTable.get(nativeConstructor.prototype) === wrapperConstructor;

260 - }

261 - function registerObject(object) {

262 - var nativePrototype = Object.getPrototypeOf(object);

263 - var superWrapperConstructor = getWrapperConstructor(nativePrototype);

264 - var GeneratedWrapper = createWrapperConstructor(superWrapperConstructor);

265 - registerInternal(nativePrototype, GeneratedWrapper, object);

266 - return GeneratedWrapper;

267 - }

268 - function createWrapperConstructor(superWrapperConstructor) {

269 - function GeneratedWrapper(node) {

270 - superWrapperConstructor.call(this, node);

271 - }

272 - var p = Object.create(superWrapperConstructor.prototype);

273 - p.constructor = GeneratedWrapper;

274 - GeneratedWrapper.prototype = p;

275 - return GeneratedWrapper;

276 - }

277 - function isWrapper(object) {

278 - return object && object.__impl4cf1e782hg__;

279 - }

280 - function isNative(object) {

281 - return !isWrapper(object);

282 - }

283 - function wrap(impl) {

284 - if (impl === null) return null;

285 - assert(isNative(impl));

286 - return impl.__wrapper8e3dd93a60__ || (impl.__wrapper8e3dd93a60__ = new (getWrapperConstructor(impl))(impl));

287 - }

288 - function unwrap(wrapper) {

289 - if (wrapper === null) return null;

290 - assert(isWrapper(wrapper));

291 - return wrapper.__impl4cf1e782hg__;

292 - }

293 - function unsafeUnwrap(wrapper) {

294 - return wrapper.__impl4cf1e782hg__;

295 - }

296 - function setWrapper(impl, wrapper) {

297 - wrapper.__impl4cf1e782hg__ = impl;

298 - impl.__wrapper8e3dd93a60__ = wrapper;

299 - }

300 - function unwrapIfNeeded(object) {

301 - return object && isWrapper(object) ? unwrap(object) : object;

302 - }

303 - function wrapIfNeeded(object) {

304 - return object && !isWrapper(object) ? wrap(object) : object;

305 - }

306 - function rewrap(node, wrapper) {

307 - if (wrapper === null) return;

308 - assert(isNative(node));

309 - assert(wrapper === undefined || isWrapper(wrapper));

310 - node.__wrapper8e3dd93a60__ = wrapper;

311 - }

312 - var getterDescriptor = {

313 - get: undefined,

314 - configurable: true,

315 - enumerable: true

316 - };

317 - function defineGetter(constructor, name, getter) {

318 - getterDescriptor.get = getter;

319 - defineProperty(constructor.prototype, name, getterDescriptor);

320 - }

321 - function defineWrapGetter(constructor, name) {

322 - defineGetter(constructor, name, function() {

323 - return wrap(this.__impl4cf1e782hg__[name]);

324 - });

325 - }

326 - function forwardMethodsToWrapper(constructors, names) {

327 - constructors.forEach(function(constructor) {

328 - names.forEach(function(name) {

329 - constructor.prototype[name] = function() {

330 - var w = wrapIfNeeded(this);

331 - return w[name].apply(w, arguments);

332 - };

333 - });

334 - });

335 - }

336 - scope.assert = assert;

337 - scope.constructorTable = constructorTable;

338 - scope.defineGetter = defineGetter;

339 - scope.defineWrapGetter = defineWrapGetter;

340 - scope.forwardMethodsToWrapper = forwardMethodsToWrapper;

341 - scope.isWrapper = isWrapper;

342 - scope.isWrapperFor = isWrapperFor;

343 - scope.mixin = mixin;

344 - scope.nativePrototypeTable = nativePrototypeTable;

345 - scope.oneOf = oneOf;

346 - scope.registerObject = registerObject;

347 - scope.registerWrapper = register;

348 - scope.rewrap = rewrap;

349 - scope.setWrapper = setWrapper;

350 - scope.unsafeUnwrap = unsafeUnwrap;

351 - scope.unwrap = unwrap;

352 - scope.unwrapIfNeeded = unwrapIfNeeded;

353 - scope.wrap = wrap;

354 - scope.wrapIfNeeded = wrapIfNeeded;

355 - scope.wrappers = wrappers;

356 - })(window.ShadowDOMPolyfill);

357 - (function(scope) {

358 - "use strict";

359 - function newSplice(index, removed, addedCount) {

360 - return {

361 - index: index,

362 - removed: removed,

363 - addedCount: addedCount

364 - };

365 - }

366 - var EDIT_LEAVE = 0;

367 - var EDIT_UPDATE = 1;

368 - var EDIT_ADD = 2;

369 - var EDIT_DELETE = 3;

370 - function ArraySplice() {}

371 - ArraySplice.prototype = {

372 - calcEditDistances: function(current, currentStart, currentEnd, old, oldStart, oldEnd) {

373 - var rowCount = oldEnd - oldStart + 1;

374 - var columnCount = currentEnd - currentStart + 1;

375 - var distances = new Array(rowCount);

376 - for (var i = 0; i < rowCount; i++) {

377 - distances[i] = new Array(columnCount);

378 - distances[i][0] = i;

379 - }

380 - for (var j = 0; j < columnCount; j++) distances[0][j] = j;

381 - for (var i = 1; i < rowCount; i++) {

382 - for (var j = 1; j < columnCount; j++) {

383 - if (this.equals(current[currentStart + j - 1], old[oldStart + i - 1])) distances[i][j] = distances[i - 1][j - 1]; else {

384 - var north = distances[i - 1][j] + 1;

385 - var west = distances[i][j - 1] + 1;

386 - distances[i][j] = north < west ? north : west;

387 - }

388 - }

389 - }

390 - return distances;

391 - },

392 - spliceOperationsFromEditDistances: function(distances) {

393 - var i = distances.length - 1;

394 - var j = distances[0].length - 1;

395 - var current = distances[i][j];

396 - var edits = [];

397 - while (i > 0 || j > 0) {

398 - if (i == 0) {

399 - edits.push(EDIT_ADD);

400 - j--;

401 - continue;

402 - }

403 - if (j == 0) {

404 - edits.push(EDIT_DELETE);

405 - i--;

406 - continue;

407 - }

408 - var northWest = distances[i - 1][j - 1];

409 - var west = distances[i - 1][j];

410 - var north = distances[i][j - 1];

411 - var min;

412 - if (west < north) min = west < northWest ? west : northWest; else min = north < northWest ? north : northWest;

413 - if (min == northWest) {

414 - if (northWest == current) {

415 - edits.push(EDIT_LEAVE);

416 - } else {

417 - edits.push(EDIT_UPDATE);

418 - current = northWest;

419 - }

420 - i--;

421 - j--;

422 - } else if (min == west) {

423 - edits.push(EDIT_DELETE);

424 - i--;

425 - current = west;

426 - } else {

427 - edits.push(EDIT_ADD);

428 - j--;

429 - current = north;

430 - }

431 - }

432 - edits.reverse();

433 - return edits;

434 - },

435 - calcSplices: function(current, currentStart, currentEnd, old, oldStart, oldEnd) {

436 - var prefixCount = 0;

437 - var suffixCount = 0;

438 - var minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);

439 - if (currentStart == 0 && oldStart == 0) prefixCount = this.sharedPrefix(current, old, minLength);

440 - if (currentEnd == current.length && oldEnd == old.length) suffixCount = this.sharedSuffix(current, old, minLength - prefixCount);

441 - currentStart += prefixCount;

442 - oldStart += prefixCount;

443 - currentEnd -= suffixCount;

444 - oldEnd -= suffixCount;

445 - if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0) return [];

446 - if (currentStart == currentEnd) {

447 - var splice = newSplice(currentStart, [], 0);

448 - while (oldStart < oldEnd) splice.removed.push(old[oldStart++]);

449 - return [ splice ];

450 - } else if (oldStart == oldEnd) return [ newSplice(currentStart, [], currentEnd - currentStart) ];

451 - var ops = this.spliceOperationsFromEditDistances(this.calcEditDistances(current, currentStart, currentEnd, old, oldStart, oldEnd));

452 - var splice = undefined;

453 - var splices = [];

454 - var index = currentStart;

455 - var oldIndex = oldStart;

456 - for (var i = 0; i < ops.length; i++) {

457 - switch (ops[i]) {

458 - case EDIT_LEAVE:

459 - if (splice) {

460 - splices.push(splice);

461 - splice = undefined;

462 - }

463 - index++;

464 - oldIndex++;

465 - break;

466 -

467 - case EDIT_UPDATE:

468 - if (!splice) splice = newSplice(index, [], 0);

469 - splice.addedCount++;

470 - index++;

471 - splice.removed.push(old[oldIndex]);

472 - oldIndex++;

473 - break;

474 -

475 - case EDIT_ADD:

476 - if (!splice) splice = newSplice(index, [], 0);

477 - splice.addedCount++;

478 - index++;

479 - break;

480 -

481 - case EDIT_DELETE:

482 - if (!splice) splice = newSplice(index, [], 0);

483 - splice.removed.push(old[oldIndex]);

484 - oldIndex++;

485 - break;

486 - }

487 - }

488 - if (splice) {

489 - splices.push(splice);

490 - }

491 - return splices;

492 - },

493 - sharedPrefix: function(current, old, searchLength) {

494 - for (var i = 0; i < searchLength; i++) if (!this.equals(current[i], old[i])) return i;

495 - return searchLength;

496 - },

497 - sharedSuffix: function(current, old, searchLength) {

498 - var index1 = current.length;

499 - var index2 = old.length;

500 - var count = 0;

501 - while (count < searchLength && this.equals(current[--index1], old[--index2])) count++;

502 - return count;

503 - },

504 - calculateSplices: function(current, previous) {

505 - return this.calcSplices(current, 0, current.length, previous, 0, previous.length);

506 - },

507 - equals: function(currentValue, previousValue) {

508 - return currentValue === previousValue;

509 - }

510 - };

511 - scope.ArraySplice = ArraySplice;

512 - })(window.ShadowDOMPolyfill);

513 - (function(context) {

514 - "use strict";

515 - var OriginalMutationObserver = window.MutationObserver;

516 - var callbacks = [];

517 - var pending = false;

518 - var timerFunc;

519 - function handle() {

520 - pending = false;

521 - var copies = callbacks.slice(0);

522 - callbacks = [];

523 - for (var i = 0; i < copies.length; i++) {

524 - (0, copies[i])();

525 - }

526 - }

527 - if (OriginalMutationObserver) {

528 - var counter = 1;

529 - var observer = new OriginalMutationObserver(handle);

530 - var textNode = document.createTextNode(counter);

531 - observer.observe(textNode, {

532 - characterData: true

533 - });

534 - timerFunc = function() {

535 - counter = (counter + 1) % 2;

536 - textNode.data = counter;

537 - };

538 - } else {

539 - timerFunc = window.setTimeout;

540 - }

541 - function setEndOfMicrotask(func) {

542 - callbacks.push(func);

543 - if (pending) return;

544 - pending = true;

545 - timerFunc(handle, 0);

546 - }

547 - context.setEndOfMicrotask = setEndOfMicrotask;

548 - })(window.ShadowDOMPolyfill);

549 - (function(scope) {

550 - "use strict";

551 - var setEndOfMicrotask = scope.setEndOfMicrotask;

552 - var wrapIfNeeded = scope.wrapIfNeeded;

553 - var wrappers = scope.wrappers;

554 - var registrationsTable = new WeakMap();

555 - var globalMutationObservers = [];

556 - var isScheduled = false;

557 - function scheduleCallback(observer) {

558 - if (observer.scheduled_) return;

559 - observer.scheduled_ = true;

560 - globalMutationObservers.push(observer);

561 - if (isScheduled) return;

562 - setEndOfMicrotask(notifyObservers);

563 - isScheduled = true;

564 - }

565 - function notifyObservers() {

566 - isScheduled = false;

567 - while (globalMutationObservers.length) {

568 - var notifyList = globalMutationObservers;

569 - globalMutationObservers = [];

570 - notifyList.sort(function(x, y) {

571 - return x.uid_ - y.uid_;

572 - });

573 - for (var i = 0; i < notifyList.length; i++) {

574 - var mo = notifyList[i];

575 - mo.scheduled_ = false;

576 - var queue = mo.takeRecords();

577 - removeTransientObserversFor(mo);

578 - if (queue.length) {

579 - mo.callback_(queue, mo);

580 - }

581 - }

582 - }

583 - }

584 - function MutationRecord(type, target) {

585 - this.type = type;

586 - this.target = target;

587 - this.addedNodes = new wrappers.NodeList();

588 - this.removedNodes = new wrappers.NodeList();

589 - this.previousSibling = null;

590 - this.nextSibling = null;

591 - this.attributeName = null;

592 - this.attributeNamespace = null;

593 - this.oldValue = null;

594 - }

595 - function registerTransientObservers(ancestor, node) {

596 - for (;ancestor; ancestor = ancestor.parentNode) {

597 - var registrations = registrationsTable.get(ancestor);

598 - if (!registrations) continue;

599 - for (var i = 0; i < registrations.length; i++) {

600 - var registration = registrations[i];

601 - if (registration.options.subtree) registration.addTransientObserver(node);

602 - }

603 - }

604 - }

605 - function removeTransientObserversFor(observer) {

606 - for (var i = 0; i < observer.nodes_.length; i++) {

607 - var node = observer.nodes_[i];

608 - var registrations = registrationsTable.get(node);

609 - if (!registrations) return;

610 - for (var j = 0; j < registrations.length; j++) {

611 - var registration = registrations[j];

612 - if (registration.observer === observer) registration.removeTransientObservers();

613 - }

614 - }

615 - }

616 - function enqueueMutation(target, type, data) {

617 - var interestedObservers = Object.create(null);

618 - var associatedStrings = Object.create(null);

619 - for (var node = target; node; node = node.parentNode) {

620 - var registrations = registrationsTable.get(node);

621 - if (!registrations) continue;

622 - for (var j = 0; j < registrations.length; j++) {

623 - var registration = registrations[j];

624 - var options = registration.options;

625 - if (node !== target && !options.subtree) continue;

626 - if (type === "attributes" && !options.attributes) continue;

627 - if (type === "attributes" && options.attributeFilter && (data.namespace !== null || options.attributeFilter.indexOf(data.name) === -1)) {

628 - continue;

629 - }

630 - if (type === "characterData" && !options.characterData) continue;

631 - if (type === "childList" && !options.childList) continue;

632 - var observer = registration.observer;

633 - interestedObservers[observer.uid_] = observer;

634 - if (type === "attributes" && options.attributeOldValue || type === "characterData" && options.characterDataOldValue) {

635 - associatedStrings[observer.uid_] = data.oldValue;

636 - }

637 - }

638 - }

639 - for (var uid in interestedObservers) {

640 - var observer = interestedObservers[uid];

641 - var record = new MutationRecord(type, target);

642 - if ("name" in data && "namespace" in data) {

643 - record.attributeName = data.name;

644 - record.attributeNamespace = data.namespace;

645 - }

646 - if (data.addedNodes) record.addedNodes = data.addedNodes;

647 - if (data.removedNodes) record.removedNodes = data.removedNodes;

648 - if (data.previousSibling) record.previousSibling = data.previousSibling;

649 - if (data.nextSibling) record.nextSibling = data.nextSibling;

650 - if (associatedStrings[uid] !== undefined) record.oldValue = associatedStrings[uid];

651 - scheduleCallback(observer);

652 - observer.records_.push(record);

653 - }

654 - }

655 - var slice = Array.prototype.slice;

656 - function MutationObserverOptions(options) {

657 - this.childList = !!options.childList;

658 - this.subtree = !!options.subtree;

659 - if (!("attributes" in options) && ("attributeOldValue" in options || "attributeFilter" in options)) {

660 - this.attributes = true;

661 - } else {

662 - this.attributes = !!options.attributes;

663 - }

664 - if ("characterDataOldValue" in options && !("characterData" in options)) this.characterData = true; else this.characterData = !!options.characterData;

665 - if (!this.attributes && (options.attributeOldValue || "attributeFilter" in options) || !this.characterData && options.characterDataOldValue) {

666 - throw new TypeError();

667 - }

668 - this.characterData = !!options.characterData;

669 - this.attributeOldValue = !!options.attributeOldValue;

670 - this.characterDataOldValue = !!options.characterDataOldValue;

671 - if ("attributeFilter" in options) {

672 - if (options.attributeFilter == null || typeof options.attributeFilter !== "object") {

673 - throw new TypeError();

674 - }

675 - this.attributeFilter = slice.call(options.attributeFilter);

676 - } else {

677 - this.attributeFilter = null;

678 - }

679 - }

680 - var uidCounter = 0;

681 - function MutationObserver(callback) {

682 - this.callback_ = callback;

683 - this.nodes_ = [];

684 - this.records_ = [];

685 - this.uid_ = ++uidCounter;

686 - this.scheduled_ = false;

687 - }

688 - MutationObserver.prototype = {

689 - constructor: MutationObserver,

690 - observe: function(target, options) {

691 - target = wrapIfNeeded(target);

692 - var newOptions = new MutationObserverOptions(options);

693 - var registration;

694 - var registrations = registrationsTable.get(target);

695 - if (!registrations) registrationsTable.set(target, registrations = []);

696 - for (var i = 0; i < registrations.length; i++) {

697 - if (registrations[i].observer === this) {

698 - registration = registrations[i];

699 - registration.removeTransientObservers();

700 - registration.options = newOptions;

701 - }

702 - }

703 - if (!registration) {

704 - registration = new Registration(this, target, newOptions);

705 - registrations.push(registration);

706 - this.nodes_.push(target);

707 - }

708 - },

709 - disconnect: function() {

710 - this.nodes_.forEach(function(node) {

711 - var registrations = registrationsTable.get(node);

712 - for (var i = 0; i < registrations.length; i++) {

713 - var registration = registrations[i];

714 - if (registration.observer === this) {

715 - registrations.splice(i, 1);

716 - break;

717 - }

718 - }

719 - }, this);

720 - this.records_ = [];

721 - },

722 - takeRecords: function() {

723 - var copyOfRecords = this.records_;

724 - this.records_ = [];

725 - return copyOfRecords;

726 - }

727 - };

728 - function Registration(observer, target, options) {

729 - this.observer = observer;

730 - this.target = target;

731 - this.options = options;

732 - this.transientObservedNodes = [];

733 - }

734 - Registration.prototype = {

735 - addTransientObserver: function(node) {

736 - if (node === this.target) return;

737 - scheduleCallback(this.observer);

738 - this.transientObservedNodes.push(node);

739 - var registrations = registrationsTable.get(node);

740 - if (!registrations) registrationsTable.set(node, registrations = []);

741 - registrations.push(this);

742 - },

743 - removeTransientObservers: function() {

744 - var transientObservedNodes = this.transientObservedNodes;

745 - this.transientObservedNodes = [];

746 - for (var i = 0; i < transientObservedNodes.length; i++) {

747 - var node = transientObservedNodes[i];

748 - var registrations = registrationsTable.get(node);

749 - for (var j = 0; j < registrations.length; j++) {

750 - if (registrations[j] === this) {

751 - registrations.splice(j, 1);

752 - break;

753 - }

754 - }

755 - }

756 - }

757 - };

758 - scope.enqueueMutation = enqueueMutation;

759 - scope.registerTransientObservers = registerTransientObservers;

760 - scope.wrappers.MutationObserver = MutationObserver;

761 - scope.wrappers.MutationRecord = MutationRecord;

762 - })(window.ShadowDOMPolyfill);

763 - (function(scope) {

764 - "use strict";

765 - function TreeScope(root, parent) {

766 - this.root = root;

767 - this.parent = parent;

768 - }

769 - TreeScope.prototype = {

770 - get renderer() {

771 - if (this.root instanceof scope.wrappers.ShadowRoot) {

772 - return scope.getRendererForHost(this.root.host);

773 - }

774 - return null;

775 - },

776 - contains: function(treeScope) {

777 - for (;treeScope; treeScope = treeScope.parent) {

778 - if (treeScope === this) return true;

779 - }

780 - return false;

781 - }

782 - };

783 - function setTreeScope(node, treeScope) {

784 - if (node.treeScope_ !== treeScope) {

785 - node.treeScope_ = treeScope;

786 - for (var sr = node.shadowRoot; sr; sr = sr.olderShadowRoot) {

787 - sr.treeScope_.parent = treeScope;

788 - }

789 - for (var child = node.firstChild; child; child = child.nextSibling) {

790 - setTreeScope(child, treeScope);

791 - }

792 - }

793 - }

794 - function getTreeScope(node) {

795 - if (node instanceof scope.wrappers.Window) {

796 - debugger;

797 - }

798 - if (node.treeScope_) return node.treeScope_;

799 - var parent = node.parentNode;

800 - var treeScope;

801 - if (parent) treeScope = getTreeScope(parent); else treeScope = new TreeScope(node, null);

802 - return node.treeScope_ = treeScope;

803 - }

804 - scope.TreeScope = TreeScope;

805 - scope.getTreeScope = getTreeScope;

806 - scope.setTreeScope = setTreeScope;

807 - })(window.ShadowDOMPolyfill);

808 - (function(scope) {

809 - "use strict";

810 - var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;

811 - var getTreeScope = scope.getTreeScope;

812 - var mixin = scope.mixin;

813 - var registerWrapper = scope.registerWrapper;

814 - var setWrapper = scope.setWrapper;

815 - var unsafeUnwrap = scope.unsafeUnwrap;

816 - var unwrap = scope.unwrap;

817 - var wrap = scope.wrap;

818 - var wrappers = scope.wrappers;

819 - var wrappedFuns = new WeakMap();

820 - var listenersTable = new WeakMap();

821 - var handledEventsTable = new WeakMap();

822 - var currentlyDispatchingEvents = new WeakMap();

823 - var targetTable = new WeakMap();

824 - var currentTargetTable = new WeakMap();

825 - var relatedTargetTable = new WeakMap();

826 - var eventPhaseTable = new WeakMap();

827 - var stopPropagationTable = new WeakMap();

828 - var stopImmediatePropagationTable = new WeakMap();

829 - var eventHandlersTable = new WeakMap();

830 - var eventPathTable = new WeakMap();

831 - function isShadowRoot(node) {

832 - return node instanceof wrappers.ShadowRoot;

833 - }

834 - function rootOfNode(node) {

835 - return getTreeScope(node).root;

836 - }

837 - function getEventPath(node, event) {

838 - var path = [];

839 - var current = node;

840 - path.push(current);

841 - while (current) {

842 - var destinationInsertionPoints = getDestinationInsertionPoints(current);

843 - if (destinationInsertionPoints && destinationInsertionPoints.length > 0) {

844 - for (var i = 0; i < destinationInsertionPoints.length; i++) {

845 - var insertionPoint = destinationInsertionPoints[i];

846 - if (isShadowInsertionPoint(insertionPoint)) {

847 - var shadowRoot = rootOfNode(insertionPoint);

848 - var olderShadowRoot = shadowRoot.olderShadowRoot;

849 - if (olderShadowRoot) path.push(olderShadowRoot);

850 - }

851 - path.push(insertionPoint);

852 - }

853 - current = destinationInsertionPoints[destinationInsertionPoints.length - 1];

854 - } else {

855 - if (isShadowRoot(current)) {

856 - if (inSameTree(node, current) && eventMustBeStopped(event)) {

857 - break;

858 - }

859 - current = current.host;

860 - path.push(current);

861 - } else {

862 - current = current.parentNode;

863 - if (current) path.push(current);

864 - }

865 - }

866 - }

867 - return path;

868 - }

869 - function eventMustBeStopped(event) {

870 - if (!event) return false;

871 - switch (event.type) {

872 - case "abort":

873 - case "error":

874 - case "select":

875 - case "change":

876 - case "load":

877 - case "reset":

878 - case "resize":

879 - case "scroll":

880 - case "selectstart":

881 - return true;

882 - }

883 - return false;

884 - }

885 - function isShadowInsertionPoint(node) {

886 - return node instanceof HTMLShadowElement;

887 - }

888 - function getDestinationInsertionPoints(node) {

889 - return scope.getDestinationInsertionPoints(node);

890 - }

891 - function eventRetargetting(path, currentTarget) {

892 - if (path.length === 0) return currentTarget;

893 - if (currentTarget instanceof wrappers.Window) currentTarget = currentTarget.document;

894 - var currentTargetTree = getTreeScope(currentTarget);

895 - var originalTarget = path[0];

896 - var originalTargetTree = getTreeScope(originalTarget);

897 - var relativeTargetTree = lowestCommonInclusiveAncestor(currentTargetTree, originalTargetTree);

898 - for (var i = 0; i < path.length; i++) {

899 - var node = path[i];

900 - if (getTreeScope(node) === relativeTargetTree) return node;

901 - }

902 - return path[path.length - 1];

903 - }

904 - function getTreeScopeAncestors(treeScope) {

905 - var ancestors = [];

906 - for (;treeScope; treeScope = treeScope.parent) {

907 - ancestors.push(treeScope);

908 - }

909 - return ancestors;

910 - }

911 - function lowestCommonInclusiveAncestor(tsA, tsB) {

912 - var ancestorsA = getTreeScopeAncestors(tsA);

913 - var ancestorsB = getTreeScopeAncestors(tsB);

914 - var result = null;

915 - while (ancestorsA.length > 0 && ancestorsB.length > 0) {

916 - var a = ancestorsA.pop();

917 - var b = ancestorsB.pop();

918 - if (a === b) result = a; else break;

919 - }

920 - return result;

921 - }

922 - function getTreeScopeRoot(ts) {

923 - if (!ts.parent) return ts;

924 - return getTreeScopeRoot(ts.parent);

925 - }

926 - function relatedTargetResolution(event, currentTarget, relatedTarget) {

927 - if (currentTarget instanceof wrappers.Window) currentTarget = currentTarget.document;

928 - var currentTargetTree = getTreeScope(currentTarget);

929 - var relatedTargetTree = getTreeScope(relatedTarget);

930 - var relatedTargetEventPath = getEventPath(relatedTarget, event);

931 - var lowestCommonAncestorTree;

932 - var lowestCommonAncestorTree = lowestCommonInclusiveAncestor(currentTargetTree, relatedTargetTree);

933 - if (!lowestCommonAncestorTree) lowestCommonAncestorTree = relatedTargetTree.root;

934 - for (var commonAncestorTree = lowestCommonAncestorTree; commonAncestorTree; commonAncestorTree = commonAncestorTree.parent) {

935 - var adjustedRelatedTarget;

936 - for (var i = 0; i < relatedTargetEventPath.length; i++) {

937 - var node = relatedTargetEventPath[i];

938 - if (getTreeScope(node) === commonAncestorTree) return node;

939 - }

940 - }

941 - return null;

942 - }

943 - function inSameTree(a, b) {

944 - return getTreeScope(a) === getTreeScope(b);

945 - }

946 - var NONE = 0;

947 - var CAPTURING_PHASE = 1;

948 - var AT_TARGET = 2;

949 - var BUBBLING_PHASE = 3;

950 - var pendingError;

951 - function dispatchOriginalEvent(originalEvent) {

952 - if (handledEventsTable.get(originalEvent)) return;

953 - handledEventsTable.set(originalEvent, true);

954 - dispatchEvent(wrap(originalEvent), wrap(originalEvent.target));

955 - if (pendingError) {

956 - var err = pendingError;

957 - pendingError = null;

958 - throw err;

959 - }

960 - }

961 - function isLoadLikeEvent(event) {

962 - switch (event.type) {

963 - case "load":

964 - case "beforeunload":

965 - case "unload":

966 - return true;

967 - }

968 - return false;

969 - }

970 - function dispatchEvent(event, originalWrapperTarget) {

971 - if (currentlyDispatchingEvents.get(event)) throw new Error("InvalidStateError");

972 - currentlyDispatchingEvents.set(event, true);

973 - scope.renderAllPending();

974 - var eventPath;

975 - var overrideTarget;

976 - var win;

977 - if (isLoadLikeEvent(event) && !event.bubbles) {

978 - var doc = originalWrapperTarget;

979 - if (doc instanceof wrappers.Document && (win = doc.defaultView)) {

980 - overrideTarget = doc;

981 - eventPath = [];

982 - }

983 - }

984 - if (!eventPath) {

985 - if (originalWrapperTarget instanceof wrappers.Window) {

986 - win = originalWrapperTarget;

987 - eventPath = [];

988 - } else {

989 - eventPath = getEventPath(originalWrapperTarget, event);

990 - if (!isLoadLikeEvent(event)) {

991 - var doc = eventPath[eventPath.length - 1];

992 - if (doc instanceof wrappers.Document) win = doc.defaultView;

993 - }

994 - }

995 - }

996 - eventPathTable.set(event, eventPath);

997 - if (dispatchCapturing(event, eventPath, win, overrideTarget)) {

998 - if (dispatchAtTarget(event, eventPath, win, overrideTarget)) {

999 - dispatchBubbling(event, eventPath, win, overrideTarget);

1000 - }

1001 - }

1002 - eventPhaseTable.set(event, NONE);

1003 - currentTargetTable.delete(event, null);

1004 - currentlyDispatchingEvents.delete(event);

1005 - return event.defaultPrevented;

1006 - }

1007 - function dispatchCapturing(event, eventPath, win, overrideTarget) {

1008 - var phase = CAPTURING_PHASE;

1009 - if (win) {

1010 - if (!invoke(win, event, phase, eventPath, overrideTarget)) return false;

1011 - }

1012 - for (var i = eventPath.length - 1; i > 0; i--) {

1013 - if (!invoke(eventPath[i], event, phase, eventPath, overrideTarget)) return false;

1014 - }

1015 - return true;

1016 - }

1017 - function dispatchAtTarget(event, eventPath, win, overrideTarget) {

1018 - var phase = AT_TARGET;

1019 - var currentTarget = eventPath[0] || win;

1020 - return invoke(currentTarget, event, phase, eventPath, overrideTarget);

1021 - }

1022 - function dispatchBubbling(event, eventPath, win, overrideTarget) {

1023 - var phase = BUBBLING_PHASE;

1024 - for (var i = 1; i < eventPath.length; i++) {

1025 - if (!invoke(eventPath[i], event, phase, eventPath, overrideTarget)) return;

1026 - }

1027 - if (win && eventPath.length > 0) {

1028 - invoke(win, event, phase, eventPath, overrideTarget);

1029 - }

1030 - }

1031 - function invoke(currentTarget, event, phase, eventPath, overrideTarget) {

1032 - var listeners = listenersTable.get(currentTarget);

1033 - if (!listeners) return true;

1034 - var target = overrideTarget || eventRetargetting(eventPath, currentTarget);

1035 - if (target === currentTarget) {

1036 - if (phase === CAPTURING_PHASE) return true;

1037 - if (phase === BUBBLING_PHASE) phase = AT_TARGET;

1038 - } else if (phase === BUBBLING_PHASE && !event.bubbles) {

1039 - return true;

1040 - }

1041 - if ("relatedTarget" in event) {

1042 - var originalEvent = unwrap(event);

1043 - var unwrappedRelatedTarget = originalEvent.relatedTarget;

1044 - if (unwrappedRelatedTarget) {

1045 - if (unwrappedRelatedTarget instanceof Object && unwrappedRelatedTarget.addEventListener) {

1046 - var relatedTarget = wrap(unwrappedRelatedTarget);

1047 - var adjusted = relatedTargetResolution(event, currentTarget, relatedTarget);

1048 - if (adjusted === target) return true;

1049 - } else {

1050 - adjusted = null;

1051 - }

1052 - relatedTargetTable.set(event, adjusted);

1053 - }

1054 - }

1055 - eventPhaseTable.set(event, phase);

1056 - var type = event.type;

1057 - var anyRemoved = false;

1058 - targetTable.set(event, target);

1059 - currentTargetTable.set(event, currentTarget);

1060 - listeners.depth++;

1061 - for (var i = 0, len = listeners.length; i < len; i++) {

1062 - var listener = listeners[i];

1063 - if (listener.removed) {

1064 - anyRemoved = true;

1065 - continue;

1066 - }

1067 - if (listener.type !== type || !listener.capture && phase === CAPTURING_PHASE || listener.capture && phase === BUBBLING_PHASE) {

1068 - continue;

1069 - }

1070 - try {

1071 - if (typeof listener.handler === "function") listener.handler.call(currentTarget, event); else listener.handler.handleEvent(event);

1072 - if (stopImmediatePropagationTable.get(event)) return false;

1073 - } catch (ex) {

1074 - if (!pendingError) pendingError = ex;

1075 - }

1076 - }

1077 - listeners.depth--;

1078 - if (anyRemoved && listeners.depth === 0) {

1079 - var copy = listeners.slice();

1080 - listeners.length = 0;

1081 - for (var i = 0; i < copy.length; i++) {

1082 - if (!copy[i].removed) listeners.push(copy[i]);

1083 - }

1084 - }

1085 - return !stopPropagationTable.get(event);

1086 - }

1087 - function Listener(type, handler, capture) {

1088 - this.type = type;

1089 - this.handler = handler;

1090 - this.capture = Boolean(capture);

1091 - }

1092 - Listener.prototype = {

1093 - equals: function(that) {

1094 - return this.handler === that.handler && this.type === that.type && this.capture === that.capture;

1095 - },

1096 - get removed() {

1097 - return this.handler === null;

1098 - },

1099 - remove: function() {

1100 - this.handler = null;

1101 - }

1102 - };

1103 - var OriginalEvent = window.Event;

1104 - OriginalEvent.prototype.polymerBlackList_ = {

1105 - returnValue: true,

1106 - keyLocation: true

1107 - };

1108 - function Event(type, options) {

1109 - if (type instanceof OriginalEvent) {

1110 - var impl = type;

1111 - if (!OriginalBeforeUnloadEvent && impl.type === "beforeunload" && !(this instanceof BeforeUnloadEvent)) {

1112 - return new BeforeUnloadEvent(impl);

1113 - }

1114 - setWrapper(impl, this);

1115 - } else {

1116 - return wrap(constructEvent(OriginalEvent, "Event", type, options));

1117 - }

1118 - }

1119 - Event.prototype = {

1120 - get target() {

1121 - return targetTable.get(this);

1122 - },

1123 - get currentTarget() {

1124 - return currentTargetTable.get(this);

1125 - },

1126 - get eventPhase() {

1127 - return eventPhaseTable.get(this);

1128 - },

1129 - get path() {

1130 - var eventPath = eventPathTable.get(this);

1131 - if (!eventPath) return [];

1132 - return eventPath.slice();

1133 - },

1134 - stopPropagation: function() {

1135 - stopPropagationTable.set(this, true);

1136 - },

1137 - stopImmediatePropagation: function() {

1138 - stopPropagationTable.set(this, true);

1139 - stopImmediatePropagationTable.set(this, true);

1140 - }

1141 - };

1142 - registerWrapper(OriginalEvent, Event, document.createEvent("Event"));

1143 - function unwrapOptions(options) {

1144 - if (!options || !options.relatedTarget) return options;

1145 - return Object.create(options, {

1146 - relatedTarget: {

1147 - value: unwrap(options.relatedTarget)

1148 - }

1149 - });

1150 - }

1151 - function registerGenericEvent(name, SuperEvent, prototype) {

1152 - var OriginalEvent = window[name];

1153 - var GenericEvent = function(type, options) {

1154 - if (type instanceof OriginalEvent) setWrapper(type, this); else return wrap(constructEvent(OriginalEvent, name, type, options));

1155 - };

1156 - GenericEvent.prototype = Object.create(SuperEvent.prototype);

1157 - if (prototype) mixin(GenericEvent.prototype, prototype);

1158 - if (OriginalEvent) {

1159 - try {

1160 - registerWrapper(OriginalEvent, GenericEvent, new OriginalEvent("temp"));

1161 - } catch (ex) {

1162 - registerWrapper(OriginalEvent, GenericEvent, document.createEvent(name));

1163 - }

1164 - }

1165 - return GenericEvent;

1166 - }

1167 - var UIEvent = registerGenericEvent("UIEvent", Event);

1168 - var CustomEvent = registerGenericEvent("CustomEvent", Event);

1169 - var relatedTargetProto = {

1170 - get relatedTarget() {

1171 - var relatedTarget = relatedTargetTable.get(this);

1172 - if (relatedTarget !== undefined) return relatedTarget;

1173 - return wrap(unwrap(this).relatedTarget);

1174 - }

1175 - };

1176 - function getInitFunction(name, relatedTargetIndex) {

1177 - return function() {

1178 - arguments[relatedTargetIndex] = unwrap(arguments[relatedTargetIndex]);

1179 - var impl = unwrap(this);

1180 - impl[name].apply(impl, arguments);

1181 - };

1182 - }

1183 - var mouseEventProto = mixin({

1184 - initMouseEvent: getInitFunction("initMouseEvent", 14)

1185 - }, relatedTargetProto);

1186 - var focusEventProto = mixin({

1187 - initFocusEvent: getInitFunction("initFocusEvent", 5)

1188 - }, relatedTargetProto);

1189 - var MouseEvent = registerGenericEvent("MouseEvent", UIEvent, mouseEventProto);

1190 - var FocusEvent = registerGenericEvent("FocusEvent", UIEvent, focusEventProto);

1191 - var defaultInitDicts = Object.create(null);

1192 - var supportsEventConstructors = function() {

1193 - try {

1194 - new window.FocusEvent("focus");

1195 - } catch (ex) {

1196 - return false;

1197 - }

1198 - return true;

1199 - }();

1200 - function constructEvent(OriginalEvent, name, type, options) {

1201 - if (supportsEventConstructors) return new OriginalEvent(type, unwrapOptions(options));

1202 - var event = unwrap(document.createEvent(name));

1203 - var defaultDict = defaultInitDicts[name];

1204 - var args = [ type ];

1205 - Object.keys(defaultDict).forEach(function(key) {

1206 - var v = options != null && key in options ? options[key] : defaultDict[key];

1207 - if (key === "relatedTarget") v = unwrap(v);

1208 - args.push(v);

1209 - });

1210 - event["init" + name].apply(event, args);

1211 - return event;

1212 - }

1213 - if (!supportsEventConstructors) {

1214 - var configureEventConstructor = function(name, initDict, superName) {

1215 - if (superName) {

1216 - var superDict = defaultInitDicts[superName];

1217 - initDict = mixin(mixin({}, superDict), initDict);

1218 - }

1219 - defaultInitDicts[name] = initDict;

1220 - };

1221 - configureEventConstructor("Event", {

1222 - bubbles: false,

1223 - cancelable: false

1224 - });

1225 - configureEventConstructor("CustomEvent", {

1226 - detail: null

1227 - }, "Event");

1228 - configureEventConstructor("UIEvent", {

1229 - view: null,

1230 - detail: 0

1231 - }, "Event");

1232 - configureEventConstructor("MouseEvent", {

1233 - screenX: 0,

1234 - screenY: 0,

1235 - clientX: 0,

1236 - clientY: 0,

1237 - ctrlKey: false,

1238 - altKey: false,

1239 - shiftKey: false,

1240 - metaKey: false,

1241 - button: 0,

1242 - relatedTarget: null

1243 - }, "UIEvent");

1244 - configureEventConstructor("FocusEvent", {

1245 - relatedTarget: null

1246 - }, "UIEvent");

1247 - }

1248 - var OriginalBeforeUnloadEvent = window.BeforeUnloadEvent;

1249 - function BeforeUnloadEvent(impl) {

1250 - Event.call(this, impl);

1251 - }

1252 - BeforeUnloadEvent.prototype = Object.create(Event.prototype);

1253 - mixin(BeforeUnloadEvent.prototype, {

1254 - get returnValue() {

1255 - return unsafeUnwrap(this).returnValue;

1256 - },

1257 - set returnValue(v) {

1258 - unsafeUnwrap(this).returnValue = v;

1259 - }

1260 - });

1261 - if (OriginalBeforeUnloadEvent) registerWrapper(OriginalBeforeUnloadEvent, BeforeUnloadEvent);

1262 - function isValidListener(fun) {

1263 - if (typeof fun === "function") return true;

1264 - return fun && fun.handleEvent;

1265 - }

1266 - function isMutationEvent(type) {

1267 - switch (type) {

1268 - case "DOMAttrModified":

1269 - case "DOMAttributeNameChanged":

1270 - case "DOMCharacterDataModified":

1271 - case "DOMElementNameChanged":

1272 - case "DOMNodeInserted":

1273 - case "DOMNodeInsertedIntoDocument":

1274 - case "DOMNodeRemoved":

1275 - case "DOMNodeRemovedFromDocument":

1276 - case "DOMSubtreeModified":

1277 - return true;

1278 - }

1279 - return false;

1280 - }

1281 - var OriginalEventTarget = window.EventTarget;

1282 - function EventTarget(impl) {

1283 - setWrapper(impl, this);

1284 - }

1285 - var methodNames = [ "addEventListener", "removeEventListener", "dispatchEvent" ];

1286 - [ Node, Window ].forEach(function(constructor) {

1287 - var p = constructor.prototype;

1288 - methodNames.forEach(function(name) {

1289 - Object.defineProperty(p, name + "_", {

1290 - value: p[name]

1291 - });

1292 - });

1293 - });

1294 - function getTargetToListenAt(wrapper) {

1295 - if (wrapper instanceof wrappers.ShadowRoot) wrapper = wrapper.host;

1296 - return unwrap(wrapper);

1297 - }

1298 - EventTarget.prototype = {

1299 - addEventListener: function(type, fun, capture) {

1300 - if (!isValidListener(fun) || isMutationEvent(type)) return;

1301 - var listener = new Listener(type, fun, capture);

1302 - var listeners = listenersTable.get(this);

1303 - if (!listeners) {

1304 - listeners = [];

1305 - listeners.depth = 0;

1306 - listenersTable.set(this, listeners);

1307 - } else {

1308 - for (var i = 0; i < listeners.length; i++) {

1309 - if (listener.equals(listeners[i])) return;

1310 - }

1311 - }

1312 - listeners.push(listener);

1313 - var target = getTargetToListenAt(this);

1314 - target.addEventListener_(type, dispatchOriginalEvent, true);

1315 - },

1316 - removeEventListener: function(type, fun, capture) {

1317 - capture = Boolean(capture);

1318 - var listeners = listenersTable.get(this);

1319 - if (!listeners) return;

1320 - var count = 0, found = false;

1321 - for (var i = 0; i < listeners.length; i++) {

1322 - if (listeners[i].type === type && listeners[i].capture === capture) {

1323 - count++;

1324 - if (listeners[i].handler === fun) {

1325 - found = true;

1326 - listeners[i].remove();

1327 - }

1328 - }

1329 - }

1330 - if (found && count === 1) {

1331 - var target = getTargetToListenAt(this);

1332 - target.removeEventListener_(type, dispatchOriginalEvent, true);

1333 - }

1334 - },

1335 - dispatchEvent: function(event) {

1336 - var nativeEvent = unwrap(event);

1337 - var eventType = nativeEvent.type;

1338 - handledEventsTable.set(nativeEvent, false);

1339 - scope.renderAllPending();

1340 - var tempListener;

1341 - if (!hasListenerInAncestors(this, eventType)) {

1342 - tempListener = function() {};

1343 - this.addEventListener(eventType, tempListener, true);

1344 - }

1345 - try {

1346 - return unwrap(this).dispatchEvent_(nativeEvent);

1347 - } finally {

1348 - if (tempListener) this.removeEventListener(eventType, tempListener, true);

1349 - }

1350 - }

1351 - };

1352 - function hasListener(node, type) {

1353 - var listeners = listenersTable.get(node);

1354 - if (listeners) {

1355 - for (var i = 0; i < listeners.length; i++) {

1356 - if (!listeners[i].removed && listeners[i].type === type) return true;

1357 - }

1358 - }

1359 - return false;

1360 - }

1361 - function hasListenerInAncestors(target, type) {

1362 - for (var node = unwrap(target); node; node = node.parentNode) {

1363 - if (hasListener(wrap(node), type)) return true;

1364 - }

1365 - return false;

1366 - }

1367 - if (OriginalEventTarget) registerWrapper(OriginalEventTarget, EventTarget);

1368 - function wrapEventTargetMethods(constructors) {

1369 - forwardMethodsToWrapper(constructors, methodNames);

1370 - }

1371 - var originalElementFromPoint = document.elementFromPoint;

1372 - function elementFromPoint(self, document, x, y) {

1373 - scope.renderAllPending();

1374 - var element = wrap(originalElementFromPoint.call(unsafeUnwrap(document), x, y));

1375 - if (!element) return null;

1376 - var path = getEventPath(element, null);

1377 - var idx = path.lastIndexOf(self);

1378 - if (idx == -1) return null; else path = path.slice(0, idx);

1379 - return eventRetargetting(path, self);

1380 - }

1381 - function getEventHandlerGetter(name) {

1382 - return function() {

1383 - var inlineEventHandlers = eventHandlersTable.get(this);

1384 - return inlineEventHandlers && inlineEventHandlers[name] && inlineEventHandlers[name].value || null;

1385 - };

1386 - }

1387 - function getEventHandlerSetter(name) {

1388 - var eventType = name.slice(2);

1389 - return function(value) {

1390 - var inlineEventHandlers = eventHandlersTable.get(this);

1391 - if (!inlineEventHandlers) {

1392 - inlineEventHandlers = Object.create(null);

1393 - eventHandlersTable.set(this, inlineEventHandlers);

1394 - }

1395 - var old = inlineEventHandlers[name];

1396 - if (old) this.removeEventListener(eventType, old.wrapped, false);

1397 - if (typeof value === "function") {

1398 - var wrapped = function(e) {

1399 - var rv = value.call(this, e);

1400 - if (rv === false) e.preventDefault(); else if (name === "onbeforeunload" && typeof rv === "string") e.returnValue = rv;

1401 - };

1402 - this.addEventListener(eventType, wrapped, false);

1403 - inlineEventHandlers[name] = {

1404 - value: value,

1405 - wrapped: wrapped

1406 - };

1407 - }

1408 - };

1409 - }

1410 - scope.elementFromPoint = elementFromPoint;

1411 - scope.getEventHandlerGetter = getEventHandlerGetter;

1412 - scope.getEventHandlerSetter = getEventHandlerSetter;

1413 - scope.wrapEventTargetMethods = wrapEventTargetMethods;

1414 - scope.wrappers.BeforeUnloadEvent = BeforeUnloadEvent;

1415 - scope.wrappers.CustomEvent = CustomEvent;

1416 - scope.wrappers.Event = Event;

1417 - scope.wrappers.EventTarget = EventTarget;

1418 - scope.wrappers.FocusEvent = FocusEvent;

1419 - scope.wrappers.MouseEvent = MouseEvent;

1420 - scope.wrappers.UIEvent = UIEvent;

1421 - })(window.ShadowDOMPolyfill);

1422 - (function(scope) {

1423 - "use strict";

1424 - var UIEvent = scope.wrappers.UIEvent;

1425 - var mixin = scope.mixin;

1426 - var registerWrapper = scope.registerWrapper;

1427 - var setWrapper = scope.setWrapper;

1428 - var unsafeUnwrap = scope.unsafeUnwrap;

1429 - var wrap = scope.wrap;

1430 - var OriginalTouchEvent = window.TouchEvent;

1431 - if (!OriginalTouchEvent) return;

1432 - var nativeEvent;

1433 - try {

1434 - nativeEvent = document.createEvent("TouchEvent");

1435 - } catch (ex) {

1436 - return;

1437 - }

1438 - var nonEnumDescriptor = {

1439 - enumerable: false

1440 - };

1441 - function nonEnum(obj, prop) {

1442 - Object.defineProperty(obj, prop, nonEnumDescriptor);

1443 - }

1444 - function Touch(impl) {

1445 - setWrapper(impl, this);

1446 - }

1447 - Touch.prototype = {

1448 - get target() {

1449 - return wrap(unsafeUnwrap(this).target);

1450 - }

1451 - };

1452 - var descr = {

1453 - configurable: true,

1454 - enumerable: true,

1455 - get: null

1456 - };

1457 - [ "clientX", "clientY", "screenX", "screenY", "pageX", "pageY", "identifier", "webkitRadiusX", "webkitRadiusY", "webkitRotationAngle", "webkitForce" ].forEach(function(name) {

1458 - descr.get = function() {

1459 - return unsafeUnwrap(this)[name];

1460 - };

1461 - Object.defineProperty(Touch.prototype, name, descr);

1462 - });

1463 - function TouchList() {

1464 - this.length = 0;

1465 - nonEnum(this, "length");

1466 - }

1467 - TouchList.prototype = {

1468 - item: function(index) {

1469 - return this[index];

1470 - }

1471 - };

1472 - function wrapTouchList(nativeTouchList) {

1473 - var list = new TouchList();

1474 - for (var i = 0; i < nativeTouchList.length; i++) {

1475 - list[i] = new Touch(nativeTouchList[i]);

1476 - }

1477 - list.length = i;

1478 - return list;

1479 - }

1480 - function TouchEvent(impl) {

1481 - UIEvent.call(this, impl);

1482 - }

1483 - TouchEvent.prototype = Object.create(UIEvent.prototype);

1484 - mixin(TouchEvent.prototype, {

1485 - get touches() {

1486 - return wrapTouchList(unsafeUnwrap(this).touches);

1487 - },

1488 - get targetTouches() {

1489 - return wrapTouchList(unsafeUnwrap(this).targetTouches);

1490 - },

1491 - get changedTouches() {

1492 - return wrapTouchList(unsafeUnwrap(this).changedTouches);

1493 - },

1494 - initTouchEvent: function() {

1495 - throw new Error("Not implemented");

1496 - }

1497 - });

1498 - registerWrapper(OriginalTouchEvent, TouchEvent, nativeEvent);

1499 - scope.wrappers.Touch = Touch;

1500 - scope.wrappers.TouchEvent = TouchEvent;

1501 - scope.wrappers.TouchList = TouchList;

1502 - })(window.ShadowDOMPolyfill);

1503 - (function(scope) {

1504 - "use strict";

1505 - var unsafeUnwrap = scope.unsafeUnwrap;

1506 - var wrap = scope.wrap;

1507 - var nonEnumDescriptor = {

1508 - enumerable: false

1509 - };

1510 - function nonEnum(obj, prop) {

1511 - Object.defineProperty(obj, prop, nonEnumDescriptor);

1512 - }

1513 - function NodeList() {

1514 - this.length = 0;

1515 - nonEnum(this, "length");

1516 - }

1517 - NodeList.prototype = {

1518 - item: function(index) {

1519 - return this[index];

1520 - }

1521 - };

1522 - nonEnum(NodeList.prototype, "item");

1523 - function wrapNodeList(list) {

1524 - if (list == null) return list;

1525 - var wrapperList = new NodeList();

1526 - for (var i = 0, length = list.length; i < length; i++) {

1527 - wrapperList[i] = wrap(list[i]);

1528 - }

1529 - wrapperList.length = length;

1530 - return wrapperList;

1531 - }

1532 - function addWrapNodeListMethod(wrapperConstructor, name) {

1533 - wrapperConstructor.prototype[name] = function() {

1534 - return wrapNodeList(unsafeUnwrap(this)[name].apply(unsafeUnwrap(this), arguments));

1535 - };

1536 - }

1537 - scope.wrappers.NodeList = NodeList;

1538 - scope.addWrapNodeListMethod = addWrapNodeListMethod;

1539 - scope.wrapNodeList = wrapNodeList;

1540 - })(window.ShadowDOMPolyfill);

1541 - (function(scope) {

1542 - "use strict";

1543 - scope.wrapHTMLCollection = scope.wrapNodeList;

1544 - scope.wrappers.HTMLCollection = scope.wrappers.NodeList;

1545 - })(window.ShadowDOMPolyfill);

1546 - (function(scope) {

1547 - "use strict";

1548 - var EventTarget = scope.wrappers.EventTarget;

1549 - var NodeList = scope.wrappers.NodeList;

1550 - var TreeScope = scope.TreeScope;

1551 - var assert = scope.assert;

1552 - var defineWrapGetter = scope.defineWrapGetter;

1553 - var enqueueMutation = scope.enqueueMutation;

1554 - var getTreeScope = scope.getTreeScope;

1555 - var isWrapper = scope.isWrapper;

1556 - var mixin = scope.mixin;

1557 - var registerTransientObservers = scope.registerTransientObservers;

1558 - var registerWrapper = scope.registerWrapper;

1559 - var setTreeScope = scope.setTreeScope;

1560 - var unsafeUnwrap = scope.unsafeUnwrap;

1561 - var unwrap = scope.unwrap;

1562 - var unwrapIfNeeded = scope.unwrapIfNeeded;

1563 - var wrap = scope.wrap;

1564 - var wrapIfNeeded = scope.wrapIfNeeded;

1565 - var wrappers = scope.wrappers;

1566 - function assertIsNodeWrapper(node) {

1567 - assert(node instanceof Node);

1568 - }

1569 - function createOneElementNodeList(node) {

1570 - var nodes = new NodeList();

1571 - nodes[0] = node;

1572 - nodes.length = 1;

1573 - return nodes;

1574 - }

1575 - var surpressMutations = false;

1576 - function enqueueRemovalForInsertedNodes(node, parent, nodes) {

1577 - enqueueMutation(parent, "childList", {

1578 - removedNodes: nodes,

1579 - previousSibling: node.previousSibling,

1580 - nextSibling: node.nextSibling

1581 - });

1582 - }

1583 - function enqueueRemovalForInsertedDocumentFragment(df, nodes) {

1584 - enqueueMutation(df, "childList", {

1585 - removedNodes: nodes

1586 - });

1587 - }

1588 - function collectNodes(node, parentNode, previousNode, nextNode) {

1589 - if (node instanceof DocumentFragment) {

1590 - var nodes = collectNodesForDocumentFragment(node);

1591 - surpressMutations = true;

1592 - for (var i = nodes.length - 1; i >= 0; i--) {

1593 - node.removeChild(nodes[i]);

1594 - nodes[i].parentNode_ = parentNode;

1595 - }

1596 - surpressMutations = false;

1597 - for (var i = 0; i < nodes.length; i++) {

1598 - nodes[i].previousSibling_ = nodes[i - 1] || previousNode;

1599 - nodes[i].nextSibling_ = nodes[i + 1] || nextNode;

1600 - }

1601 - if (previousNode) previousNode.nextSibling_ = nodes[0];

1602 - if (nextNode) nextNode.previousSibling_ = nodes[nodes.length - 1];

1603 - return nodes;

1604 - }

1605 - var nodes = createOneElementNodeList(node);

1606 - var oldParent = node.parentNode;

1607 - if (oldParent) {

1608 - oldParent.removeChild(node);

1609 - }

1610 - node.parentNode_ = parentNode;

1611 - node.previousSibling_ = previousNode;

1612 - node.nextSibling_ = nextNode;

1613 - if (previousNode) previousNode.nextSibling_ = node;

1614 - if (nextNode) nextNode.previousSibling_ = node;

1615 - return nodes;

1616 - }

1617 - function collectNodesNative(node) {

1618 - if (node instanceof DocumentFragment) return collectNodesForDocumentFragment(node);

1619 - var nodes = createOneElementNodeList(node);

1620 - var oldParent = node.parentNode;

1621 - if (oldParent) enqueueRemovalForInsertedNodes(node, oldParent, nodes);

1622 - return nodes;

1623 - }

1624 - function collectNodesForDocumentFragment(node) {

1625 - var nodes = new NodeList();

1626 - var i = 0;

1627 - for (var child = node.firstChild; child; child = child.nextSibling) {

1628 - nodes[i++] = child;

1629 - }

1630 - nodes.length = i;

1631 - enqueueRemovalForInsertedDocumentFragment(node, nodes);

1632 - return nodes;

1633 - }

1634 - function snapshotNodeList(nodeList) {

1635 - return nodeList;

1636 - }

1637 - function nodeWasAdded(node, treeScope) {

1638 - setTreeScope(node, treeScope);

1639 - node.nodeIsInserted_();

1640 - }

1641 - function nodesWereAdded(nodes, parent) {

1642 - var treeScope = getTreeScope(parent);

1643 - for (var i = 0; i < nodes.length; i++) {

1644 - nodeWasAdded(nodes[i], treeScope);

1645 - }

1646 - }

1647 - function nodeWasRemoved(node) {

1648 - setTreeScope(node, new TreeScope(node, null));

1649 - }

1650 - function nodesWereRemoved(nodes) {

1651 - for (var i = 0; i < nodes.length; i++) {

1652 - nodeWasRemoved(nodes[i]);

1653 - }

1654 - }

1655 - function ensureSameOwnerDocument(parent, child) {

1656 - var ownerDoc = parent.nodeType === Node.DOCUMENT_NODE ? parent : parent.ownerDocument;

1657 - if (ownerDoc !== child.ownerDocument) ownerDoc.adoptNode(child);

1658 - }

1659 - function adoptNodesIfNeeded(owner, nodes) {

1660 - if (!nodes.length) return;

1661 - var ownerDoc = owner.ownerDocument;

1662 - if (ownerDoc === nodes[0].ownerDocument) return;

1663 - for (var i = 0; i < nodes.length; i++) {

1664 - scope.adoptNodeNoRemove(nodes[i], ownerDoc);

1665 - }

1666 - }

1667 - function unwrapNodesForInsertion(owner, nodes) {

1668 - adoptNodesIfNeeded(owner, nodes);

1669 - var length = nodes.length;

1670 - if (length === 1) return unwrap(nodes[0]);

1671 - var df = unwrap(owner.ownerDocument.createDocumentFragment());

1672 - for (var i = 0; i < length; i++) {

1673 - df.appendChild(unwrap(nodes[i]));

1674 - }

1675 - return df;

1676 - }

1677 - function clearChildNodes(wrapper) {

1678 - if (wrapper.firstChild_ !== undefined) {

1679 - var child = wrapper.firstChild_;

1680 - while (child) {

1681 - var tmp = child;

1682 - child = child.nextSibling_;

1683 - tmp.parentNode_ = tmp.previousSibling_ = tmp.nextSibling_ = undefined;

1684 - }

1685 - }

1686 - wrapper.firstChild_ = wrapper.lastChild_ = undefined;

1687 - }

1688 - function removeAllChildNodes(wrapper) {

1689 - if (wrapper.invalidateShadowRenderer()) {

1690 - var childWrapper = wrapper.firstChild;

1691 - while (childWrapper) {

1692 - assert(childWrapper.parentNode === wrapper);

1693 - var nextSibling = childWrapper.nextSibling;

1694 - var childNode = unwrap(childWrapper);

1695 - var parentNode = childNode.parentNode;

1696 - if (parentNode) originalRemoveChild.call(parentNode, childNode);

1697 - childWrapper.previousSibling_ = childWrapper.nextSibling_ = childWrapper.parentNode_ = null;

1698 - childWrapper = nextSibling;

1699 - }

1700 - wrapper.firstChild_ = wrapper.lastChild_ = null;

1701 - } else {

1702 - var node = unwrap(wrapper);

1703 - var child = node.firstChild;

1704 - var nextSibling;

1705 - while (child) {

1706 - nextSibling = child.nextSibling;

1707 - originalRemoveChild.call(node, child);

1708 - child = nextSibling;

1709 - }

1710 - }

1711 - }

1712 - function invalidateParent(node) {

1713 - var p = node.parentNode;

1714 - return p && p.invalidateShadowRenderer();

1715 - }

1716 - function cleanupNodes(nodes) {

1717 - for (var i = 0, n; i < nodes.length; i++) {

1718 - n = nodes[i];

1719 - n.parentNode.removeChild(n);

1720 - }

1721 - }

1722 - var originalImportNode = document.importNode;

1723 - var originalCloneNode = window.Node.prototype.cloneNode;

1724 - function cloneNode(node, deep, opt_doc) {

1725 - var clone;

1726 - if (opt_doc) clone = wrap(originalImportNode.call(opt_doc, unsafeUnwrap(node), false)); else clone = wrap(originalCloneNode.call(unsafeUnwrap(node), false));

1727 - if (deep) {

1728 - for (var child = node.firstChild; child; child = child.nextSibling) {

1729 - clone.appendChild(cloneNode(child, true, opt_doc));

1730 - }

1731 - if (node instanceof wrappers.HTMLTemplateElement) {

1732 - var cloneContent = clone.content;

1733 - for (var child = node.content.firstChild; child; child = child.nextSibling) {

1734 - cloneContent.appendChild(cloneNode(child, true, opt_doc));

1735 - }

1736 - }

1737 - }

1738 - return clone;

1739 - }

1740 - function contains(self, child) {

1741 - if (!child || getTreeScope(self) !== getTreeScope(child)) return false;

1742 - for (var node = child; node; node = node.parentNode) {

1743 - if (node === self) return true;

1744 - }

1745 - return false;

1746 - }

1747 - var OriginalNode = window.Node;

1748 - function Node(original) {

1749 - assert(original instanceof OriginalNode);

1750 - EventTarget.call(this, original);

1751 - this.parentNode_ = undefined;

1752 - this.firstChild_ = undefined;

1753 - this.lastChild_ = undefined;

1754 - this.nextSibling_ = undefined;

1755 - this.previousSibling_ = undefined;

1756 - this.treeScope_ = undefined;

1757 - }

1758 - var OriginalDocumentFragment = window.DocumentFragment;

1759 - var originalAppendChild = OriginalNode.prototype.appendChild;

1760 - var originalCompareDocumentPosition = OriginalNode.prototype.compareDocumentPosition;

1761 - var originalInsertBefore = OriginalNode.prototype.insertBefore;

1762 - var originalRemoveChild = OriginalNode.prototype.removeChild;

1763 - var originalReplaceChild = OriginalNode.prototype.replaceChild;

1764 - var isIe = /Trident/.test(navigator.userAgent);

1765 - var removeChildOriginalHelper = isIe ? function(parent, child) {

1766 - try {

1767 - originalRemoveChild.call(parent, child);

1768 - } catch (ex) {

1769 - if (!(parent instanceof OriginalDocumentFragment)) throw ex;

1770 - }

1771 - } : function(parent, child) {

1772 - originalRemoveChild.call(parent, child);

1773 - };

1774 - Node.prototype = Object.create(EventTarget.prototype);

1775 - mixin(Node.prototype, {

1776 - appendChild: function(childWrapper) {

1777 - return this.insertBefore(childWrapper, null);

1778 - },

1779 - insertBefore: function(childWrapper, refWrapper) {

1780 - assertIsNodeWrapper(childWrapper);

1781 - var refNode;

1782 - if (refWrapper) {

1783 - if (isWrapper(refWrapper)) {

1784 - refNode = unwrap(refWrapper);

1785 - } else {

1786 - refNode = refWrapper;

1787 - refWrapper = wrap(refNode);

1788 - }

1789 - } else {

1790 - refWrapper = null;

1791 - refNode = null;

1792 - }

1793 - refWrapper && assert(refWrapper.parentNode === this);

1794 - var nodes;

1795 - var previousNode = refWrapper ? refWrapper.previousSibling : this.lastChild;

1796 - var useNative = !this.invalidateShadowRenderer() && !invalidateParent(childWrapper);

1797 - if (useNative) nodes = collectNodesNative(childWrapper); else nodes = collectNodes(childWrapper, this, previousNode, refWrapper);

1798 - if (useNative) {

1799 - ensureSameOwnerDocument(this, childWrapper);

1800 - clearChildNodes(this);

1801 - originalInsertBefore.call(unsafeUnwrap(this), unwrap(childWrapper), refNode);

1802 - } else {

1803 - if (!previousNode) this.firstChild_ = nodes[0];

1804 - if (!refWrapper) {

1805 - this.lastChild_ = nodes[nodes.length - 1];

1806 - if (this.firstChild_ === undefined) this.firstChild_ = this.firstChild;

1807 - }

1808 - var parentNode = refNode ? refNode.parentNode : unsafeUnwrap(this);

1809 - if (parentNode) {

1810 - originalInsertBefore.call(parentNode, unwrapNodesForInsertion(this, nodes), refNode);

1811 - } else {

1812 - adoptNodesIfNeeded(this, nodes);

1813 - }

1814 - }

1815 - enqueueMutation(this, "childList", {

1816 - addedNodes: nodes,

1817 - nextSibling: refWrapper,

1818 - previousSibling: previousNode

1819 - });

1820 - nodesWereAdded(nodes, this);

1821 - return childWrapper;

1822 - },

1823 - removeChild: function(childWrapper) {

1824 - assertIsNodeWrapper(childWrapper);

1825 - if (childWrapper.parentNode !== this) {

1826 - var found = false;

1827 - var childNodes = this.childNodes;

1828 - for (var ieChild = this.firstChild; ieChild; ieChild = ieChild.nextSibling) {

1829 - if (ieChild === childWrapper) {

1830 - found = true;

1831 - break;

1832 - }

1833 - }

1834 - if (!found) {

1835 - throw new Error("NotFoundError");

1836 - }

1837 - }

1838 - var childNode = unwrap(childWrapper);

1839 - var childWrapperNextSibling = childWrapper.nextSibling;

1840 - var childWrapperPreviousSibling = childWrapper.previousSibling;

1841 - if (this.invalidateShadowRenderer()) {

1842 - var thisFirstChild = this.firstChild;

1843 - var thisLastChild = this.lastChild;

1844 - var parentNode = childNode.parentNode;

1845 - if (parentNode) removeChildOriginalHelper(parentNode, childNode);

1846 - if (thisFirstChild === childWrapper) this.firstChild_ = childWrapperNextSibling;

1847 - if (thisLastChild === childWrapper) this.lastChild_ = childWrapperPreviousSibling;

1848 - if (childWrapperPreviousSibling) childWrapperPreviousSibling.nextSibling_ = childWrapperNextSibling;

1849 - if (childWrapperNextSibling) {

1850 - childWrapperNextSibling.previousSibling_ = childWrapperPreviousSibling;

1851 - }

1852 - childWrapper.previousSibling_ = childWrapper.nextSibling_ = childWrapper.parentNode_ = undefined;

1853 - } else {

1854 - clearChildNodes(this);

1855 - removeChildOriginalHelper(unsafeUnwrap(this), childNode);

1856 - }

1857 - if (!surpressMutations) {

1858 - enqueueMutation(this, "childList", {

1859 - removedNodes: createOneElementNodeList(childWrapper),

1860 - nextSibling: childWrapperNextSibling,

1861 - previousSibling: childWrapperPreviousSibling

1862 - });

1863 - }

1864 - registerTransientObservers(this, childWrapper);

1865 - return childWrapper;

1866 - },

1867 - replaceChild: function(newChildWrapper, oldChildWrapper) {

1868 - assertIsNodeWrapper(newChildWrapper);

1869 - var oldChildNode;

1870 - if (isWrapper(oldChildWrapper)) {

1871 - oldChildNode = unwrap(oldChildWrapper);

1872 - } else {

1873 - oldChildNode = oldChildWrapper;

1874 - oldChildWrapper = wrap(oldChildNode);

1875 - }

1876 - if (oldChildWrapper.parentNode !== this) {

1877 - throw new Error("NotFoundError");

1878 - }

1879 - var nextNode = oldChildWrapper.nextSibling;

1880 - var previousNode = oldChildWrapper.previousSibling;

1881 - var nodes;

1882 - var useNative = !this.invalidateShadowRenderer() && !invalidateParent(newChildWrapper);

1883 - if (useNative) {

1884 - nodes = collectNodesNative(newChildWrapper);

1885 - } else {

1886 - if (nextNode === newChildWrapper) nextNode = newChildWrapper.nextSibling;

1887 - nodes = collectNodes(newChildWrapper, this, previousNode, nextNode);

1888 - }

1889 - if (!useNative) {

1890 - if (this.firstChild === oldChildWrapper) this.firstChild_ = nodes[0];

1891 - if (this.lastChild === oldChildWrapper) this.lastChild_ = nodes[nodes.length - 1];

1892 - oldChildWrapper.previousSibling_ = oldChildWrapper.nextSibling_ = oldChildWrapper.parentNode_ = undefined;

1893 - if (oldChildNode.parentNode) {

1894 - originalReplaceChild.call(oldChildNode.parentNode, unwrapNodesForInsertion(this, nodes), oldChildNode);

1895 - }

1896 - } else {

1897 - ensureSameOwnerDocument(this, newChildWrapper);

1898 - clearChildNodes(this);

1899 - originalReplaceChild.call(unsafeUnwrap(this), unwrap(newChildWrapper), oldChildNode);

1900 - }

1901 - enqueueMutation(this, "childList", {

1902 - addedNodes: nodes,

1903 - removedNodes: createOneElementNodeList(oldChildWrapper),

1904 - nextSibling: nextNode,

1905 - previousSibling: previousNode

1906 - });

1907 - nodeWasRemoved(oldChildWrapper);

1908 - nodesWereAdded(nodes, this);

1909 - return oldChildWrapper;

1910 - },

1911 - nodeIsInserted_: function() {

1912 - for (var child = this.firstChild; child; child = child.nextSibling) {

1913 - child.nodeIsInserted_();

1914 - }

1915 - },

1916 - hasChildNodes: function() {

1917 - return this.firstChild !== null;

1918 - },

1919 - get parentNode() {

1920 - return this.parentNode_ !== undefined ? this.parentNode_ : wrap(unsafeUnwrap(this).parentNode);

1921 - },

1922 - get firstChild() {

1923 - return this.firstChild_ !== undefined ? this.firstChild_ : wrap(unsafeUnwrap(this).firstChild);

1924 - },

1925 - get lastChild() {

1926 - return this.lastChild_ !== undefined ? this.lastChild_ : wrap(unsafeUnwrap(this).lastChild);

1927 - },

1928 - get nextSibling() {

1929 - return this.nextSibling_ !== undefined ? this.nextSibling_ : wrap(unsafeUnwrap(this).nextSibling);

1930 - },

1931 - get previousSibling() {

1932 - return this.previousSibling_ !== undefined ? this.previousSibling_ : wrap(unsafeUnwrap(this).previousSibling);

1933 - },

1934 - get parentElement() {

1935 - var p = this.parentNode;

1936 - while (p && p.nodeType !== Node.ELEMENT_NODE) {

1937 - p = p.parentNode;

1938 - }

1939 - return p;

1940 - },

1941 - get textContent() {

1942 - var s = "";

1943 - for (var child = this.firstChild; child; child = child.nextSibling) {

1944 - if (child.nodeType != Node.COMMENT_NODE) {

1945 - s += child.textContent;

1946 - }

1947 - }

1948 - return s;

1949 - },

1950 - set textContent(textContent) {

1951 - if (textContent == null) textContent = "";

1952 - var removedNodes = snapshotNodeList(this.childNodes);

1953 - if (this.invalidateShadowRenderer()) {

1954 - removeAllChildNodes(this);

1955 - if (textContent !== "") {

1956 - var textNode = unsafeUnwrap(this).ownerDocument.createTextNode(textContent);

1957 - this.appendChild(textNode);

1958 - }

1959 - } else {

1960 - clearChildNodes(this);

1961 - unsafeUnwrap(this).textContent = textContent;

1962 - }

1963 - var addedNodes = snapshotNodeList(this.childNodes);

1964 - enqueueMutation(this, "childList", {

1965 - addedNodes: addedNodes,

1966 - removedNodes: removedNodes

1967 - });

1968 - nodesWereRemoved(removedNodes);

1969 - nodesWereAdded(addedNodes, this);

1970 - },

1971 - get childNodes() {

1972 - var wrapperList = new NodeList();

1973 - var i = 0;

1974 - for (var child = this.firstChild; child; child = child.nextSibling) {

1975 - wrapperList[i++] = child;

1976 - }

1977 - wrapperList.length = i;

1978 - return wrapperList;

1979 - },

1980 - cloneNode: function(deep) {

1981 - return cloneNode(this, deep);

1982 - },

1983 - contains: function(child) {

1984 - return contains(this, wrapIfNeeded(child));

1985 - },

1986 - compareDocumentPosition: function(otherNode) {

1987 - return originalCompareDocumentPosition.call(unsafeUnwrap(this), unwrapIfNeeded(otherNode));

1988 - },

1989 - normalize: function() {

1990 - var nodes = snapshotNodeList(this.childNodes);

1991 - var remNodes = [];

1992 - var s = "";

1993 - var modNode;

1994 - for (var i = 0, n; i < nodes.length; i++) {

1995 - n = nodes[i];

1996 - if (n.nodeType === Node.TEXT_NODE) {

1997 - if (!modNode && !n.data.length) this.removeNode(n); else if (!modNode) modNode = n; else {

1998 - s += n.data;

1999 - remNodes.push(n);

2000 - }

2001 - } else {

2002 - if (modNode && remNodes.length) {

2003 - modNode.data += s;

2004 - cleanupNodes(remNodes);

2005 - }

2006 - remNodes = [];

2007 - s = "";

2008 - modNode = null;

2009 - if (n.childNodes.length) n.normalize();

2010 - }

2011 - }

2012 - if (modNode && remNodes.length) {

2013 - modNode.data += s;

2014 - cleanupNodes(remNodes);

2015 - }

2016 - }

2017 - });

2018 - defineWrapGetter(Node, "ownerDocument");

2019 - registerWrapper(OriginalNode, Node, document.createDocumentFragment());

2020 - delete Node.prototype.querySelector;

2021 - delete Node.prototype.querySelectorAll;

2022 - Node.prototype = mixin(Object.create(EventTarget.prototype), Node.prototype);

2023 - scope.cloneNode = cloneNode;

2024 - scope.nodeWasAdded = nodeWasAdded;

2025 - scope.nodeWasRemoved = nodeWasRemoved;

2026 - scope.nodesWereAdded = nodesWereAdded;

2027 - scope.nodesWereRemoved = nodesWereRemoved;

2028 - scope.originalInsertBefore = originalInsertBefore;

2029 - scope.originalRemoveChild = originalRemoveChild;

2030 - scope.snapshotNodeList = snapshotNodeList;

2031 - scope.wrappers.Node = Node;

2032 - })(window.ShadowDOMPolyfill);

2033 - (function(scope) {

2034 - "use strict";

2035 - var HTMLCollection = scope.wrappers.HTMLCollection;

2036 - var NodeList = scope.wrappers.NodeList;

2037 - var getTreeScope = scope.getTreeScope;

2038 - var unsafeUnwrap = scope.unsafeUnwrap;

2039 - var wrap = scope.wrap;

2040 - var originalDocumentQuerySelector = document.querySelector;

2041 - var originalElementQuerySelector = document.documentElement.querySelector;

2042 - var originalDocumentQuerySelectorAll = document.querySelectorAll;

2043 - var originalElementQuerySelectorAll = document.documentElement.querySelectorAll;

2044 - var originalDocumentGetElementsByTagName = document.getElementsByTagName;

2045 - var originalElementGetElementsByTagName = document.documentElement.getElementsByTagName;

2046 - var originalDocumentGetElementsByTagNameNS = document.getElementsByTagNameNS;

2047 - var originalElementGetElementsByTagNameNS = document.documentElement.getElementsByTagNameNS;

2048 - var OriginalElement = window.Element;

2049 - var OriginalDocument = window.HTMLDocument || window.Document;

2050 - function filterNodeList(list, index, result, deep) {

2051 - var wrappedItem = null;

2052 - var root = null;

2053 - for (var i = 0, length = list.length; i < length; i++) {

2054 - wrappedItem = wrap(list[i]);

2055 - if (!deep && (root = getTreeScope(wrappedItem).root)) {

2056 - if (root instanceof scope.wrappers.ShadowRoot) {

2057 - continue;

2058 - }

2059 - }

2060 - result[index++] = wrappedItem;

2061 - }

2062 - return index;

2063 - }

2064 - function shimSelector(selector) {

2065 - return String(selector).replace(/\/deep\//g, " ");

2066 - }

2067 - function findOne(node, selector) {

2068 - var m, el = node.firstElementChild;

2069 - while (el) {

2070 - if (el.matches(selector)) return el;

2071 - m = findOne(el, selector);

2072 - if (m) return m;

2073 - el = el.nextElementSibling;

2074 - }

2075 - return null;

2076 - }

2077 - function matchesSelector(el, selector) {

2078 - return el.matches(selector);

2079 - }

2080 - var XHTML_NS = "http://www.w3.org/1999/xhtml";

2081 - function matchesTagName(el, localName, localNameLowerCase) {

2082 - var ln = el.localName;

2083 - return ln === localName || ln === localNameLowerCase && el.namespaceURI === XHTML_NS;

2084 - }

2085 - function matchesEveryThing() {

2086 - return true;

2087 - }

2088 - function matchesLocalNameOnly(el, ns, localName) {

2089 - return el.localName === localName;

2090 - }

2091 - function matchesNameSpace(el, ns) {

2092 - return el.namespaceURI === ns;

2093 - }

2094 - function matchesLocalNameNS(el, ns, localName) {

2095 - return el.namespaceURI === ns && el.localName === localName;

2096 - }

2097 - function findElements(node, index, result, p, arg0, arg1) {

2098 - var el = node.firstElementChild;

2099 - while (el) {

2100 - if (p(el, arg0, arg1)) result[index++] = el;

2101 - index = findElements(el, index, result, p, arg0, arg1);

2102 - el = el.nextElementSibling;

2103 - }

2104 - return index;

2105 - }

2106 - function querySelectorAllFiltered(p, index, result, selector, deep) {

2107 - var target = unsafeUnwrap(this);

2108 - var list;

2109 - var root = getTreeScope(this).root;

2110 - if (root instanceof scope.wrappers.ShadowRoot) {

2111 - return findElements(this, index, result, p, selector, null);

2112 - } else if (target instanceof OriginalElement) {

2113 - list = originalElementQuerySelectorAll.call(target, selector);

2114 - } else if (target instanceof OriginalDocument) {

2115 - list = originalDocumentQuerySelectorAll.call(target, selector);

2116 - } else {

2117 - return findElements(this, index, result, p, selector, null);

2118 - }

2119 - return filterNodeList(list, index, result, deep);

2120 - }

2121 - var SelectorsInterface = {

2122 - querySelector: function(selector) {

2123 - var shimmed = shimSelector(selector);

2124 - var deep = shimmed !== selector;

2125 - selector = shimmed;

2126 - var target = unsafeUnwrap(this);

2127 - var wrappedItem;

2128 - var root = getTreeScope(this).root;

2129 - if (root instanceof scope.wrappers.ShadowRoot) {

2130 - return findOne(this, selector);

2131 - } else if (target instanceof OriginalElement) {

2132 - wrappedItem = wrap(originalElementQuerySelector.call(target, selector));

2133 - } else if (target instanceof OriginalDocument) {

2134 - wrappedItem = wrap(originalDocumentQuerySelector.call(target, selector));

2135 - } else {

2136 - return findOne(this, selector);

2137 - }

2138 - if (!wrappedItem) {

2139 - return wrappedItem;

2140 - } else if (!deep && (root = getTreeScope(wrappedItem).root)) {

2141 - if (root instanceof scope.wrappers.ShadowRoot) {

2142 - return findOne(this, selector);

2143 - }

2144 - }

2145 - return wrappedItem;

2146 - },

2147 - querySelectorAll: function(selector) {

2148 - var shimmed = shimSelector(selector);

2149 - var deep = shimmed !== selector;

2150 - selector = shimmed;

2151 - var result = new NodeList();

2152 - result.length = querySelectorAllFiltered.call(this, matchesSelector, 0, result, selector, deep);

2153 - return result;

2154 - }

2155 - };

2156 - function getElementsByTagNameFiltered(p, index, result, localName, lowercase) {

2157 - var target = unsafeUnwrap(this);

2158 - var list;

2159 - var root = getTreeScope(this).root;

2160 - if (root instanceof scope.wrappers.ShadowRoot) {

2161 - return findElements(this, index, result, p, localName, lowercase);

2162 - } else if (target instanceof OriginalElement) {

2163 - list = originalElementGetElementsByTagName.call(target, localName, lowercase);

2164 - } else if (target instanceof OriginalDocument) {

2165 - list = originalDocumentGetElementsByTagName.call(target, localName, lowercase);

2166 - } else {

2167 - return findElements(this, index, result, p, localName, lowercase);

2168 - }

2169 - return filterNodeList(list, index, result, false);

2170 - }

2171 - function getElementsByTagNameNSFiltered(p, index, result, ns, localName) {

2172 - var target = unsafeUnwrap(this);

2173 - var list;

2174 - var root = getTreeScope(this).root;

2175 - if (root instanceof scope.wrappers.ShadowRoot) {

2176 - return findElements(this, index, result, p, ns, localName);

2177 - } else if (target instanceof OriginalElement) {

2178 - list = originalElementGetElementsByTagNameNS.call(target, ns, localName);

2179 - } else if (target instanceof OriginalDocument) {

2180 - list = originalDocumentGetElementsByTagNameNS.call(target, ns, localName);

2181 - } else {

2182 - return findElements(this, index, result, p, ns, localName);

2183 - }

2184 - return filterNodeList(list, index, result, false);

2185 - }

2186 - var GetElementsByInterface = {

2187 - getElementsByTagName: function(localName) {

2188 - var result = new HTMLCollection();

2189 - var match = localName === "*" ? matchesEveryThing : matchesTagName;

2190 - result.length = getElementsByTagNameFiltered.call(this, match, 0, result, localName, localName.toLowerCase());

2191 - return result;

2192 - },

2193 - getElementsByClassName: function(className) {

2194 - return this.querySelectorAll("." + className);

2195 - },

2196 - getElementsByTagNameNS: function(ns, localName) {

2197 - var result = new HTMLCollection();

2198 - var match = null;

2199 - if (ns === "*") {

2200 - match = localName === "*" ? matchesEveryThing : matchesLocalNameOnly;

2201 - } else {

2202 - match = localName === "*" ? matchesNameSpace : matchesLocalNameNS;

2203 - }

2204 - result.length = getElementsByTagNameNSFiltered.call(this, match, 0, result, ns || null, localName);

2205 - return result;

2206 - }

2207 - };

2208 - scope.GetElementsByInterface = GetElementsByInterface;

2209 - scope.SelectorsInterface = SelectorsInterface;

2210 - })(window.ShadowDOMPolyfill);

2211 - (function(scope) {

2212 - "use strict";

2213 - var NodeList = scope.wrappers.NodeList;

2214 - function forwardElement(node) {

2215 - while (node && node.nodeType !== Node.ELEMENT_NODE) {

2216 - node = node.nextSibling;

2217 - }

2218 - return node;

2219 - }

2220 - function backwardsElement(node) {

2221 - while (node && node.nodeType !== Node.ELEMENT_NODE) {

2222 - node = node.previousSibling;

2223 - }

2224 - return node;

2225 - }

2226 - var ParentNodeInterface = {

2227 - get firstElementChild() {

2228 - return forwardElement(this.firstChild);

2229 - },

2230 - get lastElementChild() {

2231 - return backwardsElement(this.lastChild);

2232 - },

2233 - get childElementCount() {

2234 - var count = 0;

2235 - for (var child = this.firstElementChild; child; child = child.nextElementSibling) {

2236 - count++;

2237 - }

2238 - return count;

2239 - },

2240 - get children() {

2241 - var wrapperList = new NodeList();

2242 - var i = 0;

2243 - for (var child = this.firstElementChild; child; child = child.nextElementSibling) {

2244 - wrapperList[i++] = child;

2245 - }

2246 - wrapperList.length = i;

2247 - return wrapperList;

2248 - },

2249 - remove: function() {

2250 - var p = this.parentNode;

2251 - if (p) p.removeChild(this);

2252 - }

2253 - };

2254 - var ChildNodeInterface = {

2255 - get nextElementSibling() {

2256 - return forwardElement(this.nextSibling);

2257 - },

2258 - get previousElementSibling() {

2259 - return backwardsElement(this.previousSibling);

2260 - }

2261 - };

2262 - scope.ChildNodeInterface = ChildNodeInterface;

2263 - scope.ParentNodeInterface = ParentNodeInterface;

2264 - })(window.ShadowDOMPolyfill);

2265 - (function(scope) {

2266 - "use strict";

2267 - var ChildNodeInterface = scope.ChildNodeInterface;

2268 - var Node = scope.wrappers.Node;

2269 - var enqueueMutation = scope.enqueueMutation;

2270 - var mixin = scope.mixin;

2271 - var registerWrapper = scope.registerWrapper;

2272 - var unsafeUnwrap = scope.unsafeUnwrap;

2273 - var OriginalCharacterData = window.CharacterData;

2274 - function CharacterData(node) {

2275 - Node.call(this, node);

2276 - }

2277 - CharacterData.prototype = Object.create(Node.prototype);

2278 - mixin(CharacterData.prototype, {

2279 - get textContent() {

2280 - return this.data;

2281 - },

2282 - set textContent(value) {

2283 - this.data = value;

2284 - },

2285 - get data() {

2286 - return unsafeUnwrap(this).data;

2287 - },

2288 - set data(value) {

2289 - var oldValue = unsafeUnwrap(this).data;

2290 - enqueueMutation(this, "characterData", {

2291 - oldValue: oldValue

2292 - });

2293 - unsafeUnwrap(this).data = value;

2294 - }

2295 - });

2296 - mixin(CharacterData.prototype, ChildNodeInterface);

2297 - registerWrapper(OriginalCharacterData, CharacterData, document.createTextNode(""));

2298 - scope.wrappers.CharacterData = CharacterData;

2299 - })(window.ShadowDOMPolyfill);

2300 - (function(scope) {

2301 - "use strict";

2302 - var CharacterData = scope.wrappers.CharacterData;

2303 - var enqueueMutation = scope.enqueueMutation;

2304 - var mixin = scope.mixin;

2305 - var registerWrapper = scope.registerWrapper;

2306 - function toUInt32(x) {

2307 - return x >>> 0;

2308 - }

2309 - var OriginalText = window.Text;

2310 - function Text(node) {

2311 - CharacterData.call(this, node);

2312 - }

2313 - Text.prototype = Object.create(CharacterData.prototype);

2314 - mixin(Text.prototype, {

2315 - splitText: function(offset) {

2316 - offset = toUInt32(offset);

2317 - var s = this.data;

2318 - if (offset > s.length) throw new Error("IndexSizeError");

2319 - var head = s.slice(0, offset);

2320 - var tail = s.slice(offset);

2321 - this.data = head;

2322 - var newTextNode = this.ownerDocument.createTextNode(tail);

2323 - if (this.parentNode) this.parentNode.insertBefore(newTextNode, this.nextSibling);

2324 - return newTextNode;

2325 - }

2326 - });

2327 - registerWrapper(OriginalText, Text, document.createTextNode(""));

2328 - scope.wrappers.Text = Text;

2329 - })(window.ShadowDOMPolyfill);

2330 - (function(scope) {

2331 - "use strict";

2332 - var setWrapper = scope.setWrapper;

2333 - var unsafeUnwrap = scope.unsafeUnwrap;

2334 - function invalidateClass(el) {

2335 - scope.invalidateRendererBasedOnAttribute(el, "class");

2336 - }

2337 - function DOMTokenList(impl, ownerElement) {

2338 - setWrapper(impl, this);

2339 - this.ownerElement_ = ownerElement;

2340 - }

2341 - DOMTokenList.prototype = {

2342 - constructor: DOMTokenList,

2343 - get length() {

2344 - return unsafeUnwrap(this).length;

2345 - },

2346 - item: function(index) {

2347 - return unsafeUnwrap(this).item(index);

2348 - },

2349 - contains: function(token) {

2350 - return unsafeUnwrap(this).contains(token);

2351 - },

2352 - add: function() {

2353 - unsafeUnwrap(this).add.apply(unsafeUnwrap(this), arguments);

2354 - invalidateClass(this.ownerElement_);

2355 - },

2356 - remove: function() {

2357 - unsafeUnwrap(this).remove.apply(unsafeUnwrap(this), arguments);

2358 - invalidateClass(this.ownerElement_);

2359 - },

2360 - toggle: function(token) {

2361 - var rv = unsafeUnwrap(this).toggle.apply(unsafeUnwrap(this), arguments);

2362 - invalidateClass(this.ownerElement_);

2363 - return rv;

2364 - },

2365 - toString: function() {

2366 - return unsafeUnwrap(this).toString();

2367 - }

2368 - };

2369 - scope.wrappers.DOMTokenList = DOMTokenList;

2370 - })(window.ShadowDOMPolyfill);

2371 - (function(scope) {

2372 - "use strict";

2373 - var ChildNodeInterface = scope.ChildNodeInterface;

2374 - var GetElementsByInterface = scope.GetElementsByInterface;

2375 - var Node = scope.wrappers.Node;

2376 - var DOMTokenList = scope.wrappers.DOMTokenList;

2377 - var ParentNodeInterface = scope.ParentNodeInterface;

2378 - var SelectorsInterface = scope.SelectorsInterface;

2379 - var addWrapNodeListMethod = scope.addWrapNodeListMethod;

2380 - var enqueueMutation = scope.enqueueMutation;

2381 - var mixin = scope.mixin;

2382 - var oneOf = scope.oneOf;

2383 - var registerWrapper = scope.registerWrapper;

2384 - var unsafeUnwrap = scope.unsafeUnwrap;

2385 - var wrappers = scope.wrappers;

2386 - var OriginalElement = window.Element;

2387 - var matchesNames = [ "matches", "mozMatchesSelector", "msMatchesSelector", "webkitMatchesSelector" ].filter(function(name) {

2388 - return OriginalElement.prototype[name];

2389 - });

2390 - var matchesName = matchesNames[0];

2391 - var originalMatches = OriginalElement.prototype[matchesName];

2392 - function invalidateRendererBasedOnAttribute(element, name) {

2393 - var p = element.parentNode;

2394 - if (!p || !p.shadowRoot) return;

2395 - var renderer = scope.getRendererForHost(p);

2396 - if (renderer.dependsOnAttribute(name)) renderer.invalidate();

2397 - }

2398 - function enqueAttributeChange(element, name, oldValue) {

2399 - enqueueMutation(element, "attributes", {

2400 - name: name,

2401 - namespace: null,

2402 - oldValue: oldValue

2403 - });

2404 - }

2405 - var classListTable = new WeakMap();

2406 - function Element(node) {

2407 - Node.call(this, node);

2408 - }

2409 - Element.prototype = Object.create(Node.prototype);

2410 - mixin(Element.prototype, {

2411 - createShadowRoot: function() {

2412 - var newShadowRoot = new wrappers.ShadowRoot(this);

2413 - unsafeUnwrap(this).polymerShadowRoot_ = newShadowRoot;

2414 - var renderer = scope.getRendererForHost(this);

2415 - renderer.invalidate();

2416 - return newShadowRoot;

2417 - },

2418 - get shadowRoot() {

2419 - return unsafeUnwrap(this).polymerShadowRoot_ || null;

2420 - },

2421 - setAttribute: function(name, value) {

2422 - var oldValue = unsafeUnwrap(this).getAttribute(name);

2423 - unsafeUnwrap(this).setAttribute(name, value);

2424 - enqueAttributeChange(this, name, oldValue);

2425 - invalidateRendererBasedOnAttribute(this, name);

2426 - },

2427 - removeAttribute: function(name) {

2428 - var oldValue = unsafeUnwrap(this).getAttribute(name);

2429 - unsafeUnwrap(this).removeAttribute(name);

2430 - enqueAttributeChange(this, name, oldValue);

2431 - invalidateRendererBasedOnAttribute(this, name);

2432 - },

2433 - matches: function(selector) {

2434 - return originalMatches.call(unsafeUnwrap(this), selector);

2435 - },

2436 - get classList() {

2437 - var list = classListTable.get(this);

2438 - if (!list) {

2439 - classListTable.set(this, list = new DOMTokenList(unsafeUnwrap(this).classList, this));

2440 - }

2441 - return list;

2442 - },

2443 - get className() {

2444 - return unsafeUnwrap(this).className;

2445 - },

2446 - set className(v) {

2447 - this.setAttribute("class", v);

2448 - },

2449 - get id() {

2450 - return unsafeUnwrap(this).id;

2451 - },

2452 - set id(v) {

2453 - this.setAttribute("id", v);

2454 - }

2455 - });

2456 - matchesNames.forEach(function(name) {

2457 - if (name !== "matches") {

2458 - Element.prototype[name] = function(selector) {

2459 - return this.matches(selector);

2460 - };

2461 - }

2462 - });

2463 - if (OriginalElement.prototype.webkitCreateShadowRoot) {

2464 - Element.prototype.webkitCreateShadowRoot = Element.prototype.createShadowRoot;

2465 - }

2466 - mixin(Element.prototype, ChildNodeInterface);

2467 - mixin(Element.prototype, GetElementsByInterface);

2468 - mixin(Element.prototype, ParentNodeInterface);

2469 - mixin(Element.prototype, SelectorsInterface);

2470 - registerWrapper(OriginalElement, Element, document.createElementNS(null, "x"));

2471 - scope.invalidateRendererBasedOnAttribute = invalidateRendererBasedOnAttribute;

2472 - scope.matchesNames = matchesNames;

2473 - scope.wrappers.Element = Element;

2474 - })(window.ShadowDOMPolyfill);

2475 - (function(scope) {

2476 - "use strict";

2477 - var Element = scope.wrappers.Element;

2478 - var defineGetter = scope.defineGetter;

2479 - var enqueueMutation = scope.enqueueMutation;

2480 - var mixin = scope.mixin;

2481 - var nodesWereAdded = scope.nodesWereAdded;

2482 - var nodesWereRemoved = scope.nodesWereRemoved;

2483 - var registerWrapper = scope.registerWrapper;

2484 - var snapshotNodeList = scope.snapshotNodeList;

2485 - var unsafeUnwrap = scope.unsafeUnwrap;

2486 - var unwrap = scope.unwrap;

2487 - var wrap = scope.wrap;

2488 - var wrappers = scope.wrappers;

2489 - var escapeAttrRegExp = /[&\u00A0"]/g;

2490 - var escapeDataRegExp = /[&\u00A0<>]/g;

2491 - function escapeReplace(c) {

2492 - switch (c) {

2493 - case "&":

2494 - return "&";

2495 -

2496 - case "<":

2497 - return "<";

2498 -

2499 - case ">":

2500 - return ">";

2501 -

2502 - case '"':

2503 - return """;

2504 -

2505 - case " ":

2506 - return " ";

2507 - }

2508 - }

2509 - function escapeAttr(s) {

2510 - return s.replace(escapeAttrRegExp, escapeReplace);

2511 - }

2512 - function escapeData(s) {

2513 - return s.replace(escapeDataRegExp, escapeReplace);

2514 - }

2515 - function makeSet(arr) {

2516 - var set = {};

2517 - for (var i = 0; i < arr.length; i++) {

2518 - set[arr[i]] = true;

2519 - }

2520 - return set;

2521 - }

2522 - var voidElements = makeSet([ "area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr" ]);

2523 - var plaintextParents = makeSet([ "style", "script", "xmp", "iframe", "noembed", "noframes", "plaintext", "noscript" ]);

2524 - function getOuterHTML(node, parentNode) {

2525 - switch (node.nodeType) {

2526 - case Node.ELEMENT_NODE:

2527 - var tagName = node.tagName.toLowerCase();

2528 - var s = "<" + tagName;

2529 - var attrs = node.attributes;

2530 - for (var i = 0, attr; attr = attrs[i]; i++) {

2531 - s += " " + attr.name + '="' + escapeAttr(attr.value) + '"';

2532 - }

2533 - s += ">";

2534 - if (voidElements[tagName]) return s;

2535 - return s + getInnerHTML(node) + "</" + tagName + ">";

2536 -

2537 - case Node.TEXT_NODE:

2538 - var data = node.data;

2539 - if (parentNode && plaintextParents[parentNode.localName]) return data;

2540 - return escapeData(data);

2541 -

2542 - case Node.COMMENT_NODE:

2543 - return "";

2544 -

2545 - default:

2546 - console.error(node);

2547 - throw new Error("not implemented");

2548 - }

2549 - }

2550 - function getInnerHTML(node) {

2551 - if (node instanceof wrappers.HTMLTemplateElement) node = node.content;

2552 - var s = "";

2553 - for (var child = node.firstChild; child; child = child.nextSibling) {

2554 - s += getOuterHTML(child, node);

2555 - }

2556 - return s;

2557 - }

2558 - function setInnerHTML(node, value, opt_tagName) {

2559 - var tagName = opt_tagName || "div";

2560 - node.textContent = "";

2561 - var tempElement = unwrap(node.ownerDocument.createElement(tagName));

2562 - tempElement.innerHTML = value;

2563 - var firstChild;

2564 - while (firstChild = tempElement.firstChild) {

2565 - node.appendChild(wrap(firstChild));

2566 - }

2567 - }

2568 - var oldIe = /MSIE/.test(navigator.userAgent);

2569 - var OriginalHTMLElement = window.HTMLElement;

2570 - var OriginalHTMLTemplateElement = window.HTMLTemplateElement;

2571 - function HTMLElement(node) {

2572 - Element.call(this, node);

2573 - }

2574 - HTMLElement.prototype = Object.create(Element.prototype);

2575 - mixin(HTMLElement.prototype, {

2576 - get innerHTML() {

2577 - return getInnerHTML(this);

2578 - },

2579 - set innerHTML(value) {

2580 - if (oldIe && plaintextParents[this.localName]) {

2581 - this.textContent = value;

2582 - return;

2583 - }

2584 - var removedNodes = snapshotNodeList(this.childNodes);

2585 - if (this.invalidateShadowRenderer()) {

2586 - if (this instanceof wrappers.HTMLTemplateElement) setInnerHTML(this.content, value); else setInnerHTML(this, value, this.tagName);

2587 - } else if (!OriginalHTMLTemplateElement && this instanceof wrappers.HTMLTemplateElement) {

2588 - setInnerHTML(this.content, value);

2589 - } else {

2590 - unsafeUnwrap(this).innerHTML = value;

2591 - }

2592 - var addedNodes = snapshotNodeList(this.childNodes);

2593 - enqueueMutation(this, "childList", {

2594 - addedNodes: addedNodes,

2595 - removedNodes: removedNodes

2596 - });

2597 - nodesWereRemoved(removedNodes);

2598 - nodesWereAdded(addedNodes, this);

2599 - },

2600 - get outerHTML() {

2601 - return getOuterHTML(this, this.parentNode);

2602 - },

2603 - set outerHTML(value) {

2604 - var p = this.parentNode;

2605 - if (p) {

2606 - p.invalidateShadowRenderer();

2607 - var df = frag(p, value);

2608 - p.replaceChild(df, this);

2609 - }

2610 - },

2611 - insertAdjacentHTML: function(position, text) {

2612 - var contextElement, refNode;

2613 - switch (String(position).toLowerCase()) {

2614 - case "beforebegin":

2615 - contextElement = this.parentNode;

2616 - refNode = this;

2617 - break;

2618 -

2619 - case "afterend":

2620 - contextElement = this.parentNode;

2621 - refNode = this.nextSibling;

2622 - break;

2623 -

2624 - case "afterbegin":

2625 - contextElement = this;

2626 - refNode = this.firstChild;

2627 - break;

2628 -

2629 - case "beforeend":

2630 - contextElement = this;

2631 - refNode = null;

2632 - break;

2633 -

2634 - default:

2635 - return;

2636 - }

2637 - var df = frag(contextElement, text);

2638 - contextElement.insertBefore(df, refNode);

2639 - },

2640 - get hidden() {

2641 - return this.hasAttribute("hidden");

2642 - },

2643 - set hidden(v) {

2644 - if (v) {

2645 - this.setAttribute("hidden", "");

2646 - } else {

2647 - this.removeAttribute("hidden");

2648 - }

2649 - }

2650 - });

2651 - function frag(contextElement, html) {

2652 - var p = unwrap(contextElement.cloneNode(false));

2653 - p.innerHTML = html;

2654 - var df = unwrap(document.createDocumentFragment());

2655 - var c;

2656 - while (c = p.firstChild) {

2657 - df.appendChild(c);

2658 - }

2659 - return wrap(df);

2660 - }

2661 - function getter(name) {

2662 - return function() {

2663 - scope.renderAllPending();

2664 - return unsafeUnwrap(this)[name];

2665 - };

2666 - }

2667 - function getterRequiresRendering(name) {

2668 - defineGetter(HTMLElement, name, getter(name));

2669 - }

2670 - [ "clientHeight", "clientLeft", "clientTop", "clientWidth", "offsetHeight", "offsetLeft", "offsetTop", "offsetWidth", "scrollHeight", "scrollWidth" ].forEach(getterRequiresRendering);

2671 - function getterAndSetterRequiresRendering(name) {

2672 - Object.defineProperty(HTMLElement.prototype, name, {

2673 - get: getter(name),

2674 - set: function(v) {

2675 - scope.renderAllPending();

2676 - unsafeUnwrap(this)[name] = v;

2677 - },

2678 - configurable: true,

2679 - enumerable: true

2680 - });

2681 - }

2682 - [ "scrollLeft", "scrollTop" ].forEach(getterAndSetterRequiresRendering);

2683 - function methodRequiresRendering(name) {

2684 - Object.defineProperty(HTMLElement.prototype, name, {

2685 - value: function() {

2686 - scope.renderAllPending();

2687 - return unsafeUnwrap(this)[name].apply(unsafeUnwrap(this), arguments);

2688 - },

2689 - configurable: true,

2690 - enumerable: true

2691 - });

2692 - }

2693 - [ "getBoundingClientRect", "getClientRects", "scrollIntoView" ].forEach(methodRequiresRendering);

2694 - registerWrapper(OriginalHTMLElement, HTMLElement, document.createElement("b"));

2695 - scope.wrappers.HTMLElement = HTMLElement;

2696 - scope.getInnerHTML = getInnerHTML;

2697 - scope.setInnerHTML = setInnerHTML;

2698 - })(window.ShadowDOMPolyfill);

2699 - (function(scope) {

2700 - "use strict";

2701 - var HTMLElement = scope.wrappers.HTMLElement;

2702 - var mixin = scope.mixin;

2703 - var registerWrapper = scope.registerWrapper;

2704 - var unsafeUnwrap = scope.unsafeUnwrap;

2705 - var wrap = scope.wrap;

2706 - var OriginalHTMLCanvasElement = window.HTMLCanvasElement;

2707 - function HTMLCanvasElement(node) {

2708 - HTMLElement.call(this, node);

2709 - }

2710 - HTMLCanvasElement.prototype = Object.create(HTMLElement.prototype);

2711 - mixin(HTMLCanvasElement.prototype, {

2712 - getContext: function() {

2713 - var context = unsafeUnwrap(this).getContext.apply(unsafeUnwrap(this), arguments);

2714 - return context && wrap(context);

2715 - }

2716 - });

2717 - registerWrapper(OriginalHTMLCanvasElement, HTMLCanvasElement, document.createElement("canvas"));

2718 - scope.wrappers.HTMLCanvasElement = HTMLCanvasElement;

2719 - })(window.ShadowDOMPolyfill);

2720 - (function(scope) {

2721 - "use strict";

2722 - var HTMLElement = scope.wrappers.HTMLElement;

2723 - var mixin = scope.mixin;

2724 - var registerWrapper = scope.registerWrapper;

2725 - var OriginalHTMLContentElement = window.HTMLContentElement;

2726 - function HTMLContentElement(node) {

2727 - HTMLElement.call(this, node);

2728 - }

2729 - HTMLContentElement.prototype = Object.create(HTMLElement.prototype);

2730 - mixin(HTMLContentElement.prototype, {

2731 - constructor: HTMLContentElement,

2732 - get select() {

2733 - return this.getAttribute("select");

2734 - },

2735 - set select(value) {

2736 - this.setAttribute("select", value);

2737 - },

2738 - setAttribute: function(n, v) {

2739 - HTMLElement.prototype.setAttribute.call(this, n, v);

2740 - if (String(n).toLowerCase() === "select") this.invalidateShadowRenderer(true);

2741 - }

2742 - });

2743 - if (OriginalHTMLContentElement) registerWrapper(OriginalHTMLContentElement, HTMLContentElement);

2744 - scope.wrappers.HTMLContentElement = HTMLContentElement;

2745 - })(window.ShadowDOMPolyfill);

2746 - (function(scope) {

2747 - "use strict";

2748 - var HTMLElement = scope.wrappers.HTMLElement;

2749 - var mixin = scope.mixin;

2750 - var registerWrapper = scope.registerWrapper;

2751 - var wrapHTMLCollection = scope.wrapHTMLCollection;

2752 - var unwrap = scope.unwrap;

2753 - var OriginalHTMLFormElement = window.HTMLFormElement;

2754 - function HTMLFormElement(node) {

2755 - HTMLElement.call(this, node);

2756 - }

2757 - HTMLFormElement.prototype = Object.create(HTMLElement.prototype);

2758 - mixin(HTMLFormElement.prototype, {

2759 - get elements() {

2760 - return wrapHTMLCollection(unwrap(this).elements);

2761 - }

2762 - });

2763 - registerWrapper(OriginalHTMLFormElement, HTMLFormElement, document.createElement("form"));

2764 - scope.wrappers.HTMLFormElement = HTMLFormElement;

2765 - })(window.ShadowDOMPolyfill);

2766 - (function(scope) {

2767 - "use strict";

2768 - var HTMLElement = scope.wrappers.HTMLElement;

2769 - var registerWrapper = scope.registerWrapper;

2770 - var unwrap = scope.unwrap;

2771 - var rewrap = scope.rewrap;

2772 - var OriginalHTMLImageElement = window.HTMLImageElement;

2773 - function HTMLImageElement(node) {

2774 - HTMLElement.call(this, node);

2775 - }

2776 - HTMLImageElement.prototype = Object.create(HTMLElement.prototype);

2777 - registerWrapper(OriginalHTMLImageElement, HTMLImageElement, document.createElement("img"));

2778 - function Image(width, height) {

2779 - if (!(this instanceof Image)) {

2780 - throw new TypeError("DOM object constructor cannot be called as a function.");

2781 - }

2782 - var node = unwrap(document.createElement("img"));

2783 - HTMLElement.call(this, node);

2784 - rewrap(node, this);

2785 - if (width !== undefined) node.width = width;

2786 - if (height !== undefined) node.height = height;

2787 - }

2788 - Image.prototype = HTMLImageElement.prototype;

2789 - scope.wrappers.HTMLImageElement = HTMLImageElement;

2790 - scope.wrappers.Image = Image;

2791 - })(window.ShadowDOMPolyfill);

2792 - (function(scope) {

2793 - "use strict";

2794 - var HTMLElement = scope.wrappers.HTMLElement;

2795 - var mixin = scope.mixin;

2796 - var NodeList = scope.wrappers.NodeList;

2797 - var registerWrapper = scope.registerWrapper;

2798 - var OriginalHTMLShadowElement = window.HTMLShadowElement;

2799 - function HTMLShadowElement(node) {

2800 - HTMLElement.call(this, node);

2801 - }

2802 - HTMLShadowElement.prototype = Object.create(HTMLElement.prototype);

2803 - HTMLShadowElement.prototype.constructor = HTMLShadowElement;

2804 - if (OriginalHTMLShadowElement) registerWrapper(OriginalHTMLShadowElement, HTMLShadowElement);

2805 - scope.wrappers.HTMLShadowElement = HTMLShadowElement;

2806 - })(window.ShadowDOMPolyfill);

2807 - (function(scope) {

2808 - "use strict";

2809 - var HTMLElement = scope.wrappers.HTMLElement;

2810 - var mixin = scope.mixin;

2811 - var registerWrapper = scope.registerWrapper;

2812 - var unsafeUnwrap = scope.unsafeUnwrap;

2813 - var unwrap = scope.unwrap;

2814 - var wrap = scope.wrap;

2815 - var contentTable = new WeakMap();

2816 - var templateContentsOwnerTable = new WeakMap();

2817 - function getTemplateContentsOwner(doc) {

2818 - if (!doc.defaultView) return doc;

2819 - var d = templateContentsOwnerTable.get(doc);

2820 - if (!d) {

2821 - d = doc.implementation.createHTMLDocument("");

2822 - while (d.lastChild) {

2823 - d.removeChild(d.lastChild);

2824 - }

2825 - templateContentsOwnerTable.set(doc, d);

2826 - }

2827 - return d;

2828 - }

2829 - function extractContent(templateElement) {

2830 - var doc = getTemplateContentsOwner(templateElement.ownerDocument);

2831 - var df = unwrap(doc.createDocumentFragment());

2832 - var child;

2833 - while (child = templateElement.firstChild) {

2834 - df.appendChild(child);

2835 - }

2836 - return df;

2837 - }

2838 - var OriginalHTMLTemplateElement = window.HTMLTemplateElement;

2839 - function HTMLTemplateElement(node) {

2840 - HTMLElement.call(this, node);

2841 - if (!OriginalHTMLTemplateElement) {

2842 - var content = extractContent(node);

2843 - contentTable.set(this, wrap(content));

2844 - }

2845 - }

2846 - HTMLTemplateElement.prototype = Object.create(HTMLElement.prototype);

2847 - mixin(HTMLTemplateElement.prototype, {

2848 - constructor: HTMLTemplateElement,

2849 - get content() {

2850 - if (OriginalHTMLTemplateElement) return wrap(unsafeUnwrap(this).content);

2851 - return contentTable.get(this);

2852 - }

2853 - });

2854 - if (OriginalHTMLTemplateElement) registerWrapper(OriginalHTMLTemplateElement, HTMLTemplateElement);

2855 - scope.wrappers.HTMLTemplateElement = HTMLTemplateElement;

2856 - })(window.ShadowDOMPolyfill);

2857 - (function(scope) {

2858 - "use strict";

2859 - var HTMLElement = scope.wrappers.HTMLElement;

2860 - var registerWrapper = scope.registerWrapper;

2861 - var OriginalHTMLMediaElement = window.HTMLMediaElement;

2862 - if (!OriginalHTMLMediaElement) return;

2863 - function HTMLMediaElement(node) {

2864 - HTMLElement.call(this, node);

2865 - }

2866 - HTMLMediaElement.prototype = Object.create(HTMLElement.prototype);

2867 - registerWrapper(OriginalHTMLMediaElement, HTMLMediaElement, document.createElement("audio"));

2868 - scope.wrappers.HTMLMediaElement = HTMLMediaElement;

2869 - })(window.ShadowDOMPolyfill);

2870 - (function(scope) {

2871 - "use strict";

2872 - var HTMLMediaElement = scope.wrappers.HTMLMediaElement;

2873 - var registerWrapper = scope.registerWrapper;

2874 - var unwrap = scope.unwrap;

2875 - var rewrap = scope.rewrap;

2876 - var OriginalHTMLAudioElement = window.HTMLAudioElement;

2877 - if (!OriginalHTMLAudioElement) return;

2878 - function HTMLAudioElement(node) {

2879 - HTMLMediaElement.call(this, node);

2880 - }

2881 - HTMLAudioElement.prototype = Object.create(HTMLMediaElement.prototype);

2882 - registerWrapper(OriginalHTMLAudioElement, HTMLAudioElement, document.createElement("audio"));

2883 - function Audio(src) {

2884 - if (!(this instanceof Audio)) {

2885 - throw new TypeError("DOM object constructor cannot be called as a function.");

2886 - }

2887 - var node = unwrap(document.createElement("audio"));

2888 - HTMLMediaElement.call(this, node);

2889 - rewrap(node, this);

2890 - node.setAttribute("preload", "auto");

2891 - if (src !== undefined) node.setAttribute("src", src);

2892 - }

2893 - Audio.prototype = HTMLAudioElement.prototype;

2894 - scope.wrappers.HTMLAudioElement = HTMLAudioElement;

2895 - scope.wrappers.Audio = Audio;

2896 - })(window.ShadowDOMPolyfill);

2897 - (function(scope) {

2898 - "use strict";

2899 - var HTMLElement = scope.wrappers.HTMLElement;

2900 - var mixin = scope.mixin;

2901 - var registerWrapper = scope.registerWrapper;

2902 - var rewrap = scope.rewrap;

2903 - var unwrap = scope.unwrap;

2904 - var wrap = scope.wrap;

2905 - var OriginalHTMLOptionElement = window.HTMLOptionElement;

2906 - function trimText(s) {

2907 - return s.replace(/\s+/g, " ").trim();

2908 - }

2909 - function HTMLOptionElement(node) {

2910 - HTMLElement.call(this, node);

2911 - }

2912 - HTMLOptionElement.prototype = Object.create(HTMLElement.prototype);

2913 - mixin(HTMLOptionElement.prototype, {

2914 - get text() {

2915 - return trimText(this.textContent);

2916 - },

2917 - set text(value) {

2918 - this.textContent = trimText(String(value));

2919 - },

2920 - get form() {

2921 - return wrap(unwrap(this).form);

2922 - }

2923 - });

2924 - registerWrapper(OriginalHTMLOptionElement, HTMLOptionElement, document.createElement("option"));

2925 - function Option(text, value, defaultSelected, selected) {

2926 - if (!(this instanceof Option)) {

2927 - throw new TypeError("DOM object constructor cannot be called as a function.");

2928 - }

2929 - var node = unwrap(document.createElement("option"));

2930 - HTMLElement.call(this, node);

2931 - rewrap(node, this);

2932 - if (text !== undefined) node.text = text;

2933 - if (value !== undefined) node.setAttribute("value", value);

2934 - if (defaultSelected === true) node.setAttribute("selected", "");

2935 - node.selected = selected === true;

2936 - }

2937 - Option.prototype = HTMLOptionElement.prototype;

2938 - scope.wrappers.HTMLOptionElement = HTMLOptionElement;

2939 - scope.wrappers.Option = Option;

2940 - })(window.ShadowDOMPolyfill);

2941 - (function(scope) {

2942 - "use strict";

2943 - var HTMLElement = scope.wrappers.HTMLElement;

2944 - var mixin = scope.mixin;

2945 - var registerWrapper = scope.registerWrapper;

2946 - var unwrap = scope.unwrap;

2947 - var wrap = scope.wrap;

2948 - var OriginalHTMLSelectElement = window.HTMLSelectElement;

2949 - function HTMLSelectElement(node) {

2950 - HTMLElement.call(this, node);

2951 - }

2952 - HTMLSelectElement.prototype = Object.create(HTMLElement.prototype);

2953 - mixin(HTMLSelectElement.prototype, {

2954 - add: function(element, before) {

2955 - if (typeof before === "object") before = unwrap(before);

2956 - unwrap(this).add(unwrap(element), before);

2957 - },

2958 - remove: function(indexOrNode) {

2959 - if (indexOrNode === undefined) {

2960 - HTMLElement.prototype.remove.call(this);

2961 - return;

2962 - }

2963 - if (typeof indexOrNode === "object") indexOrNode = unwrap(indexOrNode);

2964 - unwrap(this).remove(indexOrNode);

2965 - },

2966 - get form() {

2967 - return wrap(unwrap(this).form);

2968 - }

2969 - });

2970 - registerWrapper(OriginalHTMLSelectElement, HTMLSelectElement, document.createElement("select"));

2971 - scope.wrappers.HTMLSelectElement = HTMLSelectElement;

2972 - })(window.ShadowDOMPolyfill);

2973 - (function(scope) {

2974 - "use strict";

2975 - var HTMLElement = scope.wrappers.HTMLElement;

2976 - var mixin = scope.mixin;

2977 - var registerWrapper = scope.registerWrapper;

2978 - var unwrap = scope.unwrap;

2979 - var wrap = scope.wrap;

2980 - var wrapHTMLCollection = scope.wrapHTMLCollection;

2981 - var OriginalHTMLTableElement = window.HTMLTableElement;

2982 - function HTMLTableElement(node) {

2983 - HTMLElement.call(this, node);

2984 - }

2985 - HTMLTableElement.prototype = Object.create(HTMLElement.prototype);

2986 - mixin(HTMLTableElement.prototype, {

2987 - get caption() {

2988 - return wrap(unwrap(this).caption);

2989 - },

2990 - createCaption: function() {

2991 - return wrap(unwrap(this).createCaption());

2992 - },

2993 - get tHead() {

2994 - return wrap(unwrap(this).tHead);

2995 - },

2996 - createTHead: function() {

2997 - return wrap(unwrap(this).createTHead());

2998 - },

2999 - createTFoot: function() {

3000 - return wrap(unwrap(this).createTFoot());

3001 - },

3002 - get tFoot() {

3003 - return wrap(unwrap(this).tFoot);

3004 - },

3005 - get tBodies() {

3006 - return wrapHTMLCollection(unwrap(this).tBodies);

3007 - },

3008 - createTBody: function() {

3009 - return wrap(unwrap(this).createTBody());

3010 - },

3011 - get rows() {

3012 - return wrapHTMLCollection(unwrap(this).rows);

3013 - },

3014 - insertRow: function(index) {

3015 - return wrap(unwrap(this).insertRow(index));

3016 - }

3017 - });

3018 - registerWrapper(OriginalHTMLTableElement, HTMLTableElement, document.createElement("table"));

3019 - scope.wrappers.HTMLTableElement = HTMLTableElement;

3020 - })(window.ShadowDOMPolyfill);

3021 - (function(scope) {

3022 - "use strict";

3023 - var HTMLElement = scope.wrappers.HTMLElement;

3024 - var mixin = scope.mixin;

3025 - var registerWrapper = scope.registerWrapper;

3026 - var wrapHTMLCollection = scope.wrapHTMLCollection;

3027 - var unwrap = scope.unwrap;

3028 - var wrap = scope.wrap;

3029 - var OriginalHTMLTableSectionElement = window.HTMLTableSectionElement;

3030 - function HTMLTableSectionElement(node) {

3031 - HTMLElement.call(this, node);

3032 - }

3033 - HTMLTableSectionElement.prototype = Object.create(HTMLElement.prototype);

3034 - mixin(HTMLTableSectionElement.prototype, {

3035 - constructor: HTMLTableSectionElement,

3036 - get rows() {

3037 - return wrapHTMLCollection(unwrap(this).rows);

3038 - },

3039 - insertRow: function(index) {

3040 - return wrap(unwrap(this).insertRow(index));

3041 - }

3042 - });

3043 - registerWrapper(OriginalHTMLTableSectionElement, HTMLTableSectionElement, document.createElement("thead"));

3044 - scope.wrappers.HTMLTableSectionElement = HTMLTableSectionElement;

3045 - })(window.ShadowDOMPolyfill);

3046 - (function(scope) {

3047 - "use strict";

3048 - var HTMLElement = scope.wrappers.HTMLElement;

3049 - var mixin = scope.mixin;

3050 - var registerWrapper = scope.registerWrapper;

3051 - var wrapHTMLCollection = scope.wrapHTMLCollection;

3052 - var unwrap = scope.unwrap;

3053 - var wrap = scope.wrap;

3054 - var OriginalHTMLTableRowElement = window.HTMLTableRowElement;

3055 - function HTMLTableRowElement(node) {

3056 - HTMLElement.call(this, node);

3057 - }

3058 - HTMLTableRowElement.prototype = Object.create(HTMLElement.prototype);

3059 - mixin(HTMLTableRowElement.prototype, {

3060 - get cells() {

3061 - return wrapHTMLCollection(unwrap(this).cells);

3062 - },

3063 - insertCell: function(index) {

3064 - return wrap(unwrap(this).insertCell(index));

3065 - }

3066 - });

3067 - registerWrapper(OriginalHTMLTableRowElement, HTMLTableRowElement, document.createElement("tr"));

3068 - scope.wrappers.HTMLTableRowElement = HTMLTableRowElement;

3069 - })(window.ShadowDOMPolyfill);

3070 - (function(scope) {

3071 - "use strict";

3072 - var HTMLContentElement = scope.wrappers.HTMLContentElement;

3073 - var HTMLElement = scope.wrappers.HTMLElement;

3074 - var HTMLShadowElement = scope.wrappers.HTMLShadowElement;

3075 - var HTMLTemplateElement = scope.wrappers.HTMLTemplateElement;

3076 - var mixin = scope.mixin;

3077 - var registerWrapper = scope.registerWrapper;

3078 - var OriginalHTMLUnknownElement = window.HTMLUnknownElement;

3079 - function HTMLUnknownElement(node) {

3080 - switch (node.localName) {

3081 - case "content":

3082 - return new HTMLContentElement(node);

3083 -

3084 - case "shadow":

3085 - return new HTMLShadowElement(node);

3086 -

3087 - case "template":

3088 - return new HTMLTemplateElement(node);

3089 - }

3090 - HTMLElement.call(this, node);

3091 - }

3092 - HTMLUnknownElement.prototype = Object.create(HTMLElement.prototype);

3093 - registerWrapper(OriginalHTMLUnknownElement, HTMLUnknownElement);

3094 - scope.wrappers.HTMLUnknownElement = HTMLUnknownElement;

3095 - })(window.ShadowDOMPolyfill);

3096 - (function(scope) {

3097 - "use strict";

3098 - var Element = scope.wrappers.Element;

3099 - var HTMLElement = scope.wrappers.HTMLElement;

3100 - var registerObject = scope.registerObject;

3101 - var SVG_NS = "http://www.w3.org/2000/svg";

3102 - var svgTitleElement = document.createElementNS(SVG_NS, "title");

3103 - var SVGTitleElement = registerObject(svgTitleElement);

3104 - var SVGElement = Object.getPrototypeOf(SVGTitleElement.prototype).constructor;

3105 - if (!("classList" in svgTitleElement)) {

3106 - var descr = Object.getOwnPropertyDescriptor(Element.prototype, "classList");

3107 - Object.defineProperty(HTMLElement.prototype, "classList", descr);

3108 - delete Element.prototype.classList;

3109 - }

3110 - scope.wrappers.SVGElement = SVGElement;

3111 - })(window.ShadowDOMPolyfill);

3112 - (function(scope) {

3113 - "use strict";

3114 - var mixin = scope.mixin;

3115 - var registerWrapper = scope.registerWrapper;

3116 - var unwrap = scope.unwrap;

3117 - var wrap = scope.wrap;

3118 - var OriginalSVGUseElement = window.SVGUseElement;

3119 - var SVG_NS = "http://www.w3.org/2000/svg";

3120 - var gWrapper = wrap(document.createElementNS(SVG_NS, "g"));

3121 - var useElement = document.createElementNS(SVG_NS, "use");

3122 - var SVGGElement = gWrapper.constructor;

3123 - var parentInterfacePrototype = Object.getPrototypeOf(SVGGElement.prototype);

3124 - var parentInterface = parentInterfacePrototype.constructor;

3125 - function SVGUseElement(impl) {

3126 - parentInterface.call(this, impl);

3127 - }

3128 - SVGUseElement.prototype = Object.create(parentInterfacePrototype);

3129 - if ("instanceRoot" in useElement) {

3130 - mixin(SVGUseElement.prototype, {

3131 - get instanceRoot() {

3132 - return wrap(unwrap(this).instanceRoot);

3133 - },

3134 - get animatedInstanceRoot() {

3135 - return wrap(unwrap(this).animatedInstanceRoot);

3136 - }

3137 - });

3138 - }

3139 - registerWrapper(OriginalSVGUseElement, SVGUseElement, useElement);

3140 - scope.wrappers.SVGUseElement = SVGUseElement;

3141 - })(window.ShadowDOMPolyfill);

3142 - (function(scope) {

3143 - "use strict";

3144 - var EventTarget = scope.wrappers.EventTarget;

3145 - var mixin = scope.mixin;

3146 - var registerWrapper = scope.registerWrapper;

3147 - var unsafeUnwrap = scope.unsafeUnwrap;

3148 - var wrap = scope.wrap;

3149 - var OriginalSVGElementInstance = window.SVGElementInstance;

3150 - if (!OriginalSVGElementInstance) return;

3151 - function SVGElementInstance(impl) {

3152 - EventTarget.call(this, impl);

3153 - }

3154 - SVGElementInstance.prototype = Object.create(EventTarget.prototype);

3155 - mixin(SVGElementInstance.prototype, {

3156 - get correspondingElement() {

3157 - return wrap(unsafeUnwrap(this).correspondingElement);

3158 - },

3159 - get correspondingUseElement() {

3160 - return wrap(unsafeUnwrap(this).correspondingUseElement);

3161 - },

3162 - get parentNode() {

3163 - return wrap(unsafeUnwrap(this).parentNode);

3164 - },

3165 - get childNodes() {

3166 - throw new Error("Not implemented");

3167 - },

3168 - get firstChild() {

3169 - return wrap(unsafeUnwrap(this).firstChild);

3170 - },

3171 - get lastChild() {

3172 - return wrap(unsafeUnwrap(this).lastChild);

3173 - },

3174 - get previousSibling() {

3175 - return wrap(unsafeUnwrap(this).previousSibling);

3176 - },

3177 - get nextSibling() {

3178 - return wrap(unsafeUnwrap(this).nextSibling);

3179 - }

3180 - });

3181 - registerWrapper(OriginalSVGElementInstance, SVGElementInstance);

3182 - scope.wrappers.SVGElementInstance = SVGElementInstance;

3183 - })(window.ShadowDOMPolyfill);

3184 - (function(scope) {

3185 - "use strict";

3186 - var mixin = scope.mixin;

3187 - var registerWrapper = scope.registerWrapper;

3188 - var setWrapper = scope.setWrapper;

3189 - var unsafeUnwrap = scope.unsafeUnwrap;

3190 - var unwrap = scope.unwrap;

3191 - var unwrapIfNeeded = scope.unwrapIfNeeded;

3192 - var wrap = scope.wrap;

3193 - var OriginalCanvasRenderingContext2D = window.CanvasRenderingContext2D;

3194 - function CanvasRenderingContext2D(impl) {

3195 - setWrapper(impl, this);

3196 - }

3197 - mixin(CanvasRenderingContext2D.prototype, {

3198 - get canvas() {

3199 - return wrap(unsafeUnwrap(this).canvas);

3200 - },

3201 - drawImage: function() {

3202 - arguments[0] = unwrapIfNeeded(arguments[0]);

3203 - unsafeUnwrap(this).drawImage.apply(unsafeUnwrap(this), arguments);

3204 - },

3205 - createPattern: function() {

3206 - arguments[0] = unwrap(arguments[0]);

3207 - return unsafeUnwrap(this).createPattern.apply(unsafeUnwrap(this), arguments);

3208 - }

3209 - });

3210 - registerWrapper(OriginalCanvasRenderingContext2D, CanvasRenderingContext2D, document.createElement("canvas").getContext("2d"));

3211 - scope.wrappers.CanvasRenderingContext2D = CanvasRenderingContext2D;

3212 - })(window.ShadowDOMPolyfill);

3213 - (function(scope) {

3214 - "use strict";

3215 - var mixin = scope.mixin;

3216 - var registerWrapper = scope.registerWrapper;

3217 - var setWrapper = scope.setWrapper;

3218 - var unsafeUnwrap = scope.unsafeUnwrap;

3219 - var unwrapIfNeeded = scope.unwrapIfNeeded;

3220 - var wrap = scope.wrap;

3221 - var OriginalWebGLRenderingContext = window.WebGLRenderingContext;

3222 - if (!OriginalWebGLRenderingContext) return;

3223 - function WebGLRenderingContext(impl) {

3224 - setWrapper(impl, this);

3225 - }

3226 - mixin(WebGLRenderingContext.prototype, {

3227 - get canvas() {

3228 - return wrap(unsafeUnwrap(this).canvas);

3229 - },

3230 - texImage2D: function() {

3231 - arguments[5] = unwrapIfNeeded(arguments[5]);

3232 - unsafeUnwrap(this).texImage2D.apply(unsafeUnwrap(this), arguments);

3233 - },

3234 - texSubImage2D: function() {

3235 - arguments[6] = unwrapIfNeeded(arguments[6]);

3236 - unsafeUnwrap(this).texSubImage2D.apply(unsafeUnwrap(this), arguments);

3237 - }

3238 - });

3239 - var instanceProperties = /WebKit/.test(navigator.userAgent) ? {

3240 - drawingBufferHeight: null,

3241 - drawingBufferWidth: null

3242 - } : {};

3243 - registerWrapper(OriginalWebGLRenderingContext, WebGLRenderingContext, instanceProperties);

3244 - scope.wrappers.WebGLRenderingContext = WebGLRenderingContext;

3245 - })(window.ShadowDOMPolyfill);

3246 - (function(scope) {

3247 - "use strict";

3248 - var registerWrapper = scope.registerWrapper;

3249 - var setWrapper = scope.setWrapper;

3250 - var unsafeUnwrap = scope.unsafeUnwrap;

3251 - var unwrap = scope.unwrap;

3252 - var unwrapIfNeeded = scope.unwrapIfNeeded;

3253 - var wrap = scope.wrap;

3254 - var OriginalRange = window.Range;

3255 - function Range(impl) {

3256 - setWrapper(impl, this);

3257 - }

3258 - Range.prototype = {

3259 - get startContainer() {

3260 - return wrap(unsafeUnwrap(this).startContainer);

3261 - },

3262 - get endContainer() {

3263 - return wrap(unsafeUnwrap(this).endContainer);

3264 - },

3265 - get commonAncestorContainer() {

3266 - return wrap(unsafeUnwrap(this).commonAncestorContainer);

3267 - },

3268 - setStart: function(refNode, offset) {

3269 - unsafeUnwrap(this).setStart(unwrapIfNeeded(refNode), offset);

3270 - },

3271 - setEnd: function(refNode, offset) {

3272 - unsafeUnwrap(this).setEnd(unwrapIfNeeded(refNode), offset);

3273 - },

3274 - setStartBefore: function(refNode) {

3275 - unsafeUnwrap(this).setStartBefore(unwrapIfNeeded(refNode));

3276 - },

3277 - setStartAfter: function(refNode) {

3278 - unsafeUnwrap(this).setStartAfter(unwrapIfNeeded(refNode));

3279 - },

3280 - setEndBefore: function(refNode) {

3281 - unsafeUnwrap(this).setEndBefore(unwrapIfNeeded(refNode));

3282 - },

3283 - setEndAfter: function(refNode) {

3284 - unsafeUnwrap(this).setEndAfter(unwrapIfNeeded(refNode));

3285 - },

3286 - selectNode: function(refNode) {

3287 - unsafeUnwrap(this).selectNode(unwrapIfNeeded(refNode));

3288 - },

3289 - selectNodeContents: function(refNode) {

3290 - unsafeUnwrap(this).selectNodeContents(unwrapIfNeeded(refNode));

3291 - },

3292 - compareBoundaryPoints: function(how, sourceRange) {

3293 - return unsafeUnwrap(this).compareBoundaryPoints(how, unwrap(sourceRange));

3294 - },

3295 - extractContents: function() {

3296 - return wrap(unsafeUnwrap(this).extractContents());

3297 - },

3298 - cloneContents: function() {

3299 - return wrap(unsafeUnwrap(this).cloneContents());

3300 - },

3301 - insertNode: function(node) {

3302 - unsafeUnwrap(this).insertNode(unwrapIfNeeded(node));

3303 - },

3304 - surroundContents: function(newParent) {

3305 - unsafeUnwrap(this).surroundContents(unwrapIfNeeded(newParent));

3306 - },

3307 - cloneRange: function() {

3308 - return wrap(unsafeUnwrap(this).cloneRange());

3309 - },

3310 - isPointInRange: function(node, offset) {

3311 - return unsafeUnwrap(this).isPointInRange(unwrapIfNeeded(node), offset);

3312 - },

3313 - comparePoint: function(node, offset) {

3314 - return unsafeUnwrap(this).comparePoint(unwrapIfNeeded(node), offset);

3315 - },

3316 - intersectsNode: function(node) {

3317 - return unsafeUnwrap(this).intersectsNode(unwrapIfNeeded(node));

3318 - },

3319 - toString: function() {

3320 - return unsafeUnwrap(this).toString();

3321 - }

3322 - };

3323 - if (OriginalRange.prototype.createContextualFragment) {

3324 - Range.prototype.createContextualFragment = function(html) {

3325 - return wrap(unsafeUnwrap(this).createContextualFragment(html));

3326 - };

3327 - }

3328 - registerWrapper(window.Range, Range, document.createRange());

3329 - scope.wrappers.Range = Range;

3330 - })(window.ShadowDOMPolyfill);

3331 - (function(scope) {

3332 - "use strict";

3333 - var GetElementsByInterface = scope.GetElementsByInterface;

3334 - var ParentNodeInterface = scope.ParentNodeInterface;

3335 - var SelectorsInterface = scope.SelectorsInterface;

3336 - var mixin = scope.mixin;

3337 - var registerObject = scope.registerObject;

3338 - var DocumentFragment = registerObject(document.createDocumentFragment());

3339 - mixin(DocumentFragment.prototype, ParentNodeInterface);

3340 - mixin(DocumentFragment.prototype, SelectorsInterface);

3341 - mixin(DocumentFragment.prototype, GetElementsByInterface);

3342 - var Comment = registerObject(document.createComment(""));

3343 - scope.wrappers.Comment = Comment;

3344 - scope.wrappers.DocumentFragment = DocumentFragment;

3345 - })(window.ShadowDOMPolyfill);

3346 - (function(scope) {

3347 - "use strict";

3348 - var DocumentFragment = scope.wrappers.DocumentFragment;

3349 - var TreeScope = scope.TreeScope;

3350 - var elementFromPoint = scope.elementFromPoint;

3351 - var getInnerHTML = scope.getInnerHTML;

3352 - var getTreeScope = scope.getTreeScope;

3353 - var mixin = scope.mixin;

3354 - var rewrap = scope.rewrap;

3355 - var setInnerHTML = scope.setInnerHTML;

3356 - var unsafeUnwrap = scope.unsafeUnwrap;

3357 - var unwrap = scope.unwrap;

3358 - var shadowHostTable = new WeakMap();

3359 - var nextOlderShadowTreeTable = new WeakMap();

3360 - var spaceCharRe = /[ \t\n\r\f]/;

3361 - function ShadowRoot(hostWrapper) {

3362 - var node = unwrap(unsafeUnwrap(hostWrapper).ownerDocument.createDocumentFragment());

3363 - DocumentFragment.call(this, node);

3364 - rewrap(node, this);

3365 - var oldShadowRoot = hostWrapper.shadowRoot;

3366 - nextOlderShadowTreeTable.set(this, oldShadowRoot);

3367 - this.treeScope_ = new TreeScope(this, getTreeScope(oldShadowRoot || hostWrapper));

3368 - shadowHostTable.set(this, hostWrapper);

3369 - }

3370 - ShadowRoot.prototype = Object.create(DocumentFragment.prototype);

3371 - mixin(ShadowRoot.prototype, {

3372 - constructor: ShadowRoot,

3373 - get innerHTML() {

3374 - return getInnerHTML(this);

3375 - },

3376 - set innerHTML(value) {

3377 - setInnerHTML(this, value);

3378 - this.invalidateShadowRenderer();

3379 - },

3380 - get olderShadowRoot() {

3381 - return nextOlderShadowTreeTable.get(this) || null;

3382 - },

3383 - get host() {

3384 - return shadowHostTable.get(this) || null;

3385 - },

3386 - invalidateShadowRenderer: function() {

3387 - return shadowHostTable.get(this).invalidateShadowRenderer();

3388 - },

3389 - elementFromPoint: function(x, y) {

3390 - return elementFromPoint(this, this.ownerDocument, x, y);

3391 - },

3392 - getElementById: function(id) {

3393 - if (spaceCharRe.test(id)) return null;

3394 - return this.querySelector('[id="' + id + '"]');

3395 - }

3396 - });

3397 - scope.wrappers.ShadowRoot = ShadowRoot;

3398 - })(window.ShadowDOMPolyfill);

3399 - (function(scope) {

3400 - "use strict";

3401 - var Element = scope.wrappers.Element;

3402 - var HTMLContentElement = scope.wrappers.HTMLContentElement;

3403 - var HTMLShadowElement = scope.wrappers.HTMLShadowElement;

3404 - var Node = scope.wrappers.Node;

3405 - var ShadowRoot = scope.wrappers.ShadowRoot;

3406 - var assert = scope.assert;

3407 - var getTreeScope = scope.getTreeScope;

3408 - var mixin = scope.mixin;

3409 - var oneOf = scope.oneOf;

3410 - var unsafeUnwrap = scope.unsafeUnwrap;

3411 - var unwrap = scope.unwrap;

3412 - var wrap = scope.wrap;

3413 - var ArraySplice = scope.ArraySplice;

3414 - function updateWrapperUpAndSideways(wrapper) {

3415 - wrapper.previousSibling_ = wrapper.previousSibling;

3416 - wrapper.nextSibling_ = wrapper.nextSibling;

3417 - wrapper.parentNode_ = wrapper.parentNode;

3418 - }

3419 - function updateWrapperDown(wrapper) {

3420 - wrapper.firstChild_ = wrapper.firstChild;

3421 - wrapper.lastChild_ = wrapper.lastChild;

3422 - }

3423 - function updateAllChildNodes(parentNodeWrapper) {

3424 - assert(parentNodeWrapper instanceof Node);

3425 - for (var childWrapper = parentNodeWrapper.firstChild; childWrapper; childWrapper = childWrapper.nextSibling) {

3426 - updateWrapperUpAndSideways(childWrapper);

3427 - }

3428 - updateWrapperDown(parentNodeWrapper);

3429 - }

3430 - function insertBefore(parentNodeWrapper, newChildWrapper, refChildWrapper) {

3431 - var parentNode = unwrap(parentNodeWrapper);

3432 - var newChild = unwrap(newChildWrapper);

3433 - var refChild = refChildWrapper ? unwrap(refChildWrapper) : null;

3434 - remove(newChildWrapper);

3435 - updateWrapperUpAndSideways(newChildWrapper);

3436 - if (!refChildWrapper) {

3437 - parentNodeWrapper.lastChild_ = parentNodeWrapper.lastChild;

3438 - if (parentNodeWrapper.lastChild === parentNodeWrapper.firstChild) parentNodeWrapper.firstChild_ = parentNodeWrapper.firstChild;

3439 - var lastChildWrapper = wrap(parentNode.lastChild);

3440 - if (lastChildWrapper) lastChildWrapper.nextSibling_ = lastChildWrapper.nextSibling;

3441 - } else {

3442 - if (parentNodeWrapper.firstChild === refChildWrapper) parentNodeWrapper.firstChild_ = refChildWrapper;

3443 - refChildWrapper.previousSibling_ = refChildWrapper.previousSibling;

3444 - }

3445 - scope.originalInsertBefore.call(parentNode, newChild, refChild);

3446 - }

3447 - function remove(nodeWrapper) {

3448 - var node = unwrap(nodeWrapper);

3449 - var parentNode = node.parentNode;

3450 - if (!parentNode) return;

3451 - var parentNodeWrapper = wrap(parentNode);

3452 - updateWrapperUpAndSideways(nodeWrapper);

3453 - if (nodeWrapper.previousSibling) nodeWrapper.previousSibling.nextSibling_ = nodeWrapper;

3454 - if (nodeWrapper.nextSibling) nodeWrapper.nextSibling.previousSibling_ = nodeWrapper;

3455 - if (parentNodeWrapper.lastChild === nodeWrapper) parentNodeWrapper.lastChild_ = nodeWrapper;

3456 - if (parentNodeWrapper.firstChild === nodeWrapper) parentNodeWrapper.firstChild_ = nodeWrapper;

3457 - scope.originalRemoveChild.call(parentNode, node);

3458 - }

3459 - var distributedNodesTable = new WeakMap();

3460 - var destinationInsertionPointsTable = new WeakMap();

3461 - var rendererForHostTable = new WeakMap();

3462 - function resetDistributedNodes(insertionPoint) {

3463 - distributedNodesTable.set(insertionPoint, []);

3464 - }

3465 - function getDistributedNodes(insertionPoint) {

3466 - var rv = distributedNodesTable.get(insertionPoint);

3467 - if (!rv) distributedNodesTable.set(insertionPoint, rv = []);

3468 - return rv;

3469 - }

3470 - function getChildNodesSnapshot(node) {

3471 - var result = [], i = 0;

3472 - for (var child = node.firstChild; child; child = child.nextSibling) {

3473 - result[i++] = child;

3474 - }

3475 - return result;

3476 - }

3477 - var request = oneOf(window, [ "requestAnimationFrame", "mozRequestAnimationFrame", "webkitRequestAnimationFrame", "setTimeout" ]);

3478 - var pendingDirtyRenderers = [];

3479 - var renderTimer;

3480 - function renderAllPending() {

3481 - for (var i = 0; i < pendingDirtyRenderers.length; i++) {

3482 - var renderer = pendingDirtyRenderers[i];

3483 - var parentRenderer = renderer.parentRenderer;

3484 - if (parentRenderer && parentRenderer.dirty) continue;

3485 - renderer.render();

3486 - }

3487 - pendingDirtyRenderers = [];

3488 - }

3489 - function handleRequestAnimationFrame() {

3490 - renderTimer = null;

3491 - renderAllPending();

3492 - }

3493 - function getRendererForHost(host) {

3494 - var renderer = rendererForHostTable.get(host);

3495 - if (!renderer) {

3496 - renderer = new ShadowRenderer(host);

3497 - rendererForHostTable.set(host, renderer);

3498 - }

3499 - return renderer;

3500 - }

3501 - function getShadowRootAncestor(node) {

3502 - var root = getTreeScope(node).root;

3503 - if (root instanceof ShadowRoot) return root;

3504 - return null;

3505 - }

3506 - function getRendererForShadowRoot(shadowRoot) {

3507 - return getRendererForHost(shadowRoot.host);

3508 - }

3509 - var spliceDiff = new ArraySplice();

3510 - spliceDiff.equals = function(renderNode, rawNode) {

3511 - return unwrap(renderNode.node) === rawNode;

3512 - };

3513 - function RenderNode(node) {

3514 - this.skip = false;

3515 - this.node = node;

3516 - this.childNodes = [];

3517 - }

3518 - RenderNode.prototype = {

3519 - append: function(node) {

3520 - var rv = new RenderNode(node);

3521 - this.childNodes.push(rv);

3522 - return rv;

3523 - },

3524 - sync: function(opt_added) {

3525 - if (this.skip) return;

3526 - var nodeWrapper = this.node;

3527 - var newChildren = this.childNodes;

3528 - var oldChildren = getChildNodesSnapshot(unwrap(nodeWrapper));

3529 - var added = opt_added || new WeakMap();

3530 - var splices = spliceDiff.calculateSplices(newChildren, oldChildren);

3531 - var newIndex = 0, oldIndex = 0;

3532 - var lastIndex = 0;

3533 - for (var i = 0; i < splices.length; i++) {

3534 - var splice = splices[i];

3535 - for (;lastIndex < splice.index; lastIndex++) {

3536 - oldIndex++;

3537 - newChildren[newIndex++].sync(added);

3538 - }

3539 - var removedCount = splice.removed.length;

3540 - for (var j = 0; j < removedCount; j++) {

3541 - var wrapper = wrap(oldChildren[oldIndex++]);

3542 - if (!added.get(wrapper)) remove(wrapper);

3543 - }

3544 - var addedCount = splice.addedCount;

3545 - var refNode = oldChildren[oldIndex] && wrap(oldChildren[oldIndex]);

3546 - for (var j = 0; j < addedCount; j++) {

3547 - var newChildRenderNode = newChildren[newIndex++];

3548 - var newChildWrapper = newChildRenderNode.node;

3549 - insertBefore(nodeWrapper, newChildWrapper, refNode);

3550 - added.set(newChildWrapper, true);

3551 - newChildRenderNode.sync(added);

3552 - }

3553 - lastIndex += addedCount;

3554 - }

3555 - for (var i = lastIndex; i < newChildren.length; i++) {

3556 - newChildren[i].sync(added);

3557 - }

3558 - }

3559 - };

3560 - function ShadowRenderer(host) {

3561 - this.host = host;

3562 - this.dirty = false;

3563 - this.invalidateAttributes();

3564 - this.associateNode(host);

3565 - }

3566 - ShadowRenderer.prototype = {

3567 - render: function(opt_renderNode) {

3568 - if (!this.dirty) return;

3569 - this.invalidateAttributes();

3570 - var host = this.host;

3571 - this.distribution(host);

3572 - var renderNode = opt_renderNode || new RenderNode(host);

3573 - this.buildRenderTree(renderNode, host);

3574 - var topMostRenderer = !opt_renderNode;

3575 - if (topMostRenderer) renderNode.sync();

3576 - this.dirty = false;

3577 - },

3578 - get parentRenderer() {

3579 - return getTreeScope(this.host).renderer;

3580 - },

3581 - invalidate: function() {

3582 - if (!this.dirty) {

3583 - this.dirty = true;

3584 - var parentRenderer = this.parentRenderer;

3585 - if (parentRenderer) parentRenderer.invalidate();

3586 - pendingDirtyRenderers.push(this);

3587 - if (renderTimer) return;

3588 - renderTimer = window[request](handleRequestAnimationFrame, 0);

3589 - }

3590 - },

3591 - distribution: function(root) {

3592 - this.resetAllSubtrees(root);

3593 - this.distributionResolution(root);

3594 - },

3595 - resetAll: function(node) {

3596 - if (isInsertionPoint(node)) resetDistributedNodes(node); else resetDestinationInsertionPoints(node);

3597 - this.resetAllSubtrees(node);

3598 - },

3599 - resetAllSubtrees: function(node) {

3600 - for (var child = node.firstChild; child; child = child.nextSibling) {

3601 - this.resetAll(child);

3602 - }

3603 - if (node.shadowRoot) this.resetAll(node.shadowRoot);

3604 - if (node.olderShadowRoot) this.resetAll(node.olderShadowRoot);

3605 - },

3606 - distributionResolution: function(node) {

3607 - if (isShadowHost(node)) {

3608 - var shadowHost = node;

3609 - var pool = poolPopulation(shadowHost);

3610 - var shadowTrees = getShadowTrees(shadowHost);

3611 - for (var i = 0; i < shadowTrees.length; i++) {

3612 - this.poolDistribution(shadowTrees[i], pool);

3613 - }

3614 - for (var i = shadowTrees.length - 1; i >= 0; i--) {

3615 - var shadowTree = shadowTrees[i];

3616 - var shadow = getShadowInsertionPoint(shadowTree);

3617 - if (shadow) {

3618 - var olderShadowRoot = shadowTree.olderShadowRoot;

3619 - if (olderShadowRoot) {

3620 - pool = poolPopulation(olderShadowRoot);

3621 - }

3622 - for (var j = 0; j < pool.length; j++) {

3623 - destributeNodeInto(pool[j], shadow);

3624 - }

3625 - }

3626 - this.distributionResolution(shadowTree);

3627 - }

3628 - }

3629 - for (var child = node.firstChild; child; child = child.nextSibling) {

3630 - this.distributionResolution(child);

3631 - }

3632 - },

3633 - poolDistribution: function(node, pool) {

3634 - if (node instanceof HTMLShadowElement) return;

3635 - if (node instanceof HTMLContentElement) {

3636 - var content = node;

3637 - this.updateDependentAttributes(content.getAttribute("select"));

3638 - var anyDistributed = false;

3639 - for (var i = 0; i < pool.length; i++) {

3640 - var node = pool[i];

3641 - if (!node) continue;

3642 - if (matches(node, content)) {

3643 - destributeNodeInto(node, content);

3644 - pool[i] = undefined;

3645 - anyDistributed = true;

3646 - }

3647 - }

3648 - if (!anyDistributed) {

3649 - for (var child = content.firstChild; child; child = child.nextSibling) {

3650 - destributeNodeInto(child, content);

3651 - }

3652 - }

3653 - return;

3654 - }

3655 - for (var child = node.firstChild; child; child = child.nextSibling) {

3656 - this.poolDistribution(child, pool);

3657 - }

3658 - },

3659 - buildRenderTree: function(renderNode, node) {

3660 - var children = this.compose(node);

3661 - for (var i = 0; i < children.length; i++) {

3662 - var child = children[i];

3663 - var childRenderNode = renderNode.append(child);

3664 - this.buildRenderTree(childRenderNode, child);

3665 - }

3666 - if (isShadowHost(node)) {

3667 - var renderer = getRendererForHost(node);

3668 - renderer.dirty = false;

3669 - }

3670 - },

3671 - compose: function(node) {

3672 - var children = [];

3673 - var p = node.shadowRoot || node;

3674 - for (var child = p.firstChild; child; child = child.nextSibling) {

3675 - if (isInsertionPoint(child)) {

3676 - this.associateNode(p);

3677 - var distributedNodes = getDistributedNodes(child);

3678 - for (var j = 0; j < distributedNodes.length; j++) {

3679 - var distributedNode = distributedNodes[j];

3680 - if (isFinalDestination(child, distributedNode)) children.push(distributedNode);

3681 - }

3682 - } else {

3683 - children.push(child);

3684 - }

3685 - }

3686 - return children;

3687 - },

3688 - invalidateAttributes: function() {

3689 - this.attributes = Object.create(null);

3690 - },

3691 - updateDependentAttributes: function(selector) {

3692 - if (!selector) return;

3693 - var attributes = this.attributes;

3694 - if (/\.\w+/.test(selector)) attributes["class"] = true;

3695 - if (/#\w+/.test(selector)) attributes["id"] = true;

3696 - selector.replace(/\[\s*([^\s=\|~\]]+)/g, function(_, name) {

3697 - attributes[name] = true;

3698 - });

3699 - },

3700 - dependsOnAttribute: function(name) {

3701 - return this.attributes[name];

3702 - },

3703 - associateNode: function(node) {

3704 - unsafeUnwrap(node).polymerShadowRenderer_ = this;

3705 - }

3706 - };

3707 - function poolPopulation(node) {

3708 - var pool = [];

3709 - for (var child = node.firstChild; child; child = child.nextSibling) {

3710 - if (isInsertionPoint(child)) {

3711 - pool.push.apply(pool, getDistributedNodes(child));

3712 - } else {

3713 - pool.push(child);

3714 - }

3715 - }

3716 - return pool;

3717 - }

3718 - function getShadowInsertionPoint(node) {

3719 - if (node instanceof HTMLShadowElement) return node;

3720 - if (node instanceof HTMLContentElement) return null;

3721 - for (var child = node.firstChild; child; child = child.nextSibling) {

3722 - var res = getShadowInsertionPoint(child);

3723 - if (res) return res;

3724 - }

3725 - return null;

3726 - }

3727 - function destributeNodeInto(child, insertionPoint) {

3728 - getDistributedNodes(insertionPoint).push(child);

3729 - var points = destinationInsertionPointsTable.get(child);

3730 - if (!points) destinationInsertionPointsTable.set(child, [ insertionPoint ]); else points.push(insertionPoint);

3731 - }

3732 - function getDestinationInsertionPoints(node) {

3733 - return destinationInsertionPointsTable.get(node);

3734 - }

3735 - function resetDestinationInsertionPoints(node) {

3736 - destinationInsertionPointsTable.set(node, undefined);

3737 - }

3738 - var selectorStartCharRe = /^(:not\()?[*.#[a-zA-Z_|]/;

3739 - function matches(node, contentElement) {

3740 - var select = contentElement.getAttribute("select");

3741 - if (!select) return true;

3742 - select = select.trim();

3743 - if (!select) return true;

3744 - if (!(node instanceof Element)) return false;

3745 - if (!selectorStartCharRe.test(select)) return false;

3746 - try {

3747 - return node.matches(select);

3748 - } catch (ex) {

3749 - return false;

3750 - }

3751 - }

3752 - function isFinalDestination(insertionPoint, node) {

3753 - var points = getDestinationInsertionPoints(node);

3754 - return points && points[points.length - 1] === insertionPoint;

3755 - }

3756 - function isInsertionPoint(node) {

3757 - return node instanceof HTMLContentElement || node instanceof HTMLShadowElement;

3758 - }

3759 - function isShadowHost(shadowHost) {

3760 - return shadowHost.shadowRoot;

3761 - }

3762 - function getShadowTrees(host) {

3763 - var trees = [];

3764 - for (var tree = host.shadowRoot; tree; tree = tree.olderShadowRoot) {

3765 - trees.push(tree);

3766 - }

3767 - return trees;

3768 - }

3769 - function render(host) {

3770 - new ShadowRenderer(host).render();

3771 - }

3772 - Node.prototype.invalidateShadowRenderer = function(force) {

3773 - var renderer = unsafeUnwrap(this).polymerShadowRenderer_;

3774 - if (renderer) {

3775 - renderer.invalidate();

3776 - return true;

3777 - }

3778 - return false;

3779 - };

3780 - HTMLContentElement.prototype.getDistributedNodes = HTMLShadowElement.prototype.getDistributedNodes = function() {

3781 - renderAllPending();

3782 - return getDistributedNodes(this);

3783 - };

3784 - Element.prototype.getDestinationInsertionPoints = function() {

3785 - renderAllPending();

3786 - return getDestinationInsertionPoints(this) || [];

3787 - };

3788 - HTMLContentElement.prototype.nodeIsInserted_ = HTMLShadowElement.prototype.nodeIsInserted_ = function() {

3789 - this.invalidateShadowRenderer();

3790 - var shadowRoot = getShadowRootAncestor(this);

3791 - var renderer;

3792 - if (shadowRoot) renderer = getRendererForShadowRoot(shadowRoot);

3793 - unsafeUnwrap(this).polymerShadowRenderer_ = renderer;

3794 - if (renderer) renderer.invalidate();

3795 - };

3796 - scope.getRendererForHost = getRendererForHost;

3797 - scope.getShadowTrees = getShadowTrees;

3798 - scope.renderAllPending = renderAllPending;

3799 - scope.getDestinationInsertionPoints = getDestinationInsertionPoints;

3800 - scope.visual = {

3801 - insertBefore: insertBefore,

3802 - remove: remove

3803 - };

3804 - })(window.ShadowDOMPolyfill);

3805 - (function(scope) {

3806 - "use strict";

3807 - var HTMLElement = scope.wrappers.HTMLElement;

3808 - var assert = scope.assert;

3809 - var mixin = scope.mixin;

3810 - var registerWrapper = scope.registerWrapper;

3811 - var unwrap = scope.unwrap;

3812 - var wrap = scope.wrap;

3813 - var elementsWithFormProperty = [ "HTMLButtonElement", "HTMLFieldSetElement", "HTMLInputElement", "HTMLKeygenElement", "HTMLLabelElement", "HTMLLegendElement", "HTMLObjectElement", "HTMLOutputElement", "HTMLTextAreaElement" ];

3814 - function createWrapperConstructor(name) {

3815 - if (!window[name]) return;

3816 - assert(!scope.wrappers[name]);

3817 - var GeneratedWrapper = function(node) {

3818 - HTMLElement.call(this, node);

3819 - };

3820 - GeneratedWrapper.prototype = Object.create(HTMLElement.prototype);

3821 - mixin(GeneratedWrapper.prototype, {

3822 - get form() {

3823 - return wrap(unwrap(this).form);

3824 - }

3825 - });

3826 - registerWrapper(window[name], GeneratedWrapper, document.createElement(name.slice(4, -7)));

3827 - scope.wrappers[name] = GeneratedWrapper;

3828 - }

3829 - elementsWithFormProperty.forEach(createWrapperConstructor);

3830 - })(window.ShadowDOMPolyfill);

3831 - (function(scope) {

3832 - "use strict";

3833 - var registerWrapper = scope.registerWrapper;

3834 - var setWrapper = scope.setWrapper;

3835 - var unsafeUnwrap = scope.unsafeUnwrap;

3836 - var unwrap = scope.unwrap;

3837 - var unwrapIfNeeded = scope.unwrapIfNeeded;

3838 - var wrap = scope.wrap;

3839 - var OriginalSelection = window.Selection;

3840 - function Selection(impl) {

3841 - setWrapper(impl, this);

3842 - }

3843 - Selection.prototype = {

3844 - get anchorNode() {

3845 - return wrap(unsafeUnwrap(this).anchorNode);

3846 - },

3847 - get focusNode() {

3848 - return wrap(unsafeUnwrap(this).focusNode);

3849 - },

3850 - addRange: function(range) {

3851 - unsafeUnwrap(this).addRange(unwrap(range));

3852 - },

3853 - collapse: function(node, index) {

3854 - unsafeUnwrap(this).collapse(unwrapIfNeeded(node), index);

3855 - },

3856 - containsNode: function(node, allowPartial) {

3857 - return unsafeUnwrap(this).containsNode(unwrapIfNeeded(node), allowPartial);

3858 - },

3859 - extend: function(node, offset) {

3860 - unsafeUnwrap(this).extend(unwrapIfNeeded(node), offset);

3861 - },

3862 - getRangeAt: function(index) {

3863 - return wrap(unsafeUnwrap(this).getRangeAt(index));

3864 - },

3865 - removeRange: function(range) {

3866 - unsafeUnwrap(this).removeRange(unwrap(range));

3867 - },

3868 - selectAllChildren: function(node) {

3869 - unsafeUnwrap(this).selectAllChildren(unwrapIfNeeded(node));

3870 - },

3871 - toString: function() {

3872 - return unsafeUnwrap(this).toString();

3873 - }

3874 - };

3875 - registerWrapper(window.Selection, Selection, window.getSelection());

3876 - scope.wrappers.Selection = Selection;

3877 - })(window.ShadowDOMPolyfill);

3878 - (function(scope) {

3879 - "use strict";

3880 - var GetElementsByInterface = scope.GetElementsByInterface;

3881 - var Node = scope.wrappers.Node;

3882 - var ParentNodeInterface = scope.ParentNodeInterface;

3883 - var Selection = scope.wrappers.Selection;

3884 - var SelectorsInterface = scope.SelectorsInterface;

3885 - var ShadowRoot = scope.wrappers.ShadowRoot;

3886 - var TreeScope = scope.TreeScope;

3887 - var cloneNode = scope.cloneNode;

3888 - var defineWrapGetter = scope.defineWrapGetter;

3889 - var elementFromPoint = scope.elementFromPoint;

3890 - var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;

3891 - var matchesNames = scope.matchesNames;

3892 - var mixin = scope.mixin;

3893 - var registerWrapper = scope.registerWrapper;

3894 - var renderAllPending = scope.renderAllPending;

3895 - var rewrap = scope.rewrap;

3896 - var setWrapper = scope.setWrapper;

3897 - var unsafeUnwrap = scope.unsafeUnwrap;

3898 - var unwrap = scope.unwrap;

3899 - var wrap = scope.wrap;

3900 - var wrapEventTargetMethods = scope.wrapEventTargetMethods;

3901 - var wrapNodeList = scope.wrapNodeList;

3902 - var implementationTable = new WeakMap();

3903 - function Document(node) {

3904 - Node.call(this, node);

3905 - this.treeScope_ = new TreeScope(this, null);

3906 - }

3907 - Document.prototype = Object.create(Node.prototype);

3908 - defineWrapGetter(Document, "documentElement");

3909 - defineWrapGetter(Document, "body");

3910 - defineWrapGetter(Document, "head");

3911 - function wrapMethod(name) {

3912 - var original = document[name];

3913 - Document.prototype[name] = function() {

3914 - return wrap(original.apply(unsafeUnwrap(this), arguments));

3915 - };

3916 - }

3917 - [ "createComment", "createDocumentFragment", "createElement", "createElementNS", "createEvent", "createEventNS", "createRange", "createTextNode", "getElementById" ].forEach(wrapMethod);

3918 - var originalAdoptNode = document.adoptNode;

3919 - function adoptNodeNoRemove(node, doc) {

3920 - originalAdoptNode.call(unsafeUnwrap(doc), unwrap(node));

3921 - adoptSubtree(node, doc);

3922 - }

3923 - function adoptSubtree(node, doc) {

3924 - if (node.shadowRoot) doc.adoptNode(node.shadowRoot);

3925 - if (node instanceof ShadowRoot) adoptOlderShadowRoots(node, doc);

3926 - for (var child = node.firstChild; child; child = child.nextSibling) {

3927 - adoptSubtree(child, doc);

3928 - }

3929 - }

3930 - function adoptOlderShadowRoots(shadowRoot, doc) {

3931 - var oldShadowRoot = shadowRoot.olderShadowRoot;

3932 - if (oldShadowRoot) doc.adoptNode(oldShadowRoot);

3933 - }

3934 - var originalGetSelection = document.getSelection;

3935 - mixin(Document.prototype, {

3936 - adoptNode: function(node) {

3937 - if (node.parentNode) node.parentNode.removeChild(node);

3938 - adoptNodeNoRemove(node, this);

3939 - return node;

3940 - },

3941 - elementFromPoint: function(x, y) {

3942 - return elementFromPoint(this, this, x, y);

3943 - },

3944 - importNode: function(node, deep) {

3945 - return cloneNode(node, deep, unsafeUnwrap(this));

3946 - },

3947 - getSelection: function() {

3948 - renderAllPending();

3949 - return new Selection(originalGetSelection.call(unwrap(this)));

3950 - },

3951 - getElementsByName: function(name) {

3952 - return SelectorsInterface.querySelectorAll.call(this, "[name=" + JSON.stringify(String(name)) + "]");

3953 - }

3954 - });

3955 - if (document.registerElement) {

3956 - var originalRegisterElement = document.registerElement;

3957 - Document.prototype.registerElement = function(tagName, object) {

3958 - var prototype, extendsOption;

3959 - if (object !== undefined) {

3960 - prototype = object.prototype;

3961 - extendsOption = object.extends;

3962 - }

3963 - if (!prototype) prototype = Object.create(HTMLElement.prototype);

3964 - if (scope.nativePrototypeTable.get(prototype)) {

3965 - throw new Error("NotSupportedError");

3966 - }

3967 - var proto = Object.getPrototypeOf(prototype);

3968 - var nativePrototype;

3969 - var prototypes = [];

3970 - while (proto) {

3971 - nativePrototype = scope.nativePrototypeTable.get(proto);

3972 - if (nativePrototype) break;

3973 - prototypes.push(proto);

3974 - proto = Object.getPrototypeOf(proto);

3975 - }

3976 - if (!nativePrototype) {

3977 - throw new Error("NotSupportedError");

3978 - }

3979 - var newPrototype = Object.create(nativePrototype);

3980 - for (var i = prototypes.length - 1; i >= 0; i--) {

3981 - newPrototype = Object.create(newPrototype);

3982 - }

3983 - [ "createdCallback", "attachedCallback", "detachedCallback", "attributeChangedCallback" ].forEach(function(name) {

3984 - var f = prototype[name];

3985 - if (!f) return;

3986 - newPrototype[name] = function() {

3987 - if (!(wrap(this) instanceof CustomElementConstructor)) {

3988 - rewrap(this);

3989 - }

3990 - f.apply(wrap(this), arguments);

3991 - };

3992 - });

3993 - var p = {

3994 - prototype: newPrototype

3995 - };

3996 - if (extendsOption) p.extends = extendsOption;

3997 - function CustomElementConstructor(node) {

3998 - if (!node) {

3999 - if (extendsOption) {

4000 - return document.createElement(extendsOption, tagName);

4001 - } else {

4002 - return document.createElement(tagName);

4003 - }

4004 - }

4005 - setWrapper(node, this);

4006 - }

4007 - CustomElementConstructor.prototype = prototype;

4008 - CustomElementConstructor.prototype.constructor = CustomElementConstructor;

4009 - scope.constructorTable.set(newPrototype, CustomElementConstructor);

4010 - scope.nativePrototypeTable.set(prototype, newPrototype);

4011 - var nativeConstructor = originalRegisterElement.call(unwrap(this), tagName, p);

4012 - return CustomElementConstructor;

4013 - };

4014 - forwardMethodsToWrapper([ window.HTMLDocument || window.Document ], [ "registerElement" ]);

4015 - }

4016 - forwardMethodsToWrapper([ window.HTMLBodyElement, window.HTMLDocument || window.Document, window.HTMLHeadElement, window.HTMLHtmlElement ], [ "appendChild", "compareDocumentPosition", "contains", "getElementsByClassName", "getElementsByTagName", "getElementsByTagNameNS", "insertBefore", "querySelector", "querySelectorAll", "removeChild", "replaceChild" ].concat(matchesNames));

4017 - forwardMethodsToWrapper([ window.HTMLDocument || window.Document ], [ "adoptNode", "importNode", "contains", "createComment", "createDocumentFragment", "createElement", "createElementNS", "createEvent", "createEventNS", "createRange", "createTextNode", "elementFromPoint", "getElementById", "getElementsByName", "getSelection" ]);

4018 - mixin(Document.prototype, GetElementsByInterface);

4019 - mixin(Document.prototype, ParentNodeInterface);

4020 - mixin(Document.prototype, SelectorsInterface);

4021 - mixin(Document.prototype, {

4022 - get implementation() {

4023 - var implementation = implementationTable.get(this);

4024 - if (implementation) return implementation;

4025 - implementation = new DOMImplementation(unwrap(this).implementation);

4026 - implementationTable.set(this, implementation);

4027 - return implementation;

4028 - },

4029 - get defaultView() {

4030 - return wrap(unwrap(this).defaultView);

4031 - }

4032 - });

4033 - registerWrapper(window.Document, Document, document.implementation.createHTMLDocument(""));

4034 - if (window.HTMLDocument) registerWrapper(window.HTMLDocument, Document);

4035 - wrapEventTargetMethods([ window.HTMLBodyElement, window.HTMLDocument || window.Document, window.HTMLHeadElement ]);

4036 - function DOMImplementation(impl) {

4037 - setWrapper(impl, this);

4038 - }

4039 - function wrapImplMethod(constructor, name) {

4040 - var original = document.implementation[name];

4041 - constructor.prototype[name] = function() {

4042 - return wrap(original.apply(unsafeUnwrap(this), arguments));

4043 - };

4044 - }

4045 - function forwardImplMethod(constructor, name) {

4046 - var original = document.implementation[name];

4047 - constructor.prototype[name] = function() {

4048 - return original.apply(unsafeUnwrap(this), arguments);

4049 - };

4050 - }

4051 - wrapImplMethod(DOMImplementation, "createDocumentType");

4052 - wrapImplMethod(DOMImplementation, "createDocument");

4053 - wrapImplMethod(DOMImplementation, "createHTMLDocument");

4054 - forwardImplMethod(DOMImplementation, "hasFeature");

4055 - registerWrapper(window.DOMImplementation, DOMImplementation);

4056 - forwardMethodsToWrapper([ window.DOMImplementation ], [ "createDocumentType", "createDocument", "createHTMLDocument", "hasFeature" ]);

4057 - scope.adoptNodeNoRemove = adoptNodeNoRemove;

4058 - scope.wrappers.DOMImplementation = DOMImplementation;

4059 - scope.wrappers.Document = Document;

4060 - })(window.ShadowDOMPolyfill);

4061 - (function(scope) {

4062 - "use strict";

4063 - var EventTarget = scope.wrappers.EventTarget;

4064 - var Selection = scope.wrappers.Selection;

4065 - var mixin = scope.mixin;

4066 - var registerWrapper = scope.registerWrapper;

4067 - var renderAllPending = scope.renderAllPending;

4068 - var unwrap = scope.unwrap;

4069 - var unwrapIfNeeded = scope.unwrapIfNeeded;

4070 - var wrap = scope.wrap;

4071 - var OriginalWindow = window.Window;

4072 - var originalGetComputedStyle = window.getComputedStyle;

4073 - var originalGetDefaultComputedStyle = window.getDefaultComputedStyle;

4074 - var originalGetSelection = window.getSelection;

4075 - function Window(impl) {

4076 - EventTarget.call(this, impl);

4077 - }

4078 - Window.prototype = Object.create(EventTarget.prototype);

4079 - OriginalWindow.prototype.getComputedStyle = function(el, pseudo) {

4080 - return wrap(this || window).getComputedStyle(unwrapIfNeeded(el), pseudo);

4081 - };

4082 - if (originalGetDefaultComputedStyle) {

4083 - OriginalWindow.prototype.getDefaultComputedStyle = function(el, pseudo) {

4084 - return wrap(this || window).getDefaultComputedStyle(unwrapIfNeeded(el), pseudo);

4085 - };

4086 - }

4087 - OriginalWindow.prototype.getSelection = function() {

4088 - return wrap(this || window).getSelection();

4089 - };

4090 - delete window.getComputedStyle;

4091 - delete window.getDefaultComputedStyle;

4092 - delete window.getSelection;

4093 - [ "addEventListener", "removeEventListener", "dispatchEvent" ].forEach(function(name) {

4094 - OriginalWindow.prototype[name] = function() {

4095 - var w = wrap(this || window);

4096 - return w[name].apply(w, arguments);

4097 - };

4098 - delete window[name];

4099 - });

4100 - mixin(Window.prototype, {

4101 - getComputedStyle: function(el, pseudo) {

4102 - renderAllPending();

4103 - return originalGetComputedStyle.call(unwrap(this), unwrapIfNeeded(el), pseudo);

4104 - },

4105 - getSelection: function() {

4106 - renderAllPending();

4107 - return new Selection(originalGetSelection.call(unwrap(this)));

4108 - },

4109 - get document() {

4110 - return wrap(unwrap(this).document);

4111 - }

4112 - });

4113 - if (originalGetDefaultComputedStyle) {

4114 - Window.prototype.getDefaultComputedStyle = function(el, pseudo) {

4115 - renderAllPending();

4116 - return originalGetDefaultComputedStyle.call(unwrap(this), unwrapIfNeeded(el), pseudo);

4117 - };

4118 - }

4119 - registerWrapper(OriginalWindow, Window, window);

4120 - scope.wrappers.Window = Window;

4121 - })(window.ShadowDOMPolyfill);

4122 - (function(scope) {

4123 - "use strict";

4124 - var unwrap = scope.unwrap;

4125 - var OriginalDataTransfer = window.DataTransfer || window.Clipboard;

4126 - var OriginalDataTransferSetDragImage = OriginalDataTransfer.prototype.setDragImage;

4127 - if (OriginalDataTransferSetDragImage) {

4128 - OriginalDataTransfer.prototype.setDragImage = function(image, x, y) {

4129 - OriginalDataTransferSetDragImage.call(this, unwrap(image), x, y);

4130 - };

4131 - }

4132 - })(window.ShadowDOMPolyfill);

4133 - (function(scope) {

4134 - "use strict";

4135 - var registerWrapper = scope.registerWrapper;

4136 - var setWrapper = scope.setWrapper;

4137 - var unwrap = scope.unwrap;

4138 - var OriginalFormData = window.FormData;

4139 - if (!OriginalFormData) return;

4140 - function FormData(formElement) {

4141 - var impl;

4142 - if (formElement instanceof OriginalFormData) {

4143 - impl = formElement;

4144 - } else {

4145 - impl = new OriginalFormData(formElement && unwrap(formElement));

4146 - }

4147 - setWrapper(impl, this);

4148 - }

4149 - registerWrapper(OriginalFormData, FormData, new OriginalFormData());

4150 - scope.wrappers.FormData = FormData;

4151 - })(window.ShadowDOMPolyfill);

4152 - (function(scope) {

4153 - "use strict";

4154 - var unwrapIfNeeded = scope.unwrapIfNeeded;

4155 - var originalSend = XMLHttpRequest.prototype.send;

4156 - XMLHttpRequest.prototype.send = function(obj) {

4157 - return originalSend.call(this, unwrapIfNeeded(obj));

4158 - };

4159 - })(window.ShadowDOMPolyfill);

4160 - (function(scope) {

4161 - "use strict";

4162 - var isWrapperFor = scope.isWrapperFor;

4163 - var elements = {

4164 - a: "HTMLAnchorElement",

4165 - area: "HTMLAreaElement",

4166 - audio: "HTMLAudioElement",

4167 - base: "HTMLBaseElement",

4168 - body: "HTMLBodyElement",

4169 - br: "HTMLBRElement",

4170 - button: "HTMLButtonElement",

4171 - canvas: "HTMLCanvasElement",

4172 - caption: "HTMLTableCaptionElement",

4173 - col: "HTMLTableColElement",

4174 - content: "HTMLContentElement",

4175 - data: "HTMLDataElement",

4176 - datalist: "HTMLDataListElement",

4177 - del: "HTMLModElement",

4178 - dir: "HTMLDirectoryElement",

4179 - div: "HTMLDivElement",

4180 - dl: "HTMLDListElement",

4181 - embed: "HTMLEmbedElement",

4182 - fieldset: "HTMLFieldSetElement",

4183 - font: "HTMLFontElement",

4184 - form: "HTMLFormElement",

4185 - frame: "HTMLFrameElement",

4186 - frameset: "HTMLFrameSetElement",

4187 - h1: "HTMLHeadingElement",

4188 - head: "HTMLHeadElement",

4189 - hr: "HTMLHRElement",

4190 - html: "HTMLHtmlElement",

4191 - iframe: "HTMLIFrameElement",

4192 - img: "HTMLImageElement",

4193 - input: "HTMLInputElement",

4194 - keygen: "HTMLKeygenElement",

4195 - label: "HTMLLabelElement",

4196 - legend: "HTMLLegendElement",

4197 - li: "HTMLLIElement",

4198 - link: "HTMLLinkElement",

4199 - map: "HTMLMapElement",

4200 - marquee: "HTMLMarqueeElement",

4201 - menu: "HTMLMenuElement",

4202 - menuitem: "HTMLMenuItemElement",

4203 - meta: "HTMLMetaElement",

4204 - meter: "HTMLMeterElement",

4205 - object: "HTMLObjectElement",

4206 - ol: "HTMLOListElement",

4207 - optgroup: "HTMLOptGroupElement",

4208 - option: "HTMLOptionElement",

4209 - output: "HTMLOutputElement",

4210 - p: "HTMLParagraphElement",

4211 - param: "HTMLParamElement",

4212 - pre: "HTMLPreElement",

4213 - progress: "HTMLProgressElement",

4214 - q: "HTMLQuoteElement",

4215 - script: "HTMLScriptElement",

4216 - select: "HTMLSelectElement",

4217 - shadow: "HTMLShadowElement",

4218 - source: "HTMLSourceElement",

4219 - span: "HTMLSpanElement",

4220 - style: "HTMLStyleElement",

4221 - table: "HTMLTableElement",

4222 - tbody: "HTMLTableSectionElement",

4223 - template: "HTMLTemplateElement",

4224 - textarea: "HTMLTextAreaElement",

4225 - thead: "HTMLTableSectionElement",

4226 - time: "HTMLTimeElement",

4227 - title: "HTMLTitleElement",

4228 - tr: "HTMLTableRowElement",

4229 - track: "HTMLTrackElement",

4230 - ul: "HTMLUListElement",

4231 - video: "HTMLVideoElement"

4232 - };

4233 - function overrideConstructor(tagName) {

4234 - var nativeConstructorName = elements[tagName];

4235 - var nativeConstructor = window[nativeConstructorName];

4236 - if (!nativeConstructor) return;

4237 - var element = document.createElement(tagName);

4238 - var wrapperConstructor = element.constructor;

4239 - window[nativeConstructorName] = wrapperConstructor;

4240 - }

4241 - Object.keys(elements).forEach(overrideConstructor);

4242 - Object.getOwnPropertyNames(scope.wrappers).forEach(function(name) {

4243 - window[name] = scope.wrappers[name];

4244 - });

4245 - })(window.ShadowDOMPolyfill);

4246 - (function(scope) {

4247 - var ShadowCSS = {

4248 - strictStyling: false,

4249 - registry: {},

4250 - shimStyling: function(root, name, extendsName) {

4251 - var scopeStyles = this.prepareRoot(root, name, extendsName);

4252 - var typeExtension = this.isTypeExtension(extendsName);

4253 - var scopeSelector = this.makeScopeSelector(name, typeExtension);

4254 - var cssText = stylesToCssText(scopeStyles, true);

4255 - cssText = this.scopeCssText(cssText, scopeSelector);

4256 - if (root) {

4257 - root.shimmedStyle = cssText;

4258 - }

4259 - this.addCssToDocument(cssText, name);

4260 - },

4261 - shimStyle: function(style, selector) {

4262 - return this.shimCssText(style.textContent, selector);

4263 - },

4264 - shimCssText: function(cssText, selector) {

4265 - cssText = this.insertDirectives(cssText);

4266 - return this.scopeCssText(cssText, selector);

4267 - },

4268 - makeScopeSelector: function(name, typeExtension) {

4269 - if (name) {

4270 - return typeExtension ? "[is=" + name + "]" : name;

4271 - }

4272 - return "";

4273 - },

4274 - isTypeExtension: function(extendsName) {

4275 - return extendsName && extendsName.indexOf("-") < 0;

4276 - },

4277 - prepareRoot: function(root, name, extendsName) {

4278 - var def = this.registerRoot(root, name, extendsName);

4279 - this.replaceTextInStyles(def.rootStyles, this.insertDirectives);

4280 - this.removeStyles(root, def.rootStyles);

4281 - if (this.strictStyling) {

4282 - this.applyScopeToContent(root, name);

4283 - }

4284 - return def.scopeStyles;

4285 - },

4286 - removeStyles: function(root, styles) {

4287 - for (var i = 0, l = styles.length, s; i < l && (s = styles[i]); i++) {

4288 - s.parentNode.removeChild(s);

4289 - }

4290 - },

4291 - registerRoot: function(root, name, extendsName) {

4292 - var def = this.registry[name] = {

4293 - root: root,

4294 - name: name,

4295 - extendsName: extendsName

4296 - };

4297 - var styles = this.findStyles(root);

4298 - def.rootStyles = styles;

4299 - def.scopeStyles = def.rootStyles;

4300 - var extendee = this.registry[def.extendsName];

4301 - if (extendee) {

4302 - def.scopeStyles = extendee.scopeStyles.concat(def.scopeStyles);

4303 - }

4304 - return def;

4305 - },

4306 - findStyles: function(root) {

4307 - if (!root) {

4308 - return [];

4309 - }

4310 - var styles = root.querySelectorAll("style");

4311 - return Array.prototype.filter.call(styles, function(s) {

4312 - return !s.hasAttribute(NO_SHIM_ATTRIBUTE);

4313 - });

4314 - },

4315 - applyScopeToContent: function(root, name) {

4316 - if (root) {

4317 - Array.prototype.forEach.call(root.querySelectorAll("*"), function(node) {

4318 - node.setAttribute(name, "");

4319 - });

4320 - Array.prototype.forEach.call(root.querySelectorAll("template"), function(template) {

4321 - this.applyScopeToContent(template.content, name);

4322 - }, this);

4323 - }

4324 - },

4325 - insertDirectives: function(cssText) {

4326 - cssText = this.insertPolyfillDirectivesInCssText(cssText);

4327 - return this.insertPolyfillRulesInCssText(cssText);

4328 - },

4329 - insertPolyfillDirectivesInCssText: function(cssText) {

4330 - cssText = cssText.replace(cssCommentNextSelectorRe, function(match, p1) {

4331 - return p1.slice(0, -2) + "{";

4332 - });

4333 - return cssText.replace(cssContentNextSelectorRe, function(match, p1) {

4334 - return p1 + " {";

4335 - });

4336 - },

4337 - insertPolyfillRulesInCssText: function(cssText) {

4338 - cssText = cssText.replace(cssCommentRuleRe, function(match, p1) {

4339 - return p1.slice(0, -1);

4340 - });

4341 - return cssText.replace(cssContentRuleRe, function(match, p1, p2, p3) {

4342 - var rule = match.replace(p1, "").replace(p2, "");

4343 - return p3 + rule;

4344 - });

4345 - },

4346 - scopeCssText: function(cssText, scopeSelector) {

4347 - var unscoped = this.extractUnscopedRulesFromCssText(cssText);

4348 - cssText = this.insertPolyfillHostInCssText(cssText);

4349 - cssText = this.convertColonHost(cssText);

4350 - cssText = this.convertColonHostContext(cssText);

4351 - cssText = this.convertShadowDOMSelectors(cssText);

4352 - if (scopeSelector) {

4353 - var self = this, cssText;

4354 - withCssRules(cssText, function(rules) {

4355 - cssText = self.scopeRules(rules, scopeSelector);

4356 - });

4357 - }

4358 - cssText = cssText + "\n" + unscoped;

4359 - return cssText.trim();

4360 - },

4361 - extractUnscopedRulesFromCssText: function(cssText) {

4362 - var r = "", m;

4363 - while (m = cssCommentUnscopedRuleRe.exec(cssText)) {

4364 - r += m[1].slice(0, -1) + "\n\n";

4365 - }

4366 - while (m = cssContentUnscopedRuleRe.exec(cssText)) {

4367 - r += m[0].replace(m[2], "").replace(m[1], m[3]) + "\n\n";

4368 - }

4369 - return r;

4370 - },

4371 - convertColonHost: function(cssText) {

4372 - return this.convertColonRule(cssText, cssColonHostRe, this.colonHostPartReplacer);

4373 - },

4374 - convertColonHostContext: function(cssText) {

4375 - return this.convertColonRule(cssText, cssColonHostContextRe, this.colonHostContextPartReplacer);

4376 - },

4377 - convertColonRule: function(cssText, regExp, partReplacer) {

4378 - return cssText.replace(regExp, function(m, p1, p2, p3) {

4379 - p1 = polyfillHostNoCombinator;

4380 - if (p2) {

4381 - var parts = p2.split(","), r = [];

4382 - for (var i = 0, l = parts.length, p; i < l && (p = parts[i]); i++) {

4383 - p = p.trim();

4384 - r.push(partReplacer(p1, p, p3));

4385 - }

4386 - return r.join(",");

4387 - } else {

4388 - return p1 + p3;

4389 - }

4390 - });

4391 - },

4392 - colonHostContextPartReplacer: function(host, part, suffix) {

4393 - if (part.match(polyfillHost)) {

4394 - return this.colonHostPartReplacer(host, part, suffix);

4395 - } else {

4396 - return host + part + suffix + ", " + part + " " + host + suffix;

4397 - }

4398 - },

4399 - colonHostPartReplacer: function(host, part, suffix) {

4400 - return host + part.replace(polyfillHost, "") + suffix;

4401 - },

4402 - convertShadowDOMSelectors: function(cssText) {

4403 - for (var i = 0; i < shadowDOMSelectorsRe.length; i++) {

4404 - cssText = cssText.replace(shadowDOMSelectorsRe[i], " ");

4405 - }

4406 - return cssText;

4407 - },

4408 - scopeRules: function(cssRules, scopeSelector) {

4409 - var cssText = "";

4410 - if (cssRules) {

4411 - Array.prototype.forEach.call(cssRules, function(rule) {

4412 - if (rule.selectorText && (rule.style && rule.style.cssText !== undefined)) {

4413 - cssText += this.scopeSelector(rule.selectorText, scopeSelector, this.strictStyling) + " {\n ";

4414 - cssText += this.propertiesFromRule(rule) + "\n}\n\n";

4415 - } else if (rule.type === CSSRule.MEDIA_RULE) {

4416 - cssText += "@media " + rule.media.mediaText + " {\n";

4417 - cssText += this.scopeRules(rule.cssRules, scopeSelector);

4418 - cssText += "\n}\n\n";

4419 - } else {

4420 - try {

4421 - if (rule.cssText) {

4422 - cssText += rule.cssText + "\n\n";

4423 - }

4424 - } catch (x) {

4425 - if (rule.type === CSSRule.KEYFRAMES_RULE && rule.cssRules) {

4426 - cssText += this.ieSafeCssTextFromKeyFrameRule(rule);

4427 - }

4428 - }

4429 - }

4430 - }, this);

4431 - }

4432 - return cssText;

4433 - },

4434 - ieSafeCssTextFromKeyFrameRule: function(rule) {

4435 - var cssText = "@keyframes " + rule.name + " {";

4436 - Array.prototype.forEach.call(rule.cssRules, function(rule) {

4437 - cssText += " " + rule.keyText + " {" + rule.style.cssText + "}";

4438 - });

4439 - cssText += " }";

4440 - return cssText;

4441 - },

4442 - scopeSelector: function(selector, scopeSelector, strict) {

4443 - var r = [], parts = selector.split(",");

4444 - parts.forEach(function(p) {

4445 - p = p.trim();

4446 - if (this.selectorNeedsScoping(p, scopeSelector)) {

4447 - p = strict && !p.match(polyfillHostNoCombinator) ? this.applyStrictSelectorScope(p, scopeSelector) : this.applySelectorScope(p, scopeSelector);

4448 - }

4449 - r.push(p);

4450 - }, this);

4451 - return r.join(", ");

4452 - },

4453 - selectorNeedsScoping: function(selector, scopeSelector) {

4454 - if (Array.isArray(scopeSelector)) {

4455 - return true;

4456 - }

4457 - var re = this.makeScopeMatcher(scopeSelector);

4458 - return !selector.match(re);

4459 - },

4460 - makeScopeMatcher: function(scopeSelector) {

4461 - scopeSelector = scopeSelector.replace(/\[/g, "\\[").replace(/\[/g, "\\]");

4462 - return new RegExp("^(" + scopeSelector + ")" + selectorReSuffix, "m");

4463 - },

4464 - applySelectorScope: function(selector, selectorScope) {

4465 - return Array.isArray(selectorScope) ? this.applySelectorScopeList(selector, selectorScope) : this.applySimpleSelectorScope(selector, selectorScope);

4466 - },

4467 - applySelectorScopeList: function(selector, scopeSelectorList) {

4468 - var r = [];

4469 - for (var i = 0, s; s = scopeSelectorList[i]; i++) {

4470 - r.push(this.applySimpleSelectorScope(selector, s));

4471 - }

4472 - return r.join(", ");

4473 - },

4474 - applySimpleSelectorScope: function(selector, scopeSelector) {

4475 - if (selector.match(polyfillHostRe)) {

4476 - selector = selector.replace(polyfillHostNoCombinator, scopeSelector);

4477 - return selector.replace(polyfillHostRe, scopeSelector + " ");

4478 - } else {

4479 - return scopeSelector + " " + selector;

4480 - }

4481 - },

4482 - applyStrictSelectorScope: function(selector, scopeSelector) {

4483 - scopeSelector = scopeSelector.replace(/\[is=([^\]]*)\]/g, "$1");

4484 - var splits = [ " ", ">", "+", "~" ], scoped = selector, attrName = "[" + scopeSelector + "]";

4485 - splits.forEach(function(sep) {

4486 - var parts = scoped.split(sep);

4487 - scoped = parts.map(function(p) {

4488 - var t = p.trim().replace(polyfillHostRe, "");

4489 - if (t && splits.indexOf(t) < 0 && t.indexOf(attrName) < 0) {

4490 - p = t.replace(/([^:]*)(:*)(.*)/, "$1" + attrName + "$2$3");

4491 - }

4492 - return p;

4493 - }).join(sep);

4494 - });

4495 - return scoped;

4496 - },

4497 - insertPolyfillHostInCssText: function(selector) {

4498 - return selector.replace(colonHostContextRe, polyfillHostContext).replace(colonHostRe, polyfillHost);

4499 - },

4500 - propertiesFromRule: function(rule) {

4501 - var cssText = rule.style.cssText;

4502 - if (rule.style.content && !rule.style.content.match(/['"]+|attr/)) {

4503 - cssText = cssText.replace(/content:[^;]*;/g, "content: '" + rule.style.content + "';");

4504 - }

4505 - var style = rule.style;

4506 - for (var i in style) {

4507 - if (style[i] === "initial") {

4508 - cssText += i + ": initial; ";

4509 - }

4510 - }

4511 - return cssText;

4512 - },

4513 - replaceTextInStyles: function(styles, action) {

4514 - if (styles && action) {

4515 - if (!(styles instanceof Array)) {

4516 - styles = [ styles ];

4517 - }

4518 - Array.prototype.forEach.call(styles, function(s) {

4519 - s.textContent = action.call(this, s.textContent);

4520 - }, this);

4521 - }

4522 - },

4523 - addCssToDocument: function(cssText, name) {

4524 - if (cssText.match("@import")) {

4525 - addOwnSheet(cssText, name);

4526 - } else {

4527 - addCssToDocument(cssText);

4528 - }

4529 - }

4530 - };

4531 - var selectorRe = /([^{]*)({[\s\S]*?})/gim, cssCommentRe = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim, cssCommentNextSelectorRe = /\/\*\s*@polyfill ([^*]*\*+([^/*][^*]*\*+)*\/)([^{]*?){/gim, cssContentNextSelectorRe = /polyfill-next-selector[^}]*content\:[\s]*?['"](.*?)['"][;\s]*}([^{]*?){/gim, cssCommentRuleRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim, cssContentRuleRe = /(polyfill-rule)[^}]*(content\:[\s]*['"](.*?)['"])[;\s]*[^}]*}/gim, cssCommentUnscopedRuleRe = /\/\*\s@polyfill-unscoped-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim, cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content\:[\s]*['"](.*?)['"])[;\s]*[^}]*}/gim, cssPseudoRe = /::(x-[^\s{,(]*)/gim, cssPartRe = /::part$([^)]*)$/gim, polyfillHost = "-shadowcsshost", polyfillHostContext = "-shadowcsscontext", parenSuffix = ")(?:\$(" + "(?:\\([^)(]*\$|[^)(]*)+?" + ")\\))?([^,{]*)";

4532 - var cssColonHostRe = new RegExp("(" + polyfillHost + parenSuffix, "gim"), cssColonHostContextRe = new RegExp("(" + polyfillHostContext + parenSuffix, "gim"), selectorReSuffix = "([>\\s~+[.,{:][\\s\\S]*)?$", colonHostRe = /\:host/gim, colonHostContextRe = /\:host-context/gim, polyfillHostNoCombinator = polyfillHost + "-no-combinator", polyfillHostRe = new RegExp(polyfillHost, "gim"), polyfillHostContextRe = new RegExp(polyfillHostContext, "gim"), shadowDOMSelectorsRe = [ /\^\^/g, /\^/g, /\/shadow\//g, /\/shadow-deep\//g, /::shadow/g, /\/deep\//g, /::content/g ];

4533 - function stylesToCssText(styles, preserveComments) {

4534 - var cssText = "";

4535 - Array.prototype.forEach.call(styles, function(s) {

4536 - cssText += s.textContent + "\n\n";

4537 - });

4538 - if (!preserveComments) {

4539 - cssText = cssText.replace(cssCommentRe, "");

4540 - }

4541 - return cssText;

4542 - }

4543 - function cssTextToStyle(cssText) {

4544 - var style = document.createElement("style");

4545 - style.textContent = cssText;

4546 - return style;

4547 - }

4548 - function cssToRules(cssText) {

4549 - var style = cssTextToStyle(cssText);

4550 - document.head.appendChild(style);

4551 - var rules = [];

4552 - if (style.sheet) {

4553 - try {

4554 - rules = style.sheet.cssRules;

4555 - } catch (e) {}

4556 - } else {

4557 - console.warn("sheet not found", style);

4558 - }

4559 - style.parentNode.removeChild(style);

4560 - return rules;

4561 - }

4562 - var frame = document.createElement("iframe");

4563 - frame.style.display = "none";

4564 - function initFrame() {

4565 - frame.initialized = true;

4566 - document.body.appendChild(frame);

4567 - var doc = frame.contentDocument;

4568 - var base = doc.createElement("base");

4569 - base.href = document.baseURI;

4570 - doc.head.appendChild(base);

4571 - }

4572 - function inFrame(fn) {

4573 - if (!frame.initialized) {

4574 - initFrame();

4575 - }

4576 - document.body.appendChild(frame);

4577 - fn(frame.contentDocument);

4578 - document.body.removeChild(frame);

4579 - }

4580 - var isChrome = navigator.userAgent.match("Chrome");

4581 - function withCssRules(cssText, callback) {

4582 - if (!callback) {

4583 - return;

4584 - }

4585 - var rules;

4586 - if (cssText.match("@import") && isChrome) {

4587 - var style = cssTextToStyle(cssText);

4588 - inFrame(function(doc) {

4589 - doc.head.appendChild(style.impl);

4590 - rules = Array.prototype.slice.call(style.sheet.cssRules, 0);

4591 - callback(rules);

4592 - });

4593 - } else {

4594 - rules = cssToRules(cssText);

4595 - callback(rules);

4596 - }

4597 - }

4598 - function rulesToCss(cssRules) {

4599 - for (var i = 0, css = []; i < cssRules.length; i++) {

4600 - css.push(cssRules[i].cssText);

4601 - }

4602 - return css.join("\n\n");

4603 - }

4604 - function addCssToDocument(cssText) {

4605 - if (cssText) {

4606 - getSheet().appendChild(document.createTextNode(cssText));

4607 - }

4608 - }

4609 - function addOwnSheet(cssText, name) {

4610 - var style = cssTextToStyle(cssText);

4611 - style.setAttribute(name, "");

4612 - style.setAttribute(SHIMMED_ATTRIBUTE, "");

4613 - document.head.appendChild(style);

4614 - }

4615 - var SHIM_ATTRIBUTE = "shim-shadowdom";

4616 - var SHIMMED_ATTRIBUTE = "shim-shadowdom-css";

4617 - var NO_SHIM_ATTRIBUTE = "no-shim";

4618 - var sheet;

4619 - function getSheet() {

4620 - if (!sheet) {

4621 - sheet = document.createElement("style");

4622 - sheet.setAttribute(SHIMMED_ATTRIBUTE, "");

4623 - sheet[SHIMMED_ATTRIBUTE] = true;

4624 - }

4625 - return sheet;

4626 - }

4627 - if (window.ShadowDOMPolyfill) {

4628 - addCssToDocument("style { display: none !important; }\n");

4629 - var doc = ShadowDOMPolyfill.wrap(document);

4630 - var head = doc.querySelector("head");

4631 - head.insertBefore(getSheet(), head.childNodes[0]);

4632 - document.addEventListener("DOMContentLoaded", function() {

4633 - var urlResolver = scope.urlResolver;

4634 - if (window.HTMLImports && !HTMLImports.useNative) {

4635 - var SHIM_SHEET_SELECTOR = "link[rel=stylesheet]" + "[" + SHIM_ATTRIBUTE + "]";

4636 - var SHIM_STYLE_SELECTOR = "style[" + SHIM_ATTRIBUTE + "]";

4637 - HTMLImports.importer.documentPreloadSelectors += "," + SHIM_SHEET_SELECTOR;

4638 - HTMLImports.importer.importsPreloadSelectors += "," + SHIM_SHEET_SELECTOR;

4639 - HTMLImports.parser.documentSelectors = [ HTMLImports.parser.documentSelectors, SHIM_SHEET_SELECTOR, SHIM_STYLE_SELECTOR ].join(",");

4640 - var originalParseGeneric = HTMLImports.parser.parseGeneric;

4641 - HTMLImports.parser.parseGeneric = function(elt) {

4642 - if (elt[SHIMMED_ATTRIBUTE]) {

4643 - return;

4644 - }

4645 - var style = elt.__importElement || elt;

4646 - if (!style.hasAttribute(SHIM_ATTRIBUTE)) {

4647 - originalParseGeneric.call(this, elt);

4648 - return;

4649 - }

4650 - if (elt.__resource) {

4651 - style = elt.ownerDocument.createElement("style");

4652 - style.textContent = elt.__resource;

4653 - }

4654 - HTMLImports.path.resolveUrlsInStyle(style);

4655 - style.textContent = ShadowCSS.shimStyle(style);

4656 - style.removeAttribute(SHIM_ATTRIBUTE, "");

4657 - style.setAttribute(SHIMMED_ATTRIBUTE, "");

4658 - style[SHIMMED_ATTRIBUTE] = true;

4659 - if (style.parentNode !== head) {

4660 - if (elt.parentNode === head) {

4661 - head.replaceChild(style, elt);

4662 - } else {

4663 - this.addElementToDocument(style);

4664 - }

4665 - }

4666 - style.__importParsed = true;

4667 - this.markParsingComplete(elt);

4668 - this.parseNext();

4669 - };

4670 - var hasResource = HTMLImports.parser.hasResource;

4671 - HTMLImports.parser.hasResource = function(node) {

4672 - if (node.localName === "link" && node.rel === "stylesheet" && node.hasAttribute(SHIM_ATTRIBUTE)) {

4673 - return node.__resource;

4674 - } else {

4675 - return hasResource.call(this, node);

4676 - }

4677 - };

4678 - }

4679 - });

4680 - }

4681 - scope.ShadowCSS = ShadowCSS;

4682 - })(window.WebComponents);

4683 -}

4684 -

4685 -(function(scope) {

4686 - if (window.ShadowDOMPolyfill) {

4687 - window.wrap = ShadowDOMPolyfill.wrapIfNeeded;

4688 - window.unwrap = ShadowDOMPolyfill.unwrapIfNeeded;

4689 - } else {

4690 - window.wrap = window.unwrap = function(n) {

4691 - return n;

4692 - };

4693 - }

4694 -})(window.WebComponents);

4695 -

4696 -(function(global) {

4697 - var registrationsTable = new WeakMap();

4698 - var setImmediate;

4699 - if (/Trident/.test(navigator.userAgent)) {

4700 - setImmediate = setTimeout;

4701 - } else if (window.setImmediate) {

4702 - setImmediate = window.setImmediate;

4703 - } else {

4704 - var setImmediateQueue = [];

4705 - var sentinel = String(Math.random());

4706 - window.addEventListener("message", function(e) {

4707 - if (e.data === sentinel) {

4708 - var queue = setImmediateQueue;

4709 - setImmediateQueue = [];

4710 - queue.forEach(function(func) {

4711 - func();

4712 - });

4713 - }

4714 - });

4715 - setImmediate = function(func) {

4716 - setImmediateQueue.push(func);

4717 - window.postMessage(sentinel, "*");

4718 - };

4719 - }

4720 - var isScheduled = false;

4721 - var scheduledObservers = [];

4722 - function scheduleCallback(observer) {

4723 - scheduledObservers.push(observer);

4724 - if (!isScheduled) {

4725 - isScheduled = true;

4726 - setImmediate(dispatchCallbacks);

4727 - }

4728 - }

4729 - function wrapIfNeeded(node) {

4730 - return window.ShadowDOMPolyfill && window.ShadowDOMPolyfill.wrapIfNeeded(node) || node;

4731 - }

4732 - function dispatchCallbacks() {

4733 - isScheduled = false;

4734 - var observers = scheduledObservers;

4735 - scheduledObservers = [];

4736 - observers.sort(function(o1, o2) {

4737 - return o1.uid_ - o2.uid_;

4738 - });

4739 - var anyNonEmpty = false;

4740 - observers.forEach(function(observer) {

4741 - var queue = observer.takeRecords();

4742 - removeTransientObserversFor(observer);

4743 - if (queue.length) {

4744 - observer.callback_(queue, observer);

4745 - anyNonEmpty = true;

4746 - }

4747 - });

4748 - if (anyNonEmpty) dispatchCallbacks();

4749 - }

4750 - function removeTransientObserversFor(observer) {

4751 - observer.nodes_.forEach(function(node) {

4752 - var registrations = registrationsTable.get(node);

4753 - if (!registrations) return;

4754 - registrations.forEach(function(registration) {

4755 - if (registration.observer === observer) registration.removeTransientObservers();

4756 - });

4757 - });

4758 - }

4759 - function forEachAncestorAndObserverEnqueueRecord(target, callback) {

4760 - for (var node = target; node; node = node.parentNode) {

4761 - var registrations = registrationsTable.get(node);

4762 - if (registrations) {

4763 - for (var j = 0; j < registrations.length; j++) {

4764 - var registration = registrations[j];

4765 - var options = registration.options;

4766 - if (node !== target && !options.subtree) continue;

4767 - var record = callback(options);

4768 - if (record) registration.enqueue(record);

4769 - }

4770 - }

4771 - }

4772 - }

4773 - var uidCounter = 0;

4774 - function JsMutationObserver(callback) {

4775 - this.callback_ = callback;

4776 - this.nodes_ = [];

4777 - this.records_ = [];

4778 - this.uid_ = ++uidCounter;

4779 - }

4780 - JsMutationObserver.prototype = {

4781 - observe: function(target, options) {

4782 - target = wrapIfNeeded(target);

4783 - if (!options.childList && !options.attributes && !options.characterData || options.attributeOldValue && !options.attributes || options.attributeFilter && options.attributeFilter.length && !options.attributes || options.characterDataOldValue && !options.characterData) {

4784 - throw new SyntaxError();

4785 - }

4786 - var registrations = registrationsTable.get(target);

4787 - if (!registrations) registrationsTable.set(target, registrations = []);

4788 - var registration;

4789 - for (var i = 0; i < registrations.length; i++) {

4790 - if (registrations[i].observer === this) {

4791 - registration = registrations[i];

4792 - registration.removeListeners();

4793 - registration.options = options;

4794 - break;

4795 - }

4796 - }

4797 - if (!registration) {

4798 - registration = new Registration(this, target, options);

4799 - registrations.push(registration);

4800 - this.nodes_.push(target);

4801 - }

4802 - registration.addListeners();

4803 - },

4804 - disconnect: function() {

4805 - this.nodes_.forEach(function(node) {

4806 - var registrations = registrationsTable.get(node);

4807 - for (var i = 0; i < registrations.length; i++) {

4808 - var registration = registrations[i];

4809 - if (registration.observer === this) {

4810 - registration.removeListeners();

4811 - registrations.splice(i, 1);

4812 - break;

4813 - }

4814 - }

4815 - }, this);

4816 - this.records_ = [];

4817 - },

4818 - takeRecords: function() {

4819 - var copyOfRecords = this.records_;

4820 - this.records_ = [];

4821 - return copyOfRecords;

4822 - }

4823 - };

4824 - function MutationRecord(type, target) {

4825 - this.type = type;

4826 - this.target = target;

4827 - this.addedNodes = [];

4828 - this.removedNodes = [];

4829 - this.previousSibling = null;

4830 - this.nextSibling = null;

4831 - this.attributeName = null;

4832 - this.attributeNamespace = null;

4833 - this.oldValue = null;

4834 - }

4835 - function copyMutationRecord(original) {

4836 - var record = new MutationRecord(original.type, original.target);

4837 - record.addedNodes = original.addedNodes.slice();

4838 - record.removedNodes = original.removedNodes.slice();

4839 - record.previousSibling = original.previousSibling;

4840 - record.nextSibling = original.nextSibling;

4841 - record.attributeName = original.attributeName;

4842 - record.attributeNamespace = original.attributeNamespace;

4843 - record.oldValue = original.oldValue;

4844 - return record;

4845 - }

4846 - var currentRecord, recordWithOldValue;

4847 - function getRecord(type, target) {

4848 - return currentRecord = new MutationRecord(type, target);

4849 - }

4850 - function getRecordWithOldValue(oldValue) {

4851 - if (recordWithOldValue) return recordWithOldValue;

4852 - recordWithOldValue = copyMutationRecord(currentRecord);

4853 - recordWithOldValue.oldValue = oldValue;

4854 - return recordWithOldValue;

4855 - }

4856 - function clearRecords() {

4857 - currentRecord = recordWithOldValue = undefined;

4858 - }

4859 - function recordRepresentsCurrentMutation(record) {

4860 - return record === recordWithOldValue || record === currentRecord;

4861 - }

4862 - function selectRecord(lastRecord, newRecord) {

4863 - if (lastRecord === newRecord) return lastRecord;

4864 - if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) return recordWithOldValue;

4865 - return null;

4866 - }

4867 - function Registration(observer, target, options) {

4868 - this.observer = observer;

4869 - this.target = target;

4870 - this.options = options;

4871 - this.transientObservedNodes = [];

4872 - }

4873 - Registration.prototype = {

4874 - enqueue: function(record) {

4875 - var records = this.observer.records_;

4876 - var length = records.length;

4877 - if (records.length > 0) {

4878 - var lastRecord = records[length - 1];

4879 - var recordToReplaceLast = selectRecord(lastRecord, record);

4880 - if (recordToReplaceLast) {

4881 - records[length - 1] = recordToReplaceLast;

4882 - return;

4883 - }

4884 - } else {

4885 - scheduleCallback(this.observer);

4886 - }

4887 - records[length] = record;

4888 - },

4889 - addListeners: function() {

4890 - this.addListeners_(this.target);

4891 - },

4892 - addListeners_: function(node) {

4893 - var options = this.options;

4894 - if (options.attributes) node.addEventListener("DOMAttrModified", this, true);

4895 - if (options.characterData) node.addEventListener("DOMCharacterDataModified", this, true);

4896 - if (options.childList) node.addEventListener("DOMNodeInserted", this, true);

4897 - if (options.childList || options.subtree) node.addEventListener("DOMNodeRemoved", this, true);

4898 - },

4899 - removeListeners: function() {

4900 - this.removeListeners_(this.target);

4901 - },

4902 - removeListeners_: function(node) {

4903 - var options = this.options;

4904 - if (options.attributes) node.removeEventListener("DOMAttrModified", this, true);

4905 - if (options.characterData) node.removeEventListener("DOMCharacterDataModified", this, true);

4906 - if (options.childList) node.removeEventListener("DOMNodeInserted", this, true);

4907 - if (options.childList || options.subtree) node.removeEventListener("DOMNodeRemoved", this, true);

4908 - },

4909 - addTransientObserver: function(node) {

4910 - if (node === this.target) return;

4911 - this.addListeners_(node);

4912 - this.transientObservedNodes.push(node);

4913 - var registrations = registrationsTable.get(node);

4914 - if (!registrations) registrationsTable.set(node, registrations = []);

4915 - registrations.push(this);

4916 - },

4917 - removeTransientObservers: function() {

4918 - var transientObservedNodes = this.transientObservedNodes;

4919 - this.transientObservedNodes = [];

4920 - transientObservedNodes.forEach(function(node) {

4921 - this.removeListeners_(node);

4922 - var registrations = registrationsTable.get(node);

4923 - for (var i = 0; i < registrations.length; i++) {

4924 - if (registrations[i] === this) {

4925 - registrations.splice(i, 1);

4926 - break;

4927 - }

4928 - }

4929 - }, this);

4930 - },

4931 - handleEvent: function(e) {

4932 - e.stopImmediatePropagation();

4933 - switch (e.type) {

4934 - case "DOMAttrModified":

4935 - var name = e.attrName;

4936 - var namespace = e.relatedNode.namespaceURI;

4937 - var target = e.target;

4938 - var record = new getRecord("attributes", target);

4939 - record.attributeName = name;

4940 - record.attributeNamespace = namespace;

4941 - var oldValue = e.attrChange === MutationEvent.ADDITION ? null : e.prevValue;

4942 - forEachAncestorAndObserverEnqueueRecord(target, function(options) {

4943 - if (!options.attributes) return;

4944 - if (options.attributeFilter && options.attributeFilter.length && options.attributeFilter.indexOf(name) === -1 && options.attributeFilter.indexOf(namespace) === -1) {

4945 - return;

4946 - }

4947 - if (options.attributeOldValue) return getRecordWithOldValue(oldValue);

4948 - return record;

4949 - });

4950 - break;

4951 -

4952 - case "DOMCharacterDataModified":

4953 - var target = e.target;

4954 - var record = getRecord("characterData", target);

4955 - var oldValue = e.prevValue;

4956 - forEachAncestorAndObserverEnqueueRecord(target, function(options) {

4957 - if (!options.characterData) return;

4958 - if (options.characterDataOldValue) return getRecordWithOldValue(oldValue);

4959 - return record;

4960 - });

4961 - break;

4962 -

4963 - case "DOMNodeRemoved":

4964 - this.addTransientObserver(e.target);

4965 -

4966 - case "DOMNodeInserted":

4967 - var target = e.relatedNode;

4968 - var changedNode = e.target;

4969 - var addedNodes, removedNodes;

4970 - if (e.type === "DOMNodeInserted") {

4971 - addedNodes = [ changedNode ];

4972 - removedNodes = [];

4973 - } else {

4974 - addedNodes = [];

4975 - removedNodes = [ changedNode ];

4976 - }

4977 - var previousSibling = changedNode.previousSibling;

4978 - var nextSibling = changedNode.nextSibling;

4979 - var record = getRecord("childList", target);

4980 - record.addedNodes = addedNodes;

4981 - record.removedNodes = removedNodes;

4982 - record.previousSibling = previousSibling;

4983 - record.nextSibling = nextSibling;

4984 - forEachAncestorAndObserverEnqueueRecord(target, function(options) {

4985 - if (!options.childList) return;

4986 - return record;

4987 - });

4988 - }

4989 - clearRecords();

4990 - }

4991 - };

4992 - global.JsMutationObserver = JsMutationObserver;

4993 - if (!global.MutationObserver) global.MutationObserver = JsMutationObserver;

4994 -})(this);

4995 -

4996 -window.HTMLImports = window.HTMLImports || {

4997 - flags: {}

4998 -};

4999 -

Fix rendering into shadow root (#11037)