Add stylelint dependency
This also adds CC-BY-4.0 to the list of accepted licenses.
DISABLE_THIRD_PARTY_CHECK=update dependencies
Bug: chromium:1083142
Change-Id: I8612de2fba52dae32eeb71af79d5aacfde52142b
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/2220097
Reviewed-by: Paul Lewis <aerotwist@chromium.org>
Commit-Queue: Mathias Bynens <mathias@chromium.org>
diff --git a/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts b/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts
new file mode 100644
index 0000000..52bdb77
--- /dev/null
+++ b/node_modules/postcss-selector-parser/postcss-selector-parser.d.ts
@@ -0,0 +1,499 @@
+// Type definitions for postcss-selector-parser 2.2.3
+// Definitions by: Chris Eppstein <chris@eppsteins.net>
+
+/*~ Note that ES6 modules cannot directly export callable functions.
+ *~ This file should be imported using the CommonJS-style:
+ *~ import x = require('someLibrary');
+ *~
+ *~ Refer to the documentation to understand common
+ *~ workarounds for this limitation of ES6 modules.
+ */
+
+/*~ This declaration specifies that the function
+ *~ is the exported object from the file
+ */
+export = parser;
+
+// TODO: Conditional types in TS 1.8 will really clean this up.
+declare function parser(): parser.Processor<never>;
+declare function parser<Transform>(processor: parser.AsyncProcessor<Transform>): parser.Processor<Transform, never>;
+declare function parser(processor: parser.AsyncProcessor<void>): parser.Processor<never, never>;
+declare function parser<Transform>(processor: parser.SyncProcessor<Transform>): parser.Processor<Transform>;
+declare function parser(processor: parser.SyncProcessor<void>): parser.Processor<never>;
+declare function parser<Transform>(processor?: parser.SyncProcessor<Transform> | parser.AsyncProcessor<Transform>): parser.Processor<Transform>;
+
+/*~ If you want to expose types from your module as well, you can
+ *~ place them in this block. Often you will want to describe the
+ *~ shape of the return type of the function; that type should
+ *~ be declared in here, as this example shows.
+ */
+declare namespace parser {
+ /* copied from postcss -- so we don't need to add a dependency */
+ type ErrorOptions = {
+ plugin?: string;
+ word?: string;
+ index?: number
+ };
+ /* the bits we use of postcss.Rule, copied from postcss -- so we don't need to add a dependency */
+ type PostCSSRuleNode = {
+ selector: string
+ /**
+ * @returns postcss.CssSyntaxError but it's a complex object, caller
+ * should cast to it if they have a dependency on postcss.
+ */
+ error(message: string, options?: ErrorOptions): Error;
+ };
+ /** Accepts a string */
+ type Selectors = string | PostCSSRuleNode
+ type ProcessorFn<ReturnType = void> = (root: parser.Root) => ReturnType;
+ type SyncProcessor<Transform = void> = ProcessorFn<Transform>;
+ type AsyncProcessor<Transform = void> = ProcessorFn<PromiseLike<Transform>>;
+
+ const TAG: "tag";
+ const STRING: "string";
+ const SELECTOR: "selector";
+ const ROOT: "root";
+ const PSEUDO: "pseudo";
+ const NESTING: "nesting";
+ const ID: "id";
+ const COMMENT: "comment";
+ const COMBINATOR: "combinator";
+ const CLASS: "class";
+ const ATTRIBUTE: "attribute";
+ const UNIVERSAL: "universal";
+
+ interface NodeTypes {
+ tag: Tag,
+ string: String,
+ selector: Selector,
+ root: Root,
+ pseudo: Pseudo,
+ nesting: Nesting,
+ id: Identifier,
+ comment: Comment,
+ combinator: Combinator,
+ class: ClassName,
+ attribute: Attribute,
+ universal: Universal
+ }
+
+ type Node = NodeTypes[keyof NodeTypes];
+
+ function isNode(node: any): node is Node;
+
+ interface Options {
+ /**
+ * Preserve whitespace when true. Default: false;
+ */
+ lossless: boolean;
+ /**
+ * When true and a postcss.Rule is passed, set the result of
+ * processing back onto the rule when done. Default: false.
+ */
+ updateSelector: boolean;
+ }
+ class Processor<
+ TransformType = never,
+ SyncSelectorsType extends Selectors | never = Selectors
+ > {
+ res: Root;
+ readonly result: String;
+ ast(selectors: Selectors, options?: Partial<Options>): Promise<Root>;
+ astSync(selectors: SyncSelectorsType, options?: Partial<Options>): Root;
+ transform(selectors: Selectors, options?: Partial<Options>): Promise<TransformType>;
+ transformSync(selectors: SyncSelectorsType, options?: Partial<Options>): TransformType;
+ process(selectors: Selectors, options?: Partial<Options>): Promise<string>;
+ processSync(selectors: SyncSelectorsType, options?: Partial<Options>): string;
+ }
+ interface ParserOptions {
+ css: string;
+ error: (message: string, options: ErrorOptions) => Error;
+ options: Options;
+ }
+ class Parser {
+ input: ParserOptions;
+ lossy: boolean;
+ position: number;
+ root: Root;
+ selectors: string;
+ current: Selector;
+ constructor(input: ParserOptions);
+ /**
+ * Raises an error, if the processor is invoked on
+ * a postcss Rule node, a better error message is raised.
+ */
+ error(message: string, options?: ErrorOptions): void;
+ }
+ interface NodeSource {
+ start?: {
+ line: number,
+ column: number
+ },
+ end?: {
+ line: number,
+ column: number
+ }
+ }
+ interface SpaceAround {
+ before: string;
+ after: string;
+ }
+ interface Spaces extends SpaceAround {
+ [spaceType: string]: string | Partial<SpaceAround> | undefined;
+ }
+ interface NodeOptions<Value = string> {
+ value: Value;
+ spaces?: Partial<Spaces>;
+ source?: NodeSource;
+ sourceIndex?: number;
+ }
+ interface Base<
+ Value extends string | undefined = string,
+ ParentType extends Container | undefined = Container | undefined
+ > {
+ type: keyof NodeTypes;
+ parent: ParentType;
+ value: Value;
+ spaces: Spaces;
+ source?: NodeSource;
+ sourceIndex: number;
+ rawSpaceBefore: string;
+ rawSpaceAfter: string;
+ remove(): Node;
+ replaceWith(...nodes: Node[]): Node;
+ next(): Node;
+ prev(): Node;
+ clone(opts: {[override: string]:any}): Node;
+ /**
+ * Return whether this node includes the character at the position of the given line and column.
+ * Returns undefined if the nodes lack sufficient source metadata to determine the position.
+ * @param line 1-index based line number relative to the start of the selector.
+ * @param column 1-index based column number relative to the start of the selector.
+ */
+ isAtPosition(line: number, column: number): boolean | undefined;
+ /**
+ * Some non-standard syntax doesn't follow normal escaping rules for css,
+ * this allows the escaped value to be specified directly, allowing illegal characters to be
+ * directly inserted into css output.
+ * @param name the property to set
+ * @param value the unescaped value of the property
+ * @param valueEscaped optional. the escaped value of the property.
+ */
+ setPropertyAndEscape(name: string, value: any, valueEscaped: string): void;
+ /**
+ * When you want a value to passed through to CSS directly. This method
+ * deletes the corresponding raw value causing the stringifier to fallback
+ * to the unescaped value.
+ * @param name the property to set.
+ * @param value The value that is both escaped and unescaped.
+ */
+ setPropertyWithoutEscape(name: string, value: any): void;
+ /**
+ * Some non-standard syntax doesn't follow normal escaping rules for css.
+ * This allows non standard syntax to be appended to an existing property
+ * by specifying the escaped value. By specifying the escaped value,
+ * illegal characters are allowed to be directly inserted into css output.
+ * @param {string} name the property to set
+ * @param {any} value the unescaped value of the property
+ * @param {string} valueEscaped optional. the escaped value of the property.
+ */
+ appendToPropertyAndEscape(name: string, value: any, valueEscaped: string): void;
+ toString(): string;
+ }
+ interface ContainerOptions extends NodeOptions {
+ nodes?: Array<Node>;
+ }
+ interface Container<Value extends string | undefined = string> extends Base<Value> {
+ nodes: Array<Node>;
+ append(selector: Selector): Container;
+ prepend(selector: Selector): Container;
+ at(index: number): Node;
+ /**
+ * Return the most specific node at the line and column number given.
+ * The source location is based on the original parsed location, locations aren't
+ * updated as selector nodes are mutated.
+ *
+ * Note that this location is relative to the location of the first character
+ * of the selector, and not the location of the selector in the overall document
+ * when used in conjunction with postcss.
+ *
+ * If not found, returns undefined.
+ * @param line The line number of the node to find. (1-based index)
+ * @param col The column number of the node to find. (1-based index)
+ */
+ atPosition(line: number, column: number): Node;
+ index(child: Node): number;
+ readonly first: Node;
+ readonly last: Node;
+ readonly length: number;
+ removeChild(child: Node): Container;
+ removeAll(): Container;
+ empty(): Container;
+ insertAfter(oldNode: Node, newNode: Node): Container;
+ insertBefore(oldNode: Node, newNode: Node): Container;
+ each(callback: (node: Node) => boolean | void): boolean | undefined;
+ walk(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkAttributes(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkClasses(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkCombinators(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkComments(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkIds(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkNesting(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkPseudos(callback: (node: Node) => boolean | void): boolean | undefined;
+ walkTags(callback: (node: Node) => boolean | void): boolean | undefined;
+ split(callback: (node: Node) => boolean): [Node[], Node[]];
+ map(callback: (node: Node) => Node): Node[];
+ reduce<T>(callback: (node: Node) => Node, memo: T): T;
+ every(callback: (node: Node) => boolean): boolean;
+ some(callback: (node: Node) => boolean): boolean;
+ filter(callback: (node: Node) => boolean): Node[];
+ sort(callback: (nodeA: Node, nodeB: Node) => number): Node[];
+ toString(): string;
+ }
+ function isContainer(node: any): node is Root | Selector | Pseudo;
+
+ interface NamespaceOptions<Value extends string | undefined = string> extends NodeOptions<Value> {
+ namespace?: string | true;
+ }
+ interface Namespace<Value extends string | undefined = string> extends Base<Value> {
+ /** alias for namespace */
+ ns: string | true;
+ /**
+ * namespace prefix.
+ */
+ namespace: string | true;
+ /**
+ * If a namespace exists, prefix the value provided with it, separated by |.
+ */
+ qualifiedName(value: string): string;
+ /**
+ * A string representing the namespace suitable for output.
+ */
+ readonly namespaceString: string;
+ }
+ function isNamespace(node: any): node is Attribute | Tag;
+
+ interface Root extends Container<undefined> {
+ type: "root";
+ /**
+ * Raises an error, if the processor is invoked on
+ * a postcss Rule node, a better error message is raised.
+ */
+ error(message: string, options?: ErrorOptions): Error;
+ nodeAt(line: number, column: number): Node
+ }
+ function root(opts: ContainerOptions): Root;
+ function isRoot(node: any): node is Root;
+
+ interface Selector extends Container {
+ type: "selector";
+ }
+ function selector(opts: ContainerOptions): Selector;
+ function isSelector(node: any): node is Selector;
+
+ interface Combinator extends Base {
+ type: "combinator"
+ }
+ function combinator(opts: NodeOptions): Combinator;
+ function isCombinator(node: any): node is Combinator;
+
+ interface ClassName extends Base {
+ type: "class";
+ }
+ function className(opts: NamespaceOptions): ClassName;
+ function isClassName(node: any): node is ClassName;
+
+ type AttributeOperator = "=" | "~=" | "|=" | "^=" | "$=" | "*=";
+ type QuoteMark = '"' | "'" | null;
+ interface PreferredQuoteMarkOptions {
+ quoteMark?: QuoteMark;
+ preferCurrentQuoteMark?: boolean;
+ }
+ interface SmartQuoteMarkOptions extends PreferredQuoteMarkOptions {
+ smart?: boolean;
+ }
+ interface AttributeOptions extends NamespaceOptions<string | undefined> {
+ attribute: string;
+ operator?: AttributeOperator;
+ insensitive?: boolean;
+ quoteMark?: QuoteMark;
+ /** @deprecated Use quoteMark instead. */
+ quoted?: boolean;
+ spaces?: {
+ before?: string;
+ after?: string;
+ attribute?: Partial<SpaceAround>;
+ operator?: Partial<SpaceAround>;
+ value?: Partial<SpaceAround>;
+ insensitive?: Partial<SpaceAround>;
+ }
+ raws: {
+ unquoted?: string;
+ attribute?: string;
+ operator?: string;
+ value?: string;
+ insensitive?: string;
+ spaces?: {
+ attribute?: Partial<Spaces>;
+ operator?: Partial<Spaces>;
+ value?: Partial<Spaces>;
+ insensitive?: Partial<Spaces>;
+ }
+ };
+ }
+ interface Attribute extends Namespace<string | undefined> {
+ type: "attribute";
+ attribute: string;
+ operator?: AttributeOperator;
+ insensitive?: boolean;
+ quoteMark: QuoteMark;
+ quoted?: boolean;
+ spaces: {
+ before: string;
+ after: string;
+ attribute?: Partial<Spaces>;
+ operator?: Partial<Spaces>;
+ value?: Partial<Spaces>;
+ insensitive?: Partial<Spaces>;
+ }
+ raws: {
+ /** @deprecated The attribute value is unquoted, use that instead.. */
+ unquoted?: string;
+ attribute?: string;
+ operator?: string;
+ /** The value of the attribute with quotes and escapes. */
+ value?: string;
+ insensitive?: string;
+ spaces?: {
+ attribute?: Partial<Spaces>;
+ operator?: Partial<Spaces>;
+ value?: Partial<Spaces>;
+ insensitive?: Partial<Spaces>;
+ }
+ };
+ /**
+ * The attribute name after having been qualified with a namespace.
+ */
+ readonly qualifiedAttribute: string;
+
+ /**
+ * The case insensitivity flag or an empty string depending on whether this
+ * attribute is case insensitive.
+ */
+ readonly insensitiveFlag : 'i' | '';
+
+ /**
+ * Returns the attribute's value quoted such that it would be legal to use
+ * in the value of a css file. The original value's quotation setting
+ * used for stringification is left unchanged. See `setValue(value, options)`
+ * if you want to control the quote settings of a new value for the attribute or
+ * `set quoteMark(mark)` if you want to change the quote settings of the current
+ * value.
+ *
+ * You can also change the quotation used for the current value by setting quoteMark.
+ **/
+ getQuotedValue(options?: SmartQuoteMarkOptions): string;
+
+ /**
+ * Set the unescaped value with the specified quotation options. The value
+ * provided must not include any wrapping quote marks -- those quotes will
+ * be interpreted as part of the value and escaped accordingly.
+ * @param value
+ */
+ setValue(value: string, options?: SmartQuoteMarkOptions): void;
+
+ /**
+ * Intelligently select a quoteMark value based on the value's contents. If
+ * the value is a legal CSS ident, it will not be quoted. Otherwise a quote
+ * mark will be picked that minimizes the number of escapes.
+ *
+ * If there's no clear winner, the quote mark from these options is used,
+ * then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
+ * true). If the quoteMark is unspecified, a double quote is used.
+ **/
+ smartQuoteMark(options: PreferredQuoteMarkOptions): QuoteMark;
+
+ /**
+ * Selects the preferred quote mark based on the options and the current quote mark value.
+ * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
+ * instead.
+ */
+ preferredQuoteMark(options: PreferredQuoteMarkOptions): QuoteMark
+
+ /**
+ * returns the offset of the attribute part specified relative to the
+ * start of the node of the output string.
+ *
+ * * "ns" - alias for "namespace"
+ * * "namespace" - the namespace if it exists.
+ * * "attribute" - the attribute name
+ * * "attributeNS" - the start of the attribute or its namespace
+ * * "operator" - the match operator of the attribute
+ * * "value" - The value (string or identifier)
+ * * "insensitive" - the case insensitivity flag;
+ * @param part One of the possible values inside an attribute.
+ * @returns -1 if the name is invalid or the value doesn't exist in this attribute.
+ */
+ offsetOf(part: "ns" | "namespace" | "attribute" | "attributeNS" | "operator" | "value" | "insensitive"): number;
+ }
+ function attribute(opts: AttributeOptions): Attribute;
+ function isAttribute(node: any): node is Attribute;
+
+ interface Pseudo extends Container {
+ type: "pseudo";
+ }
+ function pseudo(opts: ContainerOptions): Pseudo;
+ /**
+ * Checks wether the node is the Psuedo subtype of node.
+ */
+ function isPseudo(node: any): node is Pseudo;
+
+ /**
+ * Checks wether the node is, specifically, a pseudo element instead of
+ * pseudo class.
+ */
+ function isPseudoElement(node: any): node is Pseudo;
+
+ /**
+ * Checks wether the node is, specifically, a pseudo class instead of
+ * pseudo element.
+ */
+ function isPseudoClass(node: any): node is Pseudo;
+
+
+ interface Tag extends Namespace {
+ type: "tag";
+ }
+ function tag(opts: NamespaceOptions): Tag;
+ function isTag(node: any): node is Tag;
+
+ interface Comment extends Base {
+ type: "comment";
+ }
+ function comment(opts: NodeOptions): Comment;
+ function isComment(node: any): node is Comment;
+
+ interface Identifier extends Base {
+ type: "id";
+ }
+ function id(opts: any): any;
+ function isIdentifier(node: any): node is Identifier;
+
+ interface Nesting extends Base {
+ type: "nesting";
+ }
+ function nesting(opts: any): any;
+ function isNesting(node: any): node is Nesting;
+
+ interface String extends Base {
+ type: "string";
+ }
+ function string(opts: NodeOptions): String;
+ function isString(node: any): node is String;
+
+ interface Universal extends Base {
+ type: "universal";
+ }
+ function universal(opts?: NamespaceOptions): any;
+ function isUniversal(node: any): node is Universal;
+}