(function (global, factory) {

[0] Fix | Delete

typeof exports === 'object' && typeof module !== 'undefined' ? factory() :

[1] Fix | Delete

typeof define === 'function' && define.amd ? define('inert', factory) :

[2] Fix | Delete

(factory());

[3] Fix | Delete

}(this, (function () { 'use strict';

[4] Fix | Delete

[5] Fix | Delete

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

[6] Fix | Delete

[7] Fix | Delete

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

[8] Fix | Delete

[9] Fix | Delete

/**

[10] Fix | Delete

* This work is licensed under the W3C Software and Document License

[11] Fix | Delete

* (http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document).

[12] Fix | Delete

*/

[13] Fix | Delete

[14] Fix | Delete

(function () {

[15] Fix | Delete

// Return early if we're not running inside of the browser.

[16] Fix | Delete

if (typeof window === 'undefined') {

[17] Fix | Delete

return;

[18] Fix | Delete

}

[19] Fix | Delete

[20] Fix | Delete

// Convenience function for converting NodeLists.

[21] Fix | Delete

/** @type {typeof Array.prototype.slice} */

[22] Fix | Delete

var slice = Array.prototype.slice;

[23] Fix | Delete

[24] Fix | Delete

/**

[25] Fix | Delete

* IE has a non-standard name for "matches".

[26] Fix | Delete

* @type {typeof Element.prototype.matches}

[27] Fix | Delete

*/

[28] Fix | Delete

var matches = Element.prototype.matches || Element.prototype.msMatchesSelector;

[29] Fix | Delete

[30] Fix | Delete

/** @type {string} */

[31] Fix | Delete

var _focusableElementsString = ['a[href]', 'area[href]', 'input:not([disabled])', 'select:not([disabled])', 'textarea:not([disabled])', 'button:not([disabled])', 'details', 'summary', 'iframe', 'object', 'embed', '[contenteditable]'].join(',');

[32] Fix | Delete

[33] Fix | Delete

/**

[34] Fix | Delete

* `InertRoot` manages a single inert subtree, i.e. a DOM subtree whose root element has an `inert`

[35] Fix | Delete

* attribute.

[36] Fix | Delete

*

[37] Fix | Delete

* Its main functions are:

[38] Fix | Delete

*

[39] Fix | Delete

* - to create and maintain a set of managed `InertNode`s, including when mutations occur in the

[40] Fix | Delete

* subtree. The `makeSubtreeUnfocusable()` method handles collecting `InertNode`s via registering

[41] Fix | Delete

* each focusable node in the subtree with the singleton `InertManager` which manages all known

[42] Fix | Delete

* focusable nodes within inert subtrees. `InertManager` ensures that a single `InertNode`

[43] Fix | Delete

* instance exists for each focusable node which has at least one inert root as an ancestor.

[44] Fix | Delete

*

[45] Fix | Delete

* - to notify all managed `InertNode`s when this subtree stops being inert (i.e. when the `inert`

[46] Fix | Delete

* attribute is removed from the root node). This is handled in the destructor, which calls the

[47] Fix | Delete

* `deregister` method on `InertManager` for each managed inert node.

[48] Fix | Delete

*/

[49] Fix | Delete

[50] Fix | Delete

var InertRoot = function () {

[51] Fix | Delete

/**

[52] Fix | Delete

* @param {!HTMLElement} rootElement The HTMLElement at the root of the inert subtree.

[53] Fix | Delete

* @param {!InertManager} inertManager The global singleton InertManager object.

[54] Fix | Delete

*/

[55] Fix | Delete

function InertRoot(rootElement, inertManager) {

[56] Fix | Delete

_classCallCheck(this, InertRoot);

[57] Fix | Delete

[58] Fix | Delete

/** @type {!InertManager} */

[59] Fix | Delete

this._inertManager = inertManager;

[60] Fix | Delete

[61] Fix | Delete

/** @type {!HTMLElement} */

[62] Fix | Delete

this._rootElement = rootElement;

[63] Fix | Delete

[64] Fix | Delete

/**

[65] Fix | Delete

* @type {!Set<!InertNode>}

[66] Fix | Delete

* All managed focusable nodes in this InertRoot's subtree.

[67] Fix | Delete

*/

[68] Fix | Delete

this._managedNodes = new Set();

[69] Fix | Delete

[70] Fix | Delete

// Make the subtree hidden from assistive technology

[71] Fix | Delete

if (this._rootElement.hasAttribute('aria-hidden')) {

[72] Fix | Delete

/** @type {?string} */

[73] Fix | Delete

this._savedAriaHidden = this._rootElement.getAttribute('aria-hidden');

[74] Fix | Delete

} else {

[75] Fix | Delete

this._savedAriaHidden = null;

[76] Fix | Delete

}

[77] Fix | Delete

this._rootElement.setAttribute('aria-hidden', 'true');

[78] Fix | Delete

[79] Fix | Delete

// Make all focusable elements in the subtree unfocusable and add them to _managedNodes

[80] Fix | Delete

this._makeSubtreeUnfocusable(this._rootElement);

[81] Fix | Delete

[82] Fix | Delete

// Watch for:

[83] Fix | Delete

// - any additions in the subtree: make them unfocusable too

[84] Fix | Delete

// - any removals from the subtree: remove them from this inert root's managed nodes

[85] Fix | Delete

// - attribute changes: if `tabindex` is added, or removed from an intrinsically focusable

[86] Fix | Delete

// element, make that node a managed node.

[87] Fix | Delete

this._observer = new MutationObserver(this._onMutation.bind(this));

[88] Fix | Delete

this._observer.observe(this._rootElement, { attributes: true, childList: true, subtree: true });

[89] Fix | Delete

}

[90] Fix | Delete

[91] Fix | Delete

/**

[92] Fix | Delete

* Call this whenever this object is about to become obsolete. This unwinds all of the state

[93] Fix | Delete

* stored in this object and updates the state of all of the managed nodes.

[94] Fix | Delete

*/

[95] Fix | Delete

[96] Fix | Delete

[97] Fix | Delete

_createClass(InertRoot, [{

[98] Fix | Delete

key: 'destructor',

[99] Fix | Delete

value: function destructor() {

[100] Fix | Delete

this._observer.disconnect();

[101] Fix | Delete

[102] Fix | Delete

if (this._rootElement) {

[103] Fix | Delete

if (this._savedAriaHidden !== null) {

[104] Fix | Delete

this._rootElement.setAttribute('aria-hidden', this._savedAriaHidden);

[105] Fix | Delete

} else {

[106] Fix | Delete

this._rootElement.removeAttribute('aria-hidden');

[107] Fix | Delete

}

[108] Fix | Delete

}

[109] Fix | Delete

[110] Fix | Delete

this._managedNodes.forEach(function (inertNode) {

[111] Fix | Delete

this._unmanageNode(inertNode.node);

[112] Fix | Delete

}, this);

[113] Fix | Delete

[114] Fix | Delete

// Note we cast the nulls to the ANY type here because:

[115] Fix | Delete

// 1) We want the class properties to be declared as non-null, or else we

[116] Fix | Delete

// need even more casts throughout this code. All bets are off if an

[117] Fix | Delete

// instance has been destroyed and a method is called.

[118] Fix | Delete

// 2) We don't want to cast "this", because we want type-aware optimizations

[119] Fix | Delete

// to know which properties we're setting.

[120] Fix | Delete

this._observer = /** @type {?} */null;

[121] Fix | Delete

this._rootElement = /** @type {?} */null;

[122] Fix | Delete

this._managedNodes = /** @type {?} */null;

[123] Fix | Delete

this._inertManager = /** @type {?} */null;

[124] Fix | Delete

}

[125] Fix | Delete

[126] Fix | Delete

/**

[127] Fix | Delete

* @return {!Set<!InertNode>} A copy of this InertRoot's managed nodes set.

[128] Fix | Delete

*/

[129] Fix | Delete

[130] Fix | Delete

}, {

[131] Fix | Delete

key: '_makeSubtreeUnfocusable',

[132] Fix | Delete

[133] Fix | Delete

[134] Fix | Delete

/**

[135] Fix | Delete

* @param {!Node} startNode

[136] Fix | Delete

*/

[137] Fix | Delete

value: function _makeSubtreeUnfocusable(startNode) {

[138] Fix | Delete

var _this2 = this;

[139] Fix | Delete

[140] Fix | Delete

composedTreeWalk(startNode, function (node) {

[141] Fix | Delete

return _this2._visitNode(node);

[142] Fix | Delete

});

[143] Fix | Delete

[144] Fix | Delete

var activeElement = document.activeElement;

[145] Fix | Delete

[146] Fix | Delete

if (!document.body.contains(startNode)) {

[147] Fix | Delete

// startNode may be in shadow DOM, so find its nearest shadowRoot to get the activeElement.

[148] Fix | Delete

var node = startNode;

[149] Fix | Delete

/** @type {!ShadowRoot|undefined} */

[150] Fix | Delete

var root = undefined;

[151] Fix | Delete

while (node) {

[152] Fix | Delete

if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {

[153] Fix | Delete

root = /** @type {!ShadowRoot} */node;

[154] Fix | Delete

break;

[155] Fix | Delete

}

[156] Fix | Delete

node = node.parentNode;

[157] Fix | Delete

}

[158] Fix | Delete

if (root) {

[159] Fix | Delete

activeElement = root.activeElement;

[160] Fix | Delete

}

[161] Fix | Delete

}

[162] Fix | Delete

if (startNode.contains(activeElement)) {

[163] Fix | Delete

activeElement.blur();

[164] Fix | Delete

// In IE11, if an element is already focused, and then set to tabindex=-1

[165] Fix | Delete

// calling blur() will not actually move the focus.

[166] Fix | Delete

// To work around this we call focus() on the body instead.

[167] Fix | Delete

if (activeElement === document.activeElement) {

[168] Fix | Delete

document.body.focus();

[169] Fix | Delete

}

[170] Fix | Delete

}

[171] Fix | Delete

}

[172] Fix | Delete

[173] Fix | Delete

/**

[174] Fix | Delete

* @param {!Node} node

[175] Fix | Delete

*/

[176] Fix | Delete

[177] Fix | Delete

}, {

[178] Fix | Delete

key: '_visitNode',

[179] Fix | Delete

value: function _visitNode(node) {

[180] Fix | Delete

if (node.nodeType !== Node.ELEMENT_NODE) {

[181] Fix | Delete

return;

[182] Fix | Delete

}

[183] Fix | Delete

var element = /** @type {!HTMLElement} */node;

[184] Fix | Delete

[185] Fix | Delete

// If a descendant inert root becomes un-inert, its descendants will still be inert because of

[186] Fix | Delete

// this inert root, so all of its managed nodes need to be adopted by this InertRoot.

[187] Fix | Delete

if (element !== this._rootElement && element.hasAttribute('inert')) {

[188] Fix | Delete

this._adoptInertRoot(element);

[189] Fix | Delete

}

[190] Fix | Delete

[191] Fix | Delete

if (matches.call(element, _focusableElementsString) || element.hasAttribute('tabindex')) {

[192] Fix | Delete

this._manageNode(element);

[193] Fix | Delete

}

[194] Fix | Delete

}

[195] Fix | Delete

[196] Fix | Delete

/**

[197] Fix | Delete

* Register the given node with this InertRoot and with InertManager.

[198] Fix | Delete

* @param {!Node} node

[199] Fix | Delete

*/

[200] Fix | Delete

[201] Fix | Delete

}, {

[202] Fix | Delete

key: '_manageNode',

[203] Fix | Delete

value: function _manageNode(node) {

[204] Fix | Delete

var inertNode = this._inertManager.register(node, this);

[205] Fix | Delete

this._managedNodes.add(inertNode);

[206] Fix | Delete

}

[207] Fix | Delete

[208] Fix | Delete

/**

[209] Fix | Delete

* Unregister the given node with this InertRoot and with InertManager.

[210] Fix | Delete

* @param {!Node} node

[211] Fix | Delete

*/

[212] Fix | Delete

[213] Fix | Delete

}, {

[214] Fix | Delete

key: '_unmanageNode',

[215] Fix | Delete

value: function _unmanageNode(node) {

[216] Fix | Delete

var inertNode = this._inertManager.deregister(node, this);

[217] Fix | Delete

if (inertNode) {

[218] Fix | Delete

this._managedNodes['delete'](inertNode);

[219] Fix | Delete

}

[220] Fix | Delete

}

[221] Fix | Delete

[222] Fix | Delete

/**

[223] Fix | Delete

* Unregister the entire subtree starting at `startNode`.

[224] Fix | Delete

* @param {!Node} startNode

[225] Fix | Delete

*/

[226] Fix | Delete

[227] Fix | Delete

}, {

[228] Fix | Delete

key: '_unmanageSubtree',

[229] Fix | Delete

value: function _unmanageSubtree(startNode) {

[230] Fix | Delete

var _this3 = this;

[231] Fix | Delete

[232] Fix | Delete

composedTreeWalk(startNode, function (node) {

[233] Fix | Delete

return _this3._unmanageNode(node);

[234] Fix | Delete

});

[235] Fix | Delete

}

[236] Fix | Delete

[237] Fix | Delete

/**

[238] Fix | Delete

* If a descendant node is found with an `inert` attribute, adopt its managed nodes.

[239] Fix | Delete

* @param {!HTMLElement} node

[240] Fix | Delete

*/

[241] Fix | Delete

[242] Fix | Delete

}, {

[243] Fix | Delete

key: '_adoptInertRoot',

[244] Fix | Delete

value: function _adoptInertRoot(node) {

[245] Fix | Delete

var inertSubroot = this._inertManager.getInertRoot(node);

[246] Fix | Delete

[247] Fix | Delete

// During initialisation this inert root may not have been registered yet,

[248] Fix | Delete

// so register it now if need be.

[249] Fix | Delete

if (!inertSubroot) {

[250] Fix | Delete

this._inertManager.setInert(node, true);

[251] Fix | Delete

inertSubroot = this._inertManager.getInertRoot(node);

[252] Fix | Delete

}

[253] Fix | Delete

[254] Fix | Delete

inertSubroot.managedNodes.forEach(function (savedInertNode) {

[255] Fix | Delete

this._manageNode(savedInertNode.node);

[256] Fix | Delete

}, this);

[257] Fix | Delete

}

[258] Fix | Delete

[259] Fix | Delete

/**

[260] Fix | Delete

* Callback used when mutation observer detects subtree additions, removals, or attribute changes.

[261] Fix | Delete

* @param {!Array<!MutationRecord>} records

[262] Fix | Delete

* @param {!MutationObserver} self

[263] Fix | Delete

*/

[264] Fix | Delete

[265] Fix | Delete

}, {

[266] Fix | Delete

key: '_onMutation',

[267] Fix | Delete

value: function _onMutation(records, self) {

[268] Fix | Delete

records.forEach(function (record) {

[269] Fix | Delete

var target = /** @type {!HTMLElement} */record.target;

[270] Fix | Delete

if (record.type === 'childList') {

[271] Fix | Delete

// Manage added nodes

[272] Fix | Delete

slice.call(record.addedNodes).forEach(function (node) {

[273] Fix | Delete

this._makeSubtreeUnfocusable(node);

[274] Fix | Delete

}, this);

[275] Fix | Delete

[276] Fix | Delete

// Un-manage removed nodes

[277] Fix | Delete

slice.call(record.removedNodes).forEach(function (node) {

[278] Fix | Delete

this._unmanageSubtree(node);

[279] Fix | Delete

}, this);

[280] Fix | Delete

} else if (record.type === 'attributes') {

[281] Fix | Delete

if (record.attributeName === 'tabindex') {

[282] Fix | Delete

// Re-initialise inert node if tabindex changes

[283] Fix | Delete

this._manageNode(target);

[284] Fix | Delete

} else if (target !== this._rootElement && record.attributeName === 'inert' && target.hasAttribute('inert')) {

[285] Fix | Delete

// If a new inert root is added, adopt its managed nodes and make sure it knows about the

[286] Fix | Delete

// already managed nodes from this inert subroot.

[287] Fix | Delete

this._adoptInertRoot(target);

[288] Fix | Delete

var inertSubroot = this._inertManager.getInertRoot(target);

[289] Fix | Delete

this._managedNodes.forEach(function (managedNode) {

[290] Fix | Delete

if (target.contains(managedNode.node)) {

[291] Fix | Delete

inertSubroot._manageNode(managedNode.node);

[292] Fix | Delete

}

[293] Fix | Delete

});

[294] Fix | Delete

}

[295] Fix | Delete

}

[296] Fix | Delete

}, this);

[297] Fix | Delete

}

[298] Fix | Delete

}, {

[299] Fix | Delete

key: 'managedNodes',

[300] Fix | Delete

get: function get() {

[301] Fix | Delete

return new Set(this._managedNodes);

[302] Fix | Delete

}

[303] Fix | Delete

[304] Fix | Delete

/** @return {boolean} */

[305] Fix | Delete

[306] Fix | Delete

}, {

[307] Fix | Delete

key: 'hasSavedAriaHidden',

[308] Fix | Delete

get: function get() {

[309] Fix | Delete

return this._savedAriaHidden !== null;

[310] Fix | Delete

}

[311] Fix | Delete

[312] Fix | Delete

/** @param {?string} ariaHidden */

[313] Fix | Delete

[314] Fix | Delete

}, {

[315] Fix | Delete

key: 'savedAriaHidden',

[316] Fix | Delete

set: function set(ariaHidden) {

[317] Fix | Delete

this._savedAriaHidden = ariaHidden;

[318] Fix | Delete

}

[319] Fix | Delete

[320] Fix | Delete

/** @return {?string} */

[321] Fix | Delete

,

[322] Fix | Delete

get: function get() {

[323] Fix | Delete

return this._savedAriaHidden;

[324] Fix | Delete

}

[325] Fix | Delete

}]);

[326] Fix | Delete

[327] Fix | Delete

return InertRoot;

[328] Fix | Delete

}();

[329] Fix | Delete

[330] Fix | Delete

/**

[331] Fix | Delete

* `InertNode` initialises and manages a single inert node.

[332] Fix | Delete

* A node is inert if it is a descendant of one or more inert root elements.

[333] Fix | Delete

*

[334] Fix | Delete

* On construction, `InertNode` saves the existing `tabindex` value for the node, if any, and

[335] Fix | Delete

* either removes the `tabindex` attribute or sets it to `-1`, depending on whether the element

[336] Fix | Delete

* is intrinsically focusable or not.

[337] Fix | Delete

*

[338] Fix | Delete

* `InertNode` maintains a set of `InertRoot`s which are descendants of this `InertNode`. When an

[339] Fix | Delete

* `InertRoot` is destroyed, and calls `InertManager.deregister()`, the `InertManager` notifies the

[340] Fix | Delete

* `InertNode` via `removeInertRoot()`, which in turn destroys the `InertNode` if no `InertRoot`s

[341] Fix | Delete

* remain in the set. On destruction, `InertNode` reinstates the stored `tabindex` if one exists,

[342] Fix | Delete

* or removes the `tabindex` attribute if the element is intrinsically focusable.

[343] Fix | Delete

*/

[344] Fix | Delete

[345] Fix | Delete

[346] Fix | Delete

var InertNode = function () {

[347] Fix | Delete

/**

[348] Fix | Delete

* @param {!Node} node A focusable element to be made inert.

[349] Fix | Delete

* @param {!InertRoot} inertRoot The inert root element associated with this inert node.

[350] Fix | Delete

*/

[351] Fix | Delete

function InertNode(node, inertRoot) {

[352] Fix | Delete

_classCallCheck(this, InertNode);

[353] Fix | Delete

[354] Fix | Delete

/** @type {!Node} */

[355] Fix | Delete

this._node = node;

[356] Fix | Delete

[357] Fix | Delete

/** @type {boolean} */

[358] Fix | Delete

this._overrodeFocusMethod = false;

[359] Fix | Delete

[360] Fix | Delete

/**

[361] Fix | Delete

* @type {!Set<!InertRoot>} The set of descendant inert roots.

[362] Fix | Delete

* If and only if this set becomes empty, this node is no longer inert.

[363] Fix | Delete

*/

[364] Fix | Delete

this._inertRoots = new Set([inertRoot]);

[365] Fix | Delete

[366] Fix | Delete

/** @type {?number} */

[367] Fix | Delete

this._savedTabIndex = null;

[368] Fix | Delete

[369] Fix | Delete

/** @type {boolean} */

[370] Fix | Delete

this._destroyed = false;

[371] Fix | Delete

[372] Fix | Delete

// Save any prior tabindex info and make this node untabbable

[373] Fix | Delete

this.ensureUntabbable();

[374] Fix | Delete

}

[375] Fix | Delete

[376] Fix | Delete

/**

[377] Fix | Delete

* Call this whenever this object is about to become obsolete.

[378] Fix | Delete

* This makes the managed node focusable again and deletes all of the previously stored state.

[379] Fix | Delete

*/

[380] Fix | Delete

[381] Fix | Delete

[382] Fix | Delete

_createClass(InertNode, [{

[383] Fix | Delete

key: 'destructor',

[384] Fix | Delete

value: function destructor() {

[385] Fix | Delete

this._throwIfDestroyed();

[386] Fix | Delete

[387] Fix | Delete

if (this._node && this._node.nodeType === Node.ELEMENT_NODE) {

[388] Fix | Delete

var element = /** @type {!HTMLElement} */this._node;

[389] Fix | Delete

if (this._savedTabIndex !== null) {

[390] Fix | Delete

element.setAttribute('tabindex', this._savedTabIndex);

[391] Fix | Delete

} else {

[392] Fix | Delete

element.removeAttribute('tabindex');

[393] Fix | Delete

}

[394] Fix | Delete

[395] Fix | Delete

// Use `delete` to restore native focus method.

[396] Fix | Delete

if (this._overrodeFocusMethod) {

[397] Fix | Delete

delete element.focus;

[398] Fix | Delete

}

[399] Fix | Delete

}

[400] Fix | Delete

[401] Fix | Delete

// See note in InertRoot.destructor for why we cast these nulls to ANY.

[402] Fix | Delete

this._node = /** @type {?} */null;

[403] Fix | Delete

this._inertRoots = /** @type {?} */null;

[404] Fix | Delete

this._destroyed = true;

[405] Fix | Delete

}

[406] Fix | Delete

[407] Fix | Delete

/**

[408] Fix | Delete

* @type {boolean} Whether this object is obsolete because the managed node is no longer inert.

[409] Fix | Delete

* If the object has been destroyed, any attempt to access it will cause an exception.

[410] Fix | Delete

*/

[411] Fix | Delete

[412] Fix | Delete

}, {

[413] Fix | Delete

key: '_throwIfDestroyed',

[414] Fix | Delete

[415] Fix | Delete

[416] Fix | Delete

/**

[417] Fix | Delete

* Throw if user tries to access destroyed InertNode.

[418] Fix | Delete

*/

[419] Fix | Delete

value: function _throwIfDestroyed() {

[420] Fix | Delete

if (this.destroyed) {

[421] Fix | Delete

throw new Error('Trying to access destroyed InertNode');

[422] Fix | Delete

}

[423] Fix | Delete

}

[424] Fix | Delete

[425] Fix | Delete

/** @return {boolean} */

[426] Fix | Delete

[427] Fix | Delete

}, {

[428] Fix | Delete

key: 'ensureUntabbable',

[429] Fix | Delete

[430] Fix | Delete

[431] Fix | Delete

/** Save the existing tabindex value and make the node untabbable and unfocusable */

[432] Fix | Delete

value: function ensureUntabbable() {

[433] Fix | Delete

if (this.node.nodeType !== Node.ELEMENT_NODE) {

[434] Fix | Delete

return;

[435] Fix | Delete

}

[436] Fix | Delete

var element = /** @type {!HTMLElement} */this.node;

[437] Fix | Delete

if (matches.call(element, _focusableElementsString)) {

[438] Fix | Delete

if ( /** @type {!HTMLElement} */element.tabIndex === -1 && this.hasSavedTabIndex) {

[439] Fix | Delete

return;

[440] Fix | Delete

}

[441] Fix | Delete

[442] Fix | Delete

if (element.hasAttribute('tabindex')) {

[443] Fix | Delete

this._savedTabIndex = /** @type {!HTMLElement} */element.tabIndex;

[444] Fix | Delete

}

[445] Fix | Delete

element.setAttribute('tabindex', '-1');

[446] Fix | Delete

if (element.nodeType === Node.ELEMENT_NODE) {

[447] Fix | Delete

element.focus = function () {};

[448] Fix | Delete

this._overrodeFocusMethod = true;

[449] Fix | Delete

}

[450] Fix | Delete

} else if (element.hasAttribute('tabindex')) {

[451] Fix | Delete

this._savedTabIndex = /** @type {!HTMLElement} */element.tabIndex;

[452] Fix | Delete

element.removeAttribute('tabindex');

[453] Fix | Delete

}

[454] Fix | Delete

}

[455] Fix | Delete

[456] Fix | Delete

/**

[457] Fix | Delete

* Add another inert root to this inert node's set of managing inert roots.

[458] Fix | Delete

* @param {!InertRoot} inertRoot

[459] Fix | Delete

*/

[460] Fix | Delete

[461] Fix | Delete

}, {

[462] Fix | Delete

key: 'addInertRoot',

[463] Fix | Delete

value: function addInertRoot(inertRoot) {

[464] Fix | Delete

this._throwIfDestroyed();

[465] Fix | Delete

this._inertRoots.add(inertRoot);

[466] Fix | Delete

}

[467] Fix | Delete

[468] Fix | Delete

/**

[469] Fix | Delete

* Remove the given inert root from this inert node's set of managing inert roots.

[470] Fix | Delete

* If the set of managing inert roots becomes empty, this node is no longer inert,

[471] Fix | Delete

* so the object should be destroyed.

[472] Fix | Delete

* @param {!InertRoot} inertRoot

[473] Fix | Delete

*/

[474] Fix | Delete

[475] Fix | Delete

}, {

[476] Fix | Delete

key: 'removeInertRoot',

[477] Fix | Delete

value: function removeInertRoot(inertRoot) {

[478] Fix | Delete

this._throwIfDestroyed();

[479] Fix | Delete

this._inertRoots['delete'](inertRoot);

[480] Fix | Delete

if (this._inertRoots.size === 0) {

[481] Fix | Delete

this.destructor();

[482] Fix | Delete

}

[483] Fix | Delete

}

[484] Fix | Delete

}, {

[485] Fix | Delete

key: 'destroyed',

[486] Fix | Delete

get: function get() {

[487] Fix | Delete

return (/** @type {!InertNode} */this._destroyed

[488] Fix | Delete

);

[489] Fix | Delete

}

[490] Fix | Delete

}, {

[491] Fix | Delete

key: 'hasSavedTabIndex',

[492] Fix | Delete

get: function get() {

[493] Fix | Delete

return this._savedTabIndex !== null;

[494] Fix | Delete

}

[495] Fix | Delete

[496] Fix | Delete

/** @return {!Node} */

[497] Fix | Delete

[498] Fix | Delete

}, {

[499] Fix | Delete