plugin-build-guide-block 1.0.2 → 1.0.3

package/dist/node_modules/sanitize-html/node_modules/postcss/lib/css-syntax-error.js

@@ -0,0 +1,100 @@
+'use strict'
+
+let pico = require('picocolors')
+
+let terminalHighlight = require('./terminal-highlight')
+
+class CssSyntaxError extends Error {
+  constructor(message, line, column, source, file, plugin) {
+    super(message)
+    this.name = 'CssSyntaxError'
+    this.reason = message
+
+    if (file) {
+      this.file = file
+    }
+    if (source) {
+      this.source = source
+    }
+    if (plugin) {
+      this.plugin = plugin
+    }
+    if (typeof line !== 'undefined' && typeof column !== 'undefined') {
+      if (typeof line === 'number') {
+        this.line = line
+        this.column = column
+      } else {
+        this.line = line.line
+        this.column = line.column
+        this.endLine = column.line
+        this.endColumn = column.column
+      }
+    }
+
+    this.setMessage()
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, CssSyntaxError)
+    }
+  }
+
+  setMessage() {
+    this.message = this.plugin ? this.plugin + ': ' : ''
+    this.message += this.file ? this.file : '<css input>'
+    if (typeof this.line !== 'undefined') {
+      this.message += ':' + this.line + ':' + this.column
+    }
+    this.message += ': ' + this.reason
+  }
+
+  showSourceCode(color) {
+    if (!this.source) return ''
+
+    let css = this.source
+    if (color == null) color = pico.isColorSupported
+    if (terminalHighlight) {
+      if (color) css = terminalHighlight(css)
+    }
+
+    let lines = css.split(/\r?\n/)
+    let start = Math.max(this.line - 3, 0)
+    let end = Math.min(this.line + 2, lines.length)
+
+    let maxWidth = String(end).length
+
+    let mark, aside
+    if (color) {
+      let { bold, gray, red } = pico.createColors(true)
+      mark = text => bold(red(text))
+      aside = text => gray(text)
+    } else {
+      mark = aside = str => str
+    }
+
+    return lines
+      .slice(start, end)
+      .map((line, index) => {
+        let number = start + 1 + index
+        let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '
+        if (number === this.line) {
+          let spacing =
+            aside(gutter.replace(/\d/g, ' ')) +
+            line.slice(0, this.column - 1).replace(/[^\t]/g, ' ')
+          return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^')
+        }
+        return ' ' + aside(gutter) + line
+      })
+      .join('\n')
+  }
+
+  toString() {
+    let code = this.showSourceCode()
+    if (code) {
+      code = '\n\n' + code + '\n'
+    }
+    return this.name + ': ' + this.message + code
+  }
+}
+
+module.exports = CssSyntaxError
+CssSyntaxError.default = CssSyntaxError

package/dist/node_modules/sanitize-html/node_modules/postcss/lib/declaration.d.ts

@@ -0,0 +1,148 @@
+import Container from './container.js'
+import Node from './node.js'
+
+declare namespace Declaration {
+  export interface DeclarationRaws extends Record<string, unknown> {
+    /**
+     * The space symbols before the node. It also stores `*`
+     * and `_` symbols before the declaration (IE hack).
+     */
+    before?: string
+
+    /**
+     * The symbols between the property and value for declarations.
+     */
+    between?: string
+
+    /**
+     * The content of the important statement, if it is not just `!important`.
+     */
+    important?: string
+
+    /**
+     * Declaration value with comments.
+     */
+    value?: {
+      raw: string
+      value: string
+    }
+  }
+
+  export interface DeclarationProps {
+    /** Whether the declaration has an `!important` annotation. */
+    important?: boolean
+    /** Name of the declaration. */
+    prop: string
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: DeclarationRaws
+    /** Value of the declaration. */
+    value: string
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Declaration_ as default }
+}
+
+/**
+ * It represents a class that handles
+ * [CSS declarations](https://developer.mozilla.org/en-US/docs/Web/CSS/Syntax#css_declarations)
+ *
+ * ```js
+ * Once (root, { Declaration }) {
+ *   const color = new Declaration({ prop: 'color', value: 'black' })
+ *   root.append(color)
+ * }
+ * ```
+ *
+ * ```js
+ * const root = postcss.parse('a { color: black }')
+ * const decl = root.first?.first
+ *
+ * decl.type       //=> 'decl'
+ * decl.toString() //=> ' color: black'
+ * ```
+ */
+declare class Declaration_ extends Node {
+  /**
+   * It represents a specificity of the declaration.
+   *
+   * If true, the CSS declaration will have an
+   * [important](https://developer.mozilla.org/en-US/docs/Web/CSS/important)
+   * specifier.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black !important; color: red }')
+   *
+   * root.first.first.important //=> true
+   * root.first.last.important  //=> undefined
+   * ```
+   */
+  important: boolean
+
+  parent: Container | undefined
+
+  /**
+   * The property name for a CSS declaration.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black }')
+   * const decl = root.first.first
+   *
+   * decl.prop //=> 'color'
+   * ```
+   */
+  prop: string
+
+  raws: Declaration.DeclarationRaws
+
+  type: 'decl'
+
+  /**
+   * The property value for a CSS declaration.
+   *
+   * Any CSS comments inside the value string will be filtered out.
+   * CSS comments present in the source value will be available in
+   * the `raws` property.
+   *
+   * Assigning new `value` would ignore the comments in `raws`
+   * property while compiling node to string.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black }')
+   * const decl = root.first.first
+   *
+   * decl.value //=> 'black'
+   * ```
+   */
+  value: string
+
+  /**
+   * It represents a getter that returns `true` if a declaration starts with
+   * `--` or `$`, which are used to declare variables in CSS and SASS/SCSS.
+   *
+   * ```js
+   * const root = postcss.parse(':root { --one: 1 }')
+   * const one = root.first.first
+   *
+   * one.variable //=> true
+   * ```
+   *
+   * ```js
+   * const root = postcss.parse('$one: 1')
+   * const one = root.first
+   *
+   * one.variable //=> true
+   * ```
+   */
+  variable: boolean
+
+  constructor(defaults?: Declaration.DeclarationProps)
+  assign(overrides: Declaration.DeclarationProps | object): this
+  clone(overrides?: Partial<Declaration.DeclarationProps>): Declaration
+  cloneAfter(overrides?: Partial<Declaration.DeclarationProps>): Declaration
+  cloneBefore(overrides?: Partial<Declaration.DeclarationProps>): Declaration
+}
+
+declare class Declaration extends Declaration_ {}
+
+export = Declaration

package/dist/node_modules/sanitize-html/node_modules/postcss/lib/declaration.js

@@ -0,0 +1,24 @@
+'use strict'
+
+let Node = require('./node')
+
+class Declaration extends Node {
+  constructor(defaults) {
+    if (
+      defaults &&
+      typeof defaults.value !== 'undefined' &&
+      typeof defaults.value !== 'string'
+    ) {
+      defaults = { ...defaults, value: String(defaults.value) }
+    }
+    super(defaults)
+    this.type = 'decl'
+  }
+
+  get variable() {
+    return this.prop.startsWith('--') || this.prop[0] === '$'
+  }
+}
+
+module.exports = Declaration
+Declaration.default = Declaration

package/dist/node_modules/sanitize-html/node_modules/postcss/lib/document.d.ts

@@ -0,0 +1,68 @@
+import Container, { ContainerProps } from './container.js'
+import { ProcessOptions } from './postcss.js'
+import Result from './result.js'
+import Root from './root.js'
+
+declare namespace Document {
+  export interface DocumentProps extends ContainerProps {
+    nodes?: Root[]
+
+    /**
+     * Information to generate byte-to-byte equal node string as it was
+     * in the origin input.
+     *
+     * Every parser saves its own properties.
+     */
+    raws?: Record<string, any>
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Document_ as default }
+}
+
+/**
+ * Represents a file and contains all its parsed nodes.
+ *
+ * **Experimental:** some aspects of this node could change within minor
+ * or patch version releases.
+ *
+ * ```js
+ * const document = htmlParser(
+ *   '<html><style>a{color:black}</style><style>b{z-index:2}</style>'
+ * )
+ * document.type         //=> 'document'
+ * document.nodes.length //=> 2
+ * ```
+ */
+declare class Document_ extends Container<Root> {
+  parent: undefined
+  type: 'document'
+
+  constructor(defaults?: Document.DocumentProps)
+
+  assign(overrides: Document.DocumentProps | object): this
+  clone(overrides?: Partial<Document.DocumentProps>): Document
+  cloneAfter(overrides?: Partial<Document.DocumentProps>): Document
+  cloneBefore(overrides?: Partial<Document.DocumentProps>): Document
+
+  /**
+   * Returns a `Result` instance representing the document’s CSS roots.
+   *
+   * ```js
+   * const root1 = postcss.parse(css1, { from: 'a.css' })
+   * const root2 = postcss.parse(css2, { from: 'b.css' })
+   * const document = postcss.document()
+   * document.append(root1)
+   * document.append(root2)
+   * const result = document.toResult({ to: 'all.css', map: true })
+   * ```
+   *
+   * @param opts Options.
+   * @return Result with current document’s CSS.
+   */
+  toResult(options?: ProcessOptions): Result
+}
+
+declare class Document extends Document_ {}
+
+export = Document

package/dist/node_modules/sanitize-html/node_modules/postcss/lib/document.js

@@ -0,0 +1,33 @@
+'use strict'
+
+let Container = require('./container')
+
+let LazyResult, Processor
+
+class Document extends Container {
+  constructor(defaults) {
+    // type needs to be passed to super, otherwise child roots won't be normalized correctly
+    super({ type: 'document', ...defaults })
+
+    if (!this.nodes) {
+      this.nodes = []
+    }
+  }
+
+  toResult(opts = {}) {
+    let lazy = new LazyResult(new Processor(), this, opts)
+
+    return lazy.stringify()
+  }
+}
+
+Document.registerLazyResult = dependant => {
+  LazyResult = dependant
+}
+
+Document.registerProcessor = dependant => {
+  Processor = dependant
+}
+
+module.exports = Document
+Document.default = Document

package/dist/node_modules/sanitize-html/node_modules/postcss/lib/fromJSON.d.ts

@@ -0,0 +1,9 @@
+import { JSONHydrator } from './postcss.js'
+
+interface FromJSON extends JSONHydrator {
+  default: FromJSON
+}
+
+declare const fromJSON: FromJSON
+
+export = fromJSON

package/dist/node_modules/sanitize-html/node_modules/postcss/lib/fromJSON.js

@@ -0,0 +1,54 @@
+'use strict'
+
+let Declaration = require('./declaration')
+let PreviousMap = require('./previous-map')
+let Comment = require('./comment')
+let AtRule = require('./at-rule')
+let Input = require('./input')
+let Root = require('./root')
+let Rule = require('./rule')
+
+function fromJSON(json, inputs) {
+  if (Array.isArray(json)) return json.map(n => fromJSON(n))
+
+  let { inputs: ownInputs, ...defaults } = json
+  if (ownInputs) {
+    inputs = []
+    for (let input of ownInputs) {
+      let inputHydrated = { ...input, __proto__: Input.prototype }
+      if (inputHydrated.map) {
+        inputHydrated.map = {
+          ...inputHydrated.map,
+          __proto__: PreviousMap.prototype
+        }
+      }
+      inputs.push(inputHydrated)
+    }
+  }
+  if (defaults.nodes) {
+    defaults.nodes = json.nodes.map(n => fromJSON(n, inputs))
+  }
+  if (defaults.source) {
+    let { inputId, ...source } = defaults.source
+    defaults.source = source
+    if (inputId != null) {
+      defaults.source.input = inputs[inputId]
+    }
+  }
+  if (defaults.type === 'root') {
+    return new Root(defaults)
+  } else if (defaults.type === 'decl') {
+    return new Declaration(defaults)
+  } else if (defaults.type === 'rule') {
+    return new Rule(defaults)
+  } else if (defaults.type === 'comment') {
+    return new Comment(defaults)
+  } else if (defaults.type === 'atrule') {
+    return new AtRule(defaults)
+  } else {
+    throw new Error('Unknown node type: ' + json.type)
+  }
+}
+
+module.exports = fromJSON
+fromJSON.default = fromJSON

package/dist/node_modules/sanitize-html/node_modules/postcss/lib/input.d.ts

@@ -0,0 +1,194 @@
+import { CssSyntaxError, ProcessOptions } from './postcss.js'
+import PreviousMap from './previous-map.js'
+
+declare namespace Input {
+  export interface FilePosition {
+    /**
+     * Column of inclusive start position in source file.
+     */
+    column: number
+
+    /**
+     * Column of exclusive end position in source file.
+     */
+    endColumn?: number
+
+    /**
+     * Line of exclusive end position in source file.
+     */
+    endLine?: number
+
+    /**
+     * Absolute path to the source file.
+     */
+    file?: string
+
+    /**
+     * Line of inclusive start position in source file.
+     */
+    line: number
+
+    /**
+     * Source code.
+     */
+    source?: string
+
+    /**
+     * URL for the source file.
+     */
+    url: string
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Input_ as default }
+}
+
+/**
+ * Represents the source CSS.
+ *
+ * ```js
+ * const root  = postcss.parse(css, { from: file })
+ * const input = root.source.input
+ * ```
+ */
+declare class Input_ {
+  /**
+   * Input CSS source.
+   *
+   * ```js
+   * const input = postcss.parse('a{}', { from: file }).input
+   * input.css //=> "a{}"
+   * ```
+   */
+  css: string
+
+  /**
+   * The absolute path to the CSS source file defined
+   * with the `from` option.
+   *
+   * ```js
+   * const root = postcss.parse(css, { from: 'a.css' })
+   * root.source.input.file //=> '/home/ai/a.css'
+   * ```
+   */
+  file?: string
+
+  /**
+   * The flag to indicate whether or not the source code has Unicode BOM.
+   */
+  hasBOM: boolean
+
+  /**
+   * The unique ID of the CSS source. It will be created if `from` option
+   * is not provided (because PostCSS does not know the file path).
+   *
+   * ```js
+   * const root = postcss.parse(css)
+   * root.source.input.file //=> undefined
+   * root.source.input.id   //=> "<input css 8LZeVF>"
+   * ```
+   */
+  id?: string
+
+  /**
+   * The input source map passed from a compilation step before PostCSS
+   * (for example, from Sass compiler).
+   *
+   * ```js
+   * root.source.input.map.consumer().sources //=> ['a.sass']
+   * ```
+   */
+  map: PreviousMap
+
+  /**
+   * @param css  Input CSS source.
+   * @param opts Process options.
+   */
+  constructor(css: string, opts?: ProcessOptions)
+
+  error(
+    message: string,
+    start:
+      | {
+          column: number
+          line: number
+        }
+      | {
+          offset: number
+        },
+    end:
+      | {
+          column: number
+          line: number
+        }
+      | {
+          offset: number
+        },
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+
+  /**
+   * Returns `CssSyntaxError` with information about the error and its position.
+   */
+  error(
+    message: string,
+    line: number,
+    column: number,
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+
+  error(
+    message: string,
+    offset: number,
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+
+  /**
+   * Converts source offset to line and column.
+   *
+   * @param offset Source offset.
+   */
+  fromOffset(offset: number): { col: number; line: number } | null
+  /**
+   * Reads the input source map and returns a symbol position
+   * in the input source (e.g., in a Sass file that was compiled
+   * to CSS before being passed to PostCSS). Optionally takes an
+   * end position, exclusive.
+   *
+   * ```js
+   * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }
+   * root.source.input.origin(1, 1, 1, 4)
+   * //=> { file: 'a.css', line: 3, column: 1, endLine: 3, endColumn: 4 }
+   * ```
+   *
+   * @param line      Line for inclusive start position in input CSS.
+   * @param column    Column for inclusive start position in input CSS.
+   * @param endLine   Line for exclusive end position in input CSS.
+   * @param endColumn Column for exclusive end position in input CSS.
+   *
+   * @return Position in input source.
+   */
+  origin(
+    line: number,
+    column: number,
+    endLine?: number,
+    endColumn?: number
+  ): false | Input.FilePosition
+  /**
+   * The CSS source identifier. Contains `Input#file` if the user
+   * set the `from` option, or `Input#id` if they did not.
+   *
+   * ```js
+   * const root = postcss.parse(css, { from: 'a.css' })
+   * root.source.input.from //=> "/home/ai/a.css"
+   *
+   * const root = postcss.parse(css)
+   * root.source.input.from //=> "<input css 1>"
+   * ```
+   */
+  get from(): string
+}
+
+declare class Input extends Input_ {}
+
+export = Input