patchright-core 1.48.2 → 1.49.1

package/lib/server/trace/recorder/tracing.js

@@ -120,7 +120,8 @@ class Tracing extends _instrumentation.SdkObject {
       traceSha1s: new Set(),
       networkSha1s: new Set(),
       recording: false,
-      callIds: new Set()
+      callIds: new Set(),
+      groupStack: []
     };
     this._fs.mkdir(this._state.resourcesDir);
     this._fs.writeFile(this._state.networkFile, '');
@@ -155,6 +156,52 @@ class Tracing extends _instrumentation.SdkObject {
       traceName: this._state.traceName
     };
   }
+  _currentGroupId() {
+    var _this$_state;
+    return (_this$_state = this._state) !== null && _this$_state !== void 0 && _this$_state.groupStack.length ? this._state.groupStack[this._state.groupStack.length - 1] : undefined;
+  }
+  async group(name, location, metadata) {
+    var _ref;
+    if (!this._state) return;
+    const stackFrames = [];
+    const {
+      file,
+      line,
+      column
+    } = (_ref = location !== null && location !== void 0 ? location : metadata.location) !== null && _ref !== void 0 ? _ref : {};
+    if (file) {
+      stackFrames.push({
+        file,
+        line: line !== null && line !== void 0 ? line : 0,
+        column: column !== null && column !== void 0 ? column : 0
+      });
+    }
+    const event = {
+      type: 'before',
+      callId: metadata.id,
+      startTime: metadata.startTime,
+      apiName: name,
+      class: 'Tracing',
+      method: 'tracingGroup',
+      params: {},
+      stepId: metadata.stepId,
+      stack: stackFrames
+    };
+    if (this._currentGroupId()) event.parentId = this._currentGroupId();
+    this._state.groupStack.push(event.callId);
+    this._appendTraceEvent(event);
+  }
+  groupEnd() {
+    if (!this._state) return;
+    const callId = this._state.groupStack.pop();
+    if (!callId) return;
+    const event = {
+      type: 'after',
+      callId,
+      endTime: (0, _utils.monotonicTime)()
+    };
+    this._appendTraceEvent(event);
+  }
   _startScreencast() {
     if (!(this._context instanceof _browserContext.BrowserContext)) return;
     for (const page of this._context.pages()) this._startScreencastInPage(page);
@@ -184,6 +231,7 @@ class Tracing extends _instrumentation.SdkObject {
     if (!this._state) return;
     if (this._isStopping) throw new Error(`Tracing is already stopping`);
     if (this._state.recording) throw new Error(`Must stop trace file before stopping tracing`);
+    this._closeAllGroups();
     this._harTracer.stop();
     this.flushHarEntries();
     await this._fs.syncAndGetError();
@@ -206,6 +254,9 @@ class Tracing extends _instrumentation.SdkObject {
     this.abort();
     await this._fs.syncAndGetError();
   }
+  _closeAllGroups() {
+    while (this._currentGroupId()) this.groupEnd();
+  }
   async stopChunk(params) {
     var _this$_snapshotter4;
     if (this._isStopping) throw new Error(`Tracing is already stopping`);
@@ -215,6 +266,7 @@ class Tracing extends _instrumentation.SdkObject {
       if (params.mode !== 'discard') throw new Error(`Must start tracing before stopping`);
       return {};
     }
+    this._closeAllGroups();
     this._context.instrumentation.removeListener(this);
     _utils.eventsHelper.removeEventListeners(this._eventListeners);
     if (this._state.options.screenshots) this._stopScreencast();
@@ -275,34 +327,34 @@ class Tracing extends _instrumentation.SdkObject {
       artifact
     };
   }
-  async _captureSnapshot(snapshotName, sdkObject, metadata, element) {
+  async _captureSnapshot(snapshotName, sdkObject, metadata) {
     if (!this._snapshotter) return;
     if (!sdkObject.attribution.page) return;
     if (!this._snapshotter.started()) return;
     if (!shouldCaptureSnapshot(metadata)) return;
-    await this._snapshotter.captureSnapshot(sdkObject.attribution.page, metadata.id, snapshotName, element).catch(() => {});
+    await this._snapshotter.captureSnapshot(sdkObject.attribution.page, metadata.id, snapshotName).catch(() => {});
   }
   onBeforeCall(sdkObject, metadata) {
-    var _sdkObject$attributio, _this$_state;
+    var _sdkObject$attributio, _this$_state2;
     // IMPORTANT: no awaits before this._appendTraceEvent in this method.
-    const event = createBeforeActionTraceEvent(metadata);
+    const event = createBeforeActionTraceEvent(metadata, this._currentGroupId());
     if (!event) return Promise.resolve();
     (_sdkObject$attributio = sdkObject.attribution.page) === null || _sdkObject$attributio === void 0 || _sdkObject$attributio.temporarilyDisableTracingScreencastThrottling();
     event.beforeSnapshot = `before@${metadata.id}`;
-    (_this$_state = this._state) === null || _this$_state === void 0 || _this$_state.callIds.add(metadata.id);
+    (_this$_state2 = this._state) === null || _this$_state2 === void 0 || _this$_state2.callIds.add(metadata.id);
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.beforeSnapshot, sdkObject, metadata);
   }
-  onBeforeInputAction(sdkObject, metadata, element) {
-    var _this$_state2, _sdkObject$attributio2;
-    if (!((_this$_state2 = this._state) !== null && _this$_state2 !== void 0 && _this$_state2.callIds.has(metadata.id))) return Promise.resolve();
+  onBeforeInputAction(sdkObject, metadata) {
+    var _this$_state3, _sdkObject$attributio2;
+    if (!((_this$_state3 = this._state) !== null && _this$_state3 !== void 0 && _this$_state3.callIds.has(metadata.id))) return Promise.resolve();
     // IMPORTANT: no awaits before this._appendTraceEvent in this method.
     const event = createInputActionTraceEvent(metadata);
     if (!event) return Promise.resolve();
     (_sdkObject$attributio2 = sdkObject.attribution.page) === null || _sdkObject$attributio2 === void 0 || _sdkObject$attributio2.temporarilyDisableTracingScreencastThrottling();
     event.inputSnapshot = `input@${metadata.id}`;
     this._appendTraceEvent(event);
-    return this._captureSnapshot(event.inputSnapshot, sdkObject, metadata, element);
+    return this._captureSnapshot(event.inputSnapshot, sdkObject, metadata);
   }
   onCallLog(sdkObject, metadata, logName, message) {
     if (metadata.isServerSide || metadata.internal) return;
@@ -311,9 +363,9 @@ class Tracing extends _instrumentation.SdkObject {
     if (event) this._appendTraceEvent(event);
   }
   async onAfterCall(sdkObject, metadata) {
-    var _this$_state3, _this$_state4, _sdkObject$attributio3;
-    if (!((_this$_state3 = this._state) !== null && _this$_state3 !== void 0 && _this$_state3.callIds.has(metadata.id))) return;
-    (_this$_state4 = this._state) === null || _this$_state4 === void 0 || _this$_state4.callIds.delete(metadata.id);
+    var _this$_state4, _this$_state5, _sdkObject$attributio3;
+    if (!((_this$_state4 = this._state) !== null && _this$_state4 !== void 0 && _this$_state4.callIds.has(metadata.id))) return;
+    (_this$_state5 = this._state) === null || _this$_state5 === void 0 || _this$_state5.callIds.delete(metadata.id);
     const event = createAfterActionTraceEvent(metadata);
     if (!event) return;
     (_sdkObject$attributio3 = sdkObject.attribution.page) === null || _sdkObject$attributio3 === void 0 || _sdkObject$attributio3.temporarilyDisableTracingScreencastThrottling();
@@ -497,9 +549,9 @@ function visitTraceEvent(object, sha1s) {
 function shouldCaptureSnapshot(metadata) {
   return _debug.commandsWithTracingSnapshots.has(metadata.type + '.' + metadata.method);
 }
-function createBeforeActionTraceEvent(metadata) {
+function createBeforeActionTraceEvent(metadata, parentId) {
   if (metadata.internal || metadata.method.startsWith('tracing')) return null;
-  return {
+  const event = {
     type: 'before',
     callId: metadata.id,
     startTime: metadata.startTime,
@@ -510,6 +562,8 @@ function createBeforeActionTraceEvent(metadata) {
     stepId: metadata.stepId,
     pageId: metadata.pageId
   };
+  if (parentId) event.parentId = parentId;
+  return event;
 }
 function createInputActionTraceEvent(metadata) {
   if (metadata.internal || metadata.method.startsWith('tracing')) return null;

package/lib/server/trace/test/inMemorySnapshotter.js

@@ -60,9 +60,9 @@ class InMemorySnapshotter {
     await this._harTracer.flush();
     this._harTracer.stop();
   }
-  async captureSnapshot(page, callId, snapshotName, element) {
+  async captureSnapshot(page, callId, snapshotName) {
     if (this._snapshotReadyPromises.has(snapshotName)) throw new Error('Duplicate snapshot name: ' + snapshotName);
-    this._snapshotter.captureSnapshot(page, callId, snapshotName, element).catch(() => {});
+    this._snapshotter.captureSnapshot(page, callId, snapshotName).catch(() => {});
     const promise = new _utils.ManualPromise();
     this._snapshotReadyPromises.set(snapshotName, promise);
     return promise;
@@ -80,7 +80,7 @@ class InMemorySnapshotter {
   onFrameSnapshot(snapshot) {
     var _this$_snapshotReadyP;
     ++this._snapshotCount;
-    const renderer = this._storage.addFrameSnapshot(snapshot);
+    const renderer = this._storage.addFrameSnapshot(snapshot, []);
     (_this$_snapshotReadyP = this._snapshotReadyPromises.get(snapshot.snapshotName || '')) === null || _this$_snapshotReadyP === void 0 || _this$_snapshotReadyP.resolve(renderer);
   }
   async resourceContentForTest(sha1) {

package/lib/server/trace/viewer/traceViewer.js

@@ -135,7 +135,8 @@ async function openTraceViewerApp(url, browserName, options) {
     persistentContextOptions: {
       ...(options === null || options === void 0 ? void 0 : options.persistentContextOptions),
       useWebSocket: (0, _utils.isUnderTest)(),
-      headless: !!(options !== null && options !== void 0 && options.headless)
+      headless: !!(options !== null && options !== void 0 && options.headless),
+      colorScheme: (0, _utils.isUnderTest)() ? 'light' : undefined
     }
   });
   const controller = new _progress.ProgressController((0, _instrumentation.serverSideCallMetadata)(), context._browser);

package/lib/server/webkit/wkBrowser.js

@@ -30,8 +30,8 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  * limitations under the License.
  */
 
-const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15';
-const BROWSER_VERSION = '18.0';
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15';
+const BROWSER_VERSION = '18.2';
 class WKBrowser extends _browser.Browser {
   static async connect(parent, transport, options) {
     const browser = new WKBrowser(parent, transport, options);

package/lib/server/webkit/wkExecutionContext.js

@@ -59,19 +59,6 @@ class WKExecutionContext {
       throw rewriteError(error);
     }
   }
-  rawCallFunctionNoReply(func, ...args) {
-    this._session.send('Runtime.callFunctionOn', {
-      functionDeclaration: func.toString(),
-      objectId: args.find(a => a instanceof js.JSHandle)._objectId,
-      arguments: args.map(a => a instanceof js.JSHandle ? {
-        objectId: a._objectId
-      } : {
-        value: a
-      }),
-      returnByValue: true,
-      emulateUserGesture: true
-    }).catch(() => {});
-  }
   async evaluateWithArguments(expression, returnByValue, utilityScript, values, objectIds) {
     try {
       const response = await this._session.send('Runtime.callFunctionOn', {

package/lib/server/webkit/wkPage.js

@@ -247,6 +247,10 @@ class WKPage {
       setting: 'InputTypeWeekEnabled',
       value: contextOptions.isMobile
     }));
+    promises.push(session.send('Page.overrideSetting', {
+      setting: 'FixedBackgroundsPaintRelativeToDocument',
+      value: contextOptions.isMobile
+    }));
     await Promise.all(promises);
   }
   _onDidCommitProvisionalTarget(event) {

package/lib/utils/comparators.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getComparator = getComparator;
 var _utilsBundle = require("../utilsBundle");
+var _pixelmatch = _interopRequireDefault(require("../third_party/pixelmatch"));
 var _compare = require("../image_tools/compare");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright 2017 Google Inc. All rights reserved.
  * Modifications copyright (c) Microsoft Corporation.
@@ -23,13 +25,8 @@ var _compare = require("../image_tools/compare");
  * limitations under the License.
  */
 
-const pixelmatch = require('../third_party/pixelmatch');
-const {
-  diff_match_patch,
-  DIFF_INSERT,
-  DIFF_DELETE,
-  DIFF_EQUAL
-} = require('../third_party/diff_match_patch');
+// @ts-ignore
+
 function getComparator(mimeType) {
   if (mimeType === 'image/png') return compareImages.bind(null, 'image/png');
   if (mimeType === 'image/jpeg') return compareImages.bind(null, 'image/jpeg');
@@ -83,7 +80,7 @@ function compareImages(mimeType, actualBuffer, expectedBuffer, options = {}) {
     });
   } else if (((_options$comparator = options.comparator) !== null && _options$comparator !== void 0 ? _options$comparator : 'pixelmatch') === 'pixelmatch') {
     var _options$threshold;
-    count = pixelmatch(expected.data, actual.data, diff.data, size.width, size.height, {
+    count = (0, _pixelmatch.default)(expected.data, actual.data, diff.data, size.width, size.height, {
       threshold: (_options$threshold = options.threshold) !== null && _options$threshold !== void 0 ? _options$threshold : 0.2
     });
   } else {
@@ -116,32 +113,17 @@ function compareText(actual, expectedBuffer) {
   };
   const expected = expectedBuffer.toString('utf-8');
   if (expected === actual) return null;
-  const dmp = new diff_match_patch();
-  const d = dmp.diff_main(expected, actual);
-  dmp.diff_cleanupSemantic(d);
+  const diffs = _utilsBundle.diff.diffChars(expected, actual);
   return {
-    errorMessage: diff_prettyTerminal(d)
+    errorMessage: diff_prettyTerminal(diffs)
   };
 }
 function diff_prettyTerminal(diffs) {
-  const html = [];
-  for (let x = 0; x < diffs.length; x++) {
-    const op = diffs[x][0]; // Operation (insert, delete, equal)
-    const data = diffs[x][1]; // Text of change.
-    const text = data;
-    switch (op) {
-      case DIFF_INSERT:
-        html[x] = _utilsBundle.colors.green(text);
-        break;
-      case DIFF_DELETE:
-        html[x] = _utilsBundle.colors.reset(_utilsBundle.colors.strikethrough(_utilsBundle.colors.red(text)));
-        break;
-      case DIFF_EQUAL:
-        html[x] = text;
-        break;
-    }
-  }
-  return html.join('');
+  const result = diffs.map(part => {
+    const text = part.value;
+    if (part.added) return _utilsBundle.colors.green(text);else if (part.removed) return _utilsBundle.colors.reset(_utilsBundle.colors.strikethrough(_utilsBundle.colors.red(text)));else return text;
+  });
+  return result.join('');
 }
 function resizeImage(image, size) {
   if (image.width === size.width && image.height === size.height) return image;

package/lib/utils/crypto.js

@@ -45,7 +45,6 @@ function encodeBase128(value) {
   } while (value > 0);
   return Buffer.from(bytes.reverse());
 }
-;
 
 // ASN1/DER Speficiation:   https://www.itu.int/rec/T-REC-X.680-X.693-202102-I/en
 class DER {
@@ -60,9 +59,7 @@ class DER {
     const parts = oid.split('.').map(v => Number(v));
     // Encode the second part, which could be large, using base-128 encoding if necessary
     const output = [encodeBase128(40 * parts[0] + parts[1])];
-    for (let i = 2; i < parts.length; i++) {
-      output.push(encodeBase128(parts[i]));
-    }
+    for (let i = 2; i < parts.length; i++) output.push(encodeBase128(parts[i]));
     return this._encode(0x06, Buffer.concat(output));
   }
   static encodeNull() {

package/lib/utils/hostPlatform.js

@@ -24,6 +24,12 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  */
 
 function calculatePlatform() {
+  if (process.env.PLAYWRIGHT_HOST_PLATFORM_OVERRIDE) {
+    return {
+      hostPlatform: process.env.PLAYWRIGHT_HOST_PLATFORM_OVERRIDE,
+      isOfficiallySupportedPlatform: false
+    };
+  }
   const platform = _os.default.platform();
   if (platform === 'darwin') {
     const ver = _os.default.release().split('.').map(a => parseInt(a, 10));

package/lib/utils/isomorphic/ariaSnapshot.js

@@ -0,0 +1,267 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AriaKeyError = void 0;
+exports.parseAriaKey = parseAriaKey;
+exports.parseYamlTemplate = parseYamlTemplate;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// https://www.w3.org/TR/wai-aria-1.2/#role_definitions
+
+function parseYamlTemplate(fragment) {
+  const result = {
+    kind: 'role',
+    role: 'fragment'
+  };
+  populateNode(result, fragment);
+  if (result.children && result.children.length === 1) return result.children[0];
+  return result;
+}
+function populateNode(node, container) {
+  for (const object of container) {
+    if (typeof object === 'string') {
+      const childNode = KeyParser.parse(object);
+      node.children = node.children || [];
+      node.children.push(childNode);
+      continue;
+    }
+    for (const key of Object.keys(object)) {
+      node.children = node.children || [];
+      const value = object[key];
+      if (key === 'text') {
+        node.children.push({
+          kind: 'text',
+          text: valueOrRegex(value)
+        });
+        continue;
+      }
+      const childNode = KeyParser.parse(key);
+      if (childNode.kind === 'text') {
+        node.children.push({
+          kind: 'text',
+          text: valueOrRegex(value)
+        });
+        continue;
+      }
+      if (typeof value === 'string') {
+        node.children.push({
+          ...childNode,
+          children: [{
+            kind: 'text',
+            text: valueOrRegex(value)
+          }]
+        });
+        continue;
+      }
+      node.children.push(childNode);
+      populateNode(childNode, value);
+    }
+  }
+}
+function normalizeWhitespace(text) {
+  return text.replace(/[\r\n\s\t]+/g, ' ').trim();
+}
+function valueOrRegex(value) {
+  return value.startsWith('/') && value.endsWith('/') ? new RegExp(value.slice(1, -1)) : normalizeWhitespace(value);
+}
+class KeyParser {
+  static parse(input) {
+    return new KeyParser(input)._parse();
+  }
+  constructor(input) {
+    this._input = void 0;
+    this._pos = void 0;
+    this._length = void 0;
+    this._input = input;
+    this._pos = 0;
+    this._length = input.length;
+  }
+  _peek() {
+    return this._input[this._pos] || '';
+  }
+  _next() {
+    if (this._pos < this._length) return this._input[this._pos++];
+    return null;
+  }
+  _eof() {
+    return this._pos >= this._length;
+  }
+  _isWhitespace() {
+    return !this._eof() && /\s/.test(this._peek());
+  }
+  _skipWhitespace() {
+    while (this._isWhitespace()) this._pos++;
+  }
+  _readIdentifier(type) {
+    if (this._eof()) this._throwError(`Unexpected end of input when expecting ${type}`);
+    const start = this._pos;
+    while (!this._eof() && /[a-zA-Z]/.test(this._peek())) this._pos++;
+    return this._input.slice(start, this._pos);
+  }
+  _readString() {
+    let result = '';
+    let escaped = false;
+    while (!this._eof()) {
+      const ch = this._next();
+      if (escaped) {
+        result += ch;
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === '"') {
+        return result;
+      } else {
+        result += ch;
+      }
+    }
+    this._throwError('Unterminated string');
+  }
+  _throwError(message, pos) {
+    throw new AriaKeyError(message, this._input, pos || this._pos);
+  }
+  _readRegex() {
+    let result = '';
+    let escaped = false;
+    let insideClass = false;
+    while (!this._eof()) {
+      const ch = this._next();
+      if (escaped) {
+        result += ch;
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+        result += ch;
+      } else if (ch === '/' && !insideClass) {
+        return result;
+      } else if (ch === '[') {
+        insideClass = true;
+        result += ch;
+      } else if (ch === ']' && insideClass) {
+        result += ch;
+        insideClass = false;
+      } else {
+        result += ch;
+      }
+    }
+    this._throwError('Unterminated regex');
+  }
+  _readStringOrRegex() {
+    const ch = this._peek();
+    if (ch === '"') {
+      this._next();
+      return this._readString();
+    }
+    if (ch === '/') {
+      this._next();
+      return new RegExp(this._readRegex());
+    }
+    return null;
+  }
+  _readAttributes(result) {
+    let errorPos = this._pos;
+    while (true) {
+      this._skipWhitespace();
+      if (this._peek() === '[') {
+        this._next();
+        this._skipWhitespace();
+        errorPos = this._pos;
+        const flagName = this._readIdentifier('attribute');
+        this._skipWhitespace();
+        let flagValue = '';
+        if (this._peek() === '=') {
+          this._next();
+          this._skipWhitespace();
+          errorPos = this._pos;
+          while (this._peek() !== ']' && !this._isWhitespace() && !this._eof()) flagValue += this._next();
+        }
+        this._skipWhitespace();
+        if (this._peek() !== ']') this._throwError('Expected ]');
+        this._next(); // Consume ']'
+        this._applyAttribute(result, flagName, flagValue || 'true', errorPos);
+      } else {
+        break;
+      }
+    }
+  }
+  _parse() {
+    this._skipWhitespace();
+    const role = this._readIdentifier('role');
+    this._skipWhitespace();
+    const name = this._readStringOrRegex() || '';
+    const result = {
+      kind: 'role',
+      role,
+      name
+    };
+    this._readAttributes(result);
+    this._skipWhitespace();
+    if (!this._eof()) this._throwError('Unexpected input');
+    return result;
+  }
+  _applyAttribute(node, key, value, errorPos) {
+    if (key === 'checked') {
+      this._assert(value === 'true' || value === 'false' || value === 'mixed', 'Value of "checked\" attribute must be a boolean or "mixed"', errorPos);
+      node.checked = value === 'true' ? true : value === 'false' ? false : 'mixed';
+      return;
+    }
+    if (key === 'disabled') {
+      this._assert(value === 'true' || value === 'false', 'Value of "disabled" attribute must be a boolean', errorPos);
+      node.disabled = value === 'true';
+      return;
+    }
+    if (key === 'expanded') {
+      this._assert(value === 'true' || value === 'false', 'Value of "expanded" attribute must be a boolean', errorPos);
+      node.expanded = value === 'true';
+      return;
+    }
+    if (key === 'level') {
+      this._assert(!isNaN(Number(value)), 'Value of "level" attribute must be a number', errorPos);
+      node.level = Number(value);
+      return;
+    }
+    if (key === 'pressed') {
+      this._assert(value === 'true' || value === 'false' || value === 'mixed', 'Value of "pressed" attribute must be a boolean or "mixed"', errorPos);
+      node.pressed = value === 'true' ? true : value === 'false' ? false : 'mixed';
+      return;
+    }
+    if (key === 'selected') {
+      this._assert(value === 'true' || value === 'false', 'Value of "selected" attribute must be a boolean', errorPos);
+      node.selected = value === 'true';
+      return;
+    }
+    this._assert(false, `Unsupported attribute [${key}]`, errorPos);
+  }
+  _assert(value, message, valuePos) {
+    if (!value) this._throwError(message || 'Assertion error', valuePos);
+  }
+}
+function parseAriaKey(key) {
+  return KeyParser.parse(key);
+}
+class AriaKeyError extends Error {
+  constructor(message, input, pos) {
+    super(message + ':\n\n' + input + '\n' + ' '.repeat(pos) + '^\n');
+    this.shortMessage = void 0;
+    this.pos = void 0;
+    this.shortMessage = message;
+    this.pos = pos;
+    this.stack = undefined;
+  }
+}
+exports.AriaKeyError = AriaKeyError;