biobulkbende/biobulkbende.org
0
0
Fork 0
mirror of https://github.com/biobulkbende/biobulkbende.org.git synced 2025-10-11 23:25:00 +00:00
Code Issues Projects Releases Wiki Activity

structure, layout and automation

Browse Source
This commit is contained in:
Tancre
2020-09-16 14:23:28 +02:00
commit 0efda7fffe
15549 changed files with 1280031 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

985
node_modules/autoprefixer/CHANGELOG.md generated vendored Normal file
View File

@ -0,0 +1,985 @@
# Change Log
This project adheres to [Semantic Versioning](http://semver.org/).
## 9.8.6
* Fixed `env` option.
## 9.8.5
* Improved Grid Layout warnings (by Daniel Tonon).
* Fixed `align-self` and `justify-self` with `display: flex` (by Daniel Tonon).
## 9.8.4
* Replace color output library.
## 9.8.3
* Return old non-LTS Node.js versions to avoid breaking changes.
## 9.8.2
* Remove Node.js 13.0-13.7 from supported engines, because of buggy ESM support.
## 9.8.1
* Replace `chalk` to `kleur` (by Luke Edwards).
* Update docs (by @mbomb007).
## 9.8 “Vigilo Confido”
* Add `:placeholder-shown` support (by Tanguy Krotoff).
## 9.7.6
* Revert `-webkit-stretch` fix.
## 9.7.5
* Fix `-webkit-stretch` support.
## 9.7.4
* Fix warning text (by Dmitry Ishkov).
## 9.7.3
* Fix compatibility with PostCSS Modules.
## 9.7.2
* Add `-ms-user-select: element` support.
* Add funding link for `npm fund`.
## 9.7.1
* Avoid unnecessary transitions in prefixed selectors (by Andrey Alexandrov).
* Fix `fit-content` for Firefox.
## 9.7 “Ad Victoriam”
* Add `AUTOPREFIXER_GRID` env variable to enable Grid Layout polyfill for IE.
* Fix `Cannot read property 'grid' of undefined` error.
## 9.6.5
* Fix selector prefixing (by Andrey Alexandrov).
## 9.6.4
* Now the real fix for `'startsWith' of undefined` error.
## 9.6.3
* Fix `Cannot read property 'startsWith' of undefined` error.
## 9.6.2
* Fix false `Replace fill to stretch` warning.
## 9.6.1
* Fix `-webkit-line-clamp` truncating multi-line text support.
## 9.6 “Nunc id vides, nunc ne vides”
* Show warning about Browserslist config on `browser` option.
* Add warning-less `overrideBrowserslist` option.
* Add `text-orientation` support.
* Add `min-resolution: 2x` alias support.
* Add `.github/CONTRIBUTING.md` (by Juan Martin Marco).
## 9.5.1
* Fix `backdrop-filter` for Edge (by Oleh Aloshkin).
* Fix `min-resolution` media query support in Firefox < 16.
## 9.5 “Draco dormiens nunquam titillandus”
* Add `mask-composite` support (by Semen Levenson).
## 9.4.10
* Add warning for named Grid rows.
## 9.4.9
* Fix `grid-template` and `@media` case (by Bogdan Dolin).
## 9.4.8
* Fix `calc()` support in Grid gap.
## 9.4.7
* Fix infinite loop on mismatched parens.
## 9.4.6
* Fix warning text (by Albert Juhé Lluveras).
## 9.4.5
* Fix `text-decoration-skip-ink` support.
## 9.4.4
* Use `direction` value for `-ms-writing-mode` (by Denys Kniazevych).
* Fix warning text (by @zzzzBov).
## 9.4.3
* Add warning to force `flex-start` instead of `start` (by Antoine du Hamel).
* Fix docs (by Christian Oliff).
## 9.4.2
* Fix Grid autoplacement warning.
## 9.4.1
* Fix unnecessary Flexbox prefixes in Grid elements.
## 9.4 “Advance Australia”
* Add Grid autoplacement for `-ms-` (by Bogdan Dolin).
* Improve docs and warnings (by Daniel Tonon).
* Remove some unnecessary warnings for Grid (by Andrey Alexandrov).
## 9.3.1
* Fix Grid prefixes with `repeat()` value (by Bogdan Dolin).
## 9.3 “Labor omnia vincit”
* Add `place-self` support (by Bogdan Dolin).
* Fix Grid row/column span inheritance bug (by Bogdan Dolin).
## 9.2.1
* Fix broken AST.
## 9.2 “Onyi est glavnaya krepost”
* Add `/* autoprefixer grid: on */` control comment (by Andrey Alexandrov).
* Add duplicate `grid-area` support (by Bogdan Dolin).
* Fix `grid-gap` support for rules with different specifity (by Bogdan Dolin).
* Disable Grid in `@supports` at-rule with non-supported Grid features.
* Improve Grid warnings (by Daniel Tonon).
* Improve docs (by Joshua Hall, Mat Gadd, Roy Revelt, and Ivan).
## 9.1.5
* Remove `@babel/register` from dependencies.
## 9.1.4
* Use Babel 7.
## 9.1.3
* Sort properties in `autoprefixer --info` alphabetically.
* Fix old Firefox gradient prefix.
## 9.1.2
* Fix `autoprefixer --info` in new Node.js.
## 9.1.1
* Retain `grid-gap` through `@media` (by Bogdan Dolin).
* Fix `grid-template` and `@media` (by Bogdan Dolin).
* Fix Grid areas searching error (by Bogdan Dolin).
* Fix `span X` Grid prefix (by Bogdan Dolin).
* Fix docs (by Eduard Kyvenko).
## 9.1 “Equality before the law”
* Add `background-clip: text` support.
* Fix adding Grid span for IE (by Bogdan Dolin).
## 9.0.2
* Show warning on Grid area names conflict (by Bogdan Dolin).
* Fix documentation (by Sven Wagner).
## 9.0.1
* Fix nested at-rules in Grid prefixes (by Ivan Malov).
## 9.0 “A Mari Usque Ad Mare”
* Remove Node.js 9 and Node.js 4 support.
* Remove IE and “dead” browsers from Babel.
* Use PostCSS 7.0.
* Use Browserslist 4.0.
## 8.6.5
* Do not show Grid warnings if IE was not selected.
## 8.6.4
* Fix `stretch` prefix in Chrome >= 46.
## 8.6.3
* Add warnings for unsupported Grid features.
* Add warnings about wrong Grid properties.
* Add note about `grid` option for grid properties in `autoprefixer --info`.
## 8.6.2
* Fix error during adding Grid prefixes in `@media` (by Evgeny Petukhov).
## 8.6.1
* Fix `grid-template` with media queries (by Evgeny Petukhov).
## 8.6 “Follow Reason”
* Add `gap` support (by Evgeny Petukhov).
* Add two values support for `grid-gap` and `gap` (by Evgeny Petukhov).
* Add `ignoreUnknownVersions` option for Browserslist.
## 8.5.2
* Fix `grid-template` support wit auto row sizes (by Yury Timofeev).
## 8.5.1
* Remove unnecessary warning on `-webkit-fill-available`.
## 8.5 “Muito Nobre e Sempre Leal”
* Add `grid-gap` support (by Evgeny Petukhov).
* Fix radial gradients direction fix.
* Fix docs (by Phani Kandula and Huáng Jùnliàng).
## 8.4.1
* Fix working in old PostCSS versions (by Diablohu).
## 8.4 “Non in aves, sed in angues”
* Add `/* autoprefixer: ignore next */` control comment (by Pavel Vostrikov).
## 8.3 “Benigno Numine”
* Add `@media` support to `grid-template` (by Evgeny Petukhov).
* Fix `radial-gradient` direction warning (by Gustavo Real).
## 8.2 “Ad Astra per Aspera”
* Add `color-adjust` (by Sergey Lysenko, Stanislav Botev, and Yuriy Alekseyev).
## 8.1 “Rex, Familia et Ultio”
* Add `overscroll-behavior` support.
* Add `grid-template` shortcut support (by Evgeny Petukhov).
* Add better `grid-column-end` and `grid-row-end` support (by Evgeny Petukhov).
* Fix Grid properties support in `@supports`.
## 8.0 “Excelsior”
* Use Browserslist 3.0.
* Rename `autoprefixer-info` CLI tool to `autoprefixer --info`.
* Remove `break-*` to `page-break-*` conversion for Firefox.
## 7.2.6
* Fix `-ms-` prefix for grid cells with same `grid-area` (by Evgeny Petukhov).
## 7.2.5
* Fix multiple prefixes in declaration value.
## 7.2.4
* Fix IE 10 support.
## 7.2.3
* Fix `grid-template-areas` in `@media` (by Evgeny Petukhov).
## 7.2.2
* Fix `_autoprefixerDisabled is undefined` issue.
## 7.2.1
* Fix IE and other old JS runtimes support.
## 7.2 “Ordem e Progresso”
* Add `grid-template-areas` support (by Evgeny Petukhov).
* Add `grid-template` support (by Evgeny Petukhov).
* Add `grid-area` support (by Alexey Komarov).
* Add `autoprefixer-info` CLI tool.
* Add wrong `radial-gradient` properties warning.
* Use current working dir on missed `from` in `info()` (by Phil Dokas).
* Fix `grid-row` and `grid-column` support (by Alexey Komarov).
* Do not prefix `reverse` animation direction.
* Improve test coverage (by Dmitry Semigradsky).
## 7.1.6
* Add warning for using `browserslist` option instead of `browsers`.
* Add warning for multiple control comments in the same scope.
* Fix `Invalid array length` error during indent changes.
## 7.1.5
* Fix `::placeholder` prefix for Edge.
* Fix `inherit`/`initial`/`unset` values for `flex-direction`.
* Fix RegExp usage in gradients (by Yet Another Minion).
## 7.1.4
* Fix `radial-gradient` direction conversion.
* Fix `image-set` in `cursor`.
## 7.1.3
* Add warning for old `radial-gradient` direction syntax.
## 7.1.2
* Fix `text-decoration` shortcut support.
## 7.1.1
* Remove non-`-webkit-` intrinsic prefixes in Grid Layout (by 一丝).
## 7.1 “Universitas litterarum”
* Add `unicode-bidi` support.
* Add `-webkit-appearance` support for Edge.
* Add `from` option to `info()`.
* Fix intrinsic widths prefixes in Grid Layout.
## 7.0.1
* Fix Autoprefixer for old JS runtimes.
## 7.0 “Coelestem adspicit lucem”
* Remove node.js 0.12 support.
* Use PostCSS 6.0.
* Use Browserslist 2.
* Use `caniuse-lite` instead of `caniuse-db` (by Ben Briggs).
* Use `^` for Browserslist dependencies, instead of `~`.
* Rewrite project from CoffeeScript to Babel (by Dmitry Semigradsky).
* Disable Grid Layout prefixes for IE by default.
* Fix `-ms-grid-column-align`.
* Move tests to Jest.
## 6.7.7
* Fix `order` for non-digit values.
## 6.7.6
* Fix `font-kerning` (by Chi Vinh Le).
## 6.7.5
* Fix `text-decoration-skip` in iOS (by Chi Vinh Le).
* Fix `clip-path` (by Chi Vinh Le).
## 6.7.4
* Improve `browsers` option perfomance.
* Update CoffeeScript compiler.
## 6.7.3
* Fix compatibility with “Intrinsic & Extrinsic Sizing” spec update.
## 6.7.2
* Do not prefix grid/flexbox in `@supports` on `grid: false`/`flexbox: false`.
## 6.7.1
* Update Browserslist with `last n version` fix.
## 6.7 “Krungthep doot thep saang”
* Add Electron support in browsers list (by Kilian Valkhof).
* Add `flex-flow` partial support for Flexbox 2009 specification.
* Fix browsers `0` version issue in some Can I Use data.
## 6.6.1
* Add metadata to use Autoprefixer in JSS tests (by Chi Vinh Le).
## 6.6 “Kaiyuan”
* Add `browserslist` key in `package.json` support.
* Add support for separated environments in browserslist config.
* Add `browserslist-stats.json` file support to load custom usage statistics.
## 6.5.4
* Fix unitless 0 basis in IE10/IE11 shorthand flex (by Google).
## 6.5.3
* Add error for popular mistake with `browser` option instead of `browsers`.
## 6.5.2
* Clean prefixes data (by Reinaldo Schiehll).
## 6.5.1
* Fix selectors with `:--` prefix support.
## 6.5 “Einigkeit und Recht und Freiheit”
* Add `defaults` keyword to browsers requirements.
* Fix CSS Grid Layout support.
* Fix `align-self` cleaning.
## 6.4.1
* Fix node cloning after some PostCSS plugins.
## 6.4 “Hic et ubique terrarum”
* Add `:any-link` selector support.
* Add `text-decoration-skip` support.
* Add `transition: duration property` support.
* Fix `-webkit-` prefix for `backface-visibility`.
* Fix `rad` unit support in gradients (by 刘祺).
* Fix `transition` support in Opera 12.
* Removed Safari TP Grid prefixes support.
## 6.3.7
* Fix rare `Cannot read property 'constructor' of null` issue.
## 6.3.6
* Add Safari TP prefix support for Grid Layout.
## 6.3.5
* Fix duplicate prefixes for `-ms-interpolation-mode`.
## 6.3.4
* Show users coverage for selected browsers in `info()`.
## 6.3.3
* Fix transition warning.
## 6.3.2
* Fix jspm support (by Sean Anderson).
## 6.3.1
* Fix compatibility with Flexibility polyfill.
## 6.3 “Pro rege et lege”
* Add Grid Layout support.
* Add `text-spacing` support.
* Add `> 10% in my stats` browsers query with custom usage statistics.
* Add options to disable `@supports`, Flexbox or Grid support.
* Fix compatibility with other PostCSS plugins.
## 6.2.3
* Fix error on broken transition with double comma.
## 6.2.2
* Fix issues in broken transitions.
## 6.2.1
* Fix AST error in transition warning (by @jvdanilo).
## 6.2 “Fluctuat nec mergitur”
* Use `fill` instead of `fill-available` according spec changes (by 一丝).
* Add `fill` support for logical dimension properties (by 一丝).
* Add `text-emphasis` support (by 一丝).
* Add prefixes to `@supports` only for compatible browsers.
* Add `rad`, `grad` and `turn` units support to linear gradients.
* Add some `deg` directions support for old WebKit linear gradients.
* Fix `@supports` parenthesis (by @heady).
* Add warning when prefixes could not be generated
for complicated `transition-property` values.
* Add warning for outdated `fill-available` value.
* Add warning for wrong `text-emphasis-position` value.
* Add “time capsule” warning for prefix-less future.
* Normalizes all warning messages.
## 6.1.2
* Fix gradient hack on some parameters (by Alexey Efremov).
## 6.1.1
* Fix `cursor: grab` and `cursor: grabbing` support.
## 6.1 “Bil-shaʿb wa lil-shaʿb”
* Change `transition` support to output more robust CSS.
* Add `:read-only` support.
* Add support for `appearance` with any values.
* Add CSS-in-JS support via `postcss-js`.
* Add loud `/*! autoprefixer: off */` control comments support.
* Convert `rotateZ` to `rotate` for `-ms-transform`.
* Use `postcss-value-parser` to carefully work with gradients.
* Remove `-ms-transform-style` and `-o-transform-style` that never existed.
## 6.0.3
* Fix old gradient direction warning.
## 6.0.2
* Remove unnecessary `-khtml-` prefix too.
## 6.0.1
* Fix `cross-fade()` support (by 一丝).
## 6.0 “Eureka”
* CLI was removed from `autoprefixer` package to `autoprefixer-cli`.
* `autoprefixer-core` and `autoprefixer` packages was merged back.
* Remove `autoprefixer(opt).process(css)`, use `autoprefixer.process(css, opt)`.
* Remove `safe` option. Use separated Safe parser from PostCSS.
* Remove Opera 12.1 from default query.
* Use PostCSS 5.0 API.
* Add custom syntaxes support.
* Add `image-set` support (by 一丝).
* Add `mask-border` support (by 一丝).
* Add `filter()` function support (by Vincent De Oliveira).
* Add `backdrop-filter` support (by Vincent De Oliveira).
* Add `element()` support (by Vincent De Oliveira).
* Add CSS Regions support.
* Add Scroll Snap Points support.
* Add `writing-mode` support.
* Add `::backdrop` support.
* Add `cross-fade()` support.
* Add other `break-` properties support.
* Add Microsoft Edge support (by Andrey Polischuk).
* Add `not` keyword and exclude browsers by query.
* Add version ranges `IE 6-9` (by Ben Briggs).
* Fix `filter` in `transition` support on Safari.
* Fix `url()` parsing.
* Fix `pixelated` cleaning.
* Always show old gradient direction warning.
## 5.2.1
* Fix parent-less node issue on some cases (by Josh Gillies).
## 5.2 “Dont tread on me”
* Add `appearance` support.
* Warn users on old gradient direction or flexbox syntax.
* Add `add: false` option to disable new prefixes adding.
* Make Autoprefixer 30% faster.
* Use PostCSS 4.1 plugin API.
* Add prefixes for `pixelated` instead of `crisp-edges` in `image-rendering`.
* Do not add `::placeholder` prefixes for `:placeholder-shown`.
* Fix `text-decoration` prefixes.
* `autoprefixer.process()` was deprecated. Use PostCSS API.
## 5.1.11
* Update `num2fraction` to fix resolution media query (by 一丝).
## 5.1.10
* Do not generate `-webkit-image-rendering`.
## 5.1.9
* Fix DynJS compatibility (by Nick Howes).
## 5.1.8
* Fix gradients in `mask` and `mask-image` properties.
* Fix old webkit prefix on some unsupported gradients.
## 5.1.7
* Fix placeholder selector (by Vincent De Oliveira).
## 5.1.6
* Use official `::placeholder-shown` selector (by Vincent De Oliveira).
## 5.1.5
* Add transition support for CSS Masks properties.
## 5.1.4
* Use `-webkit-` prefix for Opera Mobile 24.
## 5.1.3
* Add IE support for `image-rendering: crisp-edges`.
## 5.1.2
* Add never existed `@-ms-keyframes` to common mistake.
## 5.1.1
* Safer value split in `flex` hack.
## 5.1 “Jianyuan”
* Add support for resolution media query (by 一丝).
* Higher accuracy while removing prefixes in values.
* Add support for logical properties (by 一丝).
* Add `@viewport` support.
* Add `text-overflow` support (by 一丝).
* Add `text-emphasis` support (by 一丝).
* Add `image-rendering: crisp-edges` support.
* Add `text-align-last` support.
* Return `autoprefixer.defaults` as alias to current `browserslist.defaults`.
* Save code style while adding prefixes to `@keyframes` and `@viewport`.
* Do not remove `-webkit-background-clip` with non-spec `text` value.
* Fix `-webkit-filter` in `transition`.
* Better support for browser versions joined on Can I Use
like `ios_saf 7.0-7.1` (by Vincent De Oliveira).
* Fix compatibility with `postcss-import` (by Jason Kuhrt).
* Fix Flexbox prefixes for BlackBerry and UC Browser.
* Fix gradient prefixes for old Chrome.
## 5.0 “Pravda vítězí”
* Use PostCSS 4.0.
* Use Browserslist to parse browsers queries.
* Use global `browserslist` config.
* Add `> 5% in US` query to select browsers by usage in some country.
* Add `object-fit` and `object-position` properties support.
* Add CSS Shape properties support.
* Fix UC Browser name in debug info.
* Remove `autoprefixer.defaults` and use defaults from Browserslist.
## 4.0.2
* Remove `o-border-radius`, which is common mistake in legacy CSS.
## 4.0.1
* Fix `@supports` support with brackets in values (by Vincent De Oliveira).
## 4.0 “Indivisibiliter ac Inseparabiliter”
* Become 2.5 times fatser by new PostCSS 3.0 parser.
* Do not remove outdated prefixes by `remove: false` option.
* `map.inline` and `map.sourcesContent` options are now `true` by default.
* Add `box-decoration-break` support.
* Do not add old `-webkit-` prefix for gradients with `px` units.
* Use previous source map to show origin source of CSS syntax error.
* Use `from` option from previous source map `file` field.
* Set `to` value to `from` if `to` option is missing.
* Trim Unicode BOM on source maps parsing.
* Parse at-rules without spaces like `@import"file"`.
* Better previous `sourceMappingURL` annotation comment cleaning.
* Do not remove previous `sourceMappingURL` comment on `map.annotation: false`.
## 3.1.2
* Update Firefox ESR version from 24 to 31.
## 3.1.1
* Use Flexbox 2009 spec for Android stock browser < 4.4.
## 3.1 “Satyameva Jayate”
* Do not remove comments from prefixed values (by Eitan Rousso).
* Allow Safari 6.1 to use final Flexbox spec (by John Kreitlow).
* Fix `filter` value in `transition` in Webkits.
* Show greetings if your browsers don’t require any prefixes.
* Add `<=` and `<` browsers requirement (by Andreas Lind).
## 3.0.1
* Fix `autoprefixer.postcss` in callbacks.
## 3.0 “Liberté, Égalité, Fraternité”
* Project was split to autoprefixer (with CLI) and autoprefixer-core.
* `autoprefixer()` now receives only `options` object with `browsers` key.
* GNU format for syntax error messages from PostCSS 2.2.
## 2.2 “Mobilis in mobili”
* Allow to disable Autoprefixer for some rule by control comment.
* Use PostCSS 2.1 with Safe Mode option and broken source line
in CSS syntax error messages.
## 2.1.1
* Fix `-webkit-background-size` hack for `contain` and `cover` values.
* Don’t add `-webkit-` prefix to `filter` with SVG (by Vincent De Oliveira).
## 2.1 “Eleftheria i thanatos”
* Add support for `clip-path` and `mask` properties.
* Return `-webkit-` prefix to `filter` with SVG URI.
## 2.0.2
* Add readable names for new browsers from 2.0 release.
* Don’t add `-webkit-` prefix to `filter` with SVG URI.
* Don’t add `-o-` prefix 3D transforms.
## 2.0.1
* Save declaration style, when clone declaration to prefix.
## 2.0 “Hongik Ingan”
* Based on PostCSS 1.0.
See [options changes](https://github.com/postcss/postcss/releases/tag/1.0.0).
* Restore visual cascade after declaration removing.
* Enable visual cascade by default.
* Prefix declareation in `@supports` at-rule conditions.
* Add all browsers from Can I Use: `ie_mob`, `and_chr`, `and_ff`,
`op_mob` and `op_mini`.
* Allow to use latest Autoprefixer from GitHub by npm.
* Add `--no-cascade`, `--annotation` and `--sources-content` options to binary.
## 1.3.1
* Fix gradient hack, when `background` property contains color.
## 1.3 “Tenka Fubu”
* Add `text-size-adjust` support.
* Add `background-size` to support Android 2.
## 1.2 “Meiji”
* Use Can I Use data from official `caniuse-db` npm package.
* Remove package data update from binary.
* Use increment value instead of current date in minor versions.
## 1.1 “Nutrisco et extingo”
* Add source map annotation comment support.
* Add inline source map support.
* Autodetect previous source map.
* Fix source maps support on Windows.
* Fix source maps support in subdirectory.
* Prefix selector even if it is already prefixed by developer.
* Add option `cascade` to create nice visual cascade of prefixes.
* Fix flexbox support for IE 10 (by Roland Warmerdam).
* Better `break-inside` support.
* Fix prefixing, when two same properties are near.
### 20140222
* Add `touch-action` support.
### 20140226
* Chrome 33 is moved to released versions.
* Add Chrome 36 data.
### 20140302
* Add `text-decoration-*` properties support.
* Update browsers usage statistics.
* Use new PostCSS version.
### 20140319
* Check already prefixed properties after current declaration.
* Normalize spaces before already prefixed check.
* Firefox 28 is moved to released versions.
* Add Firefox 31 data.
* Add some Blackberry data.
### 20140327
* Don’t use `-ms-transform` in `@keyframes`, because IE 9 doesn’t support
animations.
* Update BlackBerry 10 data.
### 20140403
* Update browsers usage statistics.
* Opera 20 is moved to released versions.
* Add Opera 22 data.
### 20140410
* Chrome 34 is moved to released versions.
* Add Chrome 37 data.
* Fix Chrome 36 data.
### 20140429
* Fix `display: inline-flex` support by 2009 spec.
* Fix old WebKit gradient converter (by Sergey Belov).
* Fix CSS 3 cursors data (by Nick Schonning).
### 20140430
* Separate 2D and 3D transform prefixes to clean unnecessary `-ms-` prefixes.
* Firefox 29 is moved to released versions.
* Add Firefox 32 data.
### 20140510
* Do not add `-ms-` prefix for `transform` with 3D functions.
* Update browsers global usage statistics.
### 20140512
* Remove unnecessary `-moz-` prefix for `wavy` in `text-decoration`.
* Update Safari data for font properties.
### 20140521
* Chrome 36 is moved to released versions.
* Add Chrome 38 data.
### 20140523
* Opera 21 is moved to released versions.
* Add Opera 23 data.
### 20140605
* Allow to parse gradients without space between color and position.
* Add iOS 8, Safari 8 and Android 4.4.3 data.
* Update browsers usage statistics.
## 1.0 “Plus ultra”
* Source map support.
* Save origin indents and code formatting.
* Change CSS parser to PostCSS.
* Preserve vendor-prefixed properties put right after unprefixed ones.
* Rename `compile()` to `process()` and return result object,
instead of CSS string.
* Rename `inspect()` to `info()`.
* Add in binary `-d` option to specify output directory.
* Binary now will not concat output files.
* Allow to select last versions for specified browser.
* Add full browser names aliases: `firefox`, `explorer` and `blackberry`.
* Ignore case in browser names.
* Change license to MIT.
* Add prefixes inside custom at-rules.
* Add only necessary prefixes to selector inside prefixed at-rule.
* Safer backgrounds list parser in gradient hack.
* Prefix `@keyframes` inside `@media`.
* Don’t prefix values for CSS3 PIE properties.
* Binary now shows file name in syntax error.
* Use browserify to build standalone version.
### 20131225
* Fix deprecated API convertor.
* Add `::placeholder` support for Firefix >= 18.
* Fix vendor prefixes order.
### 20140103
* Add `-webkit-` prefix for `sticky` position.
* Update browsers popularity statistics.
### 20140109
* Add selectors and at-rules sections to debug info.
* Fix outdated prefixes cleaning.
### 20140110
* Add `Firefox ESR` browser requirement.
* Opera 18 is moved to released versions.
* Add Opera 20 data.
### 20140117
* Chrome 32 is moved to released versions.
* Add Opera 34 data.
### 20140130
* Fix flexbox properties names in transitions.
* Add Chrome 35 and Firefox 29 data.
### 20140203
* Android 4.4 stock browser and Opera 19 are moved to released versions.
* Add Opera 21 data.
* Update browsers usage statistics.
### 20140213
* Add case insensitive to IE’s filter hack (by Dominik Schilling).
* Improve selector prefixing in some rare cases (by Simon Lydell).
* Firefox 27 is moved to released versions.
* Add Firefox 30 data.
## 0.8 “Unbowed, Unbent, Unbroken”
* Add more browsers to defaults ("> 1%, last 2 versions, ff 17, opera 12.1"
instead of just "last 2 browsers").
* Keep vendor prefixes without unprefixed version (like vendor-specific hacks).
* Convert gradients to old WebKit syntax (actual for Android 2.3).
* Better support for several syntaxes with one prefix (like Flexbox and
gradients in WebKit).
* Add intrinsic and extrinsic sizing values support.
* Remove never existed prefixes from common mistakes (like -ms-transition).
* Add Opera 17 data.
* Fix selector prefixes order.
* Fix browser versions order in inspect.
### 20130903
* Fix old WebKit gradients convertor on rgba() colors.
* Allow to write old direction syntax in gradients.
### 20130906
* Fix direction syntax in radial gradients.
* Don’t prefix IE filter with modern syntax.
### 20130911
* Fix parsing property name with spaces.
### 20130919
* Fix processing custom framework prefixes (by Johannes J. Schmidt).
* Concat outputs if several files compiled to one output.
* Decrease standalone build size by removing unnecessary Binary class.
* iOS 7 is moved to released versions.
* Clean up binary code (by Simon Lydell).
### 20130923
* Firefox 24 is moved to released versions.
### 20131001
* Add support for grab, grabbing, zoom-in and zoom-out cursor values.
### 20131006
* Chrome 30 is moved to released versions.
### 20131007
* Don’t add another prefixes in rule with prefixed selector.
### 20131009
* Opera 17 is moved to released versions.
### 20131015
* Fix converting multiple gradients to old webkit syntax (by Aleksei Androsov).
### 20131017
* Fix @host at-rule parsing.
### 20131020
* IE 11 and Andrid 4.3 is moved to released versions.
* Add Opera 18 data.
* Add @namespace support.
* Sort browser versions in data file.
### 20131029
* Add Safari 6.1 data.
* Add fx alias for Firefox.
### 20131104
* Update Android future version to 4.4.
* Google Chrome 32 added to future versions list.
* Firefox 25 now is actual version, 27 and 28 added to future versions.
* Browsers statistics are updated.
### 20131205
* Google Chrome 33 added to future releases list.
* Google Chrome 31 moved to current releases list.
### 20131209
* Use old webkit gradients for old iOS and Safari (by Chad von Nau).
* Fix direction conversion for old webkit gradients (by Chad von Nau).
* Update browsers popularity statistics.
### 20131213
* Firefox ESR in default browsers was changed to 24 version.
* Firefox 26 was moved to current releases list.
* Firefox 28 was added to future releases list.
## 0.7 “We Do Not Sow”
* Add vendor prefixes to selectors.
* Add ::selection and ::placeholder selectors support.
* Allow to load support data from Can I Use pull requests.
* Remove deprecated API.
### 20130806
* Add hyphens support.
### 20130807
* Add tab-size support.
* Add :fullscreen support.
### 20130808
* Allow to select browser versions by > and >= operator.
* Fix flex properties in transition.
### 20130810
* Add Firefox 25 data.
### 20130824
* Add Chrome 31 and 30 data.
* Fix CSS comments parsing (by vladkens).
## 0.6 “As High As Honor”
* New faster API, which cache preprocessed data. Old API is deprecated.
* A lot of perfomance improvements.
* Add Opera 15 -webkit- prefix support.
* Update Chrome 29 and Safari 7 prefixes data.
* Add minor browsers in popularity select.
* Better syntax error messages.
### 20130721
* Add Chrome 30 data.
### 20130728
* Don’t remove non-standard -webkit-background-clip: text.
* Don’t remove IE hack on CSS parse.
### 20130729
* Add Opera 16 data.
* Fix “Invalid range in character class” error on Firefox.
### 20130730
* Fix correct clone comments inside keyframes (by Alexey Plutalov).
* Fix angle recalculation in gradients (by Roman Komarov).
### 20130731
* Add border-image support.
## 0.5 “Ours is the Fury”
* Rewrite Autoprefixer to be more flexible.
* Use css, instead of Rework, to fix CSS parsing errors faster.
* Fix a lot of CSS parsing errors.
### 20130616
* More useful message for CSS parsing errors.
* Remove old WebKit gradient syntax.
* Fix parsing error on comment with braces.
### 20130617
* Remove old Mozilla border-radius.
* Don’t prefix old IE filter.
* Remove old background-clip, background-size and background-origin prefixes.
* Speed up regexps in values.
* Allow to hack property declarations.
### 20130625
* Convert flexbox properties to 2009 and 2012 specifications.
* Improve messages on syntax errors.
### 20130626
* Add Firefox 24 data.
* Add prefixes for font-feature-settings.
### 20130629
* Fix convert flex properties to old box-flex.
## 0.4 “Winter Is Coming”
* Remove outdated prefixes.
* Add border-radius and box-shadow properties to database.
* Change degrees in webkit gradients.
### 20130515
* Add old syntax in gradient direction.
* Add old syntax for display: flex.
* Update browser global usage statistics.
### 20130521
* Add Firefox 23 data.
### 20130524
* Add Chrome 29 data.
### 20130528
* Fix compatibilty with Rework from git master.
* Add minor browsers to data, which can be selected only directly.
### 20130530
* Add Opera 15 and iOS 6.1 data.
* Fix iOS versions in properties and values data.
### 20130603
* Use latest Rework 0.15 with a lot of CSS parsing fixes.
* Update browsers usage statistics.
## 0.3 “Growing Strong”
* Rename `autoprefixer.filter()` to `autoprefixer.rework()`.
* Use own filters instead of Rework’s `prefix` and `prefixValue`.
* Smarter value prefixer without false match “order” in “border”.
* 40% faster.
* Don’t add unnecessary properties instead of Rework’s `prefixValue`.
* Don’t change properties order.
* Sort properties and values in inspect output.
* Add main to component config (by Jonathan Ong).
* Fix documentation (by Sergey Leschina and Mark Vasilkov).
### 20130424
* Fix value override in prefixer.
### 20130427
* Prefix several same values in one property.
* Fix Windows support in binary.
* Improve print errors in binary.
### 20130502
* Don’t add -webkit- prefix to IE filter.
* Don’t duplicate prefixes on second run.
## 0.2 “Hear Me Roar!”
* Update parse libraries.
* Use component package manager to build standalone script.
* Add inspect to standalone script.
## 0.1 “Fire and Blood”
* Initial release.

20
node_modules/autoprefixer/LICENSE generated vendored Normal file
View File

@ -0,0 +1,20 @@
The MIT License (MIT)
Copyright 2013 Andrey Sitnik <andrey@sitnik.ru>
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

1119
node_modules/autoprefixer/README.md generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

22
node_modules/autoprefixer/bin/autoprefixer generated vendored Executable file
View File

@ -0,0 +1,22 @@
#!/usr/bin/env node
let mode = process.argv[2]
if (mode === '--info') {
process.stdout.write(
require('../')().info() + '\n')
} else if (mode === '--version') {
process.stdout.write(
'autoprefixer ' + require('../package.json').version + '\n')
} else {
process.stdout.write(
'autoprefix\n' +
'\n' +
'Options:\n' +
' --info Show target browsers and used prefixes\n' +
' --version Show version number\n' +
' --help Show help\n' +
'\n' +
'Usage:\n' +
' autoprefixer --info\n'
)
}

714
node_modules/autoprefixer/data/prefixes.js generated vendored Normal file
View File

@ -0,0 +1,714 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
var unpack = require('caniuse-lite').feature;
function browsersSort(a, b) {
a = a.split(' ');
b = b.split(' ');
if (a[0] > b[0]) {
return 1;
} else if (a[0] < b[0]) {
return -1;
} else {
return Math.sign(parseFloat(a[1]) - parseFloat(b[1]));
}
} // Convert Can I Use data
function f(data, opts, callback) {
data = unpack(data);
if (!callback) {
var _ref = [opts, {}];
callback = _ref[0];
opts = _ref[1];
}
var match = opts.match || /\sx($|\s)/;
var need = [];
for (var browser in data.stats) {
var versions = data.stats[browser];
for (var version in versions) {
var support = versions[version];
if (support.match(match)) {
need.push(browser + ' ' + version);
}
}
}
callback(need.sort(browsersSort));
} // Add data for all properties
var result = {};
function prefix(names, data) {
for (var _iterator = _createForOfIteratorHelperLoose(names), _step; !(_step = _iterator()).done;) {
var name = _step.value;
result[name] = Object.assign({}, data);
}
}
function add(names, data) {
for (var _iterator2 = _createForOfIteratorHelperLoose(names), _step2; !(_step2 = _iterator2()).done;) {
var name = _step2.value;
result[name].browsers = result[name].browsers.concat(data.browsers).sort(browsersSort);
}
}
module.exports = result; // Border Radius
f(require('caniuse-lite/data/features/border-radius'), function (browsers) {
return prefix(['border-radius', 'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius'], {
mistakes: ['-khtml-', '-ms-', '-o-'],
feature: 'border-radius',
browsers: browsers
});
}); // Box Shadow
f(require('caniuse-lite/data/features/css-boxshadow'), function (browsers) {
return prefix(['box-shadow'], {
mistakes: ['-khtml-'],
feature: 'css-boxshadow',
browsers: browsers
});
}); // Animation
f(require('caniuse-lite/data/features/css-animation'), function (browsers) {
return prefix(['animation', 'animation-name', 'animation-duration', 'animation-delay', 'animation-direction', 'animation-fill-mode', 'animation-iteration-count', 'animation-play-state', 'animation-timing-function', '@keyframes'], {
mistakes: ['-khtml-', '-ms-'],
feature: 'css-animation',
browsers: browsers
});
}); // Transition
f(require('caniuse-lite/data/features/css-transitions'), function (browsers) {
return prefix(['transition', 'transition-property', 'transition-duration', 'transition-delay', 'transition-timing-function'], {
mistakes: ['-khtml-', '-ms-'],
browsers: browsers,
feature: 'css-transitions'
});
}); // Transform 2D
f(require('caniuse-lite/data/features/transforms2d'), function (browsers) {
return prefix(['transform', 'transform-origin'], {
feature: 'transforms2d',
browsers: browsers
});
}); // Transform 3D
var transforms3d = require('caniuse-lite/data/features/transforms3d');
f(transforms3d, function (browsers) {
prefix(['perspective', 'perspective-origin'], {
feature: 'transforms3d',
browsers: browsers
});
return prefix(['transform-style'], {
mistakes: ['-ms-', '-o-'],
browsers: browsers,
feature: 'transforms3d'
});
});
f(transforms3d, {
match: /y\sx|y\s#2/
}, function (browsers) {
return prefix(['backface-visibility'], {
mistakes: ['-ms-', '-o-'],
feature: 'transforms3d',
browsers: browsers
});
}); // Gradients
var gradients = require('caniuse-lite/data/features/css-gradients');
f(gradients, {
match: /y\sx/
}, function (browsers) {
return prefix(['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'], {
props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
mistakes: ['-ms-'],
feature: 'css-gradients',
browsers: browsers
});
});
f(gradients, {
match: /a\sx/
}, function (browsers) {
browsers = browsers.map(function (i) {
if (/firefox|op/.test(i)) {
return i;
} else {
return i + " old";
}
});
return add(['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'], {
feature: 'css-gradients',
browsers: browsers
});
}); // Box sizing
f(require('caniuse-lite/data/features/css3-boxsizing'), function (browsers) {
return prefix(['box-sizing'], {
feature: 'css3-boxsizing',
browsers: browsers
});
}); // Filter Effects
f(require('caniuse-lite/data/features/css-filters'), function (browsers) {
return prefix(['filter'], {
feature: 'css-filters',
browsers: browsers
});
}); // filter() function
f(require('caniuse-lite/data/features/css-filter-function'), function (browsers) {
return prefix(['filter-function'], {
props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
feature: 'css-filter-function',
browsers: browsers
});
}); // Backdrop-filter
var backdrop = require('caniuse-lite/data/features/css-backdrop-filter');
f(backdrop, {
match: /y\sx|y\s#2/
}, function (browsers) {
return prefix(['backdrop-filter'], {
feature: 'css-backdrop-filter',
browsers: browsers
});
}); // element() function
f(require('caniuse-lite/data/features/css-element-function'), function (browsers) {
return prefix(['element'], {
props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
feature: 'css-element-function',
browsers: browsers
});
}); // Multicolumns
f(require('caniuse-lite/data/features/multicolumn'), function (browsers) {
prefix(['columns', 'column-width', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width', 'column-count', 'column-rule-style', 'column-span', 'column-fill'], {
feature: 'multicolumn',
browsers: browsers
});
var noff = browsers.filter(function (i) {
return !/firefox/.test(i);
});
prefix(['break-before', 'break-after', 'break-inside'], {
feature: 'multicolumn',
browsers: noff
});
}); // User select
f(require('caniuse-lite/data/features/user-select-none'), function (browsers) {
return prefix(['user-select'], {
mistakes: ['-khtml-'],
feature: 'user-select-none',
browsers: browsers
});
}); // Flexible Box Layout
var flexbox = require('caniuse-lite/data/features/flexbox');
f(flexbox, {
match: /a\sx/
}, function (browsers) {
browsers = browsers.map(function (i) {
if (/ie|firefox/.test(i)) {
return i;
} else {
return i + " 2009";
}
});
prefix(['display-flex', 'inline-flex'], {
props: ['display'],
feature: 'flexbox',
browsers: browsers
});
prefix(['flex', 'flex-grow', 'flex-shrink', 'flex-basis'], {
feature: 'flexbox',
browsers: browsers
});
prefix(['flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content'], {
feature: 'flexbox',
browsers: browsers
});
});
f(flexbox, {
match: /y\sx/
}, function (browsers) {
add(['display-flex', 'inline-flex'], {
feature: 'flexbox',
browsers: browsers
});
add(['flex', 'flex-grow', 'flex-shrink', 'flex-basis'], {
feature: 'flexbox',
browsers: browsers
});
add(['flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content'], {
feature: 'flexbox',
browsers: browsers
});
}); // calc() unit
f(require('caniuse-lite/data/features/calc'), function (browsers) {
return prefix(['calc'], {
props: ['*'],
feature: 'calc',
browsers: browsers
});
}); // Background options
f(require('caniuse-lite/data/features/background-img-opts'), function (browsers) {
return prefix(['background-origin', 'background-size'], {
feature: 'background-img-opts',
browsers: browsers
});
}); // background-clip: text
f(require('caniuse-lite/data/features/background-clip-text'), function (browsers) {
return prefix(['background-clip'], {
feature: 'background-clip-text',
browsers: browsers
});
}); // Font feature settings
f(require('caniuse-lite/data/features/font-feature'), function (browsers) {
return prefix(['font-feature-settings', 'font-variant-ligatures', 'font-language-override'], {
feature: 'font-feature',
browsers: browsers
});
}); // CSS font-kerning property
f(require('caniuse-lite/data/features/font-kerning'), function (browsers) {
return prefix(['font-kerning'], {
feature: 'font-kerning',
browsers: browsers
});
}); // Border image
f(require('caniuse-lite/data/features/border-image'), function (browsers) {
return prefix(['border-image'], {
feature: 'border-image',
browsers: browsers
});
}); // Selection selector
f(require('caniuse-lite/data/features/css-selection'), function (browsers) {
return prefix(['::selection'], {
selector: true,
feature: 'css-selection',
browsers: browsers
});
}); // Placeholder selector
f(require('caniuse-lite/data/features/css-placeholder'), function (browsers) {
prefix(['::placeholder'], {
selector: true,
feature: 'css-placeholder',
browsers: browsers.concat(['ie 10 old', 'ie 11 old', 'firefox 18 old'])
});
}); // Placeholder-shown selector
f(require('caniuse-lite/data/features/css-placeholder-shown'), function (browsers) {
prefix([':placeholder-shown'], {
selector: true,
feature: 'css-placeholder-shown',
browsers: browsers
});
}); // Hyphenation
f(require('caniuse-lite/data/features/css-hyphens'), function (browsers) {
return prefix(['hyphens'], {
feature: 'css-hyphens',
browsers: browsers
});
}); // Fullscreen selector
var fullscreen = require('caniuse-lite/data/features/fullscreen');
f(fullscreen, function (browsers) {
return prefix([':fullscreen'], {
selector: true,
feature: 'fullscreen',
browsers: browsers
});
});
f(fullscreen, {
match: /x(\s#2|$)/
}, function (browsers) {
return prefix(['::backdrop'], {
selector: true,
feature: 'fullscreen',
browsers: browsers
});
}); // Tab size
f(require('caniuse-lite/data/features/css3-tabsize'), function (browsers) {
return prefix(['tab-size'], {
feature: 'css3-tabsize',
browsers: browsers
});
}); // Intrinsic & extrinsic sizing
var intrinsic = require('caniuse-lite/data/features/intrinsic-width');
var sizeProps = ['width', 'min-width', 'max-width', 'height', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size', 'grid', 'grid-template', 'grid-template-rows', 'grid-template-columns', 'grid-auto-columns', 'grid-auto-rows'];
f(intrinsic, function (browsers) {
return prefix(['max-content', 'min-content'], {
props: sizeProps,
feature: 'intrinsic-width',
browsers: browsers
});
});
f(intrinsic, {
match: /x|\s#4/
}, function (browsers) {
return prefix(['fill', 'fill-available', 'stretch'], {
props: sizeProps,
feature: 'intrinsic-width',
browsers: browsers
});
});
f(intrinsic, {
match: /x|\s#5/
}, function (browsers) {
return prefix(['fit-content'], {
props: sizeProps,
feature: 'intrinsic-width',
browsers: browsers
});
}); // Zoom cursors
f(require('caniuse-lite/data/features/css3-cursors-newer'), function (browsers) {
return prefix(['zoom-in', 'zoom-out'], {
props: ['cursor'],
feature: 'css3-cursors-newer',
browsers: browsers
});
}); // Grab cursors
f(require('caniuse-lite/data/features/css3-cursors-grab'), function (browsers) {
return prefix(['grab', 'grabbing'], {
props: ['cursor'],
feature: 'css3-cursors-grab',
browsers: browsers
});
}); // Sticky position
f(require('caniuse-lite/data/features/css-sticky'), function (browsers) {
return prefix(['sticky'], {
props: ['position'],
feature: 'css-sticky',
browsers: browsers
});
}); // Pointer Events
f(require('caniuse-lite/data/features/pointer'), function (browsers) {
return prefix(['touch-action'], {
feature: 'pointer',
browsers: browsers
});
}); // Text decoration
var decoration = require('caniuse-lite/data/features/text-decoration');
f(decoration, function (browsers) {
return prefix(['text-decoration-style', 'text-decoration-color', 'text-decoration-line', 'text-decoration'], {
feature: 'text-decoration',
browsers: browsers
});
});
f(decoration, {
match: /x.*#[235]/
}, function (browsers) {
return prefix(['text-decoration-skip', 'text-decoration-skip-ink'], {
feature: 'text-decoration',
browsers: browsers
});
}); // Text Size Adjust
f(require('caniuse-lite/data/features/text-size-adjust'), function (browsers) {
return prefix(['text-size-adjust'], {
feature: 'text-size-adjust',
browsers: browsers
});
}); // CSS Masks
f(require('caniuse-lite/data/features/css-masks'), function (browsers) {
prefix(['mask-clip', 'mask-composite', 'mask-image', 'mask-origin', 'mask-repeat', 'mask-border-repeat', 'mask-border-source'], {
feature: 'css-masks',
browsers: browsers
});
prefix(['mask', 'mask-position', 'mask-size', 'mask-border', 'mask-border-outset', 'mask-border-width', 'mask-border-slice'], {
feature: 'css-masks',
browsers: browsers
});
}); // CSS clip-path property
f(require('caniuse-lite/data/features/css-clip-path'), function (browsers) {
return prefix(['clip-path'], {
feature: 'css-clip-path',
browsers: browsers
});
}); // Fragmented Borders and Backgrounds
f(require('caniuse-lite/data/features/css-boxdecorationbreak'), function (browsers) {
return prefix(['box-decoration-break'], {
feature: 'css-boxdecorationbreak',
browsers: browsers
});
}); // CSS3 object-fit/object-position
f(require('caniuse-lite/data/features/object-fit'), function (browsers) {
return prefix(['object-fit', 'object-position'], {
feature: 'object-fit',
browsers: browsers
});
}); // CSS Shapes
f(require('caniuse-lite/data/features/css-shapes'), function (browsers) {
return prefix(['shape-margin', 'shape-outside', 'shape-image-threshold'], {
feature: 'css-shapes',
browsers: browsers
});
}); // CSS3 text-overflow
f(require('caniuse-lite/data/features/text-overflow'), function (browsers) {
return prefix(['text-overflow'], {
feature: 'text-overflow',
browsers: browsers
});
}); // Viewport at-rule
f(require('caniuse-lite/data/features/css-deviceadaptation'), function (browsers) {
return prefix(['@viewport'], {
feature: 'css-deviceadaptation',
browsers: browsers
});
}); // Resolution Media Queries
var resolut = require('caniuse-lite/data/features/css-media-resolution');
f(resolut, {
match: /( x($| )|a #2)/
}, function (browsers) {
return prefix(['@resolution'], {
feature: 'css-media-resolution',
browsers: browsers
});
}); // CSS text-align-last
f(require('caniuse-lite/data/features/css-text-align-last'), function (browsers) {
return prefix(['text-align-last'], {
feature: 'css-text-align-last',
browsers: browsers
});
}); // Crisp Edges Image Rendering Algorithm
var crispedges = require('caniuse-lite/data/features/css-crisp-edges');
f(crispedges, {
match: /y x|a x #1/
}, function (browsers) {
return prefix(['pixelated'], {
props: ['image-rendering'],
feature: 'css-crisp-edges',
browsers: browsers
});
});
f(crispedges, {
match: /a x #2/
}, function (browsers) {
return prefix(['image-rendering'], {
feature: 'css-crisp-edges',
browsers: browsers
});
}); // Logical Properties
var logicalProps = require('caniuse-lite/data/features/css-logical-props');
f(logicalProps, function (browsers) {
return prefix(['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end'], {
feature: 'css-logical-props',
browsers: browsers
});
});
f(logicalProps, {
match: /x\s#2/
}, function (browsers) {
return prefix(['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end'], {
feature: 'css-logical-props',
browsers: browsers
});
}); // CSS appearance
var appearance = require('caniuse-lite/data/features/css-appearance');
f(appearance, {
match: /#2|x/
}, function (browsers) {
return prefix(['appearance'], {
feature: 'css-appearance',
browsers: browsers
});
}); // CSS Scroll snap points
f(require('caniuse-lite/data/features/css-snappoints'), function (browsers) {
return prefix(['scroll-snap-type', 'scroll-snap-coordinate', 'scroll-snap-destination', 'scroll-snap-points-x', 'scroll-snap-points-y'], {
feature: 'css-snappoints',
browsers: browsers
});
}); // CSS Regions
f(require('caniuse-lite/data/features/css-regions'), function (browsers) {
return prefix(['flow-into', 'flow-from', 'region-fragment'], {
feature: 'css-regions',
browsers: browsers
});
}); // CSS image-set
f(require('caniuse-lite/data/features/css-image-set'), function (browsers) {
return prefix(['image-set'], {
props: ['background', 'background-image', 'border-image', 'cursor', 'mask', 'mask-image', 'list-style', 'list-style-image', 'content'],
feature: 'css-image-set',
browsers: browsers
});
}); // Writing Mode
var writingMode = require('caniuse-lite/data/features/css-writing-mode');
f(writingMode, {
match: /a|x/
}, function (browsers) {
return prefix(['writing-mode'], {
feature: 'css-writing-mode',
browsers: browsers
});
}); // Cross-Fade Function
f(require('caniuse-lite/data/features/css-cross-fade'), function (browsers) {
return prefix(['cross-fade'], {
props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
feature: 'css-cross-fade',
browsers: browsers
});
}); // Read Only selector
f(require('caniuse-lite/data/features/css-read-only-write'), function (browsers) {
return prefix([':read-only', ':read-write'], {
selector: true,
feature: 'css-read-only-write',
browsers: browsers
});
}); // Text Emphasize
f(require('caniuse-lite/data/features/text-emphasis'), function (browsers) {
return prefix(['text-emphasis', 'text-emphasis-position', 'text-emphasis-style', 'text-emphasis-color'], {
feature: 'text-emphasis',
browsers: browsers
});
}); // CSS Grid Layout
var grid = require('caniuse-lite/data/features/css-grid');
f(grid, function (browsers) {
prefix(['display-grid', 'inline-grid'], {
props: ['display'],
feature: 'css-grid',
browsers: browsers
});
prefix(['grid-template-columns', 'grid-template-rows', 'grid-row-start', 'grid-column-start', 'grid-row-end', 'grid-column-end', 'grid-row', 'grid-column', 'grid-area', 'grid-template', 'grid-template-areas', 'place-self'], {
feature: 'css-grid',
browsers: browsers
});
});
f(grid, {
match: /a x/
}, function (browsers) {
return prefix(['grid-column-align', 'grid-row-align'], {
feature: 'css-grid',
browsers: browsers
});
}); // CSS text-spacing
f(require('caniuse-lite/data/features/css-text-spacing'), function (browsers) {
return prefix(['text-spacing'], {
feature: 'css-text-spacing',
browsers: browsers
});
}); // :any-link selector
f(require('caniuse-lite/data/features/css-any-link'), function (browsers) {
return prefix([':any-link'], {
selector: true,
feature: 'css-any-link',
browsers: browsers
});
}); // unicode-bidi
var bidi = require('caniuse-lite/data/features/css-unicode-bidi');
f(bidi, function (browsers) {
return prefix(['isolate'], {
props: ['unicode-bidi'],
feature: 'css-unicode-bidi',
browsers: browsers
});
});
f(bidi, {
match: /y x|a x #2/
}, function (browsers) {
return prefix(['plaintext'], {
props: ['unicode-bidi'],
feature: 'css-unicode-bidi',
browsers: browsers
});
});
f(bidi, {
match: /y x/
}, function (browsers) {
return prefix(['isolate-override'], {
props: ['unicode-bidi'],
feature: 'css-unicode-bidi',
browsers: browsers
});
}); // overscroll-behavior selector
var over = require('caniuse-lite/data/features/css-overscroll-behavior');
f(over, {
match: /a #1/
}, function (browsers) {
return prefix(['overscroll-behavior'], {
feature: 'css-overscroll-behavior',
browsers: browsers
});
}); // color-adjust
f(require('caniuse-lite/data/features/css-color-adjust'), function (browsers) {
return prefix(['color-adjust'], {
feature: 'css-color-adjust',
browsers: browsers
});
}); // text-orientation
f(require('caniuse-lite/data/features/css-text-orientation'), function (browsers) {
return prefix(['text-orientation'], {
feature: 'css-text-orientation',
browsers: browsers
});
});

62
node_modules/autoprefixer/lib/at-rule.js generated vendored Normal file
View File

@ -0,0 +1,62 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
var Prefixer = require('./prefixer');
var AtRule = /*#__PURE__*/function (_Prefixer) {
_inheritsLoose(AtRule, _Prefixer);
function AtRule() {
return _Prefixer.apply(this, arguments) || this;
}
var _proto = AtRule.prototype;
/**
* Clone and add prefixes for at-rule
*/
_proto.add = function add(rule, prefix) {
var prefixed = prefix + rule.name;
var already = rule.parent.some(function (i) {
return i.name === prefixed && i.params === rule.params;
});
if (already) {
return undefined;
}
var cloned = this.clone(rule, {
name: prefixed
});
return rule.parent.insertBefore(rule, cloned);
}
/**
* Clone node with prefixes
*/
;
_proto.process = function process(node) {
var parent = this.parentPrefix(node);
for (var _iterator = _createForOfIteratorHelperLoose(this.prefixes), _step; !(_step = _iterator()).done;) {
var prefix = _step.value;
if (!parent || parent === prefix) {
this.add(node, prefix);
}
}
};
return AtRule;
}(Prefixer);
module.exports = AtRule;

154
node_modules/autoprefixer/lib/autoprefixer.js generated vendored Normal file
View File

@ -0,0 +1,154 @@
"use strict";
var browserslist = require('browserslist');
var colorette = require('colorette');
var postcss = require('postcss');
var agents = require('caniuse-lite').agents;
var Browsers = require('./browsers');
var Prefixes = require('./prefixes');
var data = require('../data/prefixes');
var info = require('./info');
var WARNING = '\n' + ' Replace Autoprefixer `browsers` option to Browserslist config.\n' + ' Use `browserslist` key in `package.json` or `.browserslistrc` file.\n' + '\n' + ' Using `browsers` option can cause errors. Browserslist config \n' + ' can be used for Babel, Autoprefixer, postcss-normalize and other tools.\n' + '\n' + ' If you really need to use option, rename it to `overrideBrowserslist`.\n' + '\n' + ' Learn more at:\n' + ' https://github.com/browserslist/browserslist#readme\n' + ' https://twitter.com/browserslist\n' + '\n';
function isPlainObject(obj) {
return Object.prototype.toString.apply(obj) === '[object Object]';
}
var cache = {};
function timeCapsule(result, prefixes) {
if (prefixes.browsers.selected.length === 0) {
return;
}
if (prefixes.add.selectors.length > 0) {
return;
}
if (Object.keys(prefixes.add).length > 2) {
return;
}
/* istanbul ignore next */
result.warn('Greetings, time traveller. ' + 'We are in the golden age of prefix-less CSS, ' + 'where Autoprefixer is no longer needed for your stylesheet.');
}
module.exports = postcss.plugin('autoprefixer', function () {
for (var _len = arguments.length, reqs = new Array(_len), _key = 0; _key < _len; _key++) {
reqs[_key] = arguments[_key];
}
var options;
if (reqs.length === 1 && isPlainObject(reqs[0])) {
options = reqs[0];
reqs = undefined;
} else if (reqs.length === 0 || reqs.length === 1 && !reqs[0]) {
reqs = undefined;
} else if (reqs.length <= 2 && (Array.isArray(reqs[0]) || !reqs[0])) {
options = reqs[1];
reqs = reqs[0];
} else if (typeof reqs[reqs.length - 1] === 'object') {
options = reqs.pop();
}
if (!options) {
options = {};
}
if (options.browser) {
throw new Error('Change `browser` option to `overrideBrowserslist` in Autoprefixer');
} else if (options.browserslist) {
throw new Error('Change `browserslist` option to `overrideBrowserslist` in Autoprefixer');
}
if (options.overrideBrowserslist) {
reqs = options.overrideBrowserslist;
} else if (options.browsers) {
if (typeof console !== 'undefined' && console.warn) {
if (colorette.red) {
console.warn(colorette.red(WARNING.replace(/`[^`]+`/g, function (i) {
return colorette.yellow(i.slice(1, -1));
})));
} else {
console.warn(WARNING);
}
}
reqs = options.browsers;
}
var brwlstOpts = {
ignoreUnknownVersions: options.ignoreUnknownVersions,
stats: options.stats,
env: options.env
};
function loadPrefixes(opts) {
var d = module.exports.data;
var browsers = new Browsers(d.browsers, reqs, opts, brwlstOpts);
var key = browsers.selected.join(', ') + JSON.stringify(options);
if (!cache[key]) {
cache[key] = new Prefixes(d.prefixes, browsers, options);
}
return cache[key];
}
function plugin(css, result) {
var prefixes = loadPrefixes({
from: css.source && css.source.input.file,
env: options.env
});
timeCapsule(result, prefixes);
if (options.remove !== false) {
prefixes.processor.remove(css, result);
}
if (options.add !== false) {
prefixes.processor.add(css, result);
}
}
plugin.options = options;
plugin.browsers = reqs;
plugin.info = function (opts) {
opts = opts || {};
opts.from = opts.from || process.cwd();
return info(loadPrefixes(opts));
};
return plugin;
});
/**
* Autoprefixer data
*/
module.exports.data = {
browsers: agents,
prefixes: data
};
/**
* Autoprefixer default browsers
*/
module.exports.defaults = browserslist.defaults;
/**
* Inspect with default Autoprefixer
*/
module.exports.info = function () {
return module.exports().info();
};

64
node_modules/autoprefixer/lib/brackets.js generated vendored Normal file
View File

@ -0,0 +1,64 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function last(array) {
return array[array.length - 1];
}
var brackets = {
/**
* Parse string to nodes tree
*/
parse: function parse(str) {
var current = [''];
var stack = [current];
for (var _iterator = _createForOfIteratorHelperLoose(str), _step; !(_step = _iterator()).done;) {
var sym = _step.value;
if (sym === '(') {
current = [''];
last(stack).push(current);
stack.push(current);
continue;
}
if (sym === ')') {
stack.pop();
current = last(stack);
current.push('');
continue;
}
current[current.length - 1] += sym;
}
return stack[0];
},
/**
* Generate output string by nodes tree
*/
stringify: function stringify(ast) {
var result = '';
for (var _iterator2 = _createForOfIteratorHelperLoose(ast), _step2; !(_step2 = _iterator2()).done;) {
var i = _step2.value;
if (typeof i === 'object') {
result += "(" + brackets.stringify(i) + ")";
continue;
}
result += i;
}
return result;
}
};
module.exports = brackets;

96
node_modules/autoprefixer/lib/browsers.js generated vendored Normal file
View File

@ -0,0 +1,96 @@
"use strict";
var browserslist = require('browserslist');
var agents = require('caniuse-lite').agents;
var utils = require('./utils');
var Browsers = /*#__PURE__*/function () {
/**
* Return all prefixes for default browser data
*/
Browsers.prefixes = function prefixes() {
if (this.prefixesCache) {
return this.prefixesCache;
}
this.prefixesCache = [];
for (var name in agents) {
this.prefixesCache.push("-" + agents[name].prefix + "-");
}
this.prefixesCache = utils.uniq(this.prefixesCache).sort(function (a, b) {
return b.length - a.length;
});
return this.prefixesCache;
}
/**
* Check is value contain any possible prefix
*/
;
Browsers.withPrefix = function withPrefix(value) {
if (!this.prefixesRegexp) {
this.prefixesRegexp = new RegExp(this.prefixes().join('|'));
}
return this.prefixesRegexp.test(value);
};
function Browsers(data, requirements, options, browserslistOpts) {
this.data = data;
this.options = options || {};
this.browserslistOpts = browserslistOpts || {};
this.selected = this.parse(requirements);
}
/**
* Return browsers selected by requirements
*/
var _proto = Browsers.prototype;
_proto.parse = function parse(requirements) {
var opts = {};
for (var i in this.browserslistOpts) {
opts[i] = this.browserslistOpts[i];
}
opts.path = this.options.from;
return browserslist(requirements, opts);
}
/**
* Return prefix for selected browser
*/
;
_proto.prefix = function prefix(browser) {
var _browser$split = browser.split(' '),
name = _browser$split[0],
version = _browser$split[1];
var data = this.data[name];
var prefix = data.prefix_exceptions && data.prefix_exceptions[version];
if (!prefix) {
prefix = data.prefix;
}
return "-" + prefix + "-";
}
/**
* Is browser is selected by requirements
*/
;
_proto.isSelected = function isSelected(browser) {
return this.selected.includes(browser);
};
return Browsers;
}();
module.exports = Browsers;

243
node_modules/autoprefixer/lib/declaration.js generated vendored Normal file
View File

@ -0,0 +1,243 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
var Prefixer = require('./prefixer');
var Browsers = require('./browsers');
var utils = require('./utils');
var Declaration = /*#__PURE__*/function (_Prefixer) {
_inheritsLoose(Declaration, _Prefixer);
function Declaration() {
return _Prefixer.apply(this, arguments) || this;
}
var _proto = Declaration.prototype;
/**
* Always true, because we already get prefixer by property name
*/
_proto.check = function check()
/* decl */
{
return true;
}
/**
* Return prefixed version of property
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
return prefix + prop;
}
/**
* Return unprefixed version of property
*/
;
_proto.normalize = function normalize(prop) {
return prop;
}
/**
* Check `value`, that it contain other prefixes, rather than `prefix`
*/
;
_proto.otherPrefixes = function otherPrefixes(value, prefix) {
for (var _iterator = _createForOfIteratorHelperLoose(Browsers.prefixes()), _step; !(_step = _iterator()).done;) {
var other = _step.value;
if (other === prefix) {
continue;
}
if (value.includes(other)) {
return true;
}
}
return false;
}
/**
* Set prefix to declaration
*/
;
_proto.set = function set(decl, prefix) {
decl.prop = this.prefixed(decl.prop, prefix);
return decl;
}
/**
* Should we use visual cascade for prefixes
*/
;
_proto.needCascade = function needCascade(decl) {
if (!decl._autoprefixerCascade) {
decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').includes('\n');
}
return decl._autoprefixerCascade;
}
/**
* Return maximum length of possible prefixed property
*/
;
_proto.maxPrefixed = function maxPrefixed(prefixes, decl) {
if (decl._autoprefixerMax) {
return decl._autoprefixerMax;
}
var max = 0;
for (var _iterator2 = _createForOfIteratorHelperLoose(prefixes), _step2; !(_step2 = _iterator2()).done;) {
var prefix = _step2.value;
prefix = utils.removeNote(prefix);
if (prefix.length > max) {
max = prefix.length;
}
}
decl._autoprefixerMax = max;
return decl._autoprefixerMax;
}
/**
* Calculate indentation to create visual cascade
*/
;
_proto.calcBefore = function calcBefore(prefixes, decl, prefix) {
if (prefix === void 0) {
prefix = '';
}
var max = this.maxPrefixed(prefixes, decl);
var diff = max - utils.removeNote(prefix).length;
var before = decl.raw('before');
if (diff > 0) {
before += Array(diff).fill(' ').join('');
}
return before;
}
/**
* Remove visual cascade
*/
;
_proto.restoreBefore = function restoreBefore(decl) {
var lines = decl.raw('before').split('\n');
var min = lines[lines.length - 1];
this.all.group(decl).up(function (prefixed) {
var array = prefixed.raw('before').split('\n');
var last = array[array.length - 1];
if (last.length < min.length) {
min = last;
}
});
lines[lines.length - 1] = min;
decl.raws.before = lines.join('\n');
}
/**
* Clone and insert new declaration
*/
;
_proto.insert = function insert(decl, prefix, prefixes) {
var cloned = this.set(this.clone(decl), prefix);
if (!cloned) return undefined;
var already = decl.parent.some(function (i) {
return i.prop === cloned.prop && i.value === cloned.value;
});
if (already) {
return undefined;
}
if (this.needCascade(decl)) {
cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
}
return decl.parent.insertBefore(decl, cloned);
}
/**
* Did this declaration has this prefix above
*/
;
_proto.isAlready = function isAlready(decl, prefixed) {
var already = this.all.group(decl).up(function (i) {
return i.prop === prefixed;
});
if (!already) {
already = this.all.group(decl).down(function (i) {
return i.prop === prefixed;
});
}
return already;
}
/**
* Clone and add prefixes for declaration
*/
;
_proto.add = function add(decl, prefix, prefixes, result) {
var prefixed = this.prefixed(decl.prop, prefix);
if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) {
return undefined;
}
return this.insert(decl, prefix, prefixes, result);
}
/**
* Add spaces for visual cascade
*/
;
_proto.process = function process(decl, result) {
if (!this.needCascade(decl)) {
_Prefixer.prototype.process.call(this, decl, result);
return;
}
var prefixes = _Prefixer.prototype.process.call(this, decl, result);
if (!prefixes || !prefixes.length) {
return;
}
this.restoreBefore(decl);
decl.raws.before = this.calcBefore(prefixes, decl);
}
/**
* Return list of prefixed properties to clean old prefixes
*/
;
_proto.old = function old(prop, prefix) {
return [this.prefixed(prop, prefix)];
};
return Declaration;
}(Prefixer);
module.exports = Declaration;

79
node_modules/autoprefixer/lib/hacks/align-content.js generated vendored Normal file
View File

@ -0,0 +1,79 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var AlignContent = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(AlignContent, _Declaration);
function AlignContent() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = AlignContent.prototype;
/**
* Change property name for 2012 spec
*/
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2012) {
return prefix + 'flex-line-pack';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Return property name by final spec
*/
;
_proto.normalize = function normalize() {
return 'align-content';
}
/**
* Change value for 2012 spec and ignore prefix for 2009
*/
;
_proto.set = function set(decl, prefix) {
var spec = flexSpec(prefix)[0];
if (spec === 2012) {
decl.value = AlignContent.oldValues[decl.value] || decl.value;
return _Declaration.prototype.set.call(this, decl, prefix);
}
if (spec === 'final') {
return _Declaration.prototype.set.call(this, decl, prefix);
}
return undefined;
};
return AlignContent;
}(Declaration);
_defineProperty(AlignContent, "names", ['align-content', 'flex-line-pack']);
_defineProperty(AlignContent, "oldValues", {
'flex-end': 'end',
'flex-start': 'start',
'space-between': 'justify',
'space-around': 'distribute'
});
module.exports = AlignContent;

76
node_modules/autoprefixer/lib/hacks/align-items.js generated vendored Normal file
View File

@ -0,0 +1,76 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var AlignItems = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(AlignItems, _Declaration);
function AlignItems() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = AlignItems.prototype;
/**
* Change property name for 2009 and 2012 specs
*/
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2009) {
return prefix + 'box-align';
}
if (spec === 2012) {
return prefix + 'flex-align';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Return property name by final spec
*/
;
_proto.normalize = function normalize() {
return 'align-items';
}
/**
* Change value for 2009 and 2012 specs
*/
;
_proto.set = function set(decl, prefix) {
var spec = flexSpec(prefix)[0];
if (spec === 2009 || spec === 2012) {
decl.value = AlignItems.oldValues[decl.value] || decl.value;
}
return _Declaration.prototype.set.call(this, decl, prefix);
};
return AlignItems;
}(Declaration);
_defineProperty(AlignItems, "names", ['align-items', 'flex-align', 'box-align']);
_defineProperty(AlignItems, "oldValues", {
'flex-end': 'end',
'flex-start': 'start'
});
module.exports = AlignItems;

84
node_modules/autoprefixer/lib/hacks/align-self.js generated vendored Normal file
View File

@ -0,0 +1,84 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var AlignSelf = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(AlignSelf, _Declaration);
function AlignSelf() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = AlignSelf.prototype;
_proto.check = function check(decl) {
return decl.parent && !decl.parent.some(function (i) {
return i.prop && i.prop.startsWith('grid-');
});
}
/**
* Change property name for 2012 specs
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2012) {
return prefix + 'flex-item-align';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Return property name by final spec
*/
;
_proto.normalize = function normalize() {
return 'align-self';
}
/**
* Change value for 2012 spec and ignore prefix for 2009
*/
;
_proto.set = function set(decl, prefix) {
var spec = flexSpec(prefix)[0];
if (spec === 2012) {
decl.value = AlignSelf.oldValues[decl.value] || decl.value;
return _Declaration.prototype.set.call(this, decl, prefix);
}
if (spec === 'final') {
return _Declaration.prototype.set.call(this, decl, prefix);
}
return undefined;
};
return AlignSelf;
}(Declaration);
_defineProperty(AlignSelf, "names", ['align-self', 'flex-item-align']);
_defineProperty(AlignSelf, "oldValues", {
'flex-end': 'end',
'flex-start': 'start'
});
module.exports = AlignSelf;

35
node_modules/autoprefixer/lib/hacks/animation.js generated vendored Normal file
View File

@ -0,0 +1,35 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var Animation = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(Animation, _Declaration);
function Animation() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = Animation.prototype;
/**
* Don’t add prefixes for modern values.
*/
_proto.check = function check(decl) {
return !decl.value.split(/\s+/).some(function (i) {
var lower = i.toLowerCase();
return lower === 'reverse' || lower === 'alternate-reverse';
});
};
return Animation;
}(Declaration);
_defineProperty(Animation, "names", ['animation', 'animation-direction']);
module.exports = Animation;

39
node_modules/autoprefixer/lib/hacks/appearance.js generated vendored Normal file
View File

@ -0,0 +1,39 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var utils = require('../utils');
var Appearance = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(Appearance, _Declaration);
function Appearance(name, prefixes, all) {
var _this;
_this = _Declaration.call(this, name, prefixes, all) || this;
if (_this.prefixes) {
_this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
if (i === '-ms-') {
return '-webkit-';
}
return i;
}));
}
return _this;
}
return Appearance;
}(Declaration);
_defineProperty(Appearance, "names", ['appearance']);
module.exports = Appearance;

35
node_modules/autoprefixer/lib/hacks/backdrop-filter.js generated vendored Normal file
View File

@ -0,0 +1,35 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var utils = require('../utils');
var BackdropFilter = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(BackdropFilter, _Declaration);
function BackdropFilter(name, prefixes, all) {
var _this;
_this = _Declaration.call(this, name, prefixes, all) || this;
if (_this.prefixes) {
_this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
return i === '-ms-' ? '-webkit-' : i;
}));
}
return _this;
}
return BackdropFilter;
}(Declaration);
_defineProperty(BackdropFilter, "names", ['backdrop-filter']);
module.exports = BackdropFilter;

41
node_modules/autoprefixer/lib/hacks/background-clip.js generated vendored Normal file
View File

@ -0,0 +1,41 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var utils = require('../utils');
var BackgroundClip = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(BackgroundClip, _Declaration);
function BackgroundClip(name, prefixes, all) {
var _this;
_this = _Declaration.call(this, name, prefixes, all) || this;
if (_this.prefixes) {
_this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
return i === '-ms-' ? '-webkit-' : i;
}));
}
return _this;
}
var _proto = BackgroundClip.prototype;
_proto.check = function check(decl) {
return decl.value.toLowerCase() === 'text';
};
return BackgroundClip;
}(Declaration);
_defineProperty(BackgroundClip, "names", ['background-clip']);
module.exports = BackgroundClip;

38
node_modules/autoprefixer/lib/hacks/background-size.js generated vendored Normal file
View File

@ -0,0 +1,38 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var BackgroundSize = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(BackgroundSize, _Declaration);
function BackgroundSize() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = BackgroundSize.prototype;
/**
* Duplication parameter for -webkit- browsers
*/
_proto.set = function set(decl, prefix) {
var value = decl.value.toLowerCase();
if (prefix === '-webkit-' && !value.includes(' ') && value !== 'contain' && value !== 'cover') {
decl.value = decl.value + ' ' + decl.value;
}
return _Declaration.prototype.set.call(this, decl, prefix);
};
return BackgroundSize;
}(Declaration);
_defineProperty(BackgroundSize, "names", ['background-size']);
module.exports = BackgroundSize;

48
node_modules/autoprefixer/lib/hacks/block-logical.js generated vendored Normal file
View File

@ -0,0 +1,48 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var BlockLogical = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(BlockLogical, _Declaration);
function BlockLogical() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = BlockLogical.prototype;
/**
* Use old syntax for -moz- and -webkit-
*/
_proto.prefixed = function prefixed(prop, prefix) {
if (prop.includes('-start')) {
return prefix + prop.replace('-block-start', '-before');
}
return prefix + prop.replace('-block-end', '-after');
}
/**
* Return property name by spec
*/
;
_proto.normalize = function normalize(prop) {
if (prop.includes('-before')) {
return prop.replace('-before', '-block-start');
}
return prop.replace('-after', '-block-end');
};
return BlockLogical;
}(Declaration);
_defineProperty(BlockLogical, "names", ['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', 'border-before', 'border-after', 'margin-before', 'margin-after', 'padding-before', 'padding-after']);
module.exports = BlockLogical;

33
node_modules/autoprefixer/lib/hacks/border-image.js generated vendored Normal file
View File

@ -0,0 +1,33 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var BorderImage = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(BorderImage, _Declaration);
function BorderImage() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = BorderImage.prototype;
/**
* Remove fill parameter for prefixed declarations
*/
_proto.set = function set(decl, prefix) {
decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
return _Declaration.prototype.set.call(this, decl, prefix);
};
return BorderImage;
}(Declaration);
_defineProperty(BorderImage, "names", ['border-image']);
module.exports = BorderImage;

62
node_modules/autoprefixer/lib/hacks/border-radius.js generated vendored Normal file
View File

@ -0,0 +1,62 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var BorderRadius = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(BorderRadius, _Declaration);
function BorderRadius() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = BorderRadius.prototype;
/**
* Change syntax, when add Mozilla prefix
*/
_proto.prefixed = function prefixed(prop, prefix) {
if (prefix === '-moz-') {
return prefix + (BorderRadius.toMozilla[prop] || prop);
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Return unprefixed version of property
*/
;
_proto.normalize = function normalize(prop) {
return BorderRadius.toNormal[prop] || prop;
};
return BorderRadius;
}(Declaration);
_defineProperty(BorderRadius, "names", ['border-radius']);
_defineProperty(BorderRadius, "toMozilla", {});
_defineProperty(BorderRadius, "toNormal", {});
for (var _i = 0, _arr = ['top', 'bottom']; _i < _arr.length; _i++) {
var ver = _arr[_i];
for (var _i2 = 0, _arr2 = ['left', 'right']; _i2 < _arr2.length; _i2++) {
var hor = _arr2[_i2];
var normal = "border-" + ver + "-" + hor + "-radius";
var mozilla = "border-radius-" + ver + hor;
BorderRadius.names.push(normal);
BorderRadius.names.push(mozilla);
BorderRadius.toMozilla[normal] = mozilla;
BorderRadius.toNormal[mozilla] = normal;
}
}
module.exports = BorderRadius;

76
node_modules/autoprefixer/lib/hacks/break-props.js generated vendored Normal file
View File

@ -0,0 +1,76 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var BreakProps = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(BreakProps, _Declaration);
function BreakProps() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = BreakProps.prototype;
/**
* Change name for -webkit- and -moz- prefix
*/
_proto.prefixed = function prefixed(prop, prefix) {
return prefix + "column-" + prop;
}
/**
* Return property name by final spec
*/
;
_proto.normalize = function normalize(prop) {
if (prop.includes('inside')) {
return 'break-inside';
}
if (prop.includes('before')) {
return 'break-before';
}
return 'break-after';
}
/**
* Change prefixed value for avoid-column and avoid-page
*/
;
_proto.set = function set(decl, prefix) {
if (decl.prop === 'break-inside' && decl.value === 'avoid-column' || decl.value === 'avoid-page') {
decl.value = 'avoid';
}
return _Declaration.prototype.set.call(this, decl, prefix);
}
/**
* Don’t prefix some values
*/
;
_proto.insert = function insert(decl, prefix, prefixes) {
if (decl.prop !== 'break-inside') {
return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
}
if (/region/i.test(decl.value) || /page/i.test(decl.value)) {
return undefined;
}
return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
};
return BreakProps;
}(Declaration);
_defineProperty(BreakProps, "names", ['break-inside', 'page-break-inside', 'column-break-inside', 'break-before', 'page-break-before', 'column-break-before', 'break-after', 'page-break-after', 'column-break-after']);
module.exports = BreakProps;

40
node_modules/autoprefixer/lib/hacks/color-adjust.js generated vendored Normal file
View File

@ -0,0 +1,40 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var ColorAdjust = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(ColorAdjust, _Declaration);
function ColorAdjust() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = ColorAdjust.prototype;
/**
* Change property name for WebKit-based browsers
*/
_proto.prefixed = function prefixed(prop, prefix) {
return prefix + 'print-color-adjust';
}
/**
* Return property name by spec
*/
;
_proto.normalize = function normalize() {
return 'color-adjust';
};
return ColorAdjust;
}(Declaration);
_defineProperty(ColorAdjust, "names", ['color-adjust', 'print-color-adjust']);
module.exports = ColorAdjust;

54
node_modules/autoprefixer/lib/hacks/cross-fade.js generated vendored Normal file
View File

@ -0,0 +1,54 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var list = require('postcss').list;
var Value = require('../value');
var CrossFade = /*#__PURE__*/function (_Value) {
_inheritsLoose(CrossFade, _Value);
function CrossFade() {
return _Value.apply(this, arguments) || this;
}
var _proto = CrossFade.prototype;
_proto.replace = function replace(string, prefix) {
var _this = this;
return list.space(string).map(function (value) {
if (value.slice(0, +_this.name.length + 1) !== _this.name + '(') {
return value;
}
var close = value.lastIndexOf(')');
var after = value.slice(close + 1);
var args = value.slice(_this.name.length + 1, close);
if (prefix === '-webkit-') {
var match = args.match(/\d*.?\d+%?/);
if (match) {
args = args.slice(match[0].length).trim();
args += ", " + match[0];
} else {
args += ', 0.5';
}
}
return prefix + _this.name + '(' + args + ')' + after;
}).join(' ');
};
return CrossFade;
}(Value);
_defineProperty(CrossFade, "names", ['cross-fade']);
module.exports = CrossFade;

94
node_modules/autoprefixer/lib/hacks/display-flex.js generated vendored Normal file
View File

@ -0,0 +1,94 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var OldValue = require('../old-value');
var Value = require('../value');
var DisplayFlex = /*#__PURE__*/function (_Value) {
_inheritsLoose(DisplayFlex, _Value);
function DisplayFlex(name, prefixes) {
var _this;
_this = _Value.call(this, name, prefixes) || this;
if (name === 'display-flex') {
_this.name = 'flex';
}
return _this;
}
/**
* Faster check for flex value
*/
var _proto = DisplayFlex.prototype;
_proto.check = function check(decl) {
return decl.prop === 'display' && decl.value === this.name;
}
/**
* Return value by spec
*/
;
_proto.prefixed = function prefixed(prefix) {
var spec, value;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2009) {
if (this.name === 'flex') {
value = 'box';
} else {
value = 'inline-box';
}
} else if (spec === 2012) {
if (this.name === 'flex') {
value = 'flexbox';
} else {
value = 'inline-flexbox';
}
} else if (spec === 'final') {
value = this.name;
}
return prefix + value;
}
/**
* Add prefix to value depend on flebox spec version
*/
;
_proto.replace = function replace(string, prefix) {
return this.prefixed(prefix);
}
/**
* Change value for old specs
*/
;
_proto.old = function old(prefix) {
var prefixed = this.prefixed(prefix);
if (!prefixed) return undefined;
return new OldValue(this.name, prefixed);
};
return DisplayFlex;
}(Value);
_defineProperty(DisplayFlex, "names", ['display-flex', 'inline-flex']);
module.exports = DisplayFlex;

41
node_modules/autoprefixer/lib/hacks/display-grid.js generated vendored Normal file
View File

@ -0,0 +1,41 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Value = require('../value');
var DisplayGrid = /*#__PURE__*/function (_Value) {
_inheritsLoose(DisplayGrid, _Value);
function DisplayGrid(name, prefixes) {
var _this;
_this = _Value.call(this, name, prefixes) || this;
if (name === 'display-grid') {
_this.name = 'grid';
}
return _this;
}
/**
* Faster check for flex value
*/
var _proto = DisplayGrid.prototype;
_proto.check = function check(decl) {
return decl.prop === 'display' && decl.value === this.name;
};
return DisplayGrid;
}(Value);
_defineProperty(DisplayGrid, "names", ['display-grid', 'inline-grid']);
module.exports = DisplayGrid;

31
node_modules/autoprefixer/lib/hacks/filter-value.js generated vendored Normal file
View File

@ -0,0 +1,31 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Value = require('../value');
var FilterValue = /*#__PURE__*/function (_Value) {
_inheritsLoose(FilterValue, _Value);
function FilterValue(name, prefixes) {
var _this;
_this = _Value.call(this, name, prefixes) || this;
if (name === 'filter-function') {
_this.name = 'filter';
}
return _this;
}
return FilterValue;
}(Value);
_defineProperty(FilterValue, "names", ['filter', 'filter-function']);
module.exports = FilterValue;

33
node_modules/autoprefixer/lib/hacks/filter.js generated vendored Normal file
View File

@ -0,0 +1,33 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var Filter = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(Filter, _Declaration);
function Filter() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = Filter.prototype;
/**
* Check is it Internet Explorer filter
*/
_proto.check = function check(decl) {
var v = decl.value;
return !v.toLowerCase().includes('alpha(') && !v.includes('DXImageTransform.Microsoft') && !v.includes('data:image/svg+xml');
};
return Filter;
}(Declaration);
_defineProperty(Filter, "names", ['filter']);
module.exports = Filter;

72
node_modules/autoprefixer/lib/hacks/flex-basis.js generated vendored Normal file
View File

@ -0,0 +1,72 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var FlexBasis = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(FlexBasis, _Declaration);
function FlexBasis() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = FlexBasis.prototype;
/**
* Return property name by final spec
*/
_proto.normalize = function normalize() {
return 'flex-basis';
}
/**
* Return flex property for 2012 spec
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2012) {
return prefix + 'flex-preferred-size';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Ignore 2009 spec and use flex property for 2012
*/
;
_proto.set = function set(decl, prefix) {
var spec;
var _flexSpec2 = flexSpec(prefix);
spec = _flexSpec2[0];
prefix = _flexSpec2[1];
if (spec === 2012 || spec === 'final') {
return _Declaration.prototype.set.call(this, decl, prefix);
}
return undefined;
};
return FlexBasis;
}(Declaration);
_defineProperty(FlexBasis, "names", ['flex-basis', 'flex-preferred-size']);
module.exports = FlexBasis;

108
node_modules/autoprefixer/lib/hacks/flex-direction.js generated vendored Normal file
View File

@ -0,0 +1,108 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var FlexDirection = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(FlexDirection, _Declaration);
function FlexDirection() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = FlexDirection.prototype;
/**
* Return property name by final spec
*/
_proto.normalize = function normalize() {
return 'flex-direction';
}
/**
* Use two properties for 2009 spec
*/
;
_proto.insert = function insert(decl, prefix, prefixes) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec !== 2009) {
return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
}
var already = decl.parent.some(function (i) {
return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
});
if (already) {
return undefined;
}
var v = decl.value;
var orient, dir;
if (v === 'inherit' || v === 'initial' || v === 'unset') {
orient = v;
dir = v;
} else {
orient = v.includes('row') ? 'horizontal' : 'vertical';
dir = v.includes('reverse') ? 'reverse' : 'normal';
}
var cloned = this.clone(decl);
cloned.prop = prefix + 'box-orient';
cloned.value = orient;
if (this.needCascade(decl)) {
cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
}
decl.parent.insertBefore(decl, cloned);
cloned = this.clone(decl);
cloned.prop = prefix + 'box-direction';
cloned.value = dir;
if (this.needCascade(decl)) {
cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
}
return decl.parent.insertBefore(decl, cloned);
}
/**
* Clean two properties for 2009 spec
*/
;
_proto.old = function old(prop, prefix) {
var spec;
var _flexSpec2 = flexSpec(prefix);
spec = _flexSpec2[0];
prefix = _flexSpec2[1];
if (spec === 2009) {
return [prefix + 'box-orient', prefix + 'box-direction'];
} else {
return _Declaration.prototype.old.call(this, prop, prefix);
}
};
return FlexDirection;
}(Declaration);
_defineProperty(FlexDirection, "names", ['flex-direction', 'box-direction', 'box-orient']);
module.exports = FlexDirection;

81
node_modules/autoprefixer/lib/hacks/flex-flow.js generated vendored Normal file
View File

@ -0,0 +1,81 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var FlexFlow = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(FlexFlow, _Declaration);
function FlexFlow() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = FlexFlow.prototype;
/**
* Use two properties for 2009 spec
*/
_proto.insert = function insert(decl, prefix, prefixes) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec !== 2009) {
return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
}
var values = decl.value.split(/\s+/).filter(function (i) {
return i !== 'wrap' && i !== 'nowrap' && 'wrap-reverse';
});
if (values.length === 0) {
return undefined;
}
var already = decl.parent.some(function (i) {
return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
});
if (already) {
return undefined;
}
var value = values[0];
var orient = value.includes('row') ? 'horizontal' : 'vertical';
var dir = value.includes('reverse') ? 'reverse' : 'normal';
var cloned = this.clone(decl);
cloned.prop = prefix + 'box-orient';
cloned.value = orient;
if (this.needCascade(decl)) {
cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
}
decl.parent.insertBefore(decl, cloned);
cloned = this.clone(decl);
cloned.prop = prefix + 'box-direction';
cloned.value = dir;
if (this.needCascade(decl)) {
cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
}
return decl.parent.insertBefore(decl, cloned);
};
return FlexFlow;
}(Declaration);
_defineProperty(FlexFlow, "names", ['flex-flow', 'box-direction', 'box-orient']);
module.exports = FlexFlow;

57
node_modules/autoprefixer/lib/hacks/flex-grow.js generated vendored Normal file
View File

@ -0,0 +1,57 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var Flex = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(Flex, _Declaration);
function Flex() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = Flex.prototype;
/**
* Return property name by final spec
*/
_proto.normalize = function normalize() {
return 'flex';
}
/**
* Return flex property for 2009 and 2012 specs
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2009) {
return prefix + 'box-flex';
}
if (spec === 2012) {
return prefix + 'flex-positive';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
};
return Flex;
}(Declaration);
_defineProperty(Flex, "names", ['flex-grow', 'flex-positive']);
module.exports = Flex;

72
node_modules/autoprefixer/lib/hacks/flex-shrink.js generated vendored Normal file
View File

@ -0,0 +1,72 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var FlexShrink = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(FlexShrink, _Declaration);
function FlexShrink() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = FlexShrink.prototype;
/**
* Return property name by final spec
*/
_proto.normalize = function normalize() {
return 'flex-shrink';
}
/**
* Return flex property for 2012 spec
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2012) {
return prefix + 'flex-negative';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Ignore 2009 spec and use flex property for 2012
*/
;
_proto.set = function set(decl, prefix) {
var spec;
var _flexSpec2 = flexSpec(prefix);
spec = _flexSpec2[0];
prefix = _flexSpec2[1];
if (spec === 2012 || spec === 'final') {
return _Declaration.prototype.set.call(this, decl, prefix);
}
return undefined;
};
return FlexShrink;
}(Declaration);
_defineProperty(FlexShrink, "names", ['flex-shrink', 'flex-negative']);
module.exports = FlexShrink;

22
node_modules/autoprefixer/lib/hacks/flex-spec.js generated vendored Normal file
View File

@ -0,0 +1,22 @@
"use strict";
/**
* Return flexbox spec versions by prefix
*/
module.exports = function (prefix) {
var spec;
if (prefix === '-webkit- 2009' || prefix === '-moz-') {
spec = 2009;
} else if (prefix === '-ms-') {
spec = 2012;
} else if (prefix === '-webkit-') {
spec = 'final';
}
if (prefix === '-webkit- 2009') {
prefix = '-webkit-';
}
return [spec, prefix];
};

40
node_modules/autoprefixer/lib/hacks/flex-wrap.js generated vendored Normal file
View File

@ -0,0 +1,40 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var FlexWrap = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(FlexWrap, _Declaration);
function FlexWrap() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = FlexWrap.prototype;
/**
* Don't add prefix for 2009 spec
*/
_proto.set = function set(decl, prefix) {
var spec = flexSpec(prefix)[0];
if (spec !== 2009) {
return _Declaration.prototype.set.call(this, decl, prefix);
}
return undefined;
};
return FlexWrap;
}(Declaration);
_defineProperty(FlexWrap, "names", ['flex-wrap']);
module.exports = FlexWrap;

85
node_modules/autoprefixer/lib/hacks/flex.js generated vendored Normal file
View File

@ -0,0 +1,85 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var list = require('postcss').list;
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var Flex = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(Flex, _Declaration);
function Flex() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = Flex.prototype;
/**
* Change property name for 2009 spec
*/
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2009) {
return prefix + 'box-flex';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Return property name by final spec
*/
;
_proto.normalize = function normalize() {
return 'flex';
}
/**
* Spec 2009 supports only first argument
* Spec 2012 disallows unitless basis
*/
;
_proto.set = function set(decl, prefix) {
var spec = flexSpec(prefix)[0];
if (spec === 2009) {
decl.value = list.space(decl.value)[0];
decl.value = Flex.oldValues[decl.value] || decl.value;
return _Declaration.prototype.set.call(this, decl, prefix);
}
if (spec === 2012) {
var components = list.space(decl.value);
if (components.length === 3 && components[2] === '0') {
decl.value = components.slice(0, 2).concat('0px').join(' ');
}
}
return _Declaration.prototype.set.call(this, decl, prefix);
};
return Flex;
}(Declaration);
_defineProperty(Flex, "names", ['flex', 'box-flex']);
_defineProperty(Flex, "oldValues", {
auto: '1',
none: '0'
});
module.exports = Flex;

40
node_modules/autoprefixer/lib/hacks/fullscreen.js generated vendored Normal file
View File

@ -0,0 +1,40 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Selector = require('../selector');
var Fullscreen = /*#__PURE__*/function (_Selector) {
_inheritsLoose(Fullscreen, _Selector);
function Fullscreen() {
return _Selector.apply(this, arguments) || this;
}
var _proto = Fullscreen.prototype;
/**
* Return different selectors depend on prefix
*/
_proto.prefixed = function prefixed(prefix) {
if (prefix === '-webkit-') {
return ':-webkit-full-screen';
}
if (prefix === '-moz-') {
return ':-moz-full-screen';
}
return ":" + prefix + "fullscreen";
};
return Fullscreen;
}(Selector);
_defineProperty(Fullscreen, "names", [':fullscreen']);
module.exports = Fullscreen;

519
node_modules/autoprefixer/lib/hacks/gradient.js generated vendored Normal file
View File

@ -0,0 +1,519 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var parser = require('postcss-value-parser');
var range = require('normalize-range');
var OldValue = require('../old-value');
var Value = require('../value');
var utils = require('../utils');
var IS_DIRECTION = /top|left|right|bottom/gi;
var Gradient = /*#__PURE__*/function (_Value) {
_inheritsLoose(Gradient, _Value);
function Gradient() {
var _this;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _Value.call.apply(_Value, [this].concat(args)) || this;
_defineProperty(_assertThisInitialized(_this), "directions", {
top: 'bottom',
left: 'right',
bottom: 'top',
right: 'left'
});
_defineProperty(_assertThisInitialized(_this), "oldDirections", {
'top': 'left bottom, left top',
'left': 'right top, left top',
'bottom': 'left top, left bottom',
'right': 'left top, right top',
'top right': 'left bottom, right top',
'top left': 'right bottom, left top',
'right top': 'left bottom, right top',
'right bottom': 'left top, right bottom',
'bottom right': 'left top, right bottom',
'bottom left': 'right top, left bottom',
'left top': 'right bottom, left top',
'left bottom': 'right top, left bottom'
});
return _this;
}
var _proto = Gradient.prototype;
/**
* Change degrees for webkit prefix
*/
_proto.replace = function replace(string, prefix) {
var ast = parser(string);
for (var _iterator = _createForOfIteratorHelperLoose(ast.nodes), _step; !(_step = _iterator()).done;) {
var node = _step.value;
if (node.type === 'function' && node.value === this.name) {
node.nodes = this.newDirection(node.nodes);
node.nodes = this.normalize(node.nodes);
if (prefix === '-webkit- old') {
var changes = this.oldWebkit(node);
if (!changes) {
return false;
}
} else {
node.nodes = this.convertDirection(node.nodes);
node.value = prefix + node.value;
}
}
}
return ast.toString();
}
/**
* Replace first token
*/
;
_proto.replaceFirst = function replaceFirst(params) {
for (var _len2 = arguments.length, words = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
words[_key2 - 1] = arguments[_key2];
}
var prefix = words.map(function (i) {
if (i === ' ') {
return {
type: 'space',
value: i
};
}
return {
type: 'word',
value: i
};
});
return prefix.concat(params.slice(1));
}
/**
* Convert angle unit to deg
*/
;
_proto.normalizeUnit = function normalizeUnit(str, full) {
var num = parseFloat(str);
var deg = num / full * 360;
return deg + "deg";
}
/**
* Normalize angle
*/
;
_proto.normalize = function normalize(nodes) {
if (!nodes[0]) return nodes;
if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) {
nodes[0].value = this.normalizeUnit(nodes[0].value, 400);
} else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) {
nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI);
} else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) {
nodes[0].value = this.normalizeUnit(nodes[0].value, 1);
} else if (nodes[0].value.includes('deg')) {
var num = parseFloat(nodes[0].value);
num = range.wrap(0, 360, num);
nodes[0].value = num + "deg";
}
if (nodes[0].value === '0deg') {
nodes = this.replaceFirst(nodes, 'to', ' ', 'top');
} else if (nodes[0].value === '90deg') {
nodes = this.replaceFirst(nodes, 'to', ' ', 'right');
} else if (nodes[0].value === '180deg') {
nodes = this.replaceFirst(nodes, 'to', ' ', 'bottom');
} else if (nodes[0].value === '270deg') {
nodes = this.replaceFirst(nodes, 'to', ' ', 'left');
}
return nodes;
}
/**
* Replace old direction to new
*/
;
_proto.newDirection = function newDirection(params) {
if (params[0].value === 'to') {
return params;
}
IS_DIRECTION.lastIndex = 0; // reset search index of global regexp
if (!IS_DIRECTION.test(params[0].value)) {
return params;
}
params.unshift({
type: 'word',
value: 'to'
}, {
type: 'space',
value: ' '
});
for (var i = 2; i < params.length; i++) {
if (params[i].type === 'div') {
break;
}
if (params[i].type === 'word') {
params[i].value = this.revertDirection(params[i].value);
}
}
return params;
}
/**
* Look for at word
*/
;
_proto.isRadial = function isRadial(params) {
var state = 'before';
for (var _iterator2 = _createForOfIteratorHelperLoose(params), _step2; !(_step2 = _iterator2()).done;) {
var param = _step2.value;
if (state === 'before' && param.type === 'space') {
state = 'at';
} else if (state === 'at' && param.value === 'at') {
state = 'after';
} else if (state === 'after' && param.type === 'space') {
return true;
} else if (param.type === 'div') {
break;
} else {
state = 'before';
}
}
return false;
}
/**
* Change new direction to old
*/
;
_proto.convertDirection = function convertDirection(params) {
if (params.length > 0) {
if (params[0].value === 'to') {
this.fixDirection(params);
} else if (params[0].value.includes('deg')) {
this.fixAngle(params);
} else if (this.isRadial(params)) {
this.fixRadial(params);
}
}
return params;
}
/**
* Replace `to top left` to `bottom right`
*/
;
_proto.fixDirection = function fixDirection(params) {
params.splice(0, 2);
for (var _iterator3 = _createForOfIteratorHelperLoose(params), _step3; !(_step3 = _iterator3()).done;) {
var param = _step3.value;
if (param.type === 'div') {
break;
}
if (param.type === 'word') {
param.value = this.revertDirection(param.value);
}
}
}
/**
* Add 90 degrees
*/
;
_proto.fixAngle = function fixAngle(params) {
var first = params[0].value;
first = parseFloat(first);
first = Math.abs(450 - first) % 360;
first = this.roundFloat(first, 3);
params[0].value = first + "deg";
}
/**
* Fix radial direction syntax
*/
;
_proto.fixRadial = function fixRadial(params) {
var first = [];
var second = [];
var a, b, c, i, next;
for (i = 0; i < params.length - 2; i++) {
a = params[i];
b = params[i + 1];
c = params[i + 2];
if (a.type === 'space' && b.value === 'at' && c.type === 'space') {
next = i + 3;
break;
} else {
first.push(a);
}
}
var div;
for (i = next; i < params.length; i++) {
if (params[i].type === 'div') {
div = params[i];
break;
} else {
second.push(params[i]);
}
}
params.splice.apply(params, [0, i].concat(second, [div], first));
};
_proto.revertDirection = function revertDirection(word) {
return this.directions[word.toLowerCase()] || word;
}
/**
* Round float and save digits under dot
*/
;
_proto.roundFloat = function roundFloat(_float, digits) {
return parseFloat(_float.toFixed(digits));
}
/**
* Convert to old webkit syntax
*/
;
_proto.oldWebkit = function oldWebkit(node) {
var nodes = node.nodes;
var string = parser.stringify(node.nodes);
if (this.name !== 'linear-gradient') {
return false;
}
if (nodes[0] && nodes[0].value.includes('deg')) {
return false;
}
if (string.includes('px') || string.includes('-corner') || string.includes('-side')) {
return false;
}
var params = [[]];
for (var _iterator4 = _createForOfIteratorHelperLoose(nodes), _step4; !(_step4 = _iterator4()).done;) {
var i = _step4.value;
params[params.length - 1].push(i);
if (i.type === 'div' && i.value === ',') {
params.push([]);
}
}
this.oldDirection(params);
this.colorStops(params);
node.nodes = [];
for (var _i = 0, _params = params; _i < _params.length; _i++) {
var param = _params[_i];
node.nodes = node.nodes.concat(param);
}
node.nodes.unshift({
type: 'word',
value: 'linear'
}, this.cloneDiv(node.nodes));
node.value = '-webkit-gradient';
return true;
}
/**
* Change direction syntax to old webkit
*/
;
_proto.oldDirection = function oldDirection(params) {
var div = this.cloneDiv(params[0]);
if (params[0][0].value !== 'to') {
return params.unshift([{
type: 'word',
value: this.oldDirections.bottom
}, div]);
} else {
var words = [];
for (var _iterator5 = _createForOfIteratorHelperLoose(params[0].slice(2)), _step5; !(_step5 = _iterator5()).done;) {
var node = _step5.value;
if (node.type === 'word') {
words.push(node.value.toLowerCase());
}
}
words = words.join(' ');
var old = this.oldDirections[words] || words;
params[0] = [{
type: 'word',
value: old
}, div];
return params[0];
}
}
/**
* Get div token from exists parameters
*/
;
_proto.cloneDiv = function cloneDiv(params) {
for (var _iterator6 = _createForOfIteratorHelperLoose(params), _step6; !(_step6 = _iterator6()).done;) {
var i = _step6.value;
if (i.type === 'div' && i.value === ',') {
return i;
}
}
return {
type: 'div',
value: ',',
after: ' '
};
}
/**
* Change colors syntax to old webkit
*/
;
_proto.colorStops = function colorStops(params) {
var result = [];
for (var i = 0; i < params.length; i++) {
var pos = void 0;
var param = params[i];
var item = void 0;
if (i === 0) {
continue;
}
var color = parser.stringify(param[0]);
if (param[1] && param[1].type === 'word') {
pos = param[1].value;
} else if (param[2] && param[2].type === 'word') {
pos = param[2].value;
}
var stop = void 0;
if (i === 1 && (!pos || pos === '0%')) {
stop = "from(" + color + ")";
} else if (i === params.length - 1 && (!pos || pos === '100%')) {
stop = "to(" + color + ")";
} else if (pos) {
stop = "color-stop(" + pos + ", " + color + ")";
} else {
stop = "color-stop(" + color + ")";
}
var div = param[param.length - 1];
params[i] = [{
type: 'word',
value: stop
}];
if (div.type === 'div' && div.value === ',') {
item = params[i].push(div);
}
result.push(item);
}
return result;
}
/**
* Remove old WebKit gradient too
*/
;
_proto.old = function old(prefix) {
if (prefix === '-webkit-') {
var type = this.name === 'linear-gradient' ? 'linear' : 'radial';
var string = '-gradient';
var regexp = utils.regexp("-webkit-(" + type + "-gradient|gradient\\(\\s*" + type + ")", false);
return new OldValue(this.name, prefix + this.name, string, regexp);
} else {
return _Value.prototype.old.call(this, prefix);
}
}
/**
* Do not add non-webkit prefixes for list-style and object
*/
;
_proto.add = function add(decl, prefix) {
var p = decl.prop;
if (p.includes('mask')) {
if (prefix === '-webkit-' || prefix === '-webkit- old') {
return _Value.prototype.add.call(this, decl, prefix);
}
} else if (p === 'list-style' || p === 'list-style-image' || p === 'content') {
if (prefix === '-webkit-' || prefix === '-webkit- old') {
return _Value.prototype.add.call(this, decl, prefix);
}
} else {
return _Value.prototype.add.call(this, decl, prefix);
}
return undefined;
};
return Gradient;
}(Value);
_defineProperty(Gradient, "names", ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient']);
module.exports = Gradient;

52
node_modules/autoprefixer/lib/hacks/grid-area.js generated vendored Normal file
View File

@ -0,0 +1,52 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var utils = require('./grid-utils');
var GridArea = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridArea, _Declaration);
function GridArea() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridArea.prototype;
/**
* Translate grid-area to separate -ms- prefixed properties
*/
_proto.insert = function insert(decl, prefix, prefixes, result) {
if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
var values = utils.parse(decl);
var _utils$translate = utils.translate(values, 0, 2),
rowStart = _utils$translate[0],
rowSpan = _utils$translate[1];
var _utils$translate2 = utils.translate(values, 1, 3),
columnStart = _utils$translate2[0],
columnSpan = _utils$translate2[1];
[['grid-row', rowStart], ['grid-row-span', rowSpan], ['grid-column', columnStart], ['grid-column-span', columnSpan]].forEach(function (_ref) {
var prop = _ref[0],
value = _ref[1];
utils.insertDecl(decl, prop, value);
});
utils.warnTemplateSelectorNotFound(decl, result);
utils.warnIfGridRowColumnExists(decl, result);
return undefined;
};
return GridArea;
}(Declaration);
_defineProperty(GridArea, "names", ['grid-area']);
module.exports = GridArea;

48
node_modules/autoprefixer/lib/hacks/grid-column-align.js generated vendored Normal file
View File

@ -0,0 +1,48 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var GridColumnAlign = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridColumnAlign, _Declaration);
function GridColumnAlign() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridColumnAlign.prototype;
/**
* Do not prefix flexbox values
*/
_proto.check = function check(decl) {
return !decl.value.includes('flex-') && decl.value !== 'baseline';
}
/**
* Change property name for IE
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
return prefix + 'grid-column-align';
}
/**
* Change IE property back
*/
;
_proto.normalize = function normalize() {
return 'justify-self';
};
return GridColumnAlign;
}(Declaration);
_defineProperty(GridColumnAlign, "names", ['grid-column-align']);
module.exports = GridColumnAlign;

62
node_modules/autoprefixer/lib/hacks/grid-end.js generated vendored Normal file
View File

@ -0,0 +1,62 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var GridEnd = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridEnd, _Declaration);
function GridEnd() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridEnd.prototype;
/**
* Change repeating syntax for IE
*/
_proto.insert = function insert(decl, prefix, prefixes, result) {
if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
var clonedDecl = this.clone(decl);
var startProp = decl.prop.replace(/end$/, 'start');
var spanProp = prefix + decl.prop.replace(/end$/, 'span');
if (decl.parent.some(function (i) {
return i.prop === spanProp;
})) {
return undefined;
}
clonedDecl.prop = spanProp;
if (decl.value.includes('span')) {
clonedDecl.value = decl.value.replace(/span\s/i, '');
} else {
var startDecl;
decl.parent.walkDecls(startProp, function (d) {
startDecl = d;
});
if (startDecl) {
var value = Number(decl.value) - Number(startDecl.value) + '';
clonedDecl.value = value;
} else {
decl.warn(result, "Can not prefix " + decl.prop + " (" + startProp + " is not found)");
}
}
decl.cloneBefore(clonedDecl);
return undefined;
};
return GridEnd;
}(Declaration);
_defineProperty(GridEnd, "names", ['grid-row-end', 'grid-column-end']);
module.exports = GridEnd;

48
node_modules/autoprefixer/lib/hacks/grid-row-align.js generated vendored Normal file
View File

@ -0,0 +1,48 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var GridRowAlign = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridRowAlign, _Declaration);
function GridRowAlign() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridRowAlign.prototype;
/**
* Do not prefix flexbox values
*/
_proto.check = function check(decl) {
return !decl.value.includes('flex-') && decl.value !== 'baseline';
}
/**
* Change property name for IE
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
return prefix + 'grid-row-align';
}
/**
* Change IE property back
*/
;
_proto.normalize = function normalize() {
return 'align-self';
};
return GridRowAlign;
}(Declaration);
_defineProperty(GridRowAlign, "names", ['grid-row-align']);
module.exports = GridRowAlign;

52
node_modules/autoprefixer/lib/hacks/grid-row-column.js generated vendored Normal file
View File

@ -0,0 +1,52 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var utils = require('./grid-utils');
var GridRowColumn = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridRowColumn, _Declaration);
function GridRowColumn() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridRowColumn.prototype;
/**
* Translate grid-row / grid-column to separate -ms- prefixed properties
*/
_proto.insert = function insert(decl, prefix, prefixes) {
if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
var values = utils.parse(decl);
var _utils$translate = utils.translate(values, 0, 1),
start = _utils$translate[0],
span = _utils$translate[1];
var hasStartValueSpan = values[0] && values[0].includes('span');
if (hasStartValueSpan) {
span = values[0].join('').replace(/\D/g, '');
}
[[decl.prop, start], [decl.prop + "-span", span]].forEach(function (_ref) {
var prop = _ref[0],
value = _ref[1];
utils.insertDecl(decl, prop, value);
});
return undefined;
};
return GridRowColumn;
}(Declaration);
_defineProperty(GridRowColumn, "names", ['grid-row', 'grid-column']);
module.exports = GridRowColumn;

149
node_modules/autoprefixer/lib/hacks/grid-rows-columns.js generated vendored Normal file
View File

@ -0,0 +1,149 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var _require = require('./grid-utils'),
prefixTrackProp = _require.prefixTrackProp,
prefixTrackValue = _require.prefixTrackValue,
autoplaceGridItems = _require.autoplaceGridItems,
getGridGap = _require.getGridGap,
inheritGridGap = _require.inheritGridGap;
var Processor = require('../processor');
var GridRowsColumns = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridRowsColumns, _Declaration);
function GridRowsColumns() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridRowsColumns.prototype;
/**
* Change property name for IE
*/
_proto.prefixed = function prefixed(prop, prefix) {
if (prefix === '-ms-') {
return prefixTrackProp({
prop: prop,
prefix: prefix
});
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Change IE property back
*/
;
_proto.normalize = function normalize(prop) {
return prop.replace(/^grid-(rows|columns)/, 'grid-template-$1');
};
_proto.insert = function insert(decl, prefix, prefixes, result) {
if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
var parent = decl.parent,
prop = decl.prop,
value = decl.value;
var isRowProp = prop.includes('rows');
var isColumnProp = prop.includes('columns');
var hasGridTemplate = parent.some(function (i) {
return i.prop === 'grid-template' || i.prop === 'grid-template-areas';
});
/**
* Not to prefix rows declaration if grid-template(-areas) is present
*/
if (hasGridTemplate && isRowProp) {
return false;
}
var processor = new Processor({
options: {}
});
var status = processor.gridStatus(parent, result);
var gap = getGridGap(decl);
gap = inheritGridGap(decl, gap) || gap;
var gapValue = isRowProp ? gap.row : gap.column;
if ((status === 'no-autoplace' || status === true) && !hasGridTemplate) {
gapValue = null;
}
var prefixValue = prefixTrackValue({
value: value,
gap: gapValue
});
/**
* Insert prefixes
*/
decl.cloneBefore({
prop: prefixTrackProp({
prop: prop,
prefix: prefix
}),
value: prefixValue
});
var autoflow = parent.nodes.find(function (i) {
return i.prop === 'grid-auto-flow';
});
var autoflowValue = 'row';
if (autoflow && !processor.disabled(autoflow, result)) {
autoflowValue = autoflow.value.trim();
}
if (status === 'autoplace') {
/**
* Show warning if grid-template-rows decl is not found
*/
var rowDecl = parent.nodes.find(function (i) {
return i.prop === 'grid-template-rows';
});
if (!rowDecl && hasGridTemplate) {
return undefined;
} else if (!rowDecl && !hasGridTemplate) {
decl.warn(result, 'Autoplacement does not work without grid-template-rows property');
return undefined;
}
/**
* Show warning if grid-template-columns decl is not found
*/
var columnDecl = parent.nodes.find(function (i) {
return i.prop === 'grid-template-columns';
});
if (!columnDecl && !hasGridTemplate) {
decl.warn(result, 'Autoplacement does not work without grid-template-columns property');
}
/**
* Autoplace grid items
*/
if (isColumnProp && !hasGridTemplate) {
autoplaceGridItems(decl, result, gap, autoflowValue);
}
}
return undefined;
};
return GridRowsColumns;
}(Declaration);
_defineProperty(GridRowsColumns, "names", ['grid-template-rows', 'grid-template-columns', 'grid-rows', 'grid-columns']);
module.exports = GridRowsColumns;

55
node_modules/autoprefixer/lib/hacks/grid-start.js generated vendored Normal file
View File

@ -0,0 +1,55 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var GridStart = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridStart, _Declaration);
function GridStart() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridStart.prototype;
/**
* Do not add prefix for unsupported value in IE
*/
_proto.check = function check(decl) {
var value = decl.value;
return !value.includes('/') || value.includes('span');
}
/**
* Return a final spec property
*/
;
_proto.normalize = function normalize(prop) {
return prop.replace('-start', '');
}
/**
* Change property name for IE
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
var result = _Declaration.prototype.prefixed.call(this, prop, prefix);
if (prefix === '-ms-') {
result = result.replace('-start', '');
}
return result;
};
return GridStart;
}(Declaration);
_defineProperty(GridStart, "names", ['grid-row-start', 'grid-column-start']);
module.exports = GridStart;

101
node_modules/autoprefixer/lib/hacks/grid-template-areas.js generated vendored Normal file
View File

@ -0,0 +1,101 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var _require = require('./grid-utils'),
parseGridAreas = _require.parseGridAreas,
warnMissedAreas = _require.warnMissedAreas,
prefixTrackProp = _require.prefixTrackProp,
prefixTrackValue = _require.prefixTrackValue,
getGridGap = _require.getGridGap,
warnGridGap = _require.warnGridGap,
inheritGridGap = _require.inheritGridGap;
function getGridRows(tpl) {
return tpl.trim().slice(1, -1).split(/["']\s*["']?/g);
}
var GridTemplateAreas = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridTemplateAreas, _Declaration);
function GridTemplateAreas() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridTemplateAreas.prototype;
/**
* Translate grid-template-areas to separate -ms- prefixed properties
*/
_proto.insert = function insert(decl, prefix, prefixes, result) {
if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
var hasColumns = false;
var hasRows = false;
var parent = decl.parent;
var gap = getGridGap(decl);
gap = inheritGridGap(decl, gap) || gap; // remove already prefixed rows
// to prevent doubling prefixes
parent.walkDecls(/-ms-grid-rows/, function (i) {
return i.remove();
}); // add empty tracks to rows
parent.walkDecls(/grid-template-(rows|columns)/, function (trackDecl) {
if (trackDecl.prop === 'grid-template-rows') {
hasRows = true;
var prop = trackDecl.prop,
value = trackDecl.value;
trackDecl.cloneBefore({
prop: prefixTrackProp({
prop: prop,
prefix: prefix
}),
value: prefixTrackValue({
value: value,
gap: gap.row
})
});
} else {
hasColumns = true;
}
});
var gridRows = getGridRows(decl.value);
if (hasColumns && !hasRows && gap.row && gridRows.length > 1) {
decl.cloneBefore({
prop: '-ms-grid-rows',
value: prefixTrackValue({
value: "repeat(" + gridRows.length + ", auto)",
gap: gap.row
}),
raws: {}
});
} // warnings
warnGridGap({
gap: gap,
hasColumns: hasColumns,
decl: decl,
result: result
});
var areas = parseGridAreas({
rows: gridRows,
gap: gap
});
warnMissedAreas(areas, decl, result);
return decl;
};
return GridTemplateAreas;
}(Declaration);
_defineProperty(GridTemplateAreas, "names", ['grid-template-areas']);
module.exports = GridTemplateAreas;

90
node_modules/autoprefixer/lib/hacks/grid-template.js generated vendored Normal file
View File

@ -0,0 +1,90 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var _require = require('./grid-utils'),
parseTemplate = _require.parseTemplate,
warnMissedAreas = _require.warnMissedAreas,
getGridGap = _require.getGridGap,
warnGridGap = _require.warnGridGap,
inheritGridGap = _require.inheritGridGap;
var GridTemplate = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(GridTemplate, _Declaration);
function GridTemplate() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = GridTemplate.prototype;
/**
* Translate grid-template to separate -ms- prefixed properties
*/
_proto.insert = function insert(decl, prefix, prefixes, result) {
if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
if (decl.parent.some(function (i) {
return i.prop === '-ms-grid-rows';
})) {
return undefined;
}
var gap = getGridGap(decl);
/**
* we must insert inherited gap values in some cases:
* if we are inside media query && if we have no grid-gap value
*/
var inheritedGap = inheritGridGap(decl, gap);
var _parseTemplate = parseTemplate({
decl: decl,
gap: inheritedGap || gap
}),
rows = _parseTemplate.rows,
columns = _parseTemplate.columns,
areas = _parseTemplate.areas;
var hasAreas = Object.keys(areas).length > 0;
var hasRows = Boolean(rows);
var hasColumns = Boolean(columns);
warnGridGap({
gap: gap,
hasColumns: hasColumns,
decl: decl,
result: result
});
warnMissedAreas(areas, decl, result);
if (hasRows && hasColumns || hasAreas) {
decl.cloneBefore({
prop: '-ms-grid-rows',
value: rows,
raws: {}
});
}
if (hasColumns) {
decl.cloneBefore({
prop: '-ms-grid-columns',
value: columns,
raws: {}
});
}
return decl;
};
return GridTemplate;
}(Declaration);
_defineProperty(GridTemplate, "names", ['grid-template']);
module.exports = GridTemplate;

1123
node_modules/autoprefixer/lib/hacks/grid-utils.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

71
node_modules/autoprefixer/lib/hacks/image-rendering.js generated vendored Normal file
View File

@ -0,0 +1,71 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var ImageRendering = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(ImageRendering, _Declaration);
function ImageRendering() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = ImageRendering.prototype;
/**
* Add hack only for crisp-edges
*/
_proto.check = function check(decl) {
return decl.value === 'pixelated';
}
/**
* Change property name for IE
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
if (prefix === '-ms-') {
return '-ms-interpolation-mode';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Change property and value for IE
*/
;
_proto.set = function set(decl, prefix) {
if (prefix !== '-ms-') return _Declaration.prototype.set.call(this, decl, prefix);
decl.prop = '-ms-interpolation-mode';
decl.value = 'nearest-neighbor';
return decl;
}
/**
* Return property name by spec
*/
;
_proto.normalize = function normalize() {
return 'image-rendering';
}
/**
* Warn on old value
*/
;
_proto.process = function process(node, result) {
return _Declaration.prototype.process.call(this, node, result);
};
return ImageRendering;
}(Declaration);
_defineProperty(ImageRendering, "names", ['image-rendering', 'interpolation-mode']);
module.exports = ImageRendering;

38
node_modules/autoprefixer/lib/hacks/image-set.js generated vendored Normal file
View File

@ -0,0 +1,38 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Value = require('../value');
var ImageSet = /*#__PURE__*/function (_Value) {
_inheritsLoose(ImageSet, _Value);
function ImageSet() {
return _Value.apply(this, arguments) || this;
}
var _proto = ImageSet.prototype;
/**
* Use non-standard name for WebKit and Firefox
*/
_proto.replace = function replace(string, prefix) {
var fixed = _Value.prototype.replace.call(this, string, prefix);
if (prefix === '-webkit-') {
fixed = fixed.replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2');
}
return fixed;
};
return ImageSet;
}(Value);
_defineProperty(ImageSet, "names", ['image-set']);
module.exports = ImageSet;

40
node_modules/autoprefixer/lib/hacks/inline-logical.js generated vendored Normal file
View File

@ -0,0 +1,40 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var InlineLogical = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(InlineLogical, _Declaration);
function InlineLogical() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = InlineLogical.prototype;
/**
* Use old syntax for -moz- and -webkit-
*/
_proto.prefixed = function prefixed(prop, prefix) {
return prefix + prop.replace('-inline', '');
}
/**
* Return property name by spec
*/
;
_proto.normalize = function normalize(prop) {
return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2');
};
return InlineLogical;
}(Declaration);
_defineProperty(InlineLogical, "names", ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end']);
module.exports = InlineLogical;

74
node_modules/autoprefixer/lib/hacks/intrinsic.js generated vendored Normal file
View File

@ -0,0 +1,74 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var OldValue = require('../old-value');
var Value = require('../value');
function _regexp(name) {
return new RegExp("(^|[\\s,(])(" + name + "($|[\\s),]))", 'gi');
}
var Intrinsic = /*#__PURE__*/function (_Value) {
_inheritsLoose(Intrinsic, _Value);
function Intrinsic() {
return _Value.apply(this, arguments) || this;
}
var _proto = Intrinsic.prototype;
_proto.regexp = function regexp() {
if (!this.regexpCache) this.regexpCache = _regexp(this.name);
return this.regexpCache;
};
_proto.isStretch = function isStretch() {
return this.name === 'stretch' || this.name === 'fill' || this.name === 'fill-available';
};
_proto.replace = function replace(string, prefix) {
if (prefix === '-moz-' && this.isStretch()) {
return string.replace(this.regexp(), '$1-moz-available$3');
}
if (prefix === '-webkit-' && this.isStretch()) {
return string.replace(this.regexp(), '$1-webkit-fill-available$3');
}
return _Value.prototype.replace.call(this, string, prefix);
};
_proto.old = function old(prefix) {
var prefixed = prefix + this.name;
if (this.isStretch()) {
if (prefix === '-moz-') {
prefixed = '-moz-available';
} else if (prefix === '-webkit-') {
prefixed = '-webkit-fill-available';
}
}
return new OldValue(this.name, prefixed, prefixed, _regexp(prefixed));
};
_proto.add = function add(decl, prefix) {
if (decl.prop.includes('grid') && prefix !== '-webkit-') {
return undefined;
}
return _Value.prototype.add.call(this, decl, prefix);
};
return Intrinsic;
}(Value);
_defineProperty(Intrinsic, "names", ['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch']);
module.exports = Intrinsic;

85
node_modules/autoprefixer/lib/hacks/justify-content.js generated vendored Normal file
View File

@ -0,0 +1,85 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var JustifyContent = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(JustifyContent, _Declaration);
function JustifyContent() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = JustifyContent.prototype;
/**
* Change property name for 2009 and 2012 specs
*/
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2009) {
return prefix + 'box-pack';
}
if (spec === 2012) {
return prefix + 'flex-pack';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Return property name by final spec
*/
;
_proto.normalize = function normalize() {
return 'justify-content';
}
/**
* Change value for 2009 and 2012 specs
*/
;
_proto.set = function set(decl, prefix) {
var spec = flexSpec(prefix)[0];
if (spec === 2009 || spec === 2012) {
var value = JustifyContent.oldValues[decl.value] || decl.value;
decl.value = value;
if (spec !== 2009 || value !== 'distribute') {
return _Declaration.prototype.set.call(this, decl, prefix);
}
} else if (spec === 'final') {
return _Declaration.prototype.set.call(this, decl, prefix);
}
return undefined;
};
return JustifyContent;
}(Declaration);
_defineProperty(JustifyContent, "names", ['justify-content', 'flex-pack', 'box-pack']);
_defineProperty(JustifyContent, "oldValues", {
'flex-end': 'end',
'flex-start': 'start',
'space-between': 'justify',
'space-around': 'distribute'
});
module.exports = JustifyContent;

46
node_modules/autoprefixer/lib/hacks/mask-border.js generated vendored Normal file
View File

@ -0,0 +1,46 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var MaskBorder = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(MaskBorder, _Declaration);
function MaskBorder() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = MaskBorder.prototype;
/**
* Return property name by final spec
*/
_proto.normalize = function normalize() {
return this.name.replace('box-image', 'border');
}
/**
* Return flex property for 2012 spec
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
var result = _Declaration.prototype.prefixed.call(this, prop, prefix);
if (prefix === '-webkit-') {
result = result.replace('border', 'box-image');
}
return result;
};
return MaskBorder;
}(Declaration);
_defineProperty(MaskBorder, "names", ['mask-border', 'mask-border-source', 'mask-border-slice', 'mask-border-width', 'mask-border-outset', 'mask-border-repeat', 'mask-box-image', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat']);
module.exports = MaskBorder;

104
node_modules/autoprefixer/lib/hacks/mask-composite.js generated vendored Normal file
View File

@ -0,0 +1,104 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var MaskComposite = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(MaskComposite, _Declaration);
function MaskComposite() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = MaskComposite.prototype;
/**
* Prefix mask-composite for webkit
*/
_proto.insert = function insert(decl, prefix, prefixes) {
var isCompositeProp = decl.prop === 'mask-composite';
var compositeValues;
if (isCompositeProp) {
compositeValues = decl.value.split(',');
} else {
compositeValues = decl.value.match(MaskComposite.regexp) || [];
}
compositeValues = compositeValues.map(function (el) {
return el.trim();
}).filter(function (el) {
return el;
});
var hasCompositeValues = compositeValues.length;
var compositeDecl;
if (hasCompositeValues) {
compositeDecl = this.clone(decl);
compositeDecl.value = compositeValues.map(function (value) {
return MaskComposite.oldValues[value] || value;
}).join(', ');
if (compositeValues.includes('intersect')) {
compositeDecl.value += ', xor';
}
compositeDecl.prop = prefix + 'mask-composite';
}
if (isCompositeProp) {
if (!hasCompositeValues) {
return undefined;
}
if (this.needCascade(decl)) {
compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix);
}
return decl.parent.insertBefore(decl, compositeDecl);
}
var cloned = this.clone(decl);
cloned.prop = prefix + cloned.prop;
if (hasCompositeValues) {
cloned.value = cloned.value.replace(MaskComposite.regexp, '');
}
if (this.needCascade(decl)) {
cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
}
decl.parent.insertBefore(decl, cloned);
if (!hasCompositeValues) {
return decl;
}
if (this.needCascade(decl)) {
compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix);
}
return decl.parent.insertBefore(decl, compositeDecl);
};
return MaskComposite;
}(Declaration);
_defineProperty(MaskComposite, "names", ['mask', 'mask-composite']);
_defineProperty(MaskComposite, "oldValues", {
add: 'source-over',
substract: 'source-out',
intersect: 'source-in',
exclude: 'xor'
});
_defineProperty(MaskComposite, "regexp", new RegExp("\\s+(" + Object.keys(MaskComposite.oldValues).join('|') + ")\\b(?!\\))\\s*(?=[,])", 'ig'));
module.exports = MaskComposite;

72
node_modules/autoprefixer/lib/hacks/order.js generated vendored Normal file
View File

@ -0,0 +1,72 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var flexSpec = require('./flex-spec');
var Declaration = require('../declaration');
var Order = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(Order, _Declaration);
function Order() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = Order.prototype;
/**
* Change property name for 2009 and 2012 specs
*/
_proto.prefixed = function prefixed(prop, prefix) {
var spec;
var _flexSpec = flexSpec(prefix);
spec = _flexSpec[0];
prefix = _flexSpec[1];
if (spec === 2009) {
return prefix + 'box-ordinal-group';
}
if (spec === 2012) {
return prefix + 'flex-order';
}
return _Declaration.prototype.prefixed.call(this, prop, prefix);
}
/**
* Return property name by final spec
*/
;
_proto.normalize = function normalize() {
return 'order';
}
/**
* Fix value for 2009 spec
*/
;
_proto.set = function set(decl, prefix) {
var spec = flexSpec(prefix)[0];
if (spec === 2009 && /\d/.test(decl.value)) {
decl.value = (parseInt(decl.value) + 1).toString();
return _Declaration.prototype.set.call(this, decl, prefix);
}
return _Declaration.prototype.set.call(this, decl, prefix);
};
return Order;
}(Declaration);
_defineProperty(Order, "names", ['order', 'flex-order', 'box-ordinal-group']);
module.exports = Order;

54
node_modules/autoprefixer/lib/hacks/overscroll-behavior.js generated vendored Normal file
View File

@ -0,0 +1,54 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var OverscrollBehavior = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(OverscrollBehavior, _Declaration);
function OverscrollBehavior() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = OverscrollBehavior.prototype;
/**
* Change property name for IE
*/
_proto.prefixed = function prefixed(prop, prefix) {
return prefix + 'scroll-chaining';
}
/**
* Return property name by spec
*/
;
_proto.normalize = function normalize() {
return 'overscroll-behavior';
}
/**
* Change value for IE
*/
;
_proto.set = function set(decl, prefix) {
if (decl.value === 'auto') {
decl.value = 'chained';
} else if (decl.value === 'none' || decl.value === 'contain') {
decl.value = 'none';
}
return _Declaration.prototype.set.call(this, decl, prefix);
};
return OverscrollBehavior;
}(Declaration);
_defineProperty(OverscrollBehavior, "names", ['overscroll-behavior', 'scroll-chaining']);
module.exports = OverscrollBehavior;

58
node_modules/autoprefixer/lib/hacks/pixelated.js generated vendored Normal file
View File

@ -0,0 +1,58 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var OldValue = require('../old-value');
var Value = require('../value');
var Pixelated = /*#__PURE__*/function (_Value) {
_inheritsLoose(Pixelated, _Value);
function Pixelated() {
return _Value.apply(this, arguments) || this;
}
var _proto = Pixelated.prototype;
/**
* Use non-standard name for WebKit and Firefox
*/
_proto.replace = function replace(string, prefix) {
if (prefix === '-webkit-') {
return string.replace(this.regexp(), '$1-webkit-optimize-contrast');
}
if (prefix === '-moz-') {
return string.replace(this.regexp(), '$1-moz-crisp-edges');
}
return _Value.prototype.replace.call(this, string, prefix);
}
/**
* Different name for WebKit and Firefox
*/
;
_proto.old = function old(prefix) {
if (prefix === '-webkit-') {
return new OldValue(this.name, '-webkit-optimize-contrast');
}
if (prefix === '-moz-') {
return new OldValue(this.name, '-moz-crisp-edges');
}
return _Value.prototype.old.call(this, prefix);
};
return Pixelated;
}(Value);
_defineProperty(Pixelated, "names", ['pixelated']);
module.exports = Pixelated;

55
node_modules/autoprefixer/lib/hacks/place-self.js generated vendored Normal file
View File

@ -0,0 +1,55 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var utils = require('./grid-utils');
var PlaceSelf = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(PlaceSelf, _Declaration);
function PlaceSelf() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = PlaceSelf.prototype;
/**
* Translate place-self to separate -ms- prefixed properties
*/
_proto.insert = function insert(decl, prefix, prefixes) {
if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); // prevent doubling of prefixes
if (decl.parent.some(function (i) {
return i.prop === '-ms-grid-row-align';
})) {
return undefined;
}
var _utils$parse = utils.parse(decl),
_utils$parse$ = _utils$parse[0],
first = _utils$parse$[0],
second = _utils$parse$[1];
if (second) {
utils.insertDecl(decl, 'grid-row-align', first);
utils.insertDecl(decl, 'grid-column-align', second);
} else {
utils.insertDecl(decl, 'grid-row-align', first);
utils.insertDecl(decl, 'grid-column-align', first);
}
return undefined;
};
return PlaceSelf;
}(Declaration);
_defineProperty(PlaceSelf, "names", ['place-self']);
module.exports = PlaceSelf;

36
node_modules/autoprefixer/lib/hacks/placeholder-shown.js generated vendored Normal file
View File

@ -0,0 +1,36 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Selector = require('../selector');
var PlaceholderShown = /*#__PURE__*/function (_Selector) {
_inheritsLoose(PlaceholderShown, _Selector);
function PlaceholderShown() {
return _Selector.apply(this, arguments) || this;
}
var _proto = PlaceholderShown.prototype;
/**
* Return different selectors depend on prefix
*/
_proto.prefixed = function prefixed(prefix) {
if (prefix === '-ms-') {
return ':-ms-input-placeholder';
}
return ":" + prefix + "placeholder-shown";
};
return PlaceholderShown;
}(Selector);
_defineProperty(PlaceholderShown, "names", [':placeholder-shown']);
module.exports = PlaceholderShown;

56
node_modules/autoprefixer/lib/hacks/placeholder.js generated vendored Normal file
View File

@ -0,0 +1,56 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Selector = require('../selector');
var Placeholder = /*#__PURE__*/function (_Selector) {
_inheritsLoose(Placeholder, _Selector);
function Placeholder() {
return _Selector.apply(this, arguments) || this;
}
var _proto = Placeholder.prototype;
/**
* Add old mozilla to possible prefixes
*/
_proto.possible = function possible() {
return _Selector.prototype.possible.call(this).concat(['-moz- old', '-ms- old']);
}
/**
* Return different selectors depend on prefix
*/
;
_proto.prefixed = function prefixed(prefix) {
if (prefix === '-webkit-') {
return '::-webkit-input-placeholder';
}
if (prefix === '-ms-') {
return '::-ms-input-placeholder';
}
if (prefix === '-ms- old') {
return ':-ms-input-placeholder';
}
if (prefix === '-moz- old') {
return ':-moz-placeholder';
}
return "::" + prefix + "placeholder";
};
return Placeholder;
}(Selector);
_defineProperty(Placeholder, "names", ['::placeholder']);
module.exports = Placeholder;

38
node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js generated vendored Normal file
View File

@ -0,0 +1,38 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var TextDecorationSkipInk = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(TextDecorationSkipInk, _Declaration);
function TextDecorationSkipInk() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = TextDecorationSkipInk.prototype;
/**
* Change prefix for ink value
*/
_proto.set = function set(decl, prefix) {
if (decl.prop === 'text-decoration-skip-ink' && decl.value === 'auto') {
decl.prop = prefix + 'text-decoration-skip';
decl.value = 'ink';
return decl;
} else {
return _Declaration.prototype.set.call(this, decl, prefix);
}
};
return TextDecorationSkipInk;
}(Declaration);
_defineProperty(TextDecorationSkipInk, "names", ['text-decoration-skip-ink', 'text-decoration-skip']);
module.exports = TextDecorationSkipInk;

36
node_modules/autoprefixer/lib/hacks/text-decoration.js generated vendored Normal file
View File

@ -0,0 +1,36 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var BASIC = ['none', 'underline', 'overline', 'line-through', 'blink', 'inherit', 'initial', 'unset'];
var TextDecoration = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(TextDecoration, _Declaration);
function TextDecoration() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = TextDecoration.prototype;
/**
* Do not add prefixes for basic values.
*/
_proto.check = function check(decl) {
return decl.value.split(/\s+/).some(function (i) {
return !BASIC.includes(i);
});
};
return TextDecoration;
}(Declaration);
_defineProperty(TextDecoration, "names", ['text-decoration']);
module.exports = TextDecoration;

33
node_modules/autoprefixer/lib/hacks/text-emphasis-position.js generated vendored Normal file
View File

@ -0,0 +1,33 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var TextEmphasisPosition = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(TextEmphasisPosition, _Declaration);
function TextEmphasisPosition() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = TextEmphasisPosition.prototype;
_proto.set = function set(decl, prefix) {
if (prefix === '-webkit-') {
decl.value = decl.value.replace(/\s*(right|left)\s*/i, '');
}
return _Declaration.prototype.set.call(this, decl, prefix);
};
return TextEmphasisPosition;
}(Declaration);
_defineProperty(TextEmphasisPosition, "names", ['text-emphasis-position']);
module.exports = TextEmphasisPosition;

105
node_modules/autoprefixer/lib/hacks/transform-decl.js generated vendored Normal file
View File

@ -0,0 +1,105 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var TransformDecl = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(TransformDecl, _Declaration);
function TransformDecl() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = TransformDecl.prototype;
/**
* Recursively check all parents for @keyframes
*/
_proto.keyframeParents = function keyframeParents(decl) {
var parent = decl.parent;
while (parent) {
if (parent.type === 'atrule' && parent.name === 'keyframes') {
return true;
}
var _parent = parent;
parent = _parent.parent;
}
return false;
}
/**
* Is transform contain 3D commands
*/
;
_proto.contain3d = function contain3d(decl) {
if (decl.prop === 'transform-origin') {
return false;
}
for (var _iterator = _createForOfIteratorHelperLoose(TransformDecl.functions3d), _step; !(_step = _iterator()).done;) {
var func = _step.value;
if (decl.value.includes(func + "(")) {
return true;
}
}
return false;
}
/**
* Replace rotateZ to rotate for IE 9
*/
;
_proto.set = function set(decl, prefix) {
decl = _Declaration.prototype.set.call(this, decl, prefix);
if (prefix === '-ms-') {
decl.value = decl.value.replace(/rotatez/gi, 'rotate');
}
return decl;
}
/**
* Don't add prefix for IE in keyframes
*/
;
_proto.insert = function insert(decl, prefix, prefixes) {
if (prefix === '-ms-') {
if (!this.contain3d(decl) && !this.keyframeParents(decl)) {
return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
}
} else if (prefix === '-o-') {
if (!this.contain3d(decl)) {
return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
}
} else {
return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
}
return undefined;
};
return TransformDecl;
}(Declaration);
_defineProperty(TransformDecl, "names", ['transform', 'transform-origin']);
_defineProperty(TransformDecl, "functions3d", ['matrix3d', 'translate3d', 'translateZ', 'scale3d', 'scaleZ', 'rotate3d', 'rotateX', 'rotateY', 'perspective']);
module.exports = TransformDecl;

36
node_modules/autoprefixer/lib/hacks/user-select.js generated vendored Normal file
View File

@ -0,0 +1,36 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var UserSelect = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(UserSelect, _Declaration);
function UserSelect() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = UserSelect.prototype;
/**
* Change prefixed value for IE
*/
_proto.set = function set(decl, prefix) {
if (prefix === '-ms-' && decl.value === 'contain') {
decl.value = 'element';
}
return _Declaration.prototype.set.call(this, decl, prefix);
};
return UserSelect;
}(Declaration);
_defineProperty(UserSelect, "names", ['user-select']);
module.exports = UserSelect;

59
node_modules/autoprefixer/lib/hacks/writing-mode.js generated vendored Normal file
View File

@ -0,0 +1,59 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var Declaration = require('../declaration');
var WritingMode = /*#__PURE__*/function (_Declaration) {
_inheritsLoose(WritingMode, _Declaration);
function WritingMode() {
return _Declaration.apply(this, arguments) || this;
}
var _proto = WritingMode.prototype;
_proto.insert = function insert(decl, prefix, prefixes) {
if (prefix === '-ms-') {
var cloned = this.set(this.clone(decl), prefix);
if (this.needCascade(decl)) {
cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
}
var direction = 'ltr';
decl.parent.nodes.forEach(function (i) {
if (i.prop === 'direction') {
if (i.value === 'rtl' || i.value === 'ltr') direction = i.value;
}
});
cloned.value = WritingMode.msValues[direction][decl.value] || decl.value;
return decl.parent.insertBefore(decl, cloned);
}
return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
};
return WritingMode;
}(Declaration);
_defineProperty(WritingMode, "names", ['writing-mode']);
_defineProperty(WritingMode, "msValues", {
ltr: {
'horizontal-tb': 'lr-tb',
'vertical-rl': 'tb-rl',
'vertical-lr': 'tb-lr'
},
rtl: {
'horizontal-tb': 'rl-tb',
'vertical-rl': 'bt-rl',
'vertical-lr': 'bt-lr'
}
});
module.exports = WritingMode;

149
node_modules/autoprefixer/lib/info.js generated vendored Normal file
View File

@ -0,0 +1,149 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
var browserslist = require('browserslist');
function capitalize(str) {
return str.slice(0, 1).toUpperCase() + str.slice(1);
}
var NAMES = {
ie: 'IE',
ie_mob: 'IE Mobile',
ios_saf: 'iOS',
op_mini: 'Opera Mini',
op_mob: 'Opera Mobile',
and_chr: 'Chrome for Android',
and_ff: 'Firefox for Android',
and_uc: 'UC for Android'
};
function prefix(name, prefixes, note) {
var out = " " + name;
if (note) out += ' *';
out += ': ';
out += prefixes.map(function (i) {
return i.replace(/^-(.*)-$/g, '$1');
}).join(', ');
out += '\n';
return out;
}
module.exports = function (prefixes) {
if (prefixes.browsers.selected.length === 0) {
return 'No browsers selected';
}
var versions = {};
for (var _iterator = _createForOfIteratorHelperLoose(prefixes.browsers.selected), _step; !(_step = _iterator()).done;) {
var _browser = _step.value;
var parts = _browser.split(' ');
var _name2 = parts[0];
var version = parts[1];
_name2 = NAMES[_name2] || capitalize(_name2);
if (versions[_name2]) {
versions[_name2].push(version);
} else {
versions[_name2] = [version];
}
}
var out = 'Browsers:\n';
for (var browser in versions) {
var list = versions[browser];
list = list.sort(function (a, b) {
return parseFloat(b) - parseFloat(a);
});
out += " " + browser + ": " + list.join(', ') + "\n";
}
var coverage = browserslist.coverage(prefixes.browsers.selected);
var round = Math.round(coverage * 100) / 100.0;
out += "\nThese browsers account for " + round + "% of all users globally\n";
var atrules = [];
for (var name in prefixes.add) {
var data = prefixes.add[name];
if (name[0] === '@' && data.prefixes) {
atrules.push(prefix(name, data.prefixes));
}
}
if (atrules.length > 0) {
out += "\nAt-Rules:\n" + atrules.sort().join('');
}
var selectors = [];
for (var _iterator2 = _createForOfIteratorHelperLoose(prefixes.add.selectors), _step2; !(_step2 = _iterator2()).done;) {
var selector = _step2.value;
if (selector.prefixes) {
selectors.push(prefix(selector.name, selector.prefixes));
}
}
if (selectors.length > 0) {
out += "\nSelectors:\n" + selectors.sort().join('');
}
var values = [];
var props = [];
var hadGrid = false;
for (var _name in prefixes.add) {
var _data = prefixes.add[_name];
if (_name[0] !== '@' && _data.prefixes) {
var grid = _name.indexOf('grid-') === 0;
if (grid) hadGrid = true;
props.push(prefix(_name, _data.prefixes, grid));
}
if (!Array.isArray(_data.values)) {
continue;
}
for (var _iterator3 = _createForOfIteratorHelperLoose(_data.values), _step3; !(_step3 = _iterator3()).done;) {
var value = _step3.value;
var _grid = value.name.includes('grid');
if (_grid) hadGrid = true;
var string = prefix(value.name, value.prefixes, _grid);
if (!values.includes(string)) {
values.push(string);
}
}
}
if (props.length > 0) {
out += "\nProperties:\n" + props.sort().join('');
}
if (values.length > 0) {
out += "\nValues:\n" + values.sort().join('');
}
if (hadGrid) {
out += '\n* - Prefixes will be added only on grid: true option.\n';
}
if (!atrules.length && !selectors.length && !props.length && !values.length) {
out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.';
}
return out;
};

88
node_modules/autoprefixer/lib/old-selector.js generated vendored Normal file
View File

@ -0,0 +1,88 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
var OldSelector = /*#__PURE__*/function () {
function OldSelector(selector, prefix) {
this.prefix = prefix;
this.prefixed = selector.prefixed(this.prefix);
this.regexp = selector.regexp(this.prefix);
this.prefixeds = selector.possible().map(function (x) {
return [selector.prefixed(x), selector.regexp(x)];
});
this.unprefixed = selector.name;
this.nameRegexp = selector.regexp();
}
/**
* Is rule a hack without unprefixed version bottom
*/
var _proto = OldSelector.prototype;
_proto.isHack = function isHack(rule) {
var index = rule.parent.index(rule) + 1;
var rules = rule.parent.nodes;
while (index < rules.length) {
var before = rules[index].selector;
if (!before) {
return true;
}
if (before.includes(this.unprefixed) && before.match(this.nameRegexp)) {
return false;
}
var some = false;
for (var _iterator = _createForOfIteratorHelperLoose(this.prefixeds), _step; !(_step = _iterator()).done;) {
var _step$value = _step.value,
string = _step$value[0],
regexp = _step$value[1];
if (before.includes(string) && before.match(regexp)) {
some = true;
break;
}
}
if (!some) {
return true;
}
index += 1;
}
return true;
}
/**
* Does rule contain an unnecessary prefixed selector
*/
;
_proto.check = function check(rule) {
if (!rule.selector.includes(this.prefixed)) {
return false;
}
if (!rule.selector.match(this.regexp)) {
return false;
}
if (this.isHack(rule)) {
return false;
}
return true;
};
return OldSelector;
}();
module.exports = OldSelector;

30
node_modules/autoprefixer/lib/old-value.js generated vendored Normal file
View File

@ -0,0 +1,30 @@
"use strict";
var utils = require('./utils');
var OldValue = /*#__PURE__*/function () {
function OldValue(unprefixed, prefixed, string, regexp) {
this.unprefixed = unprefixed;
this.prefixed = prefixed;
this.string = string || prefixed;
this.regexp = regexp || utils.regexp(prefixed);
}
/**
* Check, that value contain old value
*/
var _proto = OldValue.prototype;
_proto.check = function check(value) {
if (value.includes(this.string)) {
return !!value.match(this.regexp);
}
return false;
};
return OldValue;
}();
module.exports = OldValue;

167
node_modules/autoprefixer/lib/prefixer.js generated vendored Normal file
View File

@ -0,0 +1,167 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
var vendor = require('postcss').vendor;
var Browsers = require('./browsers');
var utils = require('./utils');
/**
* Recursively clone objects
*/
function _clone(obj, parent) {
var cloned = new obj.constructor();
for (var _i = 0, _Object$keys = Object.keys(obj || {}); _i < _Object$keys.length; _i++) {
var i = _Object$keys[_i];
var value = obj[i];
if (i === 'parent' && typeof value === 'object') {
if (parent) {
cloned[i] = parent;
}
} else if (i === 'source' || i === null) {
cloned[i] = value;
} else if (Array.isArray(value)) {
cloned[i] = value.map(function (x) {
return _clone(x, cloned);
});
} else if (i !== '_autoprefixerPrefix' && i !== '_autoprefixerValues') {
if (typeof value === 'object' && value !== null) {
value = _clone(value, cloned);
}
cloned[i] = value;
}
}
return cloned;
}
var Prefixer = /*#__PURE__*/function () {
/**
* Add hack to selected names
*/
Prefixer.hack = function hack(klass) {
var _this = this;
if (!this.hacks) {
this.hacks = {};
}
return klass.names.map(function (name) {
_this.hacks[name] = klass;
return _this.hacks[name];
});
}
/**
* Load hacks for some names
*/
;
Prefixer.load = function load(name, prefixes, all) {
var Klass = this.hacks && this.hacks[name];
if (Klass) {
return new Klass(name, prefixes, all);
} else {
return new this(name, prefixes, all);
}
}
/**
* Clone node and clean autprefixer custom caches
*/
;
Prefixer.clone = function clone(node, overrides) {
var cloned = _clone(node);
for (var name in overrides) {
cloned[name] = overrides[name];
}
return cloned;
};
function Prefixer(name, prefixes, all) {
this.prefixes = prefixes;
this.name = name;
this.all = all;
}
/**
* Find prefix in node parents
*/
var _proto = Prefixer.prototype;
_proto.parentPrefix = function parentPrefix(node) {
var prefix;
if (typeof node._autoprefixerPrefix !== 'undefined') {
prefix = node._autoprefixerPrefix;
} else if (node.type === 'decl' && node.prop[0] === '-') {
prefix = vendor.prefix(node.prop);
} else if (node.type === 'root') {
prefix = false;
} else if (node.type === 'rule' && node.selector.includes(':-') && /:(-\w+-)/.test(node.selector)) {
prefix = node.selector.match(/:(-\w+-)/)[1];
} else if (node.type === 'atrule' && node.name[0] === '-') {
prefix = vendor.prefix(node.name);
} else {
prefix = this.parentPrefix(node.parent);
}
if (!Browsers.prefixes().includes(prefix)) {
prefix = false;
}
node._autoprefixerPrefix = prefix;
return node._autoprefixerPrefix;
}
/**
* Clone node with prefixes
*/
;
_proto.process = function process(node, result) {
if (!this.check(node)) {
return undefined;
}
var parent = this.parentPrefix(node);
var prefixes = this.prefixes.filter(function (prefix) {
return !parent || parent === utils.removeNote(prefix);
});
var added = [];
for (var _iterator = _createForOfIteratorHelperLoose(prefixes), _step; !(_step = _iterator()).done;) {
var prefix = _step.value;
if (this.add(node, prefix, added.concat([prefix]), result)) {
added.push(prefix);
}
}
return added;
}
/**
* Shortcut for Prefixer.clone
*/
;
_proto.clone = function clone(node, overrides) {
return Prefixer.clone(node, overrides);
};
return Prefixer;
}();
module.exports = Prefixer;

471
node_modules/autoprefixer/lib/prefixes.js generated vendored Normal file
View File

@ -0,0 +1,471 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
var vendor = require('postcss').vendor;
var Declaration = require('./declaration');
var Resolution = require('./resolution');
var Transition = require('./transition');
var Processor = require('./processor');
var Supports = require('./supports');
var Browsers = require('./browsers');
var Selector = require('./selector');
var AtRule = require('./at-rule');
var Value = require('./value');
var utils = require('./utils');
Selector.hack(require('./hacks/fullscreen'));
Selector.hack(require('./hacks/placeholder'));
Selector.hack(require('./hacks/placeholder-shown'));
Declaration.hack(require('./hacks/flex'));
Declaration.hack(require('./hacks/order'));
Declaration.hack(require('./hacks/filter'));
Declaration.hack(require('./hacks/grid-end'));
Declaration.hack(require('./hacks/animation'));
Declaration.hack(require('./hacks/flex-flow'));
Declaration.hack(require('./hacks/flex-grow'));
Declaration.hack(require('./hacks/flex-wrap'));
Declaration.hack(require('./hacks/grid-area'));
Declaration.hack(require('./hacks/place-self'));
Declaration.hack(require('./hacks/grid-start'));
Declaration.hack(require('./hacks/align-self'));
Declaration.hack(require('./hacks/appearance'));
Declaration.hack(require('./hacks/flex-basis'));
Declaration.hack(require('./hacks/mask-border'));
Declaration.hack(require('./hacks/mask-composite'));
Declaration.hack(require('./hacks/align-items'));
Declaration.hack(require('./hacks/user-select'));
Declaration.hack(require('./hacks/flex-shrink'));
Declaration.hack(require('./hacks/break-props'));
Declaration.hack(require('./hacks/color-adjust'));
Declaration.hack(require('./hacks/writing-mode'));
Declaration.hack(require('./hacks/border-image'));
Declaration.hack(require('./hacks/align-content'));
Declaration.hack(require('./hacks/border-radius'));
Declaration.hack(require('./hacks/block-logical'));
Declaration.hack(require('./hacks/grid-template'));
Declaration.hack(require('./hacks/inline-logical'));
Declaration.hack(require('./hacks/grid-row-align'));
Declaration.hack(require('./hacks/transform-decl'));
Declaration.hack(require('./hacks/flex-direction'));
Declaration.hack(require('./hacks/image-rendering'));
Declaration.hack(require('./hacks/backdrop-filter'));
Declaration.hack(require('./hacks/background-clip'));
Declaration.hack(require('./hacks/text-decoration'));
Declaration.hack(require('./hacks/justify-content'));
Declaration.hack(require('./hacks/background-size'));
Declaration.hack(require('./hacks/grid-row-column'));
Declaration.hack(require('./hacks/grid-rows-columns'));
Declaration.hack(require('./hacks/grid-column-align'));
Declaration.hack(require('./hacks/overscroll-behavior'));
Declaration.hack(require('./hacks/grid-template-areas'));
Declaration.hack(require('./hacks/text-emphasis-position'));
Declaration.hack(require('./hacks/text-decoration-skip-ink'));
Value.hack(require('./hacks/gradient'));
Value.hack(require('./hacks/intrinsic'));
Value.hack(require('./hacks/pixelated'));
Value.hack(require('./hacks/image-set'));
Value.hack(require('./hacks/cross-fade'));
Value.hack(require('./hacks/display-flex'));
Value.hack(require('./hacks/display-grid'));
Value.hack(require('./hacks/filter-value'));
var declsCache = {};
var Prefixes = /*#__PURE__*/function () {
function Prefixes(data, browsers, options) {
if (options === void 0) {
options = {};
}
this.data = data;
this.browsers = browsers;
this.options = options;
var _this$preprocess = this.preprocess(this.select(this.data));
this.add = _this$preprocess[0];
this.remove = _this$preprocess[1];
this.transition = new Transition(this);
this.processor = new Processor(this);
}
/**
* Return clone instance to remove all prefixes
*/
var _proto = Prefixes.prototype;
_proto.cleaner = function cleaner() {
if (this.cleanerCache) {
return this.cleanerCache;
}
if (this.browsers.selected.length) {
var empty = new Browsers(this.browsers.data, []);
this.cleanerCache = new Prefixes(this.data, empty, this.options);
} else {
return this;
}
return this.cleanerCache;
}
/**
* Select prefixes from data, which is necessary for selected browsers
*/
;
_proto.select = function select(list) {
var _this = this;
var selected = {
add: {},
remove: {}
};
var _loop = function _loop(name) {
var data = list[name];
var add = data.browsers.map(function (i) {
var params = i.split(' ');
return {
browser: params[0] + " " + params[1],
note: params[2]
};
});
var notes = add.filter(function (i) {
return i.note;
}).map(function (i) {
return _this.browsers.prefix(i.browser) + " " + i.note;
});
notes = utils.uniq(notes);
add = add.filter(function (i) {
return _this.browsers.isSelected(i.browser);
}).map(function (i) {
var prefix = _this.browsers.prefix(i.browser);
if (i.note) {
return prefix + " " + i.note;
} else {
return prefix;
}
});
add = _this.sort(utils.uniq(add));
if (_this.options.flexbox === 'no-2009') {
add = add.filter(function (i) {
return !i.includes('2009');
});
}
var all = data.browsers.map(function (i) {
return _this.browsers.prefix(i);
});
if (data.mistakes) {
all = all.concat(data.mistakes);
}
all = all.concat(notes);
all = utils.uniq(all);
if (add.length) {
selected.add[name] = add;
if (add.length < all.length) {
selected.remove[name] = all.filter(function (i) {
return !add.includes(i);
});
}
} else {
selected.remove[name] = all;
}
};
for (var name in list) {
_loop(name);
}
return selected;
}
/**
* Sort vendor prefixes
*/
;
_proto.sort = function sort(prefixes) {
return prefixes.sort(function (a, b) {
var aLength = utils.removeNote(a).length;
var bLength = utils.removeNote(b).length;
if (aLength === bLength) {
return b.length - a.length;
} else {
return bLength - aLength;
}
});
}
/**
* Cache prefixes data to fast CSS processing
*/
;
_proto.preprocess = function preprocess(selected) {
var add = {
'selectors': [],
'@supports': new Supports(Prefixes, this)
};
for (var name in selected.add) {
var prefixes = selected.add[name];
if (name === '@keyframes' || name === '@viewport') {
add[name] = new AtRule(name, prefixes, this);
} else if (name === '@resolution') {
add[name] = new Resolution(name, prefixes, this);
} else if (this.data[name].selector) {
add.selectors.push(Selector.load(name, prefixes, this));
} else {
var props = this.data[name].props;
if (props) {
var value = Value.load(name, prefixes, this);
for (var _iterator = _createForOfIteratorHelperLoose(props), _step; !(_step = _iterator()).done;) {
var prop = _step.value;
if (!add[prop]) {
add[prop] = {
values: []
};
}
add[prop].values.push(value);
}
} else {
var values = add[name] && add[name].values || [];
add[name] = Declaration.load(name, prefixes, this);
add[name].values = values;
}
}
}
var remove = {
selectors: []
};
for (var _name in selected.remove) {
var _prefixes = selected.remove[_name];
if (this.data[_name].selector) {
var selector = Selector.load(_name, _prefixes);
for (var _iterator2 = _createForOfIteratorHelperLoose(_prefixes), _step2; !(_step2 = _iterator2()).done;) {
var prefix = _step2.value;
remove.selectors.push(selector.old(prefix));
}
} else if (_name === '@keyframes' || _name === '@viewport') {
for (var _iterator3 = _createForOfIteratorHelperLoose(_prefixes), _step3; !(_step3 = _iterator3()).done;) {
var _prefix = _step3.value;
var prefixed = "@" + _prefix + _name.slice(1);
remove[prefixed] = {
remove: true
};
}
} else if (_name === '@resolution') {
remove[_name] = new Resolution(_name, _prefixes, this);
} else {
var _props = this.data[_name].props;
if (_props) {
var _value = Value.load(_name, [], this);
for (var _iterator4 = _createForOfIteratorHelperLoose(_prefixes), _step4; !(_step4 = _iterator4()).done;) {
var _prefix2 = _step4.value;
var old = _value.old(_prefix2);
if (old) {
for (var _iterator5 = _createForOfIteratorHelperLoose(_props), _step5; !(_step5 = _iterator5()).done;) {
var _prop = _step5.value;
if (!remove[_prop]) {
remove[_prop] = {};
}
if (!remove[_prop].values) {
remove[_prop].values = [];
}
remove[_prop].values.push(old);
}
}
}
} else {
for (var _iterator6 = _createForOfIteratorHelperLoose(_prefixes), _step6; !(_step6 = _iterator6()).done;) {
var p = _step6.value;
var olds = this.decl(_name).old(_name, p);
if (_name === 'align-self') {
var a = add[_name] && add[_name].prefixes;
if (a) {
if (p === '-webkit- 2009' && a.includes('-webkit-')) {
continue;
} else if (p === '-webkit-' && a.includes('-webkit- 2009')) {
continue;
}
}
}
for (var _iterator7 = _createForOfIteratorHelperLoose(olds), _step7; !(_step7 = _iterator7()).done;) {
var _prefixed = _step7.value;
if (!remove[_prefixed]) {
remove[_prefixed] = {};
}
remove[_prefixed].remove = true;
}
}
}
}
}
return [add, remove];
}
/**
* Declaration loader with caching
*/
;
_proto.decl = function decl(prop) {
var decl = declsCache[prop];
if (decl) {
return decl;
} else {
declsCache[prop] = Declaration.load(prop);
return declsCache[prop];
}
}
/**
* Return unprefixed version of property
*/
;
_proto.unprefixed = function unprefixed(prop) {
var value = this.normalize(vendor.unprefixed(prop));
if (value === 'flex-direction') {
value = 'flex-flow';
}
return value;
}
/**
* Normalize prefix for remover
*/
;
_proto.normalize = function normalize(prop) {
return this.decl(prop).normalize(prop);
}
/**
* Return prefixed version of property
*/
;
_proto.prefixed = function prefixed(prop, prefix) {
prop = vendor.unprefixed(prop);
return this.decl(prop).prefixed(prop, prefix);
}
/**
* Return values, which must be prefixed in selected property
*/
;
_proto.values = function values(type, prop) {
var data = this[type];
var global = data['*'] && data['*'].values;
var values = data[prop] && data[prop].values;
if (global && values) {
return utils.uniq(global.concat(values));
} else {
return global || values || [];
}
}
/**
* Group declaration by unprefixed property to check them
*/
;
_proto.group = function group(decl) {
var _this2 = this;
var rule = decl.parent;
var index = rule.index(decl);
var length = rule.nodes.length;
var unprefixed = this.unprefixed(decl.prop);
var checker = function checker(step, callback) {
index += step;
while (index >= 0 && index < length) {
var other = rule.nodes[index];
if (other.type === 'decl') {
if (step === -1 && other.prop === unprefixed) {
if (!Browsers.withPrefix(other.value)) {
break;
}
}
if (_this2.unprefixed(other.prop) !== unprefixed) {
break;
} else if (callback(other) === true) {
return true;
}
if (step === +1 && other.prop === unprefixed) {
if (!Browsers.withPrefix(other.value)) {
break;
}
}
}
index += step;
}
return false;
};
return {
up: function up(callback) {
return checker(-1, callback);
},
down: function down(callback) {
return checker(+1, callback);
}
};
};
return Prefixes;
}();
module.exports = Prefixes;

703
node_modules/autoprefixer/lib/processor.js generated vendored Normal file
View File

@ -0,0 +1,703 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
var parser = require('postcss-value-parser');
var Value = require('./value');
var insertAreas = require('./hacks/grid-utils').insertAreas;
var OLD_LINEAR = /(^|[^-])linear-gradient\(\s*(top|left|right|bottom)/i;
var OLD_RADIAL = /(^|[^-])radial-gradient\(\s*\d+(\w*|%)\s+\d+(\w*|%)\s*,/i;
var IGNORE_NEXT = /(!\s*)?autoprefixer:\s*ignore\s+next/i;
var GRID_REGEX = /(!\s*)?autoprefixer\s*grid:\s*(on|off|(no-)?autoplace)/i;
var SIZES = ['width', 'height', 'min-width', 'max-width', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size'];
function hasGridTemplate(decl) {
return decl.parent.some(function (i) {
return i.prop === 'grid-template' || i.prop === 'grid-template-areas';
});
}
function hasRowsAndColumns(decl) {
var hasRows = decl.parent.some(function (i) {
return i.prop === 'grid-template-rows';
});
var hasColumns = decl.parent.some(function (i) {
return i.prop === 'grid-template-columns';
});
return hasRows && hasColumns;
}
var Processor = /*#__PURE__*/function () {
function Processor(prefixes) {
this.prefixes = prefixes;
}
/**
* Add necessary prefixes
*/
var _proto = Processor.prototype;
_proto.add = function add(css, result) {
var _this = this;
// At-rules
var resolution = this.prefixes.add['@resolution'];
var keyframes = this.prefixes.add['@keyframes'];
var viewport = this.prefixes.add['@viewport'];
var supports = this.prefixes.add['@supports'];
css.walkAtRules(function (rule) {
if (rule.name === 'keyframes') {
if (!_this.disabled(rule, result)) {
return keyframes && keyframes.process(rule);
}
} else if (rule.name === 'viewport') {
if (!_this.disabled(rule, result)) {
return viewport && viewport.process(rule);
}
} else if (rule.name === 'supports') {
if (_this.prefixes.options.supports !== false && !_this.disabled(rule, result)) {
return supports.process(rule);
}
} else if (rule.name === 'media' && rule.params.includes('-resolution')) {
if (!_this.disabled(rule, result)) {
return resolution && resolution.process(rule);
}
}
return undefined;
}); // Selectors
css.walkRules(function (rule) {
if (_this.disabled(rule, result)) return undefined;
return _this.prefixes.add.selectors.map(function (selector) {
return selector.process(rule, result);
});
});
function insideGrid(decl) {
return decl.parent.nodes.some(function (node) {
if (node.type !== 'decl') return false;
var displayGrid = node.prop === 'display' && /(inline-)?grid/.test(node.value);
var gridTemplate = node.prop.startsWith('grid-template');
var gridGap = /^grid-([A-z]+-)?gap/.test(node.prop);
return displayGrid || gridTemplate || gridGap;
});
}
function insideFlex(decl) {
return decl.parent.some(function (node) {
return node.prop === 'display' && /(inline-)?flex/.test(node.value);
});
}
var gridPrefixes = this.gridStatus(css, result) && this.prefixes.add['grid-area'] && this.prefixes.add['grid-area'].prefixes;
css.walkDecls(function (decl) {
if (_this.disabledDecl(decl, result)) return undefined;
var parent = decl.parent;
var prop = decl.prop;
var value = decl.value;
if (prop === 'grid-row-span') {
result.warn('grid-row-span is not part of final Grid Layout. Use grid-row.', {
node: decl
});
return undefined;
} else if (prop === 'grid-column-span') {
result.warn('grid-column-span is not part of final Grid Layout. Use grid-column.', {
node: decl
});
return undefined;
} else if (prop === 'display' && value === 'box') {
result.warn('You should write display: flex by final spec ' + 'instead of display: box', {
node: decl
});
return undefined;
} else if (prop === 'text-emphasis-position') {
if (value === 'under' || value === 'over') {
result.warn('You should use 2 values for text-emphasis-position ' + 'For example, `under left` instead of just `under`.', {
node: decl
});
}
} else if (/^(align|justify|place)-(items|content)$/.test(prop) && insideFlex(decl)) {
if (value === 'start' || value === 'end') {
result.warn(value + " value has mixed support, consider using " + ("flex-" + value + " instead"), {
node: decl
});
}
} else if (prop === 'text-decoration-skip' && value === 'ink') {
result.warn('Replace text-decoration-skip: ink to ' + 'text-decoration-skip-ink: auto, because spec had been changed', {
node: decl
});
} else {
if (gridPrefixes && _this.gridStatus(decl, result)) {
if (decl.value === 'subgrid') {
result.warn('IE does not support subgrid', {
node: decl
});
}
if (/^(align|justify|place)-items$/.test(prop) && insideGrid(decl)) {
var fixed = prop.replace('-items', '-self');
result.warn("IE does not support " + prop + " on grid containers. " + ("Try using " + fixed + " on child elements instead: ") + (decl.parent.selector + " > * { " + fixed + ": " + decl.value + " }"), {
node: decl
});
} else if (/^(align|justify|place)-content$/.test(prop) && insideGrid(decl)) {
result.warn("IE does not support " + decl.prop + " on grid containers", {
node: decl
});
} else if (prop === 'display' && decl.value === 'contents') {
result.warn('Please do not use display: contents; ' + 'if you have grid setting enabled', {
node: decl
});
return undefined;
} else if (decl.prop === 'grid-gap') {
var status = _this.gridStatus(decl, result);
if (status === 'autoplace' && !hasRowsAndColumns(decl) && !hasGridTemplate(decl)) {
result.warn('grid-gap only works if grid-template(-areas) is being ' + 'used or both rows and columns have been declared ' + 'and cells have not been manually ' + 'placed inside the explicit grid', {
node: decl
});
} else if ((status === true || status === 'no-autoplace') && !hasGridTemplate(decl)) {
result.warn('grid-gap only works if grid-template(-areas) is being used', {
node: decl
});
}
} else if (prop === 'grid-auto-columns') {
result.warn('grid-auto-columns is not supported by IE', {
node: decl
});
return undefined;
} else if (prop === 'grid-auto-rows') {
result.warn('grid-auto-rows is not supported by IE', {
node: decl
});
return undefined;
} else if (prop === 'grid-auto-flow') {
var hasRows = parent.some(function (i) {
return i.prop === 'grid-template-rows';
});
var hasCols = parent.some(function (i) {
return i.prop === 'grid-template-columns';
});
if (hasGridTemplate(decl)) {
result.warn('grid-auto-flow is not supported by IE', {
node: decl
});
} else if (value.includes('dense')) {
result.warn('grid-auto-flow: dense is not supported by IE', {
node: decl
});
} else if (!hasRows && !hasCols) {
result.warn('grid-auto-flow works only if grid-template-rows and ' + 'grid-template-columns are present in the same rule', {
node: decl
});
}
return undefined;
} else if (value.includes('auto-fit')) {
result.warn('auto-fit value is not supported by IE', {
node: decl,
word: 'auto-fit'
});
return undefined;
} else if (value.includes('auto-fill')) {
result.warn('auto-fill value is not supported by IE', {
node: decl,
word: 'auto-fill'
});
return undefined;
} else if (prop.startsWith('grid-template') && value.includes('[')) {
result.warn('Autoprefixer currently does not support line names. ' + 'Try using grid-template-areas instead.', {
node: decl,
word: '['
});
}
}
if (value.includes('radial-gradient')) {
if (OLD_RADIAL.test(decl.value)) {
result.warn('Gradient has outdated direction syntax. ' + 'New syntax is like `closest-side at 0 0` ' + 'instead of `0 0, closest-side`.', {
node: decl
});
} else {
var ast = parser(value);
for (var _iterator = _createForOfIteratorHelperLoose(ast.nodes), _step; !(_step = _iterator()).done;) {
var i = _step.value;
if (i.type === 'function' && i.value === 'radial-gradient') {
for (var _iterator2 = _createForOfIteratorHelperLoose(i.nodes), _step2; !(_step2 = _iterator2()).done;) {
var word = _step2.value;
if (word.type === 'word') {
if (word.value === 'cover') {
result.warn('Gradient has outdated direction syntax. ' + 'Replace `cover` to `farthest-corner`.', {
node: decl
});
} else if (word.value === 'contain') {
result.warn('Gradient has outdated direction syntax. ' + 'Replace `contain` to `closest-side`.', {
node: decl
});
}
}
}
}
}
}
}
if (value.includes('linear-gradient')) {
if (OLD_LINEAR.test(value)) {
result.warn('Gradient has outdated direction syntax. ' + 'New syntax is like `to left` instead of `right`.', {
node: decl
});
}
}
}
if (SIZES.includes(decl.prop)) {
if (!decl.value.includes('-fill-available')) {
if (decl.value.includes('fill-available')) {
result.warn('Replace fill-available to stretch, ' + 'because spec had been changed', {
node: decl
});
} else if (decl.value.includes('fill')) {
var _ast = parser(value);
if (_ast.nodes.some(function (i) {
return i.type === 'word' && i.value === 'fill';
})) {
result.warn('Replace fill to stretch, because spec had been changed', {
node: decl
});
}
}
}
}
var prefixer;
if (decl.prop === 'transition' || decl.prop === 'transition-property') {
// Transition
return _this.prefixes.transition.add(decl, result);
} else if (decl.prop === 'align-self') {
// align-self flexbox or grid
var display = _this.displayType(decl);
if (display !== 'grid' && _this.prefixes.options.flexbox !== false) {
prefixer = _this.prefixes.add['align-self'];
if (prefixer && prefixer.prefixes) {
prefixer.process(decl);
}
}
if (_this.gridStatus(decl, result) !== false) {
prefixer = _this.prefixes.add['grid-row-align'];
if (prefixer && prefixer.prefixes) {
return prefixer.process(decl, result);
}
}
} else if (decl.prop === 'justify-self') {
// justify-self flexbox or grid
if (_this.gridStatus(decl, result) !== false) {
prefixer = _this.prefixes.add['grid-column-align'];
if (prefixer && prefixer.prefixes) {
return prefixer.process(decl, result);
}
}
} else if (decl.prop === 'place-self') {
prefixer = _this.prefixes.add['place-self'];
if (prefixer && prefixer.prefixes && _this.gridStatus(decl, result) !== false) {
return prefixer.process(decl, result);
}
} else {
// Properties
prefixer = _this.prefixes.add[decl.prop];
if (prefixer && prefixer.prefixes) {
return prefixer.process(decl, result);
}
}
return undefined;
}); // Insert grid-area prefixes. We need to be able to store the different
// rules as a data and hack API is not enough for this
if (this.gridStatus(css, result)) {
insertAreas(css, this.disabled);
} // Values
return css.walkDecls(function (decl) {
if (_this.disabledValue(decl, result)) return;
var unprefixed = _this.prefixes.unprefixed(decl.prop);
var list = _this.prefixes.values('add', unprefixed);
if (Array.isArray(list)) {
for (var _iterator3 = _createForOfIteratorHelperLoose(list), _step3; !(_step3 = _iterator3()).done;) {
var value = _step3.value;
if (value.process) value.process(decl, result);
}
}
Value.save(_this.prefixes, decl);
});
}
/**
* Remove unnecessary pefixes
*/
;
_proto.remove = function remove(css, result) {
var _this2 = this;
// At-rules
var resolution = this.prefixes.remove['@resolution'];
css.walkAtRules(function (rule, i) {
if (_this2.prefixes.remove["@" + rule.name]) {
if (!_this2.disabled(rule, result)) {
rule.parent.removeChild(i);
}
} else if (rule.name === 'media' && rule.params.includes('-resolution') && resolution) {
resolution.clean(rule);
}
}); // Selectors
var _loop = function _loop() {
var checker = _step4.value;
css.walkRules(function (rule, i) {
if (checker.check(rule)) {
if (!_this2.disabled(rule, result)) {
rule.parent.removeChild(i);
}
}
});
};
for (var _iterator4 = _createForOfIteratorHelperLoose(this.prefixes.remove.selectors), _step4; !(_step4 = _iterator4()).done;) {
_loop();
}
return css.walkDecls(function (decl, i) {
if (_this2.disabled(decl, result)) return;
var rule = decl.parent;
var unprefixed = _this2.prefixes.unprefixed(decl.prop); // Transition
if (decl.prop === 'transition' || decl.prop === 'transition-property') {
_this2.prefixes.transition.remove(decl);
} // Properties
if (_this2.prefixes.remove[decl.prop] && _this2.prefixes.remove[decl.prop].remove) {
var notHack = _this2.prefixes.group(decl).down(function (other) {
return _this2.prefixes.normalize(other.prop) === unprefixed;
});
if (unprefixed === 'flex-flow') {
notHack = true;
}
if (decl.prop === '-webkit-box-orient') {
var hacks = {
'flex-direction': true,
'flex-flow': true
};
if (!decl.parent.some(function (j) {
return hacks[j.prop];
})) return;
}
if (notHack && !_this2.withHackValue(decl)) {
if (decl.raw('before').includes('\n')) {
_this2.reduceSpaces(decl);
}
rule.removeChild(i);
return;
}
} // Values
for (var _iterator5 = _createForOfIteratorHelperLoose(_this2.prefixes.values('remove', unprefixed)), _step5; !(_step5 = _iterator5()).done;) {
var checker = _step5.value;
if (!checker.check) continue;
if (!checker.check(decl.value)) continue;
unprefixed = checker.unprefixed;
var _notHack = _this2.prefixes.group(decl).down(function (other) {
return other.value.includes(unprefixed);
});
if (_notHack) {
rule.removeChild(i);
return;
}
}
});
}
/**
* Some rare old values, which is not in standard
*/
;
_proto.withHackValue = function withHackValue(decl) {
return decl.prop === '-webkit-background-clip' && decl.value === 'text';
}
/**
* Check for grid/flexbox options.
*/
;
_proto.disabledValue = function disabledValue(node, result) {
if (this.gridStatus(node, result) === false && node.type === 'decl') {
if (node.prop === 'display' && node.value.includes('grid')) {
return true;
}
}
if (this.prefixes.options.flexbox === false && node.type === 'decl') {
if (node.prop === 'display' && node.value.includes('flex')) {
return true;
}
}
return this.disabled(node, result);
}
/**
* Check for grid/flexbox options.
*/
;
_proto.disabledDecl = function disabledDecl(node, result) {
if (this.gridStatus(node, result) === false && node.type === 'decl') {
if (node.prop.includes('grid') || node.prop === 'justify-items') {
return true;
}
}
if (this.prefixes.options.flexbox === false && node.type === 'decl') {
var other = ['order', 'justify-content', 'align-items', 'align-content'];
if (node.prop.includes('flex') || other.includes(node.prop)) {
return true;
}
}
return this.disabled(node, result);
}
/**
* Check for control comment and global options
*/
;
_proto.disabled = function disabled(node, result) {
if (!node) return false;
if (node._autoprefixerDisabled !== undefined) {
return node._autoprefixerDisabled;
}
if (node.parent) {
var p = node.prev();
if (p && p.type === 'comment' && IGNORE_NEXT.test(p.text)) {
node._autoprefixerDisabled = true;
node._autoprefixerSelfDisabled = true;
return true;
}
}
var value = null;
if (node.nodes) {
var status;
node.each(function (i) {
if (i.type !== 'comment') return;
if (/(!\s*)?autoprefixer:\s*(off|on)/i.test(i.text)) {
if (typeof status !== 'undefined') {
result.warn('Second Autoprefixer control comment ' + 'was ignored. Autoprefixer applies control ' + 'comment to whole block, not to next rules.', {
node: i
});
} else {
status = /on/i.test(i.text);
}
}
});
if (status !== undefined) {
value = !status;
}
}
if (!node.nodes || value === null) {
if (node.parent) {
var isParentDisabled = this.disabled(node.parent, result);
if (node.parent._autoprefixerSelfDisabled === true) {
value = false;
} else {
value = isParentDisabled;
}
} else {
value = false;
}
}
node._autoprefixerDisabled = value;
return value;
}
/**
* Normalize spaces in cascade declaration group
*/
;
_proto.reduceSpaces = function reduceSpaces(decl) {
var stop = false;
this.prefixes.group(decl).up(function () {
stop = true;
return true;
});
if (stop) {
return;
}
var parts = decl.raw('before').split('\n');
var prevMin = parts[parts.length - 1].length;
var diff = false;
this.prefixes.group(decl).down(function (other) {
parts = other.raw('before').split('\n');
var last = parts.length - 1;
if (parts[last].length > prevMin) {
if (diff === false) {
diff = parts[last].length - prevMin;
}
parts[last] = parts[last].slice(0, -diff);
other.raws.before = parts.join('\n');
}
});
}
/**
* Is it flebox or grid rule
*/
;
_proto.displayType = function displayType(decl) {
for (var _iterator6 = _createForOfIteratorHelperLoose(decl.parent.nodes), _step6; !(_step6 = _iterator6()).done;) {
var i = _step6.value;
if (i.prop !== 'display') {
continue;
}
if (i.value.includes('flex')) {
return 'flex';
}
if (i.value.includes('grid')) {
return 'grid';
}
}
return false;
}
/**
* Set grid option via control comment
*/
;
_proto.gridStatus = function gridStatus(node, result) {
if (!node) return false;
if (node._autoprefixerGridStatus !== undefined) {
return node._autoprefixerGridStatus;
}
var value = null;
if (node.nodes) {
var status;
node.each(function (i) {
if (i.type !== 'comment') return;
if (GRID_REGEX.test(i.text)) {
var hasAutoplace = /:\s*autoplace/i.test(i.text);
var noAutoplace = /no-autoplace/i.test(i.text);
if (typeof status !== 'undefined') {
result.warn('Second Autoprefixer grid control comment was ' + 'ignored. Autoprefixer applies control comments to the whole ' + 'block, not to the next rules.', {
node: i
});
} else if (hasAutoplace) {
status = 'autoplace';
} else if (noAutoplace) {
status = true;
} else {
status = /on/i.test(i.text);
}
}
});
if (status !== undefined) {
value = status;
}
}
if (node.type === 'atrule' && node.name === 'supports') {
var params = node.params;
if (params.includes('grid') && params.includes('auto')) {
value = false;
}
}
if (!node.nodes || value === null) {
if (node.parent) {
var isParentGrid = this.gridStatus(node.parent, result);
if (node.parent._autoprefixerSelfDisabled === true) {
value = false;
} else {
value = isParentGrid;
}
} else if (typeof this.prefixes.options.grid !== 'undefined') {
value = this.prefixes.options.grid;
} else if (typeof process.env.AUTOPREFIXER_GRID !== 'undefined') {
if (process.env.AUTOPREFIXER_GRID === 'autoplace') {
value = 'autoplace';
} else {
value = true;
}
} else {
value = false;
}
}
node._autoprefixerGridStatus = value;
return value;
};
return Processor;
}();
module.exports = Processor;

125
node_modules/autoprefixer/lib/resolution.js generated vendored Normal file
View File

@ -0,0 +1,125 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
var n2f = require('num2fraction');
var Prefixer = require('./prefixer');
var utils = require('./utils');
var REGEXP = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpi|x)/gi;
var SPLIT = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpi|x)/i;
var Resolution = /*#__PURE__*/function (_Prefixer) {
_inheritsLoose(Resolution, _Prefixer);
function Resolution() {
return _Prefixer.apply(this, arguments) || this;
}
var _proto = Resolution.prototype;
/**
* Return prefixed query name
*/
_proto.prefixName = function prefixName(prefix, name) {
if (prefix === '-moz-') {
return name + '--moz-device-pixel-ratio';
} else {
return prefix + name + '-device-pixel-ratio';
}
}
/**
* Return prefixed query
*/
;
_proto.prefixQuery = function prefixQuery(prefix, name, colon, value, units) {
if (units === 'dpi') {
value = Number(value / 96);
}
if (prefix === '-o-') {
value = n2f(value);
}
return this.prefixName(prefix, name) + colon + value;
}
/**
* Remove prefixed queries
*/
;
_proto.clean = function clean(rule) {
var _this = this;
if (!this.bad) {
this.bad = [];
for (var _iterator = _createForOfIteratorHelperLoose(this.prefixes), _step; !(_step = _iterator()).done;) {
var prefix = _step.value;
this.bad.push(this.prefixName(prefix, 'min'));
this.bad.push(this.prefixName(prefix, 'max'));
}
}
rule.params = utils.editList(rule.params, function (queries) {
return queries.filter(function (query) {
return _this.bad.every(function (i) {
return !query.includes(i);
});
});
});
}
/**
* Add prefixed queries
*/
;
_proto.process = function process(rule) {
var _this2 = this;
var parent = this.parentPrefix(rule);
var prefixes = parent ? [parent] : this.prefixes;
rule.params = utils.editList(rule.params, function (origin, prefixed) {
for (var _iterator2 = _createForOfIteratorHelperLoose(origin), _step2; !(_step2 = _iterator2()).done;) {
var query = _step2.value;
if (!query.includes('min-resolution') && !query.includes('max-resolution')) {
prefixed.push(query);
continue;
}
var _loop = function _loop() {
var prefix = _step3.value;
var processed = query.replace(REGEXP, function (str) {
var parts = str.match(SPLIT);
return _this2.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]);
});
prefixed.push(processed);
};
for (var _iterator3 = _createForOfIteratorHelperLoose(prefixes), _step3; !(_step3 = _iterator3()).done;) {
_loop();
}
prefixed.push(query);
}
return utils.uniq(prefixed);
});
};
return Resolution;
}(Prefixer);
module.exports = Resolution;

198
node_modules/autoprefixer/lib/selector.js generated vendored Normal file
View File

@ -0,0 +1,198 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
var _require = require('postcss'),
list = _require.list;
var OldSelector = require('./old-selector');
var Prefixer = require('./prefixer');
var Browsers = require('./browsers');
var utils = require('./utils');
var Selector = /*#__PURE__*/function (_Prefixer) {
_inheritsLoose(Selector, _Prefixer);
function Selector(name, prefixes, all) {
var _this;
_this = _Prefixer.call(this, name, prefixes, all) || this;
_this.regexpCache = {};
return _this;
}
/**
* Is rule selectors need to be prefixed
*/
var _proto = Selector.prototype;
_proto.check = function check(rule) {
if (rule.selector.includes(this.name)) {
return !!rule.selector.match(this.regexp());
}
return false;
}
/**
* Return prefixed version of selector
*/
;
_proto.prefixed = function prefixed(prefix) {
return this.name.replace(/^(\W*)/, "$1" + prefix);
}
/**
* Lazy loadRegExp for name
*/
;
_proto.regexp = function regexp(prefix) {
if (this.regexpCache[prefix]) {
return this.regexpCache[prefix];
}
var name = prefix ? this.prefixed(prefix) : this.name;
this.regexpCache[prefix] = new RegExp("(^|[^:\"'=])" + utils.escapeRegexp(name), 'gi');
return this.regexpCache[prefix];
}
/**
* All possible prefixes
*/
;
_proto.possible = function possible() {
return Browsers.prefixes();
}
/**
* Return all possible selector prefixes
*/
;
_proto.prefixeds = function prefixeds(rule) {
var _this2 = this;
if (rule._autoprefixerPrefixeds) {
if (rule._autoprefixerPrefixeds[this.name]) {
return rule._autoprefixerPrefixeds;
}
} else {
rule._autoprefixerPrefixeds = {};
}
var prefixeds = {};
if (rule.selector.includes(',')) {
var ruleParts = list.comma(rule.selector);
var toProcess = ruleParts.filter(function (el) {
return el.includes(_this2.name);
});
var _loop = function _loop() {
var prefix = _step.value;
prefixeds[prefix] = toProcess.map(function (el) {
return _this2.replace(el, prefix);
}).join(', ');
};
for (var _iterator = _createForOfIteratorHelperLoose(this.possible()), _step; !(_step = _iterator()).done;) {
_loop();
}
} else {
for (var _iterator2 = _createForOfIteratorHelperLoose(this.possible()), _step2; !(_step2 = _iterator2()).done;) {
var prefix = _step2.value;
prefixeds[prefix] = this.replace(rule.selector, prefix);
}
}
rule._autoprefixerPrefixeds[this.name] = prefixeds;
return rule._autoprefixerPrefixeds;
}
/**
* Is rule already prefixed before
*/
;
_proto.already = function already(rule, prefixeds, prefix) {
var index = rule.parent.index(rule) - 1;
while (index >= 0) {
var before = rule.parent.nodes[index];
if (before.type !== 'rule') {
return false;
}
var some = false;
for (var key in prefixeds[this.name]) {
var prefixed = prefixeds[this.name][key];
if (before.selector === prefixed) {
if (prefix === key) {
return true;
} else {
some = true;
break;
}
}
}
if (!some) {
return false;
}
index -= 1;
}
return false;
}
/**
* Replace selectors by prefixed one
*/
;
_proto.replace = function replace(selector, prefix) {
return selector.replace(this.regexp(), "$1" + this.prefixed(prefix));
}
/**
* Clone and add prefixes for at-rule
*/
;
_proto.add = function add(rule, prefix) {
var prefixeds = this.prefixeds(rule);
if (this.already(rule, prefixeds, prefix)) {
return;
}
var cloned = this.clone(rule, {
selector: prefixeds[this.name][prefix]
});
rule.parent.insertBefore(rule, cloned);
}
/**
* Return function to fast find prefixed selector
*/
;
_proto.old = function old(prefix) {
return new OldSelector(this, prefix);
};
return Selector;
}(Prefixer);
module.exports = Selector;

346
node_modules/autoprefixer/lib/supports.js generated vendored Normal file
View File

@ -0,0 +1,346 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
var postcss = require('postcss');
var data = require('caniuse-lite').feature(require('caniuse-lite/data/features/css-featurequeries.js'));
var Browsers = require('./browsers');
var brackets = require('./brackets');
var Value = require('./value');
var utils = require('./utils');
var supported = [];
for (var browser in data.stats) {
var versions = data.stats[browser];
for (var version in versions) {
var support = versions[version];
if (/y/.test(support)) {
supported.push(browser + ' ' + version);
}
}
}
var Supports = /*#__PURE__*/function () {
function Supports(Prefixes, all) {
this.Prefixes = Prefixes;
this.all = all;
}
/**
* Return prefixer only with @supports supported browsers
*/
var _proto = Supports.prototype;
_proto.prefixer = function prefixer() {
if (this.prefixerCache) {
return this.prefixerCache;
}
var filtered = this.all.browsers.selected.filter(function (i) {
return supported.includes(i);
});
var browsers = new Browsers(this.all.browsers.data, filtered, this.all.options);
this.prefixerCache = new this.Prefixes(this.all.data, browsers, this.all.options);
return this.prefixerCache;
}
/**
* Parse string into declaration property and value
*/
;
_proto.parse = function parse(str) {
var parts = str.split(':');
var prop = parts[0];
var value = parts[1];
if (!value) value = '';
return [prop.trim(), value.trim()];
}
/**
* Create virtual rule to process it by prefixer
*/
;
_proto.virtual = function virtual(str) {
var _this$parse = this.parse(str),
prop = _this$parse[0],
value = _this$parse[1];
var rule = postcss.parse('a{}').first;
rule.append({
prop: prop,
value: value,
raws: {
before: ''
}
});
return rule;
}
/**
* Return array of Declaration with all necessary prefixes
*/
;
_proto.prefixed = function prefixed(str) {
var rule = this.virtual(str);
if (this.disabled(rule.first)) {
return rule.nodes;
}
var result = {
warn: function warn() {
return null;
}
};
var prefixer = this.prefixer().add[rule.first.prop];
prefixer && prefixer.process && prefixer.process(rule.first, result);
for (var _iterator = _createForOfIteratorHelperLoose(rule.nodes), _step; !(_step = _iterator()).done;) {
var decl = _step.value;
for (var _iterator2 = _createForOfIteratorHelperLoose(this.prefixer().values('add', rule.first.prop)), _step2; !(_step2 = _iterator2()).done;) {
var value = _step2.value;
value.process(decl);
}
Value.save(this.all, decl);
}
return rule.nodes;
}
/**
* Return true if brackets node is "not" word
*/
;
_proto.isNot = function isNot(node) {
return typeof node === 'string' && /not\s*/i.test(node);
}
/**
* Return true if brackets node is "or" word
*/
;
_proto.isOr = function isOr(node) {
return typeof node === 'string' && /\s*or\s*/i.test(node);
}
/**
* Return true if brackets node is (prop: value)
*/
;
_proto.isProp = function isProp(node) {
return typeof node === 'object' && node.length === 1 && typeof node[0] === 'string';
}
/**
* Return true if prefixed property has no unprefixed
*/
;
_proto.isHack = function isHack(all, unprefixed) {
var check = new RegExp("(\\(|\\s)" + utils.escapeRegexp(unprefixed) + ":");
return !check.test(all);
}
/**
* Return true if we need to remove node
*/
;
_proto.toRemove = function toRemove(str, all) {
var _this$parse2 = this.parse(str),
prop = _this$parse2[0],
value = _this$parse2[1];
var unprefixed = this.all.unprefixed(prop);
var cleaner = this.all.cleaner();
if (cleaner.remove[prop] && cleaner.remove[prop].remove && !this.isHack(all, unprefixed)) {
return true;
}
for (var _iterator3 = _createForOfIteratorHelperLoose(cleaner.values('remove', unprefixed)), _step3; !(_step3 = _iterator3()).done;) {
var checker = _step3.value;
if (checker.check(value)) {
return true;
}
}
return false;
}
/**
* Remove all unnecessary prefixes
*/
;
_proto.remove = function remove(nodes, all) {
var i = 0;
while (i < nodes.length) {
if (!this.isNot(nodes[i - 1]) && this.isProp(nodes[i]) && this.isOr(nodes[i + 1])) {
if (this.toRemove(nodes[i][0], all)) {
nodes.splice(i, 2);
continue;
}
i += 2;
continue;
}
if (typeof nodes[i] === 'object') {
nodes[i] = this.remove(nodes[i], all);
}
i += 1;
}
return nodes;
}
/**
* Clean brackets with one child
*/
;
_proto.cleanBrackets = function cleanBrackets(nodes) {
var _this = this;
return nodes.map(function (i) {
if (typeof i !== 'object') {
return i;
}
if (i.length === 1 && typeof i[0] === 'object') {
return _this.cleanBrackets(i[0]);
}
return _this.cleanBrackets(i);
});
}
/**
* Add " or " between properties and convert it to brackets format
*/
;
_proto.convert = function convert(progress) {
var result = [''];
for (var _iterator4 = _createForOfIteratorHelperLoose(progress), _step4; !(_step4 = _iterator4()).done;) {
var i = _step4.value;
result.push([i.prop + ": " + i.value]);
result.push(' or ');
}
result[result.length - 1] = '';
return result;
}
/**
* Compress value functions into a string nodes
*/
;
_proto.normalize = function normalize(nodes) {
var _this2 = this;
if (typeof nodes !== 'object') {
return nodes;
}
nodes = nodes.filter(function (i) {
return i !== '';
});
if (typeof nodes[0] === 'string' && nodes[0].includes(':')) {
return [brackets.stringify(nodes)];
}
return nodes.map(function (i) {
return _this2.normalize(i);
});
}
/**
* Add prefixes
*/
;
_proto.add = function add(nodes, all) {
var _this3 = this;
return nodes.map(function (i) {
if (_this3.isProp(i)) {
var prefixed = _this3.prefixed(i[0]);
if (prefixed.length > 1) {
return _this3.convert(prefixed);
}
return i;
}
if (typeof i === 'object') {
return _this3.add(i, all);
}
return i;
});
}
/**
* Add prefixed declaration
*/
;
_proto.process = function process(rule) {
var ast = brackets.parse(rule.params);
ast = this.normalize(ast);
ast = this.remove(ast, rule.params);
ast = this.add(ast, rule.params);
ast = this.cleanBrackets(ast);
rule.params = brackets.stringify(ast);
}
/**
* Check global options
*/
;
_proto.disabled = function disabled(node) {
if (!this.all.options.grid) {
if (node.prop === 'display' && node.value.includes('grid')) {
return true;
}
if (node.prop.includes('grid') || node.prop === 'justify-items') {
return true;
}
}
if (this.all.options.flexbox === false) {
if (node.prop === 'display' && node.value.includes('flex')) {
return true;
}
var other = ['order', 'justify-content', 'align-items', 'align-content'];
if (node.prop.includes('flex') || other.includes(node.prop)) {
return true;
}
}
return false;
};
return Supports;
}();
module.exports = Supports;

411
node_modules/autoprefixer/lib/transition.js generated vendored Normal file
View File

@ -0,0 +1,411 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var parser = require('postcss-value-parser');
var vendor = require('postcss').vendor;
var list = require('postcss').list;
var Browsers = require('./browsers');
var Transition = /*#__PURE__*/function () {
function Transition(prefixes) {
_defineProperty(this, "props", ['transition', 'transition-property']);
this.prefixes = prefixes;
}
/**
* Process transition and add prefixes for all necessary properties
*/
var _proto = Transition.prototype;
_proto.add = function add(decl, result) {
var _this = this;
var prefix, prop;
var add = this.prefixes.add[decl.prop];
var vendorPrefixes = this.ruleVendorPrefixes(decl);
var declPrefixes = vendorPrefixes || add && add.prefixes || [];
var params = this.parse(decl.value);
var names = params.map(function (i) {
return _this.findProp(i);
});
var added = [];
if (names.some(function (i) {
return i[0] === '-';
})) {
return;
}
for (var _iterator = _createForOfIteratorHelperLoose(params), _step; !(_step = _iterator()).done;) {
var param = _step.value;
prop = this.findProp(param);
if (prop[0] === '-') continue;
var prefixer = this.prefixes.add[prop];
if (!prefixer || !prefixer.prefixes) continue;
for (var _iterator3 = _createForOfIteratorHelperLoose(prefixer.prefixes), _step3; !(_step3 = _iterator3()).done;) {
prefix = _step3.value;
if (vendorPrefixes && !vendorPrefixes.some(function (p) {
return prefix.includes(p);
})) {
continue;
}
var prefixed = this.prefixes.prefixed(prop, prefix);
if (prefixed !== '-ms-transform' && !names.includes(prefixed)) {
if (!this.disabled(prop, prefix)) {
added.push(this.clone(prop, prefixed, param));
}
}
}
}
params = params.concat(added);
var value = this.stringify(params);
var webkitClean = this.stringify(this.cleanFromUnprefixed(params, '-webkit-'));
if (declPrefixes.includes('-webkit-')) {
this.cloneBefore(decl, "-webkit-" + decl.prop, webkitClean);
}
this.cloneBefore(decl, decl.prop, webkitClean);
if (declPrefixes.includes('-o-')) {
var operaClean = this.stringify(this.cleanFromUnprefixed(params, '-o-'));
this.cloneBefore(decl, "-o-" + decl.prop, operaClean);
}
for (var _iterator2 = _createForOfIteratorHelperLoose(declPrefixes), _step2; !(_step2 = _iterator2()).done;) {
prefix = _step2.value;
if (prefix !== '-webkit-' && prefix !== '-o-') {
var prefixValue = this.stringify(this.cleanOtherPrefixes(params, prefix));
this.cloneBefore(decl, prefix + decl.prop, prefixValue);
}
}
if (value !== decl.value && !this.already(decl, decl.prop, value)) {
this.checkForWarning(result, decl);
decl.cloneBefore();
decl.value = value;
}
}
/**
* Find property name
*/
;
_proto.findProp = function findProp(param) {
var prop = param[0].value;
if (/^\d/.test(prop)) {
for (var _iterator4 = _createForOfIteratorHelperLoose(param.entries()), _step4; !(_step4 = _iterator4()).done;) {
var _step4$value = _step4.value,
i = _step4$value[0],
token = _step4$value[1];
if (i !== 0 && token.type === 'word') {
return token.value;
}
}
}
return prop;
}
/**
* Does we already have this declaration
*/
;
_proto.already = function already(decl, prop, value) {
return decl.parent.some(function (i) {
return i.prop === prop && i.value === value;
});
}
/**
* Add declaration if it is not exist
*/
;
_proto.cloneBefore = function cloneBefore(decl, prop, value) {
if (!this.already(decl, prop, value)) {
decl.cloneBefore({
prop: prop,
value: value
});
}
}
/**
* Show transition-property warning
*/
;
_proto.checkForWarning = function checkForWarning(result, decl) {
if (decl.prop !== 'transition-property') {
return;
}
decl.parent.each(function (i) {
if (i.type !== 'decl') {
return undefined;
}
if (i.prop.indexOf('transition-') !== 0) {
return undefined;
}
if (i.prop === 'transition-property') {
return undefined;
}
if (list.comma(i.value).length > 1) {
decl.warn(result, 'Replace transition-property to transition, ' + 'because Autoprefixer could not support ' + 'any cases of transition-property ' + 'and other transition-*');
}
return false;
});
}
/**
* Process transition and remove all unnecessary properties
*/
;
_proto.remove = function remove(decl) {
var _this2 = this;
var params = this.parse(decl.value);
params = params.filter(function (i) {
var prop = _this2.prefixes.remove[_this2.findProp(i)];
return !prop || !prop.remove;
});
var value = this.stringify(params);
if (decl.value === value) {
return;
}
if (params.length === 0) {
decl.remove();
return;
}
var _double = decl.parent.some(function (i) {
return i.prop === decl.prop && i.value === value;
});
var smaller = decl.parent.some(function (i) {
return i !== decl && i.prop === decl.prop && i.value.length > value.length;
});
if (_double || smaller) {
decl.remove();
return;
}
decl.value = value;
}
/**
* Parse properties list to array
*/
;
_proto.parse = function parse(value) {
var ast = parser(value);
var result = [];
var param = [];
for (var _iterator5 = _createForOfIteratorHelperLoose(ast.nodes), _step5; !(_step5 = _iterator5()).done;) {
var node = _step5.value;
param.push(node);
if (node.type === 'div' && node.value === ',') {
result.push(param);
param = [];
}
}
result.push(param);
return result.filter(function (i) {
return i.length > 0;
});
}
/**
* Return properties string from array
*/
;
_proto.stringify = function stringify(params) {
if (params.length === 0) {
return '';
}
var nodes = [];
for (var _iterator6 = _createForOfIteratorHelperLoose(params), _step6; !(_step6 = _iterator6()).done;) {
var param = _step6.value;
if (param[param.length - 1].type !== 'div') {
param.push(this.div(params));
}
nodes = nodes.concat(param);
}
if (nodes[0].type === 'div') {
nodes = nodes.slice(1);
}
if (nodes[nodes.length - 1].type === 'div') {
nodes = nodes.slice(0, +-2 + 1 || undefined);
}
return parser.stringify({
nodes: nodes
});
}
/**
* Return new param array with different name
*/
;
_proto.clone = function clone(origin, name, param) {
var result = [];
var changed = false;
for (var _iterator7 = _createForOfIteratorHelperLoose(param), _step7; !(_step7 = _iterator7()).done;) {
var i = _step7.value;
if (!changed && i.type === 'word' && i.value === origin) {
result.push({
type: 'word',
value: name
});
changed = true;
} else {
result.push(i);
}
}
return result;
}
/**
* Find or create separator
*/
;
_proto.div = function div(params) {
for (var _iterator8 = _createForOfIteratorHelperLoose(params), _step8; !(_step8 = _iterator8()).done;) {
var param = _step8.value;
for (var _iterator9 = _createForOfIteratorHelperLoose(param), _step9; !(_step9 = _iterator9()).done;) {
var node = _step9.value;
if (node.type === 'div' && node.value === ',') {
return node;
}
}
}
return {
type: 'div',
value: ',',
after: ' '
};
};
_proto.cleanOtherPrefixes = function cleanOtherPrefixes(params, prefix) {
var _this3 = this;
return params.filter(function (param) {
var current = vendor.prefix(_this3.findProp(param));
return current === '' || current === prefix;
});
}
/**
* Remove all non-webkit prefixes and unprefixed params if we have prefixed
*/
;
_proto.cleanFromUnprefixed = function cleanFromUnprefixed(params, prefix) {
var _this4 = this;
var remove = params.map(function (i) {
return _this4.findProp(i);
}).filter(function (i) {
return i.slice(0, prefix.length) === prefix;
}).map(function (i) {
return _this4.prefixes.unprefixed(i);
});
var result = [];
for (var _iterator10 = _createForOfIteratorHelperLoose(params), _step10; !(_step10 = _iterator10()).done;) {
var param = _step10.value;
var prop = this.findProp(param);
var p = vendor.prefix(prop);
if (!remove.includes(prop) && (p === prefix || p === '')) {
result.push(param);
}
}
return result;
}
/**
* Check property for disabled by option
*/
;
_proto.disabled = function disabled(prop, prefix) {
var other = ['order', 'justify-content', 'align-self', 'align-content'];
if (prop.includes('flex') || other.includes(prop)) {
if (this.prefixes.options.flexbox === false) {
return true;
}
if (this.prefixes.options.flexbox === 'no-2009') {
return prefix.includes('2009');
}
}
return undefined;
}
/**
* Check if transition prop is inside vendor specific rule
*/
;
_proto.ruleVendorPrefixes = function ruleVendorPrefixes(decl) {
var parent = decl.parent;
if (parent.type !== 'rule') {
return false;
} else if (!parent.selector.includes(':-')) {
return false;
}
var selectors = Browsers.prefixes().filter(function (s) {
return parent.selector.includes(':' + s);
});
return selectors.length > 0 ? selectors : false;
};
return Transition;
}();
module.exports = Transition;

103
node_modules/autoprefixer/lib/utils.js generated vendored Normal file
View File

@ -0,0 +1,103 @@
"use strict";
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
var list = require('postcss').list;
module.exports = {
/**
* Throw special error, to tell beniary,
* that this error is from Autoprefixer.
*/
error: function error(text) {
var err = new Error(text);
err.autoprefixer = true;
throw err;
},
/**
* Return array, that doesn’t contain duplicates.
*/
uniq: function uniq(array) {
var filtered = [];
for (var _iterator = _createForOfIteratorHelperLoose(array), _step; !(_step = _iterator()).done;) {
var i = _step.value;
if (!filtered.includes(i)) {
filtered.push(i);
}
}
return filtered;
},
/**
* Return "-webkit-" on "-webkit- old"
*/
removeNote: function removeNote(string) {
if (!string.includes(' ')) {
return string;
}
return string.split(' ')[0];
},
/**
* Escape RegExp symbols
*/
escapeRegexp: function escapeRegexp(string) {
return string.replace(/[$()*+-.?[\\\]^{|}]/g, '\\$&');
},
/**
* Return regexp to check, that CSS string contain word
*/
regexp: function regexp(word, escape) {
if (escape === void 0) {
escape = true;
}
if (escape) {
word = this.escapeRegexp(word);
}
return new RegExp("(^|[\\s,(])(" + word + "($|[\\s(,]))", 'gi');
},
/**
* Change comma list
*/
editList: function editList(value, callback) {
var origin = list.comma(value);
var changed = callback(origin, []);
if (origin === changed) {
return value;
}
var join = value.match(/,\s*/);
join = join ? join[0] : ', ';
return changed.join(join);
},
/**
* Split the selector into parts.
* It returns 3 level deep array because selectors can be comma
* separated (1), space separated (2), and combined (3)
* @param {String} selector selector string
* @return {Array<Array<Array>>} 3 level deep array of split selector
* @see utils.test.js for examples
*/
splitSelector: function splitSelector(selector) {
return list.comma(selector).map(function (i) {
return list.space(i).map(function (k) {
return k.split(/(?=\.|#)/g);
});
});
}
};

164
node_modules/autoprefixer/lib/value.js generated vendored Normal file
View File

@ -0,0 +1,164 @@
"use strict";
function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
var vendor = require('postcss').vendor;
var Prefixer = require('./prefixer');
var OldValue = require('./old-value');
var utils = require('./utils');
var Value = /*#__PURE__*/function (_Prefixer) {
_inheritsLoose(Value, _Prefixer);
function Value() {
return _Prefixer.apply(this, arguments) || this;
}
/**
* Clone decl for each prefixed values
*/
Value.save = function save(prefixes, decl) {
var _this = this;
var prop = decl.prop;
var result = [];
var _loop = function _loop(prefix) {
var value = decl._autoprefixerValues[prefix];
if (value === decl.value) {
return "continue";
}
var item = void 0;
var propPrefix = vendor.prefix(prop);
if (propPrefix === '-pie-') {
return "continue";
}
if (propPrefix === prefix) {
item = decl.value = value;
result.push(item);
return "continue";
}
var prefixed = prefixes.prefixed(prop, prefix);
var rule = decl.parent;
if (!rule.every(function (i) {
return i.prop !== prefixed;
})) {
result.push(item);
return "continue";
}
var trimmed = value.replace(/\s+/, ' ');
var already = rule.some(function (i) {
return i.prop === decl.prop && i.value.replace(/\s+/, ' ') === trimmed;
});
if (already) {
result.push(item);
return "continue";
}
var cloned = _this.clone(decl, {
value: value
});
item = decl.parent.insertBefore(decl, cloned);
result.push(item);
};
for (var prefix in decl._autoprefixerValues) {
var _ret = _loop(prefix);
if (_ret === "continue") continue;
}
return result;
}
/**
* Is declaration need to be prefixed
*/
;
var _proto = Value.prototype;
_proto.check = function check(decl) {
var value = decl.value;
if (!value.includes(this.name)) {
return false;
}
return !!value.match(this.regexp());
}
/**
* Lazy regexp loading
*/
;
_proto.regexp = function regexp() {
return this.regexpCache || (this.regexpCache = utils.regexp(this.name));
}
/**
* Add prefix to values in string
*/
;
_proto.replace = function replace(string, prefix) {
return string.replace(this.regexp(), "$1" + prefix + "$2");
}
/**
* Get value with comments if it was not changed
*/
;
_proto.value = function value(decl) {
if (decl.raws.value && decl.raws.value.value === decl.value) {
return decl.raws.value.raw;
} else {
return decl.value;
}
}
/**
* Save values with next prefixed token
*/
;
_proto.add = function add(decl, prefix) {
if (!decl._autoprefixerValues) {
decl._autoprefixerValues = {};
}
var value = decl._autoprefixerValues[prefix] || this.value(decl);
var before;
do {
before = value;
value = this.replace(value, prefix);
if (value === false) return;
} while (value !== before);
decl._autoprefixerValues[prefix] = value;
}
/**
* Return function to fast find prefixed value
*/
;
_proto.old = function old(prefix) {
return new OldValue(this.name, prefix + this.name);
};
return Value;
}(Prefixer);
module.exports = Value;

75
node_modules/autoprefixer/package.json generated vendored Normal file
View File

@ -0,0 +1,75 @@
{
"_from": "autoprefixer",
"_id": "autoprefixer@9.8.6",
"_inBundle": false,
"_integrity": "sha512-XrvP4VVHdRBCdX1S3WXVD8+RyG9qeb1D5Sn1DeLiG2xfSpzellk5k54xbUERJ3M5DggQxes39UGOTP8CFrEGbg==",
"_location": "/autoprefixer",
"_phantomChildren": {},
"_requested": {
"type": "tag",
"registry": true,
"raw": "autoprefixer",
"name": "autoprefixer",
"escapedName": "autoprefixer",
"rawSpec": "",
"saveSpec": null,
"fetchSpec": "latest"
},
"_requiredBy": [
"#DEV:/",
"#USER"
],
"_resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-9.8.6.tgz",
"_shasum": "3b73594ca1bf9266320c5acf1588d74dea74210f",
"_spec": "autoprefixer",
"_where": "/home/outis/Documents/Sites/BBB",
"author": {
"name": "Andrey Sitnik",
"email": "andrey@sitnik.ru"
},
"bin": {
"autoprefixer": "bin/autoprefixer"
},
"browser": {
"colorette": false,
"chalk": false
},
"bugs": {
"url": "https://github.com/postcss/autoprefixer/issues"
},
"bundleDependencies": false,
"dependencies": {
"browserslist": "^4.12.0",
"caniuse-lite": "^1.0.30001109",
"colorette": "^1.2.1",
"normalize-range": "^0.1.2",
"num2fraction": "^1.2.2",
"postcss": "^7.0.32",
"postcss-value-parser": "^4.1.0"
},
"deprecated": false,
"description": "Parse CSS and add vendor prefixes to CSS rules using values from the Can I Use website",
"eslintIgnore": [
"build/"
],
"funding": {
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/autoprefixer"
},
"homepage": "https://github.com/postcss/autoprefixer#readme",
"keywords": [
"autoprefixer",
"css",
"prefix",
"postcss",
"postcss-plugin"
],
"license": "MIT",
"main": "lib/autoprefixer",
"name": "autoprefixer",
"repository": {
"type": "git",
"url": "git+https://github.com/postcss/autoprefixer.git"
},
"version": "9.8.6"
}