easytouch-linux 1.0.7 → 1.0.18

package/.playwright/package/lib/utils/isomorphic/ariaSnapshot.js

@@ -1,391 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ParserError = exports.KeyParser = void 0;
-exports.parseAriaSnapshot = parseAriaSnapshot;
-exports.parseAriaSnapshotUnsafe = parseAriaSnapshotUnsafe;
-exports.valueOrRegex = valueOrRegex;
-/**
- * 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
-
-// We pass parsed template between worlds using JSON, make it easy.
-
-function parseAriaSnapshotUnsafe(yaml, text) {
-  const result = parseAriaSnapshot(yaml, text);
-  if (result.errors.length) throw new Error(result.errors[0].message);
-  return result.fragment;
-}
-function parseAriaSnapshot(yaml, text, options = {}) {
-  var _fragment$children;
-  const lineCounter = new yaml.LineCounter();
-  const parseOptions = {
-    keepSourceTokens: true,
-    lineCounter,
-    ...options
-  };
-  const yamlDoc = yaml.parseDocument(text, parseOptions);
-  const errors = [];
-  const convertRange = range => {
-    return [lineCounter.linePos(range[0]), lineCounter.linePos(range[1])];
-  };
-  const addError = error => {
-    errors.push({
-      message: error.message,
-      range: [lineCounter.linePos(error.pos[0]), lineCounter.linePos(error.pos[1])]
-    });
-  };
-  const convertSeq = (container, seq) => {
-    for (const item of seq.items) {
-      const itemIsString = item instanceof yaml.Scalar && typeof item.value === 'string';
-      if (itemIsString) {
-        const childNode = KeyParser.parse(item, parseOptions, errors);
-        if (childNode) {
-          container.children = container.children || [];
-          container.children.push(childNode);
-        }
-        continue;
-      }
-      const itemIsMap = item instanceof yaml.YAMLMap;
-      if (itemIsMap) {
-        convertMap(container, item);
-        continue;
-      }
-      errors.push({
-        message: 'Sequence items should be strings or maps',
-        range: convertRange(item.range || seq.range)
-      });
-    }
-  };
-  const convertMap = (container, map) => {
-    for (const entry of map.items) {
-      container.children = container.children || [];
-      // Key must by a string
-      const keyIsString = entry.key instanceof yaml.Scalar && typeof entry.key.value === 'string';
-      if (!keyIsString) {
-        errors.push({
-          message: 'Only string keys are supported',
-          range: convertRange(entry.key.range || map.range)
-        });
-        continue;
-      }
-      const key = entry.key;
-      const value = entry.value;
-
-      // - text: "text"
-      if (key.value === 'text') {
-        const valueIsString = value instanceof yaml.Scalar && typeof value.value === 'string';
-        if (!valueIsString) {
-          errors.push({
-            message: 'Text value should be a string',
-            range: convertRange(entry.value.range || map.range)
-          });
-          continue;
-        }
-        container.children.push({
-          kind: 'text',
-          text: valueOrRegex(value.value)
-        });
-        continue;
-      }
-
-      // role "name": ...
-      const childNode = KeyParser.parse(key, parseOptions, errors);
-      if (!childNode) continue;
-
-      // - role "name": "text"
-      const valueIsScalar = value instanceof yaml.Scalar;
-      if (valueIsScalar) {
-        const type = typeof value.value;
-        if (type !== 'string' && type !== 'number' && type !== 'boolean') {
-          errors.push({
-            message: 'Node value should be a string or a sequence',
-            range: convertRange(entry.value.range || map.range)
-          });
-          continue;
-        }
-        container.children.push({
-          ...childNode,
-          children: [{
-            kind: 'text',
-            text: valueOrRegex(String(value.value))
-          }]
-        });
-        continue;
-      }
-
-      // - role "name":
-      //   - child
-      const valueIsSequence = value instanceof yaml.YAMLSeq;
-      if (valueIsSequence) {
-        container.children.push(childNode);
-        convertSeq(childNode, value);
-        continue;
-      }
-      errors.push({
-        message: 'Map values should be strings or sequences',
-        range: convertRange(entry.value.range || map.range)
-      });
-    }
-  };
-  const fragment = {
-    kind: 'role',
-    role: 'fragment'
-  };
-  yamlDoc.errors.forEach(addError);
-  if (errors.length) return {
-    errors,
-    fragment
-  };
-  if (!(yamlDoc.contents instanceof yaml.YAMLSeq)) {
-    errors.push({
-      message: 'Aria snapshot must be a YAML sequence, elements starting with " -"',
-      range: yamlDoc.contents ? convertRange(yamlDoc.contents.range) : [{
-        line: 0,
-        col: 0
-      }, {
-        line: 0,
-        col: 0
-      }]
-    });
-  }
-  if (errors.length) return {
-    errors,
-    fragment
-  };
-  convertSeq(fragment, yamlDoc.contents);
-  if (errors.length) return {
-    errors,
-    fragment: emptyFragment
-  };
-  if (((_fragment$children = fragment.children) === null || _fragment$children === void 0 ? void 0 : _fragment$children.length) === 1) return {
-    fragment: fragment.children[0],
-    errors
-  };
-  return {
-    fragment,
-    errors
-  };
-}
-const emptyFragment = {
-  kind: 'role',
-  role: 'fragment'
-};
-function normalizeWhitespace(text) {
-  return text.replace(/[\r\n\s\t]+/g, ' ').trim();
-}
-function valueOrRegex(value) {
-  return value.startsWith('/') && value.endsWith('/') && value.length > 1 ? {
-    pattern: value.slice(1, -1)
-  } : normalizeWhitespace(value);
-}
-class KeyParser {
-  static parse(text, options, errors) {
-    try {
-      return new KeyParser(text.value)._parse();
-    } catch (e) {
-      if (e instanceof ParserError) {
-        const message = options.prettyErrors === false ? e.message : e.message + ':\n\n' + text.value + '\n' + ' '.repeat(e.pos) + '^\n';
-        errors.push({
-          message,
-          range: [options.lineCounter.linePos(text.range[0]), options.lineCounter.linePos(text.range[0] + e.pos)]
-        });
-        return null;
-      }
-      throw e;
-    }
-  }
-  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, offset = 0) {
-    throw new ParserError(message, offset || 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 {
-          pattern: 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 normalizeWhitespace(this._readString());
-    }
-    if (ch === '/') {
-      this._next();
-      return 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);
-  }
-}
-exports.KeyParser = KeyParser;
-class ParserError extends Error {
-  constructor(message, pos) {
-    super(message);
-    this.pos = void 0;
-    this.pos = pos;
-  }
-}
-exports.ParserError = ParserError;

package/.playwright/package/lib/utils/isomorphic/cssParser.js

@@ -1,250 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.InvalidSelectorError = void 0;
-exports.isInvalidSelectorError = isInvalidSelectorError;
-exports.parseCSS = parseCSS;
-exports.serializeSelector = serializeSelector;
-var css = _interopRequireWildcard(require("./cssTokenizer"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-/**
- * 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.
- */
-
-class InvalidSelectorError extends Error {}
-exports.InvalidSelectorError = InvalidSelectorError;
-function isInvalidSelectorError(error) {
-  return error instanceof InvalidSelectorError;
-}
-
-// Note: '>=' is used internally for text engine to preserve backwards compatibility.
-
-// TODO: consider
-//   - key=value
-//   - operators like `=`, `|=`, `~=`, `*=`, `/`
-//   - <empty>~=value
-//   - argument modes: "parse all", "parse commas", "just a string"
-
-function parseCSS(selector, customNames) {
-  let tokens;
-  try {
-    tokens = css.tokenize(selector);
-    if (!(tokens[tokens.length - 1] instanceof css.EOFToken)) tokens.push(new css.EOFToken());
-  } catch (e) {
-    const newMessage = e.message + ` while parsing css selector "${selector}". Did you mean to CSS.escape it?`;
-    const index = (e.stack || '').indexOf(e.message);
-    if (index !== -1) e.stack = e.stack.substring(0, index) + newMessage + e.stack.substring(index + e.message.length);
-    e.message = newMessage;
-    throw e;
-  }
-  const unsupportedToken = tokens.find(token => {
-    return token instanceof css.AtKeywordToken || token instanceof css.BadStringToken || token instanceof css.BadURLToken || token instanceof css.ColumnToken || token instanceof css.CDOToken || token instanceof css.CDCToken || token instanceof css.SemicolonToken ||
-    // TODO: Consider using these for something, e.g. to escape complex strings.
-    // For example :xpath{ (//div/bar[@attr="foo"])[2]/baz }
-    // Or this way :xpath( {complex-xpath-goes-here("hello")} )
-    token instanceof css.OpenCurlyToken || token instanceof css.CloseCurlyToken ||
-    // TODO: Consider treating these as strings?
-    token instanceof css.URLToken || token instanceof css.PercentageToken;
-  });
-  if (unsupportedToken) throw new InvalidSelectorError(`Unsupported token "${unsupportedToken.toSource()}" while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
-  let pos = 0;
-  const names = new Set();
-  function unexpected() {
-    return new InvalidSelectorError(`Unexpected token "${tokens[pos].toSource()}" while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
-  }
-  function skipWhitespace() {
-    while (tokens[pos] instanceof css.WhitespaceToken) pos++;
-  }
-  function isIdent(p = pos) {
-    return tokens[p] instanceof css.IdentToken;
-  }
-  function isString(p = pos) {
-    return tokens[p] instanceof css.StringToken;
-  }
-  function isNumber(p = pos) {
-    return tokens[p] instanceof css.NumberToken;
-  }
-  function isComma(p = pos) {
-    return tokens[p] instanceof css.CommaToken;
-  }
-  function isOpenParen(p = pos) {
-    return tokens[p] instanceof css.OpenParenToken;
-  }
-  function isCloseParen(p = pos) {
-    return tokens[p] instanceof css.CloseParenToken;
-  }
-  function isFunction(p = pos) {
-    return tokens[p] instanceof css.FunctionToken;
-  }
-  function isStar(p = pos) {
-    return tokens[p] instanceof css.DelimToken && tokens[p].value === '*';
-  }
-  function isEOF(p = pos) {
-    return tokens[p] instanceof css.EOFToken;
-  }
-  function isClauseCombinator(p = pos) {
-    return tokens[p] instanceof css.DelimToken && ['>', '+', '~'].includes(tokens[p].value);
-  }
-  function isSelectorClauseEnd(p = pos) {
-    return isComma(p) || isCloseParen(p) || isEOF(p) || isClauseCombinator(p) || tokens[p] instanceof css.WhitespaceToken;
-  }
-  function consumeFunctionArguments() {
-    const result = [consumeArgument()];
-    while (true) {
-      skipWhitespace();
-      if (!isComma()) break;
-      pos++;
-      result.push(consumeArgument());
-    }
-    return result;
-  }
-  function consumeArgument() {
-    skipWhitespace();
-    if (isNumber()) return tokens[pos++].value;
-    if (isString()) return tokens[pos++].value;
-    return consumeComplexSelector();
-  }
-  function consumeComplexSelector() {
-    const result = {
-      simples: []
-    };
-    skipWhitespace();
-    if (isClauseCombinator()) {
-      // Put implicit ":scope" at the start. https://drafts.csswg.org/selectors-4/#relative
-      result.simples.push({
-        selector: {
-          functions: [{
-            name: 'scope',
-            args: []
-          }]
-        },
-        combinator: ''
-      });
-    } else {
-      result.simples.push({
-        selector: consumeSimpleSelector(),
-        combinator: ''
-      });
-    }
-    while (true) {
-      skipWhitespace();
-      if (isClauseCombinator()) {
-        result.simples[result.simples.length - 1].combinator = tokens[pos++].value;
-        skipWhitespace();
-      } else if (isSelectorClauseEnd()) {
-        break;
-      }
-      result.simples.push({
-        combinator: '',
-        selector: consumeSimpleSelector()
-      });
-    }
-    return result;
-  }
-  function consumeSimpleSelector() {
-    let rawCSSString = '';
-    const functions = [];
-    while (!isSelectorClauseEnd()) {
-      if (isIdent() || isStar()) {
-        rawCSSString += tokens[pos++].toSource();
-      } else if (tokens[pos] instanceof css.HashToken) {
-        rawCSSString += tokens[pos++].toSource();
-      } else if (tokens[pos] instanceof css.DelimToken && tokens[pos].value === '.') {
-        pos++;
-        if (isIdent()) rawCSSString += '.' + tokens[pos++].toSource();else throw unexpected();
-      } else if (tokens[pos] instanceof css.ColonToken) {
-        pos++;
-        if (isIdent()) {
-          if (!customNames.has(tokens[pos].value.toLowerCase())) {
-            rawCSSString += ':' + tokens[pos++].toSource();
-          } else {
-            const name = tokens[pos++].value.toLowerCase();
-            functions.push({
-              name,
-              args: []
-            });
-            names.add(name);
-          }
-        } else if (isFunction()) {
-          const name = tokens[pos++].value.toLowerCase();
-          if (!customNames.has(name)) {
-            rawCSSString += `:${name}(${consumeBuiltinFunctionArguments()})`;
-          } else {
-            functions.push({
-              name,
-              args: consumeFunctionArguments()
-            });
-            names.add(name);
-          }
-          skipWhitespace();
-          if (!isCloseParen()) throw unexpected();
-          pos++;
-        } else {
-          throw unexpected();
-        }
-      } else if (tokens[pos] instanceof css.OpenSquareToken) {
-        rawCSSString += '[';
-        pos++;
-        while (!(tokens[pos] instanceof css.CloseSquareToken) && !isEOF()) rawCSSString += tokens[pos++].toSource();
-        if (!(tokens[pos] instanceof css.CloseSquareToken)) throw unexpected();
-        rawCSSString += ']';
-        pos++;
-      } else {
-        throw unexpected();
-      }
-    }
-    if (!rawCSSString && !functions.length) throw unexpected();
-    return {
-      css: rawCSSString || undefined,
-      functions
-    };
-  }
-  function consumeBuiltinFunctionArguments() {
-    let s = '';
-    let balance = 1; // First open paren is a part of a function token.
-    while (!isEOF()) {
-      if (isOpenParen() || isFunction()) balance++;
-      if (isCloseParen()) balance--;
-      if (!balance) break;
-      s += tokens[pos++].toSource();
-    }
-    return s;
-  }
-  const result = consumeFunctionArguments();
-  if (!isEOF()) throw unexpected();
-  if (result.some(arg => typeof arg !== 'object' || !('simples' in arg))) throw new InvalidSelectorError(`Error while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
-  return {
-    selector: result,
-    names: Array.from(names)
-  };
-}
-function serializeSelector(args) {
-  return args.map(arg => {
-    if (typeof arg === 'string') return `"${arg}"`;
-    if (typeof arg === 'number') return String(arg);
-    return arg.simples.map(({
-      selector,
-      combinator
-    }) => {
-      let s = selector.css || '';
-      s = s + selector.functions.map(func => `:${func.name}(${serializeSelector(func.args)})`).join('');
-      if (combinator) s += ' ' + combinator;
-      return s;
-    }).join(' ');
-  }).join(', ');
-}