create-yoya-ui 0.2.2 → 0.3.3

package/templates/admin/node_modules/postcss/lib/previous-map.js

@@ -1,176 +0,0 @@
-'use strict'
-
-let { existsSync, readFileSync, realpathSync } = require('fs')
-let { dirname, isAbsolute, join, relative, sep } = require('path')
-let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
-
-function realPath(path) {
-  try {
-    return realpathSync(path)
-  } catch {
-    // Missing or dangling: keep the literal path. The existsSync() check below
-    // still gates the read, and a path that does not exist cannot escape.
-    return path
-  }
-}
-
-function fromBase64(str) {
-  if (Buffer) {
-    return Buffer.from(str, 'base64').toString()
-  } else {
-    /* c8 ignore next 2 */
-    return window.atob(str)
-  }
-}
-
-class PreviousMap {
-  constructor(css, opts) {
-    if (opts.map === false) return
-    if (opts.unsafeMap) this.unsafeMap = true
-    this.loadAnnotation(css)
-    this.inline = this.startWith(this.annotation, 'data:')
-
-    let prev = opts.map ? opts.map.prev : undefined
-    let text = this.loadMap(opts.from, prev)
-    if (!this.mapFile && opts.from) {
-      this.mapFile = opts.from
-    }
-    if (this.mapFile) this.root = dirname(this.mapFile)
-    if (text) this.text = text
-  }
-
-  consumer() {
-    if (!this.consumerCache) {
-      this.consumerCache = new SourceMapConsumer(this.json || this.text)
-    }
-    return this.consumerCache
-  }
-
-  decodeInline(text) {
-    let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/
-    let baseUri = /^data:application\/json;base64,/
-    let charsetUri = /^data:application\/json;charset=utf-?8,/
-    let uri = /^data:application\/json,/
-
-    let uriMatch = text.match(charsetUri) || text.match(uri)
-    if (uriMatch) {
-      return decodeURIComponent(text.substr(uriMatch[0].length))
-    }
-
-    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri)
-    if (baseUriMatch) {
-      return fromBase64(text.substr(baseUriMatch[0].length))
-    }
-
-    let encoding = text.slice('data:application/json;'.length)
-    encoding = encoding.slice(0, encoding.indexOf(','))
-    throw new Error('Unsupported source map encoding ' + encoding)
-  }
-
-  getAnnotationURL(sourceMapString) {
-    return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
-  }
-
-  isMap(map) {
-    if (typeof map !== 'object') return false
-    return (
-      typeof map.mappings === 'string' ||
-      typeof map._mappings === 'string' ||
-      Array.isArray(map.sections)
-    )
-  }
-
-  loadAnnotation(css) {
-    let comments = css.match(/\/\*\s*# sourceMappingURL=/g)
-    if (!comments) return
-
-    // sourceMappingURLs from comments, strings, etc.
-    let start = css.lastIndexOf(comments.pop())
-    let end = css.indexOf('*/', start)
-
-    if (start > -1 && end > -1) {
-      // Locate the last sourceMappingURL to avoid pickin
-      this.annotation = this.getAnnotationURL(css.substring(start, end))
-    }
-  }
-
-  loadFile(path, cssFile, trusted) {
-    if (!trusted && !this.unsafeMap) {
-      if (!/\.map$/i.test(path)) return undefined
-      if (!cssFile) return undefined
-
-      // Compare *resolved* paths: relative() is textual, so without this a
-      // symlink at or below the CSS file's directory points the map outside it.
-      let rel = relative(realPath(dirname(cssFile)), realPath(path))
-      if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel)) {
-        return undefined
-      }
-    }
-    this.root = dirname(path)
-    if (existsSync(path)) {
-      this.mapFile = path
-      return readFileSync(path, 'utf-8').toString().trim()
-    }
-  }
-
-  loadMap(file, prev) {
-    if (prev === false) return false
-
-    if (prev) {
-      if (typeof prev === 'string') {
-        return prev
-      } else if (typeof prev === 'function') {
-        let prevPath = prev(file)
-        if (prevPath) {
-          let map = this.loadFile(prevPath, file, true)
-          if (!map) {
-            throw new Error(
-              'Unable to load previous source map: ' + prevPath.toString()
-            )
-          }
-          return map
-        }
-      } else if (prev instanceof SourceMapConsumer) {
-        return SourceMapGenerator.fromSourceMap(prev).toString()
-      } else if (prev instanceof SourceMapGenerator) {
-        return prev.toString()
-      } else if (this.isMap(prev)) {
-        return JSON.stringify(prev)
-      } else {
-        throw new Error(
-          'Unsupported previous source map format: ' + prev.toString()
-        )
-      }
-    } else if (this.inline) {
-      return this.decodeInline(this.annotation)
-    } else if (this.annotation) {
-      let map = this.annotation
-      if (file) map = join(dirname(file), map)
-      let unknown = this.loadFile(map, file, false)
-      if (unknown) {
-        try {
-          /* c8 ignore next 4 */
-          this.json = JSON.parse(unknown.replace(/^\)]}'[^\n]*\n/, ''))
-        } catch {
-          return undefined
-        }
-      }
-      return unknown
-    }
-  }
-
-  startWith(string, start) {
-    if (!string) return false
-    return string.substr(0, start.length) === start
-  }
-
-  withContent() {
-    return !!(
-      this.consumer().sourcesContent &&
-      this.consumer().sourcesContent.length > 0
-    )
-  }
-}
-
-module.exports = PreviousMap
-PreviousMap.default = PreviousMap

package/templates/admin/node_modules/postcss/lib/processor.d.ts

@@ -1,114 +0,0 @@
-import Document from './document.js'
-import LazyResult from './lazy-result.js'
-import NoWorkResult from './no-work-result.js'
-import {
-  AcceptedPlugin,
-  Plugin,
-  ProcessOptions,
-  TransformCallback,
-  Transformer
-} from './postcss.js'
-import Result from './result.js'
-import Root from './root.js'
-
-declare namespace Processor {
-  export { Processor_ as default }
-}
-
-/**
- * Contains plugins to process CSS. Create one `Processor` instance,
- * initialize its plugins, and then use that instance on numerous CSS files.
- *
- * ```js
- * const processor = postcss([autoprefixer, postcssNested])
- * processor.process(css1).then(result => console.log(result.css))
- * processor.process(css2).then(result => console.log(result.css))
- * ```
- */
-declare class Processor_ {
-  /**
-   * Plugins added to this processor.
-   *
-   * ```js
-   * const processor = postcss([autoprefixer, postcssNested])
-   * processor.plugins.length //=> 2
-   * ```
-   */
-  plugins: (Plugin | TransformCallback | Transformer)[]
-
-  /**
-   * Current PostCSS version.
-   *
-   * ```js
-   * if (result.processor.version.split('.')[0] !== '6') {
-   *   throw new Error('This plugin works only with PostCSS 6')
-   * }
-   * ```
-   */
-  version: string
-
-  /**
-   * @param plugins PostCSS plugins
-   */
-  constructor(plugins?: readonly AcceptedPlugin[])
-
-  /**
-   * Parses source CSS and returns a `LazyResult` Promise proxy.
-   * Because some plugins can be asynchronous it doesn’t make
-   * any transformations. Transformations will be applied
-   * in the `LazyResult` methods.
-   *
-   * ```js
-   * processor.process(css, { from: 'a.css', to: 'a.out.css' })
-   *   .then(result => {
-   *      console.log(result.css)
-   *   })
-   * ```
-   *
-   * @param css String with input CSS or any object with a `toString()` method,
-   *            like a Buffer. Optionally, send a `Result` instance
-   *            and the processor will take the `Root` from it.
-   * @param opts Options.
-   * @return Promise proxy.
-   */
-  process(
-    css: { toString(): string } | LazyResult | Result | Root | string
-  ): LazyResult | NoWorkResult
-  process<RootNode extends Document | Root = Root>(
-    css: { toString(): string } | LazyResult | Result | Root | string,
-    options: ProcessOptions<RootNode>
-  ): LazyResult<RootNode>
-
-  /**
-   * Adds a plugin to be used as a CSS processor.
-   *
-   * PostCSS plugin can be in 4 formats:
-   * * A plugin in `Plugin` format.
-   * * A plugin creator function with `pluginCreator.postcss = true`.
-   *   PostCSS will call this function without argument to get plugin.
-   * * A function. PostCSS will pass the function a {@link Root}
-   *   as the first argument and current `Result` instance
-   *   as the second.
-   * * Another `Processor` instance. PostCSS will copy plugins
-   *   from that instance into this one.
-   *
-   * Plugins can also be added by passing them as arguments when creating
-   * a `postcss` instance (see [`postcss(plugins)`]).
-   *
-   * Asynchronous plugins should return a `Promise` instance.
-   *
-   * ```js
-   * const processor = postcss()
-   *   .use(autoprefixer)
-   *   .use(postcssNested)
-   * ```
-   *
-   * @param plugin PostCSS plugin or `Processor` with plugins.
-   * @return Current processor to make methods chain.
-   */
-  use(plugin: AcceptedPlugin): this
-}
-
-declare class Processor extends Processor_ {}
-
-export = Processor

package/templates/admin/node_modules/postcss/lib/processor.js

@@ -1,67 +0,0 @@
-'use strict'
-
-let Document = require('./document')
-let LazyResult = require('./lazy-result')
-let NoWorkResult = require('./no-work-result')
-let Root = require('./root')
-
-class Processor {
-  constructor(plugins = []) {
-    this.version = '8.5.26'
-    this.plugins = this.normalize(plugins)
-  }
-
-  normalize(plugins) {
-    let normalized = []
-    for (let i of plugins) {
-      if (i.postcss === true) {
-        i = i()
-      } else if (i.postcss) {
-        i = i.postcss
-      }
-
-      if (typeof i === 'object' && Array.isArray(i.plugins)) {
-        normalized = normalized.concat(i.plugins)
-      } else if (typeof i === 'object' && i.postcssPlugin) {
-        normalized.push(i)
-      } else if (typeof i === 'function') {
-        normalized.push(i)
-      } else if (typeof i === 'object' && (i.parse || i.stringify)) {
-        if (process.env.NODE_ENV !== 'production') {
-          throw new Error(
-            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +
-              'one of the syntax/parser/stringifier options as outlined ' +
-              'in your PostCSS runner documentation.'
-          )
-        }
-      } else {
-        throw new Error(i + ' is not a PostCSS plugin')
-      }
-    }
-    return normalized
-  }
-
-  process(css, opts = {}) {
-    if (
-      !this.plugins.length &&
-      !opts.parser &&
-      !opts.stringifier &&
-      !opts.syntax
-    ) {
-      return new NoWorkResult(this, css, opts)
-    } else {
-      return new LazyResult(this, css, opts)
-    }
-  }
-
-  use(plugin) {
-    this.plugins = this.plugins.concat(this.normalize([plugin]))
-    return this
-  }
-}
-
-module.exports = Processor
-Processor.default = Processor
-
-Root.registerProcessor(Processor)
-Document.registerProcessor(Processor)

package/templates/admin/node_modules/postcss/lib/result.d.ts

@@ -1,204 +0,0 @@
-import {
-  Document,
-  Node,
-  Plugin,
-  ProcessOptions,
-  Root,
-  SourceMap,
-  TransformCallback,
-  Warning,
-  WarningOptions
-} from './postcss.js'
-import Processor from './processor.js'
-
-declare namespace Result {
-  export interface Message {
-    [others: string]: any
-
-    /**
-     * Source PostCSS plugin name.
-     */
-    plugin?: string
-
-    /**
-     * Message type.
-     */
-    type: string
-  }
-
-  export interface ResultOptions extends ProcessOptions {
-    /**
-     * The CSS node that was the source of the warning.
-     */
-    node?: Node
-
-    /**
-     * Name of plugin that created this warning. `Result#warn` will fill it
-     * automatically with `Plugin#postcssPlugin` value.
-     */
-    plugin?: string
-  }
-
-  export { Result_ as default }
-}
-
-/**
- * Provides the result of the PostCSS transformations.
- *
- * A Result instance is returned by `LazyResult#then`
- * or `Root#toResult` methods.
- *
- * ```js
- * postcss([autoprefixer]).process(css).then(result => {
- *  console.log(result.css)
- * })
- * ```
- *
- * ```js
- * const result2 = postcss.parse(css).toResult()
- * ```
- */
-declare class Result_<RootNode = Document | Root> {
-  /**
-   * A CSS string representing of `Result#root`.
-   *
-   * ```js
-   * postcss.parse('a{}').toResult().css //=> "a{}"
-   * ```
-   */
-  css: string
-
-  /**
-   * Last runned PostCSS plugin.
-   */
-  lastPlugin: Plugin | TransformCallback
-
-  /**
-   * An instance of `SourceMapGenerator` class from the `source-map` library,
-   * representing changes to the `Result#root` instance.
-   *
-   * ```js
-   * result.map.toJSON() //=> { version: 3, file: 'a.css', … }
-   * ```
-   *
-   * ```js
-   * if (result.map) {
-   *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())
-   * }
-   * ```
-   */
-  map: SourceMap
-
-  /**
-   * Contains messages from plugins (e.g., warnings or custom messages).
-   * Each message should have type and plugin properties.
-   *
-   * ```js
-   * AtRule: {
-   *   import: (atRule, { result }) {
-   *     const importedFile = parseImport(atRule)
-   *     result.messages.push({
-   *       type: 'dependency',
-   *       plugin: 'postcss-import',
-   *       file: importedFile,
-   *       parent: result.opts.from
-   *     })
-   *   }
-   * }
-   * ```
-   */
-  messages: Result.Message[]
-
-  /**
-   * Options from the `Processor#process` or `Root#toResult` call
-   * that produced this Result instance.]
-   *
-   * ```js
-   * root.toResult(opts).opts === opts
-   * ```
-   */
-  opts: Result.ResultOptions
-
-  /**
-   * The Processor instance used for this transformation.
-   *
-   * ```js
-   * for (const plugin of result.processor.plugins) {
-   *   if (plugin.postcssPlugin === 'postcss-bad') {
-   *     throw 'postcss-good is incompatible with postcss-bad'
-   *   }
-   * })
-   * ```
-   */
-  processor: Processor
-
-  /**
-   * Root node after all transformations.
-   *
-   * ```js
-   * root.toResult().root === root
-   * ```
-   */
-  root: RootNode
-
-  /**
-   * An alias for the `Result#css` property.
-   * Use it with syntaxes that generate non-CSS output.
-   *
-   * ```js
-   * result.css === result.content
-   * ```
-   */
-  get content(): string
-
-  /**
-   * @param processor Processor used for this transformation.
-   * @param root      Root node after all transformations.
-   * @param opts      Options from the `Processor#process` or `Root#toResult`.
-   */
-  constructor(processor: Processor, root: RootNode, opts: Result.ResultOptions)
-
-  /**
-   * Returns for `Result#css` content.
-   *
-   * ```js
-   * result + '' === result.css
-   * ```
-   *
-   * @return String representing of `Result#root`.
-   */
-  toString(): string
-
-  /**
-   * Creates an instance of `Warning` and adds it to `Result#messages`.
-   *
-   * ```js
-   * if (decl.important) {
-   *   result.warn('Avoid !important', { node: decl, word: '!important' })
-   * }
-   * ```
-   *
-   * @param text Warning message.
-   * @param opts Warning options.
-   * @return Created warning.
-   */
-  warn(message: string, options?: WarningOptions): Warning
-
-  /**
-   * Returns warnings from plugins. Filters `Warning` instances
-   * from `Result#messages`.
-   *
-   * ```js
-   * result.warnings().forEach(warn => {
-   *   console.warn(warn.toString())
-   * })
-   * ```
-   *
-   * @return Warnings from plugins.
-   */
-  warnings(): Warning[]
-}
-
-declare class Result<RootNode = Document | Root> extends Result_<RootNode> {}
-
-export = Result

package/templates/admin/node_modules/postcss/lib/result.js

@@ -1,42 +0,0 @@
-'use strict'
-
-let Warning = require('./warning')
-
-class Result {
-  get content() {
-    return this.css
-  }
-
-  constructor(processor, root, opts) {
-    this.processor = processor
-    this.messages = []
-    this.root = root
-    this.opts = opts
-    this.css = ''
-    this.map = undefined
-  }
-
-  toString() {
-    return this.css
-  }
-
-  warn(text, opts = {}) {
-    if (!opts.plugin) {
-      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
-        opts.plugin = this.lastPlugin.postcssPlugin
-      }
-    }
-
-    let warning = new Warning(text, opts)
-    this.messages.push(warning)
-
-    return warning
-  }
-
-  warnings() {
-    return this.messages.filter(i => i.type === 'warning')
-  }
-}
-
-module.exports = Result
-Result.default = Result

package/templates/admin/node_modules/postcss/lib/root.d.ts

@@ -1,86 +0,0 @@
-import Container, { ContainerProps } from './container.js'
-import Document from './document.js'
-import { ProcessOptions } from './postcss.js'
-import Result from './result.js'
-
-declare namespace Root {
-  export interface RootRaws extends Record<string, any> {
-    /**
-     * The space symbols after the last child to the end of file.
-     */
-    after?: string
-
-    /**
-     * Non-CSS code after `Root`, when `Root` is inside `Document`.
-     *
-     * **Experimental:** some aspects of this node could change within minor
-     * or patch version releases.
-     */
-    codeAfter?: string
-
-    /**
-     * Non-CSS code before `Root`, when `Root` is inside `Document`.
-     *
-     * **Experimental:** some aspects of this node could change within minor
-     * or patch version releases.
-     */
-    codeBefore?: string
-
-    /**
-     * Is the last child has an (optional) semicolon.
-     */
-    semicolon?: boolean
-  }
-
-  export interface RootProps extends ContainerProps {
-    /**
-     * Information used to generate byte-to-byte equal node string
-     * as it was in the origin input.
-     * */
-    raws?: RootRaws
-  }
-
-  export { Root_ as default }
-}
-
-/**
- * Represents a CSS file and contains all its parsed nodes.
- *
- * ```js
- * const root = postcss.parse('a{color:black} b{z-index:2}')
- * root.type         //=> 'root'
- * root.nodes.length //=> 2
- * ```
- */
-declare class Root_ extends Container {
-  nodes: NonNullable<Container['nodes']>
-  parent: Document | undefined
-  raws: Root.RootRaws
-  type: 'root'
-
-  constructor(defaults?: Root.RootProps)
-
-  assign(overrides: object | Root.RootProps): this
-  clone(overrides?: Partial<Root.RootProps>): this
-  cloneAfter(overrides?: Partial<Root.RootProps>): this
-  cloneBefore(overrides?: Partial<Root.RootProps>): this
-
-  /**
-   * Returns a `Result` instance representing the root’s CSS.
-   *
-   * ```js
-   * const root1 = postcss.parse(css1, { from: 'a.css' })
-   * const root2 = postcss.parse(css2, { from: 'b.css' })
-   * root1.append(root2)
-   * const result = root1.toResult({ to: 'all.css', map: true })
-   * ```
-   *
-   * @param options Options.
-   * @return Result with current root’s CSS.
-   */
-  toResult(options?: ProcessOptions): Result
-}
-
-declare class Root extends Root_ {}
-
-export = Root