mockaton 13.9.9 → 13.10.0

package/vite-plugin/node_modules/postcss/lib/root.js

@@ -1,61 +0,0 @@
-'use strict'
-
-let Container = require('./container')
-
-let LazyResult, Processor
-
-class Root extends Container {
-  constructor(defaults) {
-    super(defaults)
-    this.type = 'root'
-    if (!this.nodes) this.nodes = []
-  }
-
-  normalize(child, sample, type) {
-    let nodes = super.normalize(child)
-
-    if (sample) {
-      if (type === 'prepend') {
-        if (this.nodes.length > 1) {
-          sample.raws.before = this.nodes[1].raws.before
-        } else {
-          delete sample.raws.before
-        }
-      } else if (this.first !== sample) {
-        for (let node of nodes) {
-          node.raws.before = sample.raws.before
-        }
-      }
-    }
-
-    return nodes
-  }
-
-  removeChild(child, ignore) {
-    let index = this.index(child)
-
-    if (!ignore && index === 0 && this.nodes.length > 1) {
-      this.nodes[1].raws.before = this.nodes[index].raws.before
-    }
-
-    return super.removeChild(child)
-  }
-
-  toResult(opts = {}) {
-    let lazy = new LazyResult(new Processor(), this, opts)
-    return lazy.stringify()
-  }
-}
-
-Root.registerLazyResult = dependant => {
-  LazyResult = dependant
-}
-
-Root.registerProcessor = dependant => {
-  Processor = dependant
-}
-
-module.exports = Root
-Root.default = Root
-
-Container.registerRoot(Root)

package/vite-plugin/node_modules/postcss/lib/rule.d.ts

@@ -1,126 +0,0 @@
-import Container, {
-  ContainerProps,
-  ContainerWithChildren
-} from './container.js'
-
-declare namespace Rule {
-  export interface RuleRaws extends Record<string, unknown> {
-    /**
-     * The space symbols after the last child of the node to the end of the node.
-     */
-    after?: string
-
-    /**
-     * The space symbols before the node. It also stores `*`
-     * and `_` symbols before the declaration (IE hack).
-     */
-    before?: string
-
-    /**
-     * The symbols between the selector and `{` for rules.
-     */
-    between?: string
-
-    /**
-     * Contains the text of the semicolon after this rule.
-     */
-    ownSemicolon?: string
-
-    /**
-     * The rule’s selector with comments.
-     */
-    selector?: {
-      raw: string
-      value: string
-    }
-
-    /**
-     * Contains `true` if the last child has an (optional) semicolon.
-     */
-    semicolon?: boolean
-  }
-
-  export type RuleProps = {
-    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
-    raws?: RuleRaws
-  } & (
-    | {
-        /** Selector or selectors of the rule. */
-        selector: string
-        selectors?: never
-      }
-    | {
-        selector?: never
-        /** Selectors of the rule represented as an array of strings. */
-        selectors: readonly string[]
-      }
-  ) &
-    ContainerProps
-
-  export { Rule_ as default }
-}
-
-/**
- * Represents a CSS rule: a selector followed by a declaration block.
- *
- * ```js
- * Once (root, { Rule }) {
- *   let a = new Rule({ selector: 'a' })
- *   a.append(…)
- *   root.append(a)
- * }
- * ```
- *
- * ```js
- * const root = postcss.parse('a{}')
- * const rule = root.first
- * rule.type       //=> 'rule'
- * rule.toString() //=> 'a{}'
- * ```
- */
-declare class Rule_ extends Container {
-  nodes: NonNullable<Container['nodes']>
-  parent: ContainerWithChildren | undefined
-  raws: Rule.RuleRaws
-  type: 'rule'
-  /**
-   * The rule’s full selector represented as a string.
-   *
-   * ```js
-   * const root = postcss.parse('a, b { }')
-   * const rule = root.first
-   * rule.selector //=> 'a, b'
-   * ```
-   */
-  get selector(): string
-
-  set selector(value: string)
-  /**
-   * An array containing the rule’s individual selectors.
-   * Groups of selectors are split at commas.
-   *
-   * ```js
-   * const root = postcss.parse('a, b { }')
-   * const rule = root.first
-   *
-   * rule.selector  //=> 'a, b'
-   * rule.selectors //=> ['a', 'b']
-   *
-   * rule.selectors = ['a', 'strong']
-   * rule.selector //=> 'a, strong'
-   * ```
-   */
-  get selectors(): string[]
-
-  set selectors(values: string[])
-
-  constructor(defaults?: Rule.RuleProps)
-  assign(overrides: object | Rule.RuleProps): this
-  clone(overrides?: Partial<Rule.RuleProps>): this
-  cloneAfter(overrides?: Partial<Rule.RuleProps>): this
-  cloneBefore(overrides?: Partial<Rule.RuleProps>): this
-}
-
-declare class Rule extends Rule_ {}
-
-export = Rule

package/vite-plugin/node_modules/postcss/lib/rule.js

@@ -1,27 +0,0 @@
-'use strict'
-
-let Container = require('./container')
-let list = require('./list')
-
-class Rule extends Container {
-  get selectors() {
-    return list.comma(this.selector)
-  }
-
-  set selectors(values) {
-    let match = this.selector ? this.selector.match(/,\s*/) : null
-    let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen')
-    this.selector = values.join(sep)
-  }
-
-  constructor(defaults) {
-    super(defaults)
-    this.type = 'rule'
-    if (!this.nodes) this.nodes = []
-  }
-}
-
-module.exports = Rule
-Rule.default = Rule
-
-Container.registerRule(Rule)

package/vite-plugin/node_modules/postcss/lib/stringifier.d.ts

@@ -1,45 +0,0 @@
-import {
-  AnyNode,
-  AtRule,
-  Builder,
-  Comment,
-  Container,
-  Declaration,
-  Document,
-  Root,
-  Rule
-} from './postcss.js'
-
-declare namespace Stringifier {
-  export { Stringifier_ as default }
-}
-
-declare class Stringifier_ {
-  builder: Builder
-  constructor(builder: Builder)
-  atrule(node: AtRule, semicolon?: boolean): void
-  beforeAfter(node: AnyNode, detect: 'after' | 'before'): string
-  block(node: AnyNode, start: string): void
-  body(node: Container): void
-  comment(node: Comment): void
-  decl(node: Declaration, semicolon?: boolean): void
-  document(node: Document): void
-  raw(node: AnyNode, own: null | string, detect?: string): boolean | string
-  rawBeforeClose(root: Root): string | undefined
-  rawBeforeComment(root: Root, node: Comment): string | undefined
-  rawBeforeDecl(root: Root, node: Declaration): string | undefined
-  rawBeforeOpen(root: Root): string | undefined
-  rawBeforeRule(root: Root): string | undefined
-  rawColon(root: Root): string | undefined
-  rawEmptyBody(root: Root): string | undefined
-  rawIndent(root: Root): string | undefined
-  rawSemicolon(root: Root): boolean | undefined
-  rawValue(node: AnyNode, prop: string): number | string
-  root(node: Root): void
-  rule(node: Rule): void
-  stringify(node: AnyNode, semicolon?: boolean): void
-}
-
-declare class Stringifier extends Stringifier_ {}
-
-export = Stringifier

package/vite-plugin/node_modules/postcss/lib/stringifier.js

@@ -1,370 +0,0 @@
-'use strict'
-
-// Escapes sequences that could break out of an HTML <style> context.
-// Uses CSS unicode escaping (\3c = '<') which is valid CSS and parsed
-// correctly by all compliant CSS consumers.
-const STYLE_TAG = /(<)(\/?style\b)/gi
-const COMMENT_OPEN = /(<)(!--)/g
-
-function escapeHTMLInCSS(str) {
-  if (typeof str !== 'string') return str
-  if (!str.includes('<')) return str
-  return str.replace(STYLE_TAG, '\\3c $2').replace(COMMENT_OPEN, '\\3c $2')
-}
-
-const DEFAULT_RAW = {
-  after: '\n',
-  beforeClose: '\n',
-  beforeComment: '\n',
-  beforeDecl: '\n',
-  beforeOpen: ' ',
-  beforeRule: '\n',
-  colon: ': ',
-  commentLeft: ' ',
-  commentRight: ' ',
-  emptyBody: '',
-  indent: '    ',
-  semicolon: false
-}
-
-function capitalize(str) {
-  return str[0].toUpperCase() + str.slice(1)
-}
-
-class Stringifier {
-  constructor(builder) {
-    this.builder = builder
-  }
-
-  atrule(node, semicolon) {
-    let name = '@' + node.name
-    let params = node.params ? this.rawValue(node, 'params') : ''
-
-    if (typeof node.raws.afterName !== 'undefined') {
-      name += node.raws.afterName
-    } else if (params) {
-      name += ' '
-    }
-
-    if (node.nodes) {
-      this.block(node, name + params)
-    } else {
-      let end = (node.raws.between || '') + (semicolon ? ';' : '')
-      this.builder(escapeHTMLInCSS(name + params + end), node)
-    }
-  }
-
-  beforeAfter(node, detect) {
-    let value
-    if (node.type === 'decl') {
-      value = this.raw(node, null, 'beforeDecl')
-    } else if (node.type === 'comment') {
-      value = this.raw(node, null, 'beforeComment')
-    } else if (detect === 'before') {
-      value = this.raw(node, null, 'beforeRule')
-    } else {
-      value = this.raw(node, null, 'beforeClose')
-    }
-
-    let buf = node.parent
-    let depth = 0
-    while (buf && buf.type !== 'root') {
-      depth += 1
-      buf = buf.parent
-    }
-
-    if (value.includes('\n')) {
-      let indent = this.raw(node, null, 'indent')
-      if (indent.length) {
-        for (let step = 0; step < depth; step++) value += indent
-      }
-    }
-
-    return value
-  }
-
-  block(node, start) {
-    let between = this.raw(node, 'between', 'beforeOpen')
-    this.builder(escapeHTMLInCSS(start + between) + '{', node, 'start')
-
-    let after
-    if (node.nodes && node.nodes.length) {
-      this.body(node)
-      after = this.raw(node, 'after')
-    } else {
-      after = this.raw(node, 'after', 'emptyBody')
-    }
-
-    if (after) this.builder(escapeHTMLInCSS(after))
-    this.builder('}', node, 'end')
-  }
-
-  body(node) {
-    let last = node.nodes.length - 1
-    while (last > 0) {
-      if (node.nodes[last].type !== 'comment') break
-      last -= 1
-    }
-
-    let semicolon = this.raw(node, 'semicolon')
-    let isDocument = node.type === 'document'
-    for (let i = 0; i < node.nodes.length; i++) {
-      let child = node.nodes[i]
-      let before = this.raw(child, 'before')
-      if (before) this.builder(isDocument ? before : escapeHTMLInCSS(before))
-      this.stringify(child, last !== i || semicolon)
-    }
-  }
-
-  comment(node) {
-    let left = this.raw(node, 'left', 'commentLeft')
-    let right = this.raw(node, 'right', 'commentRight')
-    this.builder(escapeHTMLInCSS('/*' + left + node.text + right + '*/'), node)
-  }
-
-  decl(node, semicolon) {
-    let between = this.raw(node, 'between', 'colon')
-    let string = node.prop + between + this.rawValue(node, 'value')
-
-    if (node.important) {
-      string += node.raws.important || ' !important'
-    }
-
-    if (semicolon) string += ';'
-    this.builder(escapeHTMLInCSS(string), node)
-  }
-
-  document(node) {
-    this.body(node)
-  }
-
-  raw(node, own, detect) {
-    let value
-    if (!detect) detect = own
-
-    // Already had
-    if (own) {
-      value = node.raws[own]
-      if (typeof value !== 'undefined') return value
-    }
-
-    let parent = node.parent
-
-    if (detect === 'before') {
-      // Hack for first rule in CSS
-      if (!parent || (parent.type === 'root' && parent.first === node)) {
-        return ''
-      }
-
-      // `root` nodes in `document` should use only their own raws
-      if (parent && parent.type === 'document') {
-        return ''
-      }
-    }
-
-    // Floating child without parent
-    if (!parent) return DEFAULT_RAW[detect]
-
-    // Detect style by other nodes
-    let root = node.root()
-    if (!root.rawCache) root.rawCache = {}
-    if (typeof root.rawCache[detect] !== 'undefined') {
-      return root.rawCache[detect]
-    }
-
-    if (detect === 'before' || detect === 'after') {
-      return this.beforeAfter(node, detect)
-    } else {
-      let method = 'raw' + capitalize(detect)
-      if (this[method]) {
-        value = this[method](root, node)
-      } else {
-        root.walk(i => {
-          value = i.raws[own]
-          if (typeof value !== 'undefined') return false
-        })
-      }
-    }
-
-    if (typeof value === 'undefined') value = DEFAULT_RAW[detect]
-
-    root.rawCache[detect] = value
-    return value
-  }
-
-  rawBeforeClose(root) {
-    let value
-    root.walk(i => {
-      if (i.nodes && i.nodes.length > 0) {
-        if (typeof i.raws.after !== 'undefined') {
-          value = i.raws.after
-          if (value.includes('\n')) {
-            value = value.replace(/[^\n]+$/, '')
-          }
-          return false
-        }
-      }
-    })
-    if (value) value = value.replace(/\S/g, '')
-    return value
-  }
-
-  rawBeforeComment(root, node) {
-    let value
-    root.walkComments(i => {
-      if (typeof i.raws.before !== 'undefined') {
-        value = i.raws.before
-        if (value.includes('\n')) {
-          value = value.replace(/[^\n]+$/, '')
-        }
-        return false
-      }
-    })
-    if (typeof value === 'undefined') {
-      value = this.raw(node, null, 'beforeDecl')
-    } else if (value) {
-      value = value.replace(/\S/g, '')
-    }
-    return value
-  }
-
-  rawBeforeDecl(root, node) {
-    let value
-    root.walkDecls(i => {
-      if (typeof i.raws.before !== 'undefined') {
-        value = i.raws.before
-        if (value.includes('\n')) {
-          value = value.replace(/[^\n]+$/, '')
-        }
-        return false
-      }
-    })
-    if (typeof value === 'undefined') {
-      value = this.raw(node, null, 'beforeRule')
-    } else if (value) {
-      value = value.replace(/\S/g, '')
-    }
-    return value
-  }
-
-  rawBeforeOpen(root) {
-    let value
-    root.walk(i => {
-      if (i.type !== 'decl') {
-        value = i.raws.between
-        if (typeof value !== 'undefined') return false
-      }
-    })
-    return value
-  }
-
-  rawBeforeRule(root) {
-    let value
-    root.walk(i => {
-      if (i.nodes && (i.parent !== root || root.first !== i)) {
-        if (typeof i.raws.before !== 'undefined') {
-          value = i.raws.before
-          if (value.includes('\n')) {
-            value = value.replace(/[^\n]+$/, '')
-          }
-          return false
-        }
-      }
-    })
-    if (value) value = value.replace(/\S/g, '')
-    return value
-  }
-
-  rawColon(root) {
-    let value
-    root.walkDecls(i => {
-      if (typeof i.raws.between !== 'undefined') {
-        value = i.raws.between.replace(/[^\s:]/g, '')
-        return false
-      }
-    })
-    return value
-  }
-
-  rawEmptyBody(root) {
-    let value
-    root.walk(i => {
-      if (i.nodes && i.nodes.length === 0) {
-        value = i.raws.after
-        if (typeof value !== 'undefined') return false
-      }
-    })
-    return value
-  }
-
-  rawIndent(root) {
-    if (root.raws.indent) return root.raws.indent
-    let value
-    root.walk(i => {
-      let p = i.parent
-      if (p && p !== root && p.parent && p.parent === root) {
-        if (typeof i.raws.before !== 'undefined') {
-          let parts = i.raws.before.split('\n')
-          value = parts[parts.length - 1]
-          value = value.replace(/\S/g, '')
-          return false
-        }
-      }
-    })
-    return value
-  }
-
-  rawSemicolon(root) {
-    let value
-    root.walk(i => {
-      if (i.nodes && i.nodes.length && i.last.type === 'decl') {
-        value = i.raws.semicolon
-        if (typeof value !== 'undefined') return false
-      }
-    })
-    return value
-  }
-
-  rawValue(node, prop) {
-    let value = node[prop]
-    let raw = node.raws[prop]
-    if (raw && raw.value === value) {
-      return raw.raw
-    }
-
-    return value
-  }
-
-  root(node) {
-    this.body(node)
-    if (node.raws.after) {
-      let after = node.raws.after
-      let isDocument = node.parent && node.parent.type === 'document'
-      this.builder(isDocument ? after : escapeHTMLInCSS(after))
-    }
-  }
-
-  rule(node) {
-    this.block(node, this.rawValue(node, 'selector'))
-    if (node.raws.ownSemicolon) {
-      this.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end')
-    }
-  }
-
-  stringify(node, semicolon) {
-    /* c8 ignore start */
-    if (!this[node.type]) {
-      throw new Error(
-        'Unknown AST node type ' +
-          node.type +
-          '. ' +
-          'Maybe you need to change PostCSS stringifier.'
-      )
-    }
-    /* c8 ignore stop */
-    this[node.type](node, semicolon)
-  }
-}
-
-module.exports = Stringifier
-Stringifier.default = Stringifier

package/vite-plugin/node_modules/postcss/lib/stringify.d.ts

@@ -1,9 +0,0 @@
-import { Stringifier } from './postcss.js'
-
-interface Stringify extends Stringifier {
-  default: Stringify
-}
-
-declare let stringify: Stringify
-
-export = stringify

package/vite-plugin/node_modules/postcss/lib/stringify.js

@@ -1,11 +0,0 @@
-'use strict'
-
-let Stringifier = require('./stringifier')
-
-function stringify(node, builder) {
-  let str = new Stringifier(builder)
-  str.stringify(node)
-}
-
-module.exports = stringify
-stringify.default = stringify

package/vite-plugin/node_modules/postcss/lib/symbols.js

@@ -1,5 +0,0 @@
-'use strict'
-
-module.exports.isClean = Symbol('isClean')
-
-module.exports.my = Symbol('my')