├── .eslintignore
├── .eslintrc.json
├── .gitignore
├── .npmignore
├── LICENSE
├── NOTICE
├── README.md
├── css-property-parser.d.ts
├── package-lock.json
├── package.json
├── src
    ├── constants
    │   ├── css.js
    │   ├── genericLexer.js
    │   ├── grammars.js
    │   ├── index.js
    │   ├── paths.js
    │   ├── shorthandIdentToLonghandPropertyMap.json
    │   ├── shorthandProperties.js
    │   └── syntaxOverrides.json
    ├── errors
    │   ├── ParseError.js
    │   ├── UnknownPropertyError.js
    │   ├── UnsupportedPropertyError.js
    │   └── index.js
    ├── expandShorthandProperty.js
    ├── formatters
    │   ├── grammarFormatters
    │   │   ├── JsonGrammarFormatter.js
    │   │   └── NearleyGrammarFormatter.js
    │   └── shorthandPropertyTypeFormatters
    │   │   ├── BackgroundPropertyFormatter.js
    │   │   ├── BorderRadiusPropertyFormatter.js
    │   │   ├── CommaSeparatedListPropertyFormatter.js
    │   │   ├── FlexPropertyFormatter.js
    │   │   ├── FontPropertyFormatter.js
    │   │   ├── TrblPropertyFormatter.js
    │   │   ├── UnorderedOptionalListPropertyFormatter.js
    │   │   └── index.js
    ├── getShorthandComputedProperties.js
    ├── getShorthandsForProperty.js
    ├── grammars
    │   ├── LICENSE
    │   ├── js
    │   │   └── formalSyntax.js
    │   ├── json
    │   │   ├── an-plus-b.json
    │   │   ├── angle.json
    │   │   ├── any-value.json
    │   │   ├── attr-fallback.json
    │   │   ├── attr-name.json
    │   │   ├── background.json
    │   │   ├── color.json
    │   │   ├── cubic-bezier-timing-function.json
    │   │   ├── custom-ident.json
    │   │   ├── custom-property-name.json
    │   │   ├── declaration-list.json
    │   │   ├── declaration-value.json
    │   │   ├── declaration.json
    │   │   ├── dimension.json
    │   │   ├── feature-value-declaration.json
    │   │   ├── final-bg-layer.json
    │   │   ├── flex.json
    │   │   ├── frames-timing-function.json
    │   │   ├── frequency.json
    │   │   ├── function-token.json
    │   │   ├── hex-color.json
    │   │   ├── hsl().json
    │   │   ├── hsla().json
    │   │   ├── id-selector.json
    │   │   ├── ident.json
    │   │   ├── image().json
    │   │   ├── integer.json
    │   │   ├── length.json
    │   │   ├── name-repeat.json
    │   │   ├── number.json
    │   │   ├── outline-radius.json
    │   │   ├── path().json
    │   │   ├── percentage.json
    │   │   ├── positive-integer.json
    │   │   ├── ratio.json
    │   │   ├── resolution.json
    │   │   ├── rgb().json
    │   │   ├── rgba().json
    │   │   ├── shape.json
    │   │   ├── string.json
    │   │   ├── time.json
    │   │   ├── url.json
    │   │   ├── x.json
    │   │   └── y.json
    │   └── nearley
    │   │   ├── formalSyntax.ne
    │   │   └── properties
    │   │       ├── animation.ne
    │   │       ├── background.ne
    │   │       ├── font.ne
    │   │       └── transition.ne
    ├── index.js
    ├── initialValueMap.js
    ├── isInitialValue.js
    ├── isShorthandProperty.js
    ├── isValidDeclaration.js
    ├── scripts
    │   ├── .eslintrc.json
    │   ├── extractProperties.js
    │   ├── formatData.js
    │   ├── formatFormalSyntaxes.js
    │   ├── formatGrammars.js
    │   └── updateBasicDataUnits.js
    └── utils
    │   ├── ArrayUtils.js
    │   ├── CaseConverterUtils.js
    │   ├── LocationIndexTracker.js
    │   ├── ShorthandPropertyClassifierUtils.js
    │   └── ShorthandPropertyTypeFormatterUtils.js
├── test
    ├── .eslintrc.json
    ├── BaseGrammarsTest.js
    ├── ExpandShorthandPropertyTest.js
    ├── GetShorthandComputedPropertiesTest.js
    ├── GetShorthandsForPropertyTest.js
    ├── InitialValuesTest.js
    ├── benchmark.js
    ├── formatters
    │   ├── JsonGrammarFormatterTest.js
    │   └── NearleyGrammarFormatterTest.js
    └── isValidDeclarationTest.js
└── updateCSSData.sh


/.eslintignore:
--------------------------------------------------------------------------------
1 | src/grammars/


--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "parserOptions": {
 3 |     "ecmaVersion": 7
 4 |   },
 5 |   "env": {
 6 |     "node": true
 7 |   },
 8 |   "extends": "airbnb/base",
 9 |   "rules": {
10 |     "max-len": [
11 |       "error",
12 |       {
13 |         "code": 120,
14 |         "ignoreStrings": true,
15 |         "ignoreRegExpLiterals": true
16 |       }
17 |     ],
18 |     "no-bitwise": [
19 |       "error",
20 |       {
21 |         "allow": [
22 |           "~"
23 |         ]
24 |       }
25 |     ],
26 |     "no-underscore-dangle": "off",
27 |     "no-shadow": "off",
28 |     "comma-dangle": ["error", {
29 |       "arrays": "always-multiline",
30 |       "objects": "always-multiline",
31 |       "imports": "always-multiline",
32 |       "exports": "always-multiline",
33 |       "functions": "ignore"
34 |     }],
35 |     "global-require": "off",
36 |     "valid-jsdoc": "error"
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .idea
 2 | node_modules
 3 | .DS_STORE
 4 | .vscode
 5 | 
 6 | # ignore generated grammars
 7 | src/formatted-data
 8 | src/grammars/generated
 9 | 
10 | 
11 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | test
2 | src/grammars/json
3 | src/grammars/js
4 | src/grammars/nearley
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2017 Mahir Shah
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.


--------------------------------------------------------------------------------
/NOTICE:
--------------------------------------------------------------------------------
1 | This software uses a derivative form of the data contained in
2 | https://github.com/mdn/data/blob/master/ (MDN Data). The software that is
3 | a derivative form of MDN Data, either checked in under src/grammar/ or
4 | distributed under src/grammar/generated, is licensed under MPL 2.0
5 | (https://www.mozilla.org/en-US/MPL/2.0/).
6 | 
7 | All other software contained in this project is provided under the MIT license.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # CSS Property Validation and Shorthand Expansion
  2 | > Validate css properties and expand css shorthand properties
  3 | 
  4 | ## Contents
  5 | 
  6 | <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  7 | <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
  8 | 
  9 | 
 10 | - [Why](#why)
 11 | - [Installation](#installation)
 12 | - [Usage](#usage)
 13 | - [API](#api)
 14 |   - [isShorthandProperty(property: string): boolean](#isshorthandpropertyproperty-string-boolean)
 15 |     - [Examples](#examples)
 16 |   - [[Experimental] [isValidDeclaration(property: string, value: string): boolean](./src/isValidDeclaration.js)](#experimental-isvaliddeclarationproperty-string-value-string-booleansrcisvaliddeclarationjs)
 17 |     - [Examples](#examples-1)
 18 |   - [getShorthandComputedProperties(property: string, [recursivelyResolve=false]): Array](#getshorthandcomputedpropertiesproperty-string-recursivelyresolvefalse-array)
 19 |       - [Examples](#examples-2)
 20 |   - [expandShorthandProperty(property: string, value: string, [recursivelyResolve=false], [includeInitialValues=false]): Object](#expandshorthandpropertyproperty-string-value-string-recursivelyresolvefalse-includeinitialvaluesfalse-object)
 21 |       - [Examples](#examples-3)
 22 |   - [getShorthandsForProperty(property: string): Array&lt;string&gt;](#getshorthandsforpropertyproperty-string-arrayltstringgt)
 23 |       - [Examples](#examples-4)
 24 |   - [isInitialValue(property, value)](#isinitialvalueproperty-value)
 25 |   - [initialValues(property, recursivelyResolve, includeShorthands)](#initialvaluesproperty-recursivelyresolve-includeshorthands)
 26 |       - [Examples](#examples-5)
 27 |   - [initialValue(property)](#initialvalueproperty)
 28 |       - [Examples](#examples-6)
 29 |   - [Developer/Contribution HOWTO](#developercontribution-howto)
 30 | 
 31 | <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 32 | 
 33 | 
 34 | ## Why
 35 | 
 36 | - Uses [MDN data](https://github.com/mdn/data/tree/master/css) to generate validators and shorthand property expanders
 37 | - Supports experimental properties and values
 38 | 
 39 | ## Installation
 40 | ```
 41 | $ npm install css-property-parser
 42 | ```
 43 | 
 44 | ## Usage
 45 | ```js
 46 | const {
 47 |   isShorthandProperty,
 48 |   isValidDeclaration,
 49 |   getShorthandComputedProperties,
 50 |   expandShorthandProperty,
 51 |   getShorthandsForProperty,
 52 | } = require('css-property-parser');
 53 | 
 54 | // isShorthandProperty
 55 | // returns boolean indicating if the given property is a shorthand property
 56 | console.log(isShorthandProperty('border')); // => true
 57 | console.log(isShorthandProperty('color')); // => false
 58 | 
 59 | // isValidDeclaration
 60 | // returns boolean indicating if the given property value pair is valid
 61 | console.log(isValidDeclaration('border', '1px solid black')); // => true
 62 | console.log(isValidDeclaration('color', 'rgba(0, 0, 0, .25)')); // => true
 63 | console.log(isValidDeclaration('z-index', 'abc')); // => false
 64 | console.log(isValidDeclaration('height', 'red')); // => false
 65 | 
 66 | // getShorthandComputedProperties
 67 | // returns an array of computed property names for the given shorthand
 68 | console.log(getShorthandComputedProperties('background'))
 69 | // => [
 70 | //      "background-image",
 71 | //      "background-position",
 72 | //      "background-size",
 73 | //      "background-repeat",
 74 | //      "background-origin",
 75 | //      "background-clip",
 76 | //      "background-attachment",
 77 | //      "background-color"
 78 | //     ]
 79 | console.log(getShorthandComputedProperties('color')) 
 80 | // => ["color"]
 81 | console.log(getShorthandComputedProperties('unknown'))
 82 | // => []
 83 | 
 84 | // expandShorthandProperty
 85 | // returns an obejct mapping longhand property names to their values
 86 | console.log(expandShorthandProperty('margin', '0 3px 10rem'))
 87 | // => {
 88 | //      'margin-top': '0',
 89 | //      'margin-right': '3px',
 90 | //      'margin-bottom': '10rem',
 91 | //      'margin-left': '3px',
 92 | //     }
 93 | 
 94 | console.log(expandShorthandProperty('background', 'fixed padding-box url(image.png) rgb(255, 255, 0) 10px top / cover repeat-x'))
 95 | // => {
 96 | //      'background-attachment': 'fixed',
 97 | //      'background-clip': 'padding-box',
 98 | //      'background-origin': 'padding-box',
 99 | //      'background-image': 'url(image.png)',
100 | //      'background-repeat': 'repeat-x',
101 | //      'background-color': 'rgb(255, 255, 0)',
102 | //      'background-position': '10px top',
103 | //      'background-size': 'cover',
104 | //     }
105 | 
106 | console.log(getShorthandsForProperty('border-left-width'));
107 | // => [ 'border-left-width', 'border-left', 'border-width', 'border' ]
108 | ```
109 | 
110 | ## API
111 | 
112 | ### [isShorthandProperty(property: string): boolean](./src/isShorthandProperty.js)
113 | Checks if a given property is a shorthand property
114 | 
115 |  * property - the property name
116 |  * returns true if property is a shorthand, false otherwise
117 |  
118 | #### Examples
119 | 
120 | ```js
121 | isShorthandProperty('border')
122 | // => true
123 | 
124 | isShorthandProperty('color')
125 | // => false
126 | ```
127 | 
128 | ### [Experimental] [isValidDeclaration(property: string, value: string): boolean](./src/isValidDeclaration.js)
129 | Checks if the given property, value pair is valid.
130 | 
131 |  * property - the property name. For example, 'border' or 'color'.
132 |  * value - the property value. For example, '1px solid black'.
133 |  * returns true if the given value is valid for the property. Else, false.
134 |  
135 | #### Examples
136 |  
137 |  ```js
138 | isValidDeclaration('color', 'currentColor')
139 | // => true
140 | 
141 | isValidDeclaration('color', 'rgb(0)')
142 | // => false (rgba expects at least 3 parameters)
143 | 
144 | isValidDeclaration('z-index', '-1')
145 | // => true
146 | 
147 | isValidDeclaration('z-index', 'abc')
148 | // => false (z-index expects an integer)
149 | 
150 | isValidDeclaration('width', '300px')
151 | // => true
152 | 
153 | isValidDeclaration('width', '300ms')
154 | // => false ('ms' is not a valid length unit)
155 | ```
156 | 
157 | ### [getShorthandComputedProperties(property: string, [recursivelyResolve=false]): Array](./src/getShorthandComputedProperties.js)
158 | Given a shorthand property, returns an array of the computed properties for that shorthand property. If given
159 | a known property that is not a shorthand, simply returns the given property. If given an unknown property,
160 | returns an empty array.
161 |  
162 |  * shorthandProperty - the shorthand property name. For example, "background" or "border".
163 |  * [recursivelyResolve=false] - recursively resolve additional longhand properties if the shorthands expand to additional shorthands. For example, the border property expands to border-width, which expands further to border-left-width, border-right-width, etc.
164 |  * returns an array containing the computed properties for the given shorthand property. Returns an empty array if the given property is not a valid property.
165 |  
166 | ##### Examples
167 |  
168 | ```js
169 | getShorthandComputedProperties('background');
170 | // -> [
171 | //   "background-image",
172 | //   "background-position",
173 | //   "background-size",
174 | //   "background-repeat",
175 | //   "background-origin",
176 | //   "background-clip",
177 | //   "background-attachment",
178 | //   "background-color"
179 | // ]
180 | ```
181 | 
182 | ```js
183 | getShorthandComputedProperties('color');
184 | // -> ["color"]
185 | ```
186 | 
187 | ```js
188 | getShorthandComputedProperties('border', true); 
189 | // -> [
190 | //       'border-width',
191 | //       'border-style',
192 | //       'border-color',
193 | //       'border-bottom-width',
194 | //       'border-left-width',
195 | //       'border-right-width',
196 | //       'border-top-width',
197 | //       'border-bottom-style',
198 | //       'border-left-style',
199 | //       'border-right-style',
200 | //       'border-top-style',
201 | //       'border-bottom-color',
202 | //       'border-left-color',
203 | //       'border-right-color',
204 | //       'border-top-color'
205 | // ];
206 | ```
207 | 
208 | ```js
209 |  getShorthandComputedProperties('unknownProperty');
210 | // -> []
211 | ``` 
212 | 
213 | ### [expandShorthandProperty(property: string, value: string, [recursivelyResolve=false], [includeInitialValues=false]): Object](./src/expandShorthandProperty.js)
214 | 
215 | Given a property and value attempts to expand the value into its longhand equivalents. Returns an object
216 | mapping the property longhand names to the longhand values. If the property cannot be expanded (i.e. the property
217 | is not a shorthand property) simply returns an object mapping the original property to the original value.
218 | 
219 |  * propertyName - the property name for the given value
220 |  * propertyValue - the value of the property
221 |  * [recursivelyResolve=false] - recursively resolve additional longhand properties if the shorthands expand to additional shorthands. For example, the border property expands to border-width, which expands further to border-left-width, border-right-width, etc.
222 |  * [includeInitialValues=false] - when expanding the shorthand property, fill in any missing longhand values with their initial value. For example, the property declaration "border: 1px" only explicitly sets the "border-width" longhand property. If this param is true, the returned object will fill in the initial values for "border-style" and "border-color". By default, the returned object will only contain the "border-width".
223 |  * throws {[ParseError](./src/errors/ParseError.js)} - if the propertyValue cannot be parsed.
224 |  * throws {[UnknownPropertyError](./src/errors/UnknownPropertyError.js)} - if the propertyName is not defined in mdn.
225 |  * throws {[UnsupportedPropertyError](./src/errors/UnsupportedPropertyError.js)} - if the propertyName is a shorthand property, but we don't support expanding it yet.
226 | 
227 | Currently supports the following properties:
228 | 
229 |   - animation
230 |   - background
231 |   - border
232 |   - border-bottom
233 |   - border-color
234 |   - border-left
235 |   - border-radius
236 |   - border-right
237 |   - border-style
238 |   - border-top
239 |   - border-width
240 |   - column-rule
241 |   - columns
242 |   - flex
243 |   - flex-flow
244 |   - font
245 |   - list-style
246 |   - margin
247 |   - outline
248 |   - padding
249 |   - text-decoration
250 |   - text-emphasis
251 |   - transition
252 | 
253 | ##### Examples
254 | 
255 | ```js
256 | expandShorthandProperty('margin', '0 3px 10rem')
257 | // => {
258 | //      'margin-top': '0',
259 | //      'margin-right': '3px',
260 | //      'margin-bottom': '10rem',
261 | //      'margin-left': '3px',
262 | //     }
263 | ```
264 | 
265 | ```js
266 | expandShorthandProperty('flex', 'initial')
267 | // => {
268 | //  'flex-grow': 'initial',
269 | //  'flex-shrink': 'initial',
270 | //  'flex-basis': 'initial',
271 | // }
272 | ```
273 | 
274 | ```js
275 | expandShorthandProperty('border-radius', '10px 5px 2em / 20px 25px 30%')
276 | // => {
277 | //   'border-top-left-radius': '10px / 20px',
278 | //   'border-top-right-radius': '5px / 25px',
279 | //   'border-bottom-left-radius': '5px / 25px',
280 | //   'border-bottom-right-radius': '2em / 30%',
281 | // }
282 | ```
283 | 
284 | ### [getShorthandsForProperty(property: string): Array&lt;string&gt;](./src/getShorthandsForProperty.js)
285 | 
286 | This function is the inverse of `getShorthandComputedProperties`.
287 | 
288 | It returns all properties that set the given property, including the property itself.
289 | If the property is unknown, an empty array is returned.
290 | 
291 | ##### Examples
292 | 
293 | ```js
294 | console.log(getShorthandsForProperty('border-left-width'));
295 | // => [ 'border-left-width', 'border-left', 'border-width', 'border' ]
296 | ```
297 | 
298 | ```js
299 | console.log(getShorthandsForProperty('float'));
300 | // => [ 'float' ]
301 | ```
302 | 
303 | ```js
304 | console.log(getShorthandsForProperty('unknown'));
305 | // => [ ]
306 | ```
307 | 
308 | ### [isInitialValue(property, value)](./src/getShorthandsForProperty.js)
309 | 
310 | Because of the `initial` keyword and shorthand expansion,
311 | there are many possible values that are equivalently identical
312 | with the initial value of a css property. This function
313 | returns true for all possible values that have the effect of
314 | setting a property to its initial value.
315 | 
316 |  * `property` - string. the property to which the value is assigned.
317 |  * `value` string. the value to check.
318 | 
319 | ##### Examples
320 | 
321 | ```js
322 | console.log(isInitialValue('padding-left', '0'));
323 | // => true
324 | console.log(isInitialValue('padding-left', '0px'));
325 | // => true
326 | console.log(isInitialValue('padding-left', '1px'));
327 | // => false
328 | console.log(isInitialValue('padding', '0'));
329 | // => true
330 | console.log(isInitialValue('padding', '0 0px 0in'));
331 | // => true
332 | console.log(isInitialValue('padding', '1px'));
333 | // => false
334 | ```
335 | 
336 | ### [initialValues(property, recursivelyResolve, includeShorthands)](./src/initialValueMap.js)
337 | 
338 | Get the initial values for a property.
339 | 
340 | Returns the initial value or values a property has by
341 | default according the CSS specification. If the property's initial
342 | value(s) is/are unknown, the global keyword `initial` is returned.
343 | 
344 |  * `property` - (string) the property name
345 |  * `recursivelyResolve` - (boolean) when given a shorthand property,
346 |    causes the result to include long hand values.
347 |  * `includeShorthands` - (boolean) when resolving recursively, causes the
348 |    the result to include the specified shorthand property as well as any
349 |    intermediate shorthands of this property set to the initial value.
350 | 
351 | ##### Examples
352 | 
353 | ```js
354 | console.log(initialValues('border-width'));
355 | // => { 'border-width': 'medium' }
356 | console.log(initialValues('border-width', true));
357 | // => {
358 | //   'border-bottom-width': 'medium',
359 | //   'border-left-width': 'medium',
360 | //   'border-right-width': 'medium',
361 | //   'border-top-width': 'medium',
362 | //   'border-width': 'medium'
363 | // }
364 | ```
365 | 
366 | ### [initialValue(property)](./src/initialValueMap.js)
367 | 
368 | Get the initial value for a property. Returns a string that is the initial
369 | value has by default according the CSS specification. If the property's
370 | initial value is unknown, the global keyword `initial` is returned.
371 | 
372 | * `property` - the css property name
373 | 
374 | ##### Examples
375 | 
376 | ```js
377 | console.log(initialValue('border-width'));
378 | => 'medium'
379 | ```
380 | 
381 | ### Developer/Contribution HOWTO
382 | 
383 | To use a locally-built version of `css-values-parser`:
384 | 
385 | ```
386 | $ npm install
387 | $ npm run start
388 | $ npm test
389 | ```
390 | 
391 | This will generate grammars and javascript code required to parse the
392 | css properties.
393 | 


--------------------------------------------------------------------------------
/css-property-parser.d.ts:
--------------------------------------------------------------------------------
  1 | export = CssPropertyParser;
  2 | 
  3 | declare namespace CssPropertyParser {
  4 |   class ParseError extends Error {
  5 |   }
  6 |   class UnsupportedPropertyError extends Error {
  7 |     readonly property: string;
  8 |     constructor(property: string);
  9 |   }
 10 |   class UnknownPropertyError extends Error {
 11 |     readonly property: string;
 12 |     constructor(property: string);
 13 |   }
 14 |   interface Declarations {
 15 |     [property: string]: string;
 16 |   }
 17 | 
 18 |   /**
 19 |    * Given a property and value attempts to expand the value into its longhand
 20 |    * equivalents. Returns an object mapping the property longhand names to the
 21 |    * longhand values. If the property cannot be expanded (i.e. the property is
 22 |    * not a shorthand property) simply returns an object mapping the original
 23 |    * property to the original value.
 24 |    *
 25 |    * @param {string} propertyName - the property name for the given value
 26 |    * @param {string} propertyValue - the value of the property
 27 |    * @param {boolean} [recursivelyResolve=true] - recursively resolve additional
 28 |    *   longhand properties if the shorthands expand to additional shorthands. For
 29 |    *   example, the border property expands to border-width, which expands
 30 |    *   further to border-left-width, border-right-width, etc.
 31 |    * @param {boolean} [includeInitialValues=false] - when expanding the shorthand
 32 |    *   property, fill in any missing longhand values with their initial value.
 33 |    *   For example, the property declaration "border: 1px" only explicitly sets the
 34 |    *   "border-width" longhand property. If this param is true, the returned object
 35 |    *   will fill in the initial values for "border-style" and "border-color". By
 36 |    *   default, the returned object will only contain the "border-width".
 37 |    */
 38 |   function expandShorthandProperty(
 39 |     propertyName: string,
 40 |     propertyValue: string,
 41 |     recursivelyResolve?: boolean,
 42 |     includeInitialValues?: boolean,
 43 |   ): Declarations;
 44 | 
 45 |  /**
 46 |   * Given a shorthand property, returns an array of the computed properties for
 47 |   * that shorthand property. If given a known property that is not a shorthand,
 48 |   * simply returns the given property. If given an unknown property, returns an
 49 |   * empty array.
 50 |   *
 51 |   * @param {string} shorthandProperty - the shorthand property name. For
 52 |   *   example, "background" or "border".
 53 |   * @param {boolean} recursivelyResolve - recursively resolve additional
 54 |   *   longhand properties if the shorthands expand to additional shorthands. For
 55 |   *   example, the border property expands to border-width, which expands further
 56 |   *   to border-left-width, border-right-width, etc. Defaults to false.
 57 |   * @returns {Array} - an array containing the computed properties for the given
 58 |   *   shorthand property. Returns an empty array if the given property is not a
 59 |   *   valid property.
 60 |   */
 61 |   function getShorthandComputedProperties(
 62 |     shorthandProperty: string,
 63 |     recursivelyResolve?: boolean
 64 |   ): Array<string>;
 65 | 
 66 |   /**
 67 |    * Checks if a given property is a shorthand property
 68 |    * @param {String} property - the property name
 69 |    * @returns {boolean} - true if property is a shorthand, false otherwise
 70 |    */
 71 |   function isShorthandProperty(
 72 |     shorthandProperty: string
 73 |   ): boolean;
 74 | 
 75 |   /**
 76 |    * Return a list of all properties that set the given property.
 77 |    * Includes at least the value provided, plus any other shorthands that can
 78 |    * set it.
 79 |    */
 80 |   function getShorthandsForProperty(
 81 |     longhandProperty: string
 82 |   ): Array<string>;
 83 |   /**
 84 |    * Checks if the given property, value pair is valid.
 85 |    *
 86 |    * @param {String} property - the property name. For example, 'border' or 'color'.
 87 |    * @param {String} value - the property value. For example, '1px solid black'.
 88 |    * @return {boolean} - true if the given value is valid for the property. Else, false.
 89 |    */
 90 |   function isValidDeclaration(
 91 |     property: string,
 92 |     value: string
 93 |   ): boolean;
 94 | 
 95 |   /**
 96 |    * Because of the `initial` keyword and shorthand expansion,
 97 |    * there are many possible values that are equivalently identical
 98 |    * with the initial value of a css property. This function
 99 |    * returns true for all possible values that have the effect of
100 |    * setting a property to its initial value.
101 |    *
102 |    * @param property the property to which  the value is assigned
103 |    * @param value the value to check
104 |    * @return whether the value is equivalent to the initial value.
105 |    */
106 |   function isInitialValue(
107 |     property: string,
108 |     value: string
109 |   ): boolean;
110 | 
111 |   /**
112 |    * Warms up the initial value cache for all known css properties.
113 |    * It is not usually necessary to call this function but
114 |    * may be useful in some performance testing scenarios.
115 |    */
116 |   function computeInitialValues(): void;
117 | 
118 |   /**
119 |    * Get the initial values for a property.
120 |    * @param property - the property name
121 |    * @param recursivelyResolve - Defaults to false. when given a shorthand property,
122 |    *   causes the result to include long hand values.
123 |    * @param includeShorthands - Defaults to false. when resolving recursively, causes the
124 |    *   the result to include the specified shorthand property as well as any
125 |    *   intermediate shorthands of this property to to the initial value.
126 |    * @return the initial value or values a property has by
127 |    *   default according the CSS specification. If the property's initial
128 |    *   value(s) is/are unknown, the global keyword `initial` is returned.
129 |    */
130 |   function initialValues(
131 |     property: string,
132 |     recursivelyResolve?: boolean,
133 |     includeShorthands?: boolean
134 |   ): Declarations;
135 | 
136 |   /**
137 |    * Get the initial value for a property. the property can be a shorthand or a
138 |    * longhand.
139 |    * @param property - the property name
140 |    * @return {string} the initial value has by default according the CSS
141 |    * specification. If the property's initial value is unknown, the global
142 |    * keyword `initial` is returned. There's no spec value for shorthands
143 |    * so in those cases, the value returned is not the only legal value that can be returned,
144 |    * instead, it is a value that developers is commonly in practice.
145 |    */
146 |   function initialValue(property: string): string;
147 | }
148 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "css-property-parser",
 3 |   "version": "1.0.6",
 4 |   "description": "Validate css properties and expand shorthand css properties",
 5 |   "keywords": [
 6 |     "css"
 7 |   ],
 8 |   "bugs": "https://github.com/mahirshah/css-property-parser/issues",
 9 |   "main": "src/index.js",
10 |   "scripts": {
11 |     "prepublish": "npm start",
12 |     "test": "mocha --reporter spec --recursive",
13 |     "start": "./updateCSSData.sh",
14 |     "clean": "rm -rf src/formatted-data src/grammars/generated",
15 |     "benchmark": "node test/benchmark.js",
16 |     "doctoc": "doctoc README.md",
17 |     "lint": "eslint src/",
18 |     "precommit-msg": "echo 'Pre-commit checks...' && exit 0"
19 |   },
20 |   "pre-commit": [
21 |     "precommit-msg",
22 |     "lint",
23 |     "test"
24 |   ],
25 |   "author": "mahirshah",
26 |   "license": "(MIT AND MPL-2.0)",
27 |   "repository": {
28 |     "type": "git",
29 |     "url": "https://github.com/mahirshah/css-property-parser"
30 |   },
31 |   "types": "css-property-parser.d.ts",
32 |   "devDependencies": {
33 |     "async": "^2.5.0",
34 |     "benchmark": "^2.1.4",
35 |     "chai": "^4.1.1",
36 |     "css-values": "^0.1.0",
37 |     "doctoc": "^1.3.0",
38 |     "eslint": "^3.19.0",
39 |     "eslint-config-airbnb": "^15.1.0",
40 |     "eslint-plugin-import": "^2.7.0",
41 |     "microtime": "^2.1.6",
42 |     "mocha": "^3.5.0",
43 |     "pre-commit": "^1.2.2",
44 |     "postcss-value-parser": "^3.3.0",
45 |     "sinon": "^2.4.1",
46 |     "mdn-data": "1.0.0"
47 |   },
48 |   "dependencies": {
49 |     "fs-extra": "^3.0.1",
50 |     "moo": "^0.4.1",
51 |     "nearley": "^2.11.0"
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/constants/css.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   globalValues: ['inherit', 'initial', 'unset'],
3 |   variableRegex: /var\(--[^)]+\)/,
4 | };
5 | 


--------------------------------------------------------------------------------
/src/constants/genericLexer.js:
--------------------------------------------------------------------------------
 1 | const moo = require('moo');
 2 | 
 3 | module.exports = moo.compile({
 4 |   color: {
 5 |     match: /(?:#(?:[0-9a-fA-F]{2}){2,4}|#[0-9a-fA-F]{3}|(?:rgba?|hsla?)\(\s*(?:\d+%?(?:deg|rad|grad|turn)?(?:,|\s)+){2,3}[\s/]*[\d.]+%?\s*\))/,
 6 |     value: match => match.toLowerCase(),
 7 |   },
 8 |   number: /(?:[+-])?(?:(?:\d+\.\d*)|(?:\d*\.\d+))/,
 9 |   integer: /(?:[+-])?[0-9]+/,
10 |   string: /(?:"[^"]")|(?:'[^']')/,
11 |   functionStart: /[a-zA-Z]+\(/,
12 |   customIdent: {
13 |     match: /[^0-9\s](?:[a-zA-Z0-9_-]|(?:\\.))*/,
14 |     value: match => match.toLowerCase(),
15 |   },
16 |   ident: {
17 |     match: /[a-zA-Z-]+/,
18 |     value: match => match.toLowerCase(),
19 |   },
20 |   char: {
21 |     match: /./,
22 |     value: match => match.toLowerCase(),
23 |   },
24 | });
25 | 


--------------------------------------------------------------------------------
/src/constants/grammars.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   R_GRAMMAR_IDENT_GLOBAL: /<(([^>( ]+)(\(\))?)>/g,
3 |   R_GRAMMAR_IDENT: /<(([^>(]+)(\(\))?)>/,
4 |   R_GRAMMAR_IDENT_NAME_GLOBAL: /(([^>(]+)(\(\))?)/g,
5 |   BASE_GRAMMAR_RULE_NAME: 'Base',
6 |   TOP_LEVEL_NODE_NAME: 'Exp',
7 |   GRAMMAR_FILE_EXTENSION: 'ne',
8 | };
9 | 


--------------------------------------------------------------------------------
/src/constants/index.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   CSS: require('./css'),
3 |   GRAMMARS: require('./grammars'),
4 |   PATHS: require('./paths'),
5 |   SYNTAX_OVERRIDES: require('./syntaxOverrides.json'),
6 | };
7 | 


--------------------------------------------------------------------------------
/src/constants/paths.js:
--------------------------------------------------------------------------------
 1 | const path = require('path');
 2 | 
 3 | module.exports = {
 4 |   JSON_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'json'),
 5 |   NEARLEY_PROPERTY_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'nearley', 'properties'),
 6 |   GENERATED_JSON_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'generated', 'json'),
 7 |   GENERATED_NEARLEY_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'generated', 'nearley'),
 8 |   GENERATED_JS_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars', 'generated', 'js'),
 9 |   FORMATTED_DATA_PATH: path.join(__dirname, '..', 'formatted-data'),
10 |   FORMAL_SYNTAX_GRAMMAR_PATH: path.join(__dirname, '..', 'grammars'),
11 |   NEARLEY_BIN_ROOT: path.join(__dirname, '..', '..', 'node_modules', 'nearley', 'bin'),
12 | };
13 | 


--------------------------------------------------------------------------------
/src/constants/shorthandIdentToLonghandPropertyMap.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "transition": {
  3 |     "SingleTransitionTimingFunction": "transition-timing-function",
  4 |     "SingleTransitionProperty": "transition-property",
  5 |     "Time": [
  6 |       "transition-duration",
  7 |       "transition-delay"
  8 |     ],
  9 |     "SingleTransition": ""
 10 |   },
 11 |   "mask": {
 12 |     "MaskClip": "mask-clip",
 13 |     "MaskOrigin": "mask-origin"
 14 |   },
 15 |   "animation": {
 16 |     "SingleAnimationPlayState": "animation-play-state",
 17 |     "SingleAnimationFillMode": "animation-fill-mode",
 18 |     "SingleAnimationIterationCount": "animation-iteration-count",
 19 |     "SingleAnimationDirection": "animation-direction",
 20 |     "SingleTimingFunction": "animation-timing-function",
 21 |     "KeyframesName": "animation-name",
 22 |     "Time": [
 23 |       "animation-duration",
 24 |       "animation-delay"
 25 |     ],
 26 |     "SingleAnimation": ""
 27 |   },
 28 |   "flex": {
 29 |     "FlexGrow": "flex-grow",
 30 |     "FlexShrink": "flex-shrink",
 31 |     "FlexBasis": "flex-basis"
 32 |   },
 33 |   "background": {
 34 |     "BgImage": "background-image",
 35 |     "BackgroundColor": "background-color",
 36 |     "Box": [
 37 |       "background-origin",
 38 |       "background-clip"
 39 |     ],
 40 |     "Position": "background-position",
 41 |     "BgSize": "background-size",
 42 |     "RepeatStyle": "background-repeat",
 43 |     "Attachment": "background-attachment"
 44 |   },
 45 |   "font": {
 46 |     "FontStyle": "font-style",
 47 |     "FontVariantCss21": "font-variant",
 48 |     "FontWeight": "font-weight",
 49 |     "FontStretch": "font-stretch",
 50 |     "FontSize": "font-size",
 51 |     "LineHeight": "line-height",
 52 |     "FontFamily": "font-family"
 53 |   },
 54 |   "border-radius": [
 55 |     "border-top-left-radius",
 56 |     "border-top-right-radius",
 57 |     "border-bottom-right-radius",
 58 |     "border-bottom-left-radius"
 59 |   ],
 60 |   "padding": [
 61 |     "padding-top",
 62 |     "padding-right",
 63 |     "padding-bottom",
 64 |     "padding-left"
 65 |   ],
 66 |   "margin": [
 67 |     "margin-top",
 68 |     "margin-right",
 69 |     "margin-bottom",
 70 |     "margin-left"
 71 |   ],
 72 |   "border-width": [
 73 |     "border-top-width",
 74 |     "border-right-width",
 75 |     "border-bottom-width",
 76 |     "border-left-width"
 77 |   ],
 78 |   "border-style": [
 79 |     "border-top-style",
 80 |     "border-right-style",
 81 |     "border-bottom-style",
 82 |     "border-left-style"
 83 |   ],
 84 |   "border-color": [
 85 |     "border-top-color",
 86 |     "border-right-color",
 87 |     "border-bottom-color",
 88 |     "border-left-color"
 89 |   ],
 90 |   "text-emphasis": {
 91 |     "TextEmphasisColor": "text-emphasis-color",
 92 |     "TextEmphasisStyle": "text-emphasis-style"
 93 |   },
 94 |   "text-decoration": {
 95 |     "TextDecorationColor": "text-decoration-color",
 96 |     "TextDecorationStyle": "text-decoration-style",
 97 |     "TextDecorationLine": "text-decoration-line"
 98 |   },
 99 |   "outline": {
100 |     "OutlineStyle": "outline-style",
101 |     "OutlineWidth": "outline-width",
102 |     "OutlineColor": "outline-color"
103 |   },
104 |   "list-style": {
105 |     "ListStyleType": "list-style-type",
106 |     "ListStylePosition": "list-style-position",
107 |     "ListStyleImage": "list-style-image"
108 |   },
109 |   "flex-flow": {
110 |     "FlexWrap": "flex-wrap",
111 |     "FlexDirection": "flex-direction"
112 |   },
113 |   "columns": {
114 |     "ColumnCount": "column-count",
115 |     "ColumnWidth": "column-width"
116 |   },
117 |   "column-rule": {
118 |     "ColumnRuleWidth": "column-rule-width",
119 |     "ColumnRuleStyle": "column-rule-style",
120 |     "ColumnRuleColor": "column-rule-color"
121 |   },
122 |   "border-top": {
123 |     "Color": "border-top-color",
124 |     "BrStyle": "border-top-style",
125 |     "BrWidth": "border-top-width"
126 |   },
127 |   "border-right": {
128 |     "Color": "border-right-color",
129 |     "BrStyle": "border-right-style",
130 |     "BrWidth": "border-right-width"
131 |   },
132 |   "border-left": {
133 |     "Color": "border-left-color",
134 |     "BrStyle": "border-left-style",
135 |     "BrWidth": "border-left-width"
136 |   },
137 |   "border-bottom": {
138 |     "Color": "border-bottom-color",
139 |     "BrStyle": "border-bottom-style",
140 |     "BrWidth": "border-bottom-width"
141 |   },
142 |   "border-inline-start": {
143 |     "Color": "color",
144 |     "BorderStyle": "border-style",
145 |     "BorderWidth": "border-width"
146 |   },
147 |   "border-inline-end": {
148 |     "Color": "color",
149 |     "BorderStyle": "border-style",
150 |     "BorderWidth": "border-width"
151 |   },
152 |   "border-block-start": {
153 |     "Color": "color",
154 |     "BorderStyle": "border-style",
155 |     "BorderWidth": "border-width"
156 |   },
157 |   "border-block-end": {
158 |     "Color": "color",
159 |     "BorderStyle": "border-style",
160 |     "BorderWidth": "border-width"
161 |   },
162 |   "border": {
163 |     "Color": "border-color",
164 |     "BrStyle": "border-style",
165 |     "BrWidth": "border-width"
166 |   }
167 | }


--------------------------------------------------------------------------------
/src/constants/shorthandProperties.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   CLASSIFICATIONS: {
 3 |     TRBL: 'TRBL',
 4 |     COMMA_SEPARATED_LIST: 'COMMA_SEPARATED_LIST',
 5 |     UNORDERED_OPTIONAL_TUPLE: 'UNORDERED_OPTIONAL_TUPLE',
 6 |     AND_LIST: 'AND_LIST',
 7 |     OTHER: 'OTHER',
 8 |     FLEX: 'FLEX',
 9 |     BACKGROUND: 'BACKGROUND',
10 |     BORDER_RADIUS: 'BORDER_RADIUS',
11 |     FONT: 'FONT',
12 |   },
13 |   R_CLASSIFICATION_MAP: {
14 |     TRBL: /^\[? ?<['a-z-]+> ?(\| <?['a-z-]+>? ?)*]?\{1,4\}$/, // top left bottom right properties
15 |     COMMA_SEPARATED_LIST: /<[a-z-]+>#/, // <ident>#
16 |     UNORDERED_OPTIONAL_TUPLE: /^\[? ?<['a-z-]+> (\|\| <?['a-z-]+>? ?)*]?$/, // <ident> || <ident> || ....
17 |     AND_LIST: /^\[? ?<['a-z-]+> (&& <?['a-z-]+>? ?)*]?$/, // <ident> && <ident> && ...
18 |   },
19 |   OTHER_PROPERTY_CLASSIFICATION_MAP: {
20 |     FLEX: ['flex'],
21 |     BACKGROUND: ['background'],
22 |     BORDER_RADIUS: ['border-radius'],
23 |     FONT: ['font'],
24 |   },
25 | };
26 | 


--------------------------------------------------------------------------------
/src/constants/syntaxOverrides.json:
--------------------------------------------------------------------------------
1 | {
2 |   "list-style": "<'list-style-position'> || <'list-style-image'> || <'list-style-type'>",
3 |   "step-timing-function": "step-start | step-end | [ steps( <integer> [ , [ start | end ] ]? ) ]",
4 |   "cubic-bezier-timing-function": "ease | ease-in | ease-out | ease-in-out | [ cubic-bezier(<number> , <number> , <number> , <number> ) ]",
5 |   "single-transition": "<time> || <single-transition-timing-function> || [ none | <single-transition-property> ]",
6 |   "width": "[ [ <length> | <percentage> ] && [ border-box | content-box ]? ] | available | min-content | max-content | fit-content | auto"
7 | }


--------------------------------------------------------------------------------
/src/errors/ParseError.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * An error to be thrown when a css value cannot be parsed by nearley.
 3 |  * @type {module.ParseError}
 4 |  */
 5 | module.exports = class ParseError extends Error {
 6 |   constructor(...args) {
 7 |     super(...args);
 8 |     Error.captureStackTrace(this, ParseError);
 9 |   }
10 | };
11 | 


--------------------------------------------------------------------------------
/src/errors/UnknownPropertyError.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Error to be thrown when a property is not defined in the mdn properties object.
 3 |  * @type {module.UnknownPropertyError}
 4 |  */
 5 | module.exports = class UnknownPropertyError extends Error {
 6 |   constructor(property) {
 7 |     super(`Unknown property error: ${property} is not a known property`);
 8 |     this._property = property;
 9 |     Error.captureStackTrace(this, UnknownPropertyError);
10 |   }
11 |   get property() {
12 |     return this._property;
13 |   }
14 | };
15 | 


--------------------------------------------------------------------------------
/src/errors/UnsupportedPropertyError.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Error to be thrown when a property is not supported yet. For example, a longhand property that we do not support
 3 |  * yet.
 4 |  * @type {module.UnsupportedPropertyError}
 5 |  */
 6 | module.exports = class UnsupportedPropertyError extends Error {
 7 |   constructor(property) {
 8 |     super(`Unsupported property error: ${property} is not a supported property`);
 9 |     this._property = property;
10 |     Error.captureStackTrace(this, UnsupportedPropertyError);
11 |   }
12 |   get property() {
13 |     return this._property;
14 |   }
15 | };
16 | 


--------------------------------------------------------------------------------
/src/errors/index.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   ParseError: require('./ParseError'),
3 |   UnsupportedPropertyError: require('./UnsupportedPropertyError'),
4 |   UnknownPropertyError: require('./UnknownPropertyError'),
5 | };
6 | 


--------------------------------------------------------------------------------
/src/expandShorthandProperty.js:
--------------------------------------------------------------------------------
  1 | const nearley = require('nearley');
  2 | const properties = require('./formatted-data/properties.json');
  3 | const isShorthandProperty = require('./isShorthandProperty');
  4 | const getShorthandComputedProperties = require('./getShorthandComputedProperties');
  5 | const shorthandProperties = require('./formatted-data/shorthand-properties.json');
  6 | const CSS_CONSTANTS = require('./constants/css');
  7 | const { CLASSIFICATIONS } = require('./constants/shorthandProperties');
  8 | const LocationIndexTracker = require('./utils/LocationIndexTracker');
  9 | const { ParseError, UnsupportedPropertyError, UnknownPropertyError } = require('./errors');
 10 | const SHORTHAND_IDENT_TO_LONGHAND_PROPERTY_MAP = require('./constants/shorthandIdentToLonghandPropertyMap.json');
 11 | const {
 12 |   BackgroundPropertyFormatter,
 13 |   BorderRadiusPropertyFormatter,
 14 |   CommaSeparatedListPropertyFormatter,
 15 |   FlexPropertyFormatter,
 16 |   FontPropertyFormatter,
 17 |   TrblPropertyFormatter,
 18 |   UnorderedOptionalListPropertyFormatter,
 19 | } = require('./formatters/shorthandPropertyTypeFormatters');
 20 | const { initialValue, initialValues } = require('./initialValueMap');
 21 | const grammars = require('./grammars/generated');
 22 | 
 23 | const shorthandPropertyTypeToActionDictionaryFactoryMap = {
 24 |   [CLASSIFICATIONS.TRBL]: TrblPropertyFormatter,
 25 |   [CLASSIFICATIONS.UNORDERED_OPTIONAL_TUPLE]: UnorderedOptionalListPropertyFormatter,
 26 |   [CLASSIFICATIONS.COMMA_SEPARATED_LIST]: CommaSeparatedListPropertyFormatter,
 27 |   [CLASSIFICATIONS.FLEX]: FlexPropertyFormatter,
 28 |   [CLASSIFICATIONS.BORDER_RADIUS]: BorderRadiusPropertyFormatter,
 29 |   [CLASSIFICATIONS.BACKGROUND]: BackgroundPropertyFormatter,
 30 |   [CLASSIFICATIONS.FONT]: FontPropertyFormatter,
 31 | };
 32 | const R_BLOCK_COMMENT = /\/\*.*?\*\//g;
 33 | 
 34 | /**
 35 |  * Given a property and value attempts to expand the value into its longhand equivalents. Returns an object
 36 |  * mapping the property longhand names to the longhand values. If the property cannot be expanded (i.e. the property
 37 |  * is not a shorthand property) simply returns an object mapping the original property to the original value.
 38 |  *
 39 |  * @param {string} propertyName - the property name for the given value
 40 |  * @param {string} propertyValue - the value of the property
 41 |  * @param {boolean} [recursivelyResolve=false] - recursively resolve additional longhand properties if the shorthands
 42 |  *                                              expand to additional shorthands. For example, the border property
 43 |  *                                              expands to border-width, which expands further to border-left-width,
 44 |  *                                              border-right-width, etc.
 45 |  * @param {boolean} [includeInitialValues=false] - when expanding the shorthand property, fill in any missing longhand
 46 |  *                                                 values with their initial value. For example, the property
 47 |  *                                                 declaration "border: 1px" only explicitly sets the "border-width"
 48 |  *                                                 longhand property. If this param is true, the returned object will
 49 |  *                                                 fill in the initial values for "border-style" and "border-color". By
 50 |  *                                                 default, the returned object will only contain the "border-width".
 51 |  * @return {Object} - object mapping longhand property names to values
 52 |  *
 53 |  * @throws {ParseError} - if the propertyValue cannot be parsed.
 54 |  * @throws {UnknownPropertyError} - if the propertyName is not defined in mdn.
 55 |  * @throws {UnsupportedPropertyError} - if the propertyName is a shorthand property, but we don't support expanding it
 56 |  *                                      yet.
 57 |  *
 58 |  * @example
 59 |  * expandShorthandProperty('margin', '0 3px 10rem')
 60 |  *  {
 61 |  *    'margin-top': '0',
 62 |  *    'margin-right': '3px',
 63 |  *    'margin-bottom': '10rem',
 64 |  *    'margin-left': '3px',
 65 |  *   }
 66 |  *
 67 |  * @example
 68 |  * expandShorthandProperty('flex', 'initial')
 69 |  * {
 70 |  *  'flex-grow': 'initial',
 71 |  *  'flex-shrink': 'initial',
 72 |  *  'flex-basis': 'initial',
 73 |  * }
 74 |  */
 75 | module.exports = function expandShorthandProperty(propertyName,
 76 |   propertyValue,
 77 |   recursivelyResolve = false,
 78 |   includeInitialValues = false) {
 79 |   if (!properties[propertyName]) {
 80 |     throw new UnknownPropertyError(propertyName);
 81 |   } else if (!isShorthandProperty(propertyName)) {
 82 |     return { [propertyName]: propertyValue };
 83 |   } else if (!SHORTHAND_IDENT_TO_LONGHAND_PROPERTY_MAP[propertyName]) {
 84 |     throw new UnsupportedPropertyError(propertyName);
 85 |   } else if (CSS_CONSTANTS.globalValues.includes(propertyValue)) {
 86 |     return getShorthandComputedProperties(propertyName).reduce((propertyMap, computedPropertyName) => (
 87 |       Object.assign({ [computedPropertyName]: propertyValue }, propertyMap)
 88 |     ), {});
 89 |   }
 90 | 
 91 |   // get the compiled grammar file for this property
 92 |   const grammar = grammars[propertyName];
 93 |   // remove any block style comments and extra whitespace
 94 |   const formattedPropertyValue = propertyValue.replace(R_BLOCK_COMMENT, ' ').replace(/\s+/g, ' ').trim();
 95 |   let parser;
 96 | 
 97 |   // attempt to parse the css value, using the property specific parser
 98 |   try {
 99 |     parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar)).feed(formattedPropertyValue);
100 |   } catch (parseError) {
101 |     throw new ParseError(`Error parsing shorthand property ${propertyName}: ${propertyValue}. ${parseError.message}`);
102 |   }
103 | 
104 |   // get the first parsing and use the formatter for the specific shorthand type for this property
105 |   const { shorthandType } = shorthandProperties[propertyName];
106 |   const [rootNode] = parser.results;
107 |   LocationIndexTracker.reset();
108 |   let propertyExpansion = shorthandPropertyTypeToActionDictionaryFactoryMap[shorthandType]
109 |     .format(propertyName, rootNode, formattedPropertyValue);
110 | 
111 |   if (recursivelyResolve) {
112 |     Object.keys(propertyExpansion).forEach((prop) => {
113 |       if (shorthandProperties[prop]) {
114 |         Object.assign(
115 |           propertyExpansion,
116 |           expandShorthandProperty(prop, propertyExpansion[prop], true));
117 |       }
118 |     });
119 |   }
120 | 
121 |   if (includeInitialValues) {
122 |     let initials = {};
123 |     if (recursivelyResolve) {
124 |       initials = initialValues(propertyName, true, true);
125 |       delete initials[propertyName];
126 |     } else {
127 |       getShorthandComputedProperties(propertyName).forEach((prop) => {
128 |         initials[prop] = initialValue(prop);
129 |       });
130 |     }
131 |     propertyExpansion = Object.assign(initials, propertyExpansion);
132 |   }
133 | 
134 |   return propertyExpansion;
135 | };
136 | 


--------------------------------------------------------------------------------
/src/formatters/grammarFormatters/JsonGrammarFormatter.js:
--------------------------------------------------------------------------------
  1 | /* eslint-disable no-use-before-define */
  2 | const nearley = require('nearley');
  3 | const GRAMMAR_CONSTANTS = require('../../constants/grammars');
  4 | const grammar = require('../../grammars/js/formalSyntax');
  5 | 
  6 | module.exports = class JsonGrammarFormatter {
  7 |   static format(formalSyntax) {
  8 |     const parser = new nearley.Parser(grammar.ParserRules, grammar.ParserStart).feed(formalSyntax);
  9 |     const [rootNode] = parser.results;
 10 |     return JsonGrammarFormatter._evaluateNode(rootNode);
 11 |   }
 12 | 
 13 |   static _evaluateNode(node) {
 14 |     const grammarsToResolve = new Set();
 15 |     const tokenToEvaluationMap = {
 16 |       Asterisk([expression]) {
 17 |         return `( _ ${evaluate(expression)} _ ):*`;
 18 |       },
 19 | 
 20 |       Plus([expression]) {
 21 |         return `( _ ${evaluate(expression)} _ ):+`;
 22 |       },
 23 | 
 24 |       QuestionMark([expression]) {
 25 |         return `${evaluate(expression)}:?`;
 26 |       },
 27 | 
 28 |       CurlyHash([expression, number, comma]) {
 29 |         if (comma) {
 30 |           return `( ${Array(+number).fill(evaluate(expression)).join(' _ "," _ ')} ( _ "," _ ${evaluate(expression)} ):* )`;
 31 |         }
 32 | 
 33 |         return `( ${Array(+number).fill(evaluate(expression)).join(' _ "," _ ')} )`;
 34 |       },
 35 | 
 36 |       CurlyBraces([expression, min, comma, max]) {
 37 |         const minimumString = new Array(+min).fill().map(() => evaluate(expression)).join(' __ ');
 38 |         let maximumString = '';
 39 | 
 40 |         if (!comma) {
 41 |           return `( ${minimumString} )`;
 42 |         } else if (max) { // {integer,integer}
 43 |           maximumString = new Array(+max - +min).fill().map(() => `( __ ${evaluate(expression)} ):?`).join(' ');
 44 |         } else { // {integer,}
 45 |           maximumString = `${evaluate(expression)}:*`;
 46 |         }
 47 | 
 48 |         return `( ${minimumString} ${maximumString} )`.trim();
 49 |       },
 50 | 
 51 |       HashMark([expression]) {
 52 |         return `( ( ${evaluate(expression)} _ "," _):* ${evaluate(expression)} )`;
 53 |       },
 54 | 
 55 |       SingleBarList([list, end]) {
 56 |         const alternationNodes = list.map(([expression]) => evaluate(expression)).concat(evaluate(end)).join(' | ');
 57 | 
 58 |         return `( ${alternationNodes} )`;
 59 |       },
 60 | 
 61 |       Brackets([expression]) {
 62 |         return `( ${evaluate(expression)} )`;
 63 |       },
 64 | 
 65 |       DoubleAmpersand([left, right]) {
 66 |         if (right.nodeName === 'QuestionMark') {
 67 |           return `( ( ${evaluate(left)} ( __ ${evaluate(right)} ):? ) | ( ${evaluate(right)} __ ${evaluate(left)} ) )`;
 68 |         } else if (left.nodeName === 'QuestionMark') {
 69 |           return `( ( ${evaluate(left)} __ ${evaluate(right)} ) | ( ${evaluate(right)} ( __ ${evaluate(left)} ):? ) )`;
 70 |         }
 71 | 
 72 |         return `( ( ${evaluate(left)} __ ${evaluate(right)} ) | ( ${evaluate(right)} __ ${evaluate(left)} ) )`;
 73 |       },
 74 | 
 75 |       DoubleBarList([list, end]) {
 76 |         const alternationNodes = list.map(([expression]) => evaluate(expression)).concat(evaluate(end)).join(' | ');
 77 | 
 78 |         return `( ${alternationNodes} ) ( __ ( ${alternationNodes} ) ):*`;
 79 |       },
 80 | 
 81 |       Juxtaposition([left, right]) {
 82 |         return `( ${evaluate(left)} __ ${evaluate(right)} )`;
 83 |       },
 84 | 
 85 |       Comma([left, right]) {
 86 |         return `${evaluate(left)} ${evaluate(right)}`;
 87 |       },
 88 | 
 89 |       node([nodeName]) {
 90 |         grammarsToResolve.add(`<${nodeName}>`);
 91 |         return `<${nodeName}>`;
 92 |       },
 93 |     };
 94 |     const rootNodeEvaluation = evaluate(node);
 95 | 
 96 |     function evaluate(root) {
 97 |       if (typeof root !== 'object') {
 98 |         return root;
 99 |       } else if (!tokenToEvaluationMap[root.nodeName]) {
100 |         return root;
101 |       }
102 | 
103 |       return tokenToEvaluationMap[root.nodeName](root.values);
104 |     }
105 | 
106 |     return [
107 |       [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, rootNodeEvaluation],
108 |       ...[...grammarsToResolve].map(grammarName => [grammarName]),
109 |     ];
110 |   }
111 | };
112 | 


--------------------------------------------------------------------------------
/src/formatters/grammarFormatters/NearleyGrammarFormatter.js:
--------------------------------------------------------------------------------
  1 | const CaseConverterUtils = require('../../utils/CaseConverterUtils');
  2 | const fs = require('fs-extra');
  3 | const path = require('path');
  4 | const PATHS = require('../../constants/paths');
  5 | const GRAMMAR_CONSTANTS = require('../../constants/grammars');
  6 | const shorthandIdentToLongHandPropertyMap = require('../../constants/shorthandIdentToLonghandPropertyMap.json');
  7 | 
  8 | // any nearley builtin grammars that we want to include
  9 | const BUILTIN_GRAMMARS = ['whitespace'];
 10 | const LEXER_HEADING = '@{%\n  const lexer = require("../../../constants/genericLexer");\n%}\n\n@lexer lexer\n';
 11 | 
 12 | /**
 13 |  * Class to format a JSON Grammar into an Nearley Grammar
 14 |  * @type {NearleyGrammarFormatter}
 15 |  */
 16 | module.exports = class NearleyGrammarFormatter {
 17 |   /**
 18 |    * Given a JSON grammar format it into an Nearley Grammar string. This function, recursively resolves grammar
 19 |    * rules defined in the given json grammar. Any intermediate grammar rules are prefixed with the file name in order
 20 |    * to avoid rule name collisions between recursively resolved grammar rules.
 21 |    * <p>
 22 |    * @see {@link https://github.com/Hardmath123/nearley | Nearley Readme} for more information on
 23 |    * Nearley Syntax.
 24 |    *
 25 |    * @param {Array} jsonGrammar - json structure representing a grammar
 26 |    * @param {string} grammarName - the name of the property being converted to nearley form. For example, "rgba()"
 27 |    * @returns {string} - the formatted Ohm Grammar string
 28 |    */
 29 |   static format(jsonGrammar, grammarName) {
 30 |     NearleyGrammarFormatter._isGrammarValid(jsonGrammar);
 31 | 
 32 |     // Create a 2d array from a grammar name to its json grammar. All of these grammars need to be recursively resolved.
 33 |     // i.e. [["color", [<jsonGrammarForColor>]], "z-index", [<jsonGrammarForZIndex>]]
 34 |     // Then get the file name for each grammar that needs to be pulled into this grammar. Grab the files for those
 35 |     // jsonGrammars and pull in the rule definitions in those jsonGrammars.
 36 |     const recursivelyResolvedGrammars = NearleyGrammarFormatter
 37 |       ._getGrammarsToResolve(jsonGrammar)
 38 |       .map(fileToResolve => [
 39 |         fileToResolve,
 40 |         fs.readJsonSync(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, `${fileToResolve}.json`)),
 41 |       ])
 42 |       .filter(([, json]) => NearleyGrammarFormatter._isGrammarValid(json))
 43 |       .map(([grammarName, jsonGrammar]) => (
 44 |         [grammarName, NearleyGrammarFormatter._prefixIntermediateGrammarRules(grammarName, jsonGrammar)]
 45 |       ))
 46 |       .map(([grammarName, json]) => json
 47 |         .filter(grammarPair => grammarPair.length === 2) // filter out any jsonGrammars that need resolution
 48 |         .map(([ruleName, ruleBody]) => (
 49 |           ruleName === GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME
 50 |             ? [CaseConverterUtils.formalSyntaxIdentToNearleyIdent(grammarName), ruleBody]
 51 |             : [ruleName, ruleBody]
 52 |         )));
 53 |     const [[, baseValue], ...otherRules] = NearleyGrammarFormatter
 54 |       ._prefixIntermediateGrammarRules(grammarName, jsonGrammar);
 55 |     // the base key for this grammar should be mapped to Base, then concat the rest of the rules and
 56 |     // format them into nearley syntax. i.e <ruleName> -> <ruleBody>.
 57 |     const nearleyGrammarBody = [[GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, baseValue]]
 58 |       .concat(otherRules.filter(rule => rule.length === 2)) // add any rules that don't need to be resolved
 59 |       .concat(...recursivelyResolvedGrammars) // add all the rules we resolved
 60 |       .map(([ruleName, ruleBody]) => {
 61 |         const ruleBodyString = NearleyGrammarFormatter._formatJsonRuleBody(ruleBody);
 62 |         const postProcessorString = this._getPostProcessorString(grammarName, ruleName);
 63 | 
 64 |         return postProcessorString
 65 |           ? `${ruleName} -> ${ruleBodyString} ${postProcessorString}`
 66 |           : `${ruleName} -> ${ruleBodyString}`;
 67 |       })
 68 |       .join('\n');
 69 |     const builtinGrammarsHeader = BUILTIN_GRAMMARS
 70 |       .map(grammarName => `@builtin "${grammarName}.${GRAMMAR_CONSTANTS.GRAMMAR_FILE_EXTENSION}"`)
 71 |       .join('\n');
 72 | 
 73 |     return `${builtinGrammarsHeader}\n${LEXER_HEADING}\n\n${nearleyGrammarBody}`;
 74 |   }
 75 | 
 76 |   /**
 77 |    * Generate a postprocessing string for a given ruleName in the context of grammarName. This postprocessing string
 78 |    * is used in a nearley grammar to run code after a specific rule is parsed. We only need to create postprocessing
 79 |    * strings for longhand properties we intend to expand from a shorthand prop. All other properties will not have a
 80 |    * postprocessing string.
 81 |    *
 82 |    * @param {string} grammarName - the name of the grammar to generate the post processing string for. For example,
 83 |    *                               "border".
 84 |    * @param {string} ruleName - the rule name to get the postprocessing string for. For example, "Color".
 85 |    * @returns {String} - a string containing the postprocessing function for the given ruleName or an empty string if
 86 |    *                     no postprocessing is required
 87 |    * @private
 88 |    */
 89 |   static _getPostProcessorString(grammarName, ruleName) {
 90 |     // if its not a shorthand property we don't support, we don't need postprocessing, since we only use the grammar
 91 |     // for property validation
 92 |     if (!shorthandIdentToLongHandPropertyMap[grammarName]
 93 |       || Array.isArray(shorthandIdentToLongHandPropertyMap[grammarName])) {
 94 |       return '';
 95 |     }
 96 | 
 97 |     return Object.keys(shorthandIdentToLongHandPropertyMap[grammarName])
 98 |       .concat(GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME)
 99 |       .includes(ruleName)
100 |       ? `{% function (data,location) { return { name: '${ruleName}', values: data.filter(Boolean), location }; } %}`
101 |       : '';
102 |   }
103 | 
104 |   /**
105 |    * Given a json grammar recursively finds all additional jsonGrammars that the grammar depends on. Returns a set
106 |    * of unique file names indicating which jsonGrammars need to be resolved.
107 |    *
108 |    * @param {Array} jsonGrammar - a json structure representing a grammar
109 |    * @param {Array} [resolved=[]] - cached array of grammar names that have already been resolved. Caller does not
110 |    *                                need to use this param, since it only used for recursive grammars.
111 |    * @returns {Array} - a set of unique file names indicating which json grammars need to resolved.
112 |    * @private
113 |    */
114 |   static _getGrammarsToResolve(jsonGrammar, resolved = []) {
115 |     const resolutions = jsonGrammar
116 |       .filter(grammarLine => grammarLine.length === 1)
117 |       .map(([grammarName]) => GRAMMAR_CONSTANTS.R_GRAMMAR_IDENT.exec(grammarName)[1])
118 |       .filter(grammarName => !resolved.includes(grammarName));
119 | 
120 |     if (resolutions.length === 0) {
121 |       return [];
122 |     }
123 | 
124 |     return [...new Set(resolutions.concat(
125 |       ...resolutions
126 |         .map(file => fs.readJsonSync(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, `${file}.json`)))
127 |         .map(grammar => NearleyGrammarFormatter._getGrammarsToResolve(grammar, resolved.concat(resolutions)))))];
128 |   }
129 | 
130 |   /**
131 |    * Given a grammarName and a json grammar, prefixes all the intermediate rule names with the grammar name.
132 |    * This is necessary in order to prevent rule name conflicts when recursively resolving grammars.
133 |    * <p>
134 |    * For example, two grammars 'a' and 'b' may contain a rule named 'foo'. If another grammar uses both 'a' and 'b'
135 |    * we need to differentiate between the rule 'foo' defined in both 'a' and 'b'. Thus we prefix 'foo' for both grammars
136 |    * and rename the rules 'a_foo' and 'b_foo'.
137 |    *
138 |    * @param {string} grammarName - the name of the given json grammar. This should be a camelCase name.
139 |    * @param {Array} jsonGrammar - the json grammar to be prefixed
140 |    * @returns {Array} - the prefixed json grammar
141 |    * @private
142 |    */
143 |   static _prefixIntermediateGrammarRules(grammarName, jsonGrammar) {
144 |     // prefix all rules that we don't need to recursively resolve and are not base rules
145 |     const ruleNamesToPrefix = jsonGrammar
146 |       .filter(rule => rule.length === 2)
147 |       .filter(([ruleName]) => ruleName !== GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME)
148 |       .map(([ruleName]) => (
149 |         `(?:[^a-z"](${ruleName})$|^(${ruleName})[^a-z"]|^(${ruleName})$|[^a-z"](${ruleName})[^a-z"])`
150 |       ));
151 | 
152 |     // iterate through all the rules and replace rule name/rule body with prefixed rule names
153 |     if (ruleNamesToPrefix.length) {
154 |       const ruleNamesToPrefixRegex = new RegExp(`${ruleNamesToPrefix.join('|')}`, 'g');
155 | 
156 |       return jsonGrammar
157 |         .filter(rule => rule.length === 2)
158 |         .map(rule => rule.map(rulePart => rulePart
159 |           .split(' ')
160 |           .map(ruleExpression => ruleExpression
161 |             .replace(ruleNamesToPrefixRegex, (completeMatch, ...ruleNameMatches) => {
162 |               const ruleName = ruleNameMatches.find(Boolean);
163 | 
164 |               return completeMatch
165 |                 .replace(ruleName, NearleyGrammarFormatter._prefixRuleName(grammarName, ruleName));
166 |             }))
167 |           .join(' ')));
168 |     }
169 | 
170 |     return jsonGrammar;
171 |   }
172 | 
173 |   /**
174 |    * Prefixes the given rule name with the grammar name.
175 |    * @param {string} grammarName - the grammar name
176 |    * @param {string} ruleName - the rule name
177 |    * @returns {string} - the prefixed rule name
178 |    * @private
179 |    */
180 |   static _prefixRuleName(grammarName, ruleName) {
181 |     return `${CaseConverterUtils.formalSyntaxIdentToNearleyIdent(grammarName)}_${ruleName}`;
182 |   }
183 | 
184 |   /**
185 |    * Formats the given rule body into a string that is compatible with Nearley.
186 |    *
187 |    * @param {string} ruleBody - the JSON grammar body
188 |    * @returns {string} - the formatted rule body
189 |    * @private
190 |    */
191 |   static _formatJsonRuleBody(ruleBody) {
192 |     return ruleBody.replace(GRAMMAR_CONSTANTS.R_GRAMMAR_IDENT_GLOBAL, (fullMatch, innerIdent, identName, parens) => {
193 |       const nearleyIdent = CaseConverterUtils.formalSyntaxIdentToNearleyIdent(identName);
194 | 
195 |       return `${nearleyIdent}${parens ? 'Func' : ''}`;
196 |     });
197 |   }
198 | 
199 |   /**
200 |    * Given a grammar json, checks if the grammar is valid.
201 |    *
202 |    * @param {Object} jsonGrammar - a json structure representing a grammar.
203 |    * @returns {boolean} - returns true if given grammar is valid, else throws an error
204 |    * @throws {Error} - error indicating why the grammar is invalid
205 |    * @private
206 |    */
207 |   static _isGrammarValid(jsonGrammar) {
208 |     if (!Array.isArray(jsonGrammar)) {
209 |       throw new Error(`Invalid grammar. Grammar must be a 2-dimensional array:\n${jsonGrammar}`);
210 |     } else if (!jsonGrammar.length) {
211 |       throw new Error(`Invalid grammar. Grammar must be of length >= 1:\n${jsonGrammar}`);
212 |     } else if (!jsonGrammar[0][0] === GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME) {
213 |       throw new Error(
214 |         `Invalid grammar. Grammar must have base key: ${GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME}\n${jsonGrammar}`
215 |       );
216 |     }
217 | 
218 |     return true;
219 |   }
220 | };
221 | 


--------------------------------------------------------------------------------
/src/formatters/shorthandPropertyTypeFormatters/BackgroundPropertyFormatter.js:
--------------------------------------------------------------------------------
 1 | const ShorthandPropertyTypeFormatterUtils = require('../../utils/ShorthandPropertyTypeFormatterUtils');
 2 | const shorthandIdentToLonghandPropertyMap = require('../../constants/shorthandIdentToLonghandPropertyMap.json');
 3 | 
 4 | const BG_LAYER_NODE_NAME = 'BgLayer';
 5 | const FINAL_BG_LAYER_NODE_NAME = 'FinalBgLayer';
 6 | const BACKGROUND_PROPERTY_NAME = 'background';
 7 | 
 8 | module.exports = class BackgroundPropertyFormatter {
 9 |   /**
10 |    * Formats a parser tree generated from feeding a shorthand property value to nearley, into an object, mapping
11 |    * longhand property names to their values.
12 |    *
13 |    * @param {string} propertyName - the css property name. For example, 'background'.
14 |    * @param {Object} node - the root node of the nearley parser tree
15 |    * @param {string} value - the property value string. For example, "green center top".
16 |    * @returns {Object} - a mapping between longhand property names to their longhand values.
17 |    */
18 |   static format(propertyName, node, value) {
19 |     const layerPropertyMaps = ShorthandPropertyTypeFormatterUtils
20 |       .filterNodesByName(node, [BG_LAYER_NODE_NAME, FINAL_BG_LAYER_NODE_NAME])
21 |       .sort(({ location: location1 }, { location: location2 }) => location1 - location2)
22 |       .map((layerNode, idx, originalNodeArray) => {
23 |         const layerValueString = idx === originalNodeArray.length - 1
24 |           ? value.slice(layerNode.location)
25 |           : value.slice(layerNode.location, originalNodeArray[idx + 1].location - 1).replace(/,\s*$/, '').trim();
26 | 
27 |         return BackgroundPropertyFormatter._formatLayer(layerNode, layerValueString);
28 |       });
29 | 
30 |     return ShorthandPropertyTypeFormatterUtils.mergePropertyMaps(layerPropertyMaps);
31 |   }
32 | 
33 |   static _formatLayer(layerNode, valueString) {
34 |     const backgroundOrigin = shorthandIdentToLonghandPropertyMap[BACKGROUND_PROPERTY_NAME].Box[0];
35 |     const backgroundClip = shorthandIdentToLonghandPropertyMap[BACKGROUND_PROPERTY_NAME].Box[1];
36 |     const backgroundPosition = shorthandIdentToLonghandPropertyMap[BACKGROUND_PROPERTY_NAME].Position;
37 |     const backgroundSize = shorthandIdentToLonghandPropertyMap[BACKGROUND_PROPERTY_NAME].BgSize;
38 |     const longhandValueMap = Object.entries(
39 |       ShorthandPropertyTypeFormatterUtils.getPropertyNodeMappingCommaSeparatedList(BACKGROUND_PROPERTY_NAME, layerNode)
40 |     )
41 |       .map(([property, node]) => [property, node.location])
42 |       .sort(([, location1], [, location2]) => location1 - location2)
43 |       .map(([property, location], idx, entries) => {
44 |         if (idx === entries.length - 1) {
45 |           return [property, valueString.slice(location - layerNode.location)];
46 |         }
47 | 
48 |         return [property, valueString.slice(location - layerNode.location, entries[idx + 1][1] - 1)];
49 |       })
50 |       .reduce((longhandMap, [longhandPropertyName, longhandPropertyValue]) => (
51 |         Object.assign({ [longhandPropertyName]: longhandPropertyValue }, longhandMap)
52 |       ), {});
53 | 
54 |     // The <box> value may be included zero, one, or two times. If included once, it sets both background-origin
55 |     // and background-clip. If it is included twice, the first occurrence sets background-origin, and the second sets
56 |     // background-clip. This logic checks if only one <box> value was encountered. If so, set background-clip to
57 |     // background-origin's value.
58 |     if (longhandValueMap[backgroundOrigin] && !longhandValueMap[backgroundClip]) {
59 |       longhandValueMap[backgroundClip] = longhandValueMap[backgroundOrigin];
60 |     }
61 | 
62 |     // The <bg-size> value may only be included immediately after <position>, separated with the '/' character,
63 |     // like this: "center/80%". This logic removes the trailing slash we parse out from the background-position
64 |     // property
65 |     if (longhandValueMap[backgroundPosition] && longhandValueMap[backgroundSize]) {
66 |       longhandValueMap[backgroundPosition] = longhandValueMap[backgroundPosition].replace(/\/$/, '').trim();
67 |     }
68 | 
69 |     return longhandValueMap;
70 |   }
71 | };
72 | 


--------------------------------------------------------------------------------
/src/formatters/shorthandPropertyTypeFormatters/BorderRadiusPropertyFormatter.js:
--------------------------------------------------------------------------------
 1 | const shorthandIdentToLonghandPropertyMap = require('../../constants/shorthandIdentToLonghandPropertyMap.json');
 2 | 
 3 | // maps the length of the property value to an array mapping the property value index that should be used for each
 4 | // computed property.
 5 | const valueLengthToCornerPropertyIndexMap = {
 6 |   0: [],
 7 |   1: [1, 1, 1, 1],
 8 |   2: [1, 2, 1, 2],
 9 |   3: [1, 2, 3, 2],
10 |   4: [1, 2, 3, 4],
11 | };
12 | 
13 | module.exports = class BorderRadiusPropertyFormatter {
14 |   /**
15 |    * Formats a border-radius value into an object mapping border-radius longhand property names to their
16 |    * values.
17 |    *
18 |    * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/border-radius | border-radius spec}
19 |    *
20 |    * @param {string} propertyName - the css property name. In this case, 'border-radius'
21 |    * @param {Object} node - the root node of the nearley parser tree
22 |    * @param {string} value - the property value string. For example, "4px 4px 3px / 2px".
23 |    * @returns {Object} - a mapping between longhand property names to their longhand values.
24 |    */
25 |   static format(propertyName, node, value) {
26 |     // split property value by any whitespace or by the "/"
27 |     const [firstRadii, additionalRadii = ''] = value.split('/');
28 |     const borderRadiusProperties = shorthandIdentToLonghandPropertyMap[propertyName];
29 | 
30 |     // get everything before the '/' and create a map from longhand property name to value
31 |     const radiusValues = firstRadii.trim().split(/\s+/);
32 |     const radiusValueMap = valueLengthToCornerPropertyIndexMap[radiusValues.length]
33 |       .reduce((expandedPropertyMap, propertyValueIndex, idx) => (
34 |         Object.assign({
35 |           [borderRadiusProperties[idx]]: radiusValues[propertyValueIndex - 1],
36 |         }, expandedPropertyMap)
37 |       ), {});
38 | 
39 |     // do the same for everything after the '/'
40 |     const additionalValues = additionalRadii.trim().split(/\s+/);
41 |     const additionalValueMap = valueLengthToCornerPropertyIndexMap[additionalValues.length]
42 |       .reduce((expandedPropertyMap, propertyValueIndex, idx) => (
43 |         Object.assign({
44 |           [borderRadiusProperties[idx]]: additionalValues[propertyValueIndex - 1],
45 |         }, expandedPropertyMap)
46 |       ), {});
47 | 
48 |     // merge radiusValues and additional values for each longhand property
49 |     return Object.entries(radiusValueMap)
50 |       .map(([property, value]) => (additionalValueMap[property]
51 |         ? [property, `${value} / ${additionalValueMap[property]}`]
52 |         : [property, value]))
53 |       .reduce((propertyMap, [key, value]) => Object.assign({ [key]: value }, propertyMap), {});
54 |   }
55 | };
56 | 


--------------------------------------------------------------------------------
/src/formatters/shorthandPropertyTypeFormatters/CommaSeparatedListPropertyFormatter.js:
--------------------------------------------------------------------------------
 1 | const ShorthandPropertyTypeFormatterUtils = require('../../utils/ShorthandPropertyTypeFormatterUtils');
 2 | const shorthandIdentToLonghandPropertyMap = require('../../constants/shorthandIdentToLonghandPropertyMap.json');
 3 | const ArrayUtils = require('../../utils/ArrayUtils');
 4 | 
 5 | module.exports = class CommaSeparatedListPropertyFormatter {
 6 |   /**
 7 |    * Formats a parser tree generated from feeding a shorthand property value to nearley, into an object mapping
 8 |    * longhand property names to their values.
 9 |    *
10 |    * @param {string} propertyName - the css property name. For example, 'transition'.
11 |    * @param {Object} node - the root node of the nearley parser tree
12 |    * @param {string} value - the property value string. For example, "padding-left 1s 1s".
13 |    * @returns {Object} - a mapping between longhand property names to their longhand values.
14 |    */
15 |   static format(propertyName, node) {
16 |     // in the shorthand ident map, a mapping to an empty string signifies the single property rule name. For
17 |     // example, for transition, "SingleAnimation" maps to the empty string.
18 |     const [[singlePropertyRuleName]] = Object.entries(shorthandIdentToLonghandPropertyMap[propertyName])
19 |       .filter(([, propertyMapping]) => propertyMapping === '');
20 |     // get each single property and create a longhand map for it. For example, for transition, the value
21 |     // "padding 1s, margin 1s" will produce a parse tree with multiple "SingleTransition" nodes. We format each
22 |     // "SingleTransition" node into a longhand property map, and then merge them together.
23 |     const singlePropertyMaps = ShorthandPropertyTypeFormatterUtils.filterNodesByName(node, [singlePropertyRuleName])
24 |       .sort(({ location: location1 }, { location: location2 }) => location1 - location2)
25 |       .map(layerNode => CommaSeparatedListPropertyFormatter._formatSingleProperty(propertyName, layerNode));
26 | 
27 |     return ShorthandPropertyTypeFormatterUtils.mergePropertyMaps(singlePropertyMaps);
28 |   }
29 | 
30 |   /**
31 |    * Formats a single property node into an object mapping the longhand property name, to its value.
32 |    *
33 |    * @param {string} propertyName - the property name this single property node belongs to. For example, "transition".
34 |    * @param {Object} singlePropertyNode - the single property parse tree node
35 |    * @return {Object} - object mapping the longhand property name to its value
36 |    * @private
37 |    */
38 |   static _formatSingleProperty(propertyName, singlePropertyNode) {
39 |     return Object.entries(
40 |       ShorthandPropertyTypeFormatterUtils.getPropertyNodeMappingCommaSeparatedList(propertyName, singlePropertyNode)
41 |     )
42 |       .reduce(
43 |         ArrayUtils.entriesToObject(
44 |           ArrayUtils.identityFunction,
45 |           node => ShorthandPropertyTypeFormatterUtils.getTokensFromNode(node).map(token => token.text).join('')
46 |         ),
47 |         {}
48 |       );
49 |   }
50 | };
51 | 


--------------------------------------------------------------------------------
/src/formatters/shorthandPropertyTypeFormatters/FlexPropertyFormatter.js:
--------------------------------------------------------------------------------
 1 | const ShorthandPropertyTypeFormatterUtils = require('../../utils/ShorthandPropertyTypeFormatterUtils');
 2 | 
 3 | const flexKeywordToExpandedMap = {
 4 |   auto: {
 5 |     'flex-grow': '1',
 6 |     'flex-shrink': '1',
 7 |     'flex-basis': 'auto',
 8 |   },
 9 |   initial: {
10 |     'flex-grow': '0',
11 |     'flex-shrink': '1',
12 |     'flex-basis': 'auto',
13 |   },
14 |   none: {
15 |     'flex-grow': '0',
16 |     'flex-shrink': '0',
17 |     'flex-basis': 'auto',
18 |   },
19 |   number(num) {
20 |     return {
21 |       'flex-grow': num,
22 |       'flex-shrink': '1',
23 |       'flex-basis': '0',
24 |     };
25 |   },
26 | };
27 | 
28 | module.exports = class BorderRadiusPropertyFormatter {
29 |   /**
30 |    * Formats a border-radius value into an object mapping flex longhand property names to their
31 |    * values.
32 |    *
33 |    * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/border-radius | border-radius spec}
34 |    *
35 |    * @param {string} propertyName - the css property name. In this case, 'flex'
36 |    * @param {Object} node - the root node of the nearley parser tree
37 |    * @param {string} value - the property value string. For example, "1 0 auto".
38 |    * @returns {Object} - a mapping between longhand property names to their longhand values.
39 |    */
40 |   static format(propertyName, node, value) {
41 |     if (flexKeywordToExpandedMap[value]) {
42 |       return flexKeywordToExpandedMap[value];
43 |     } else if (typeof +value === 'number' && !Number.isNaN(+value)) {
44 |       return flexKeywordToExpandedMap.number(value);
45 |     }
46 | 
47 |     return Object.entries(ShorthandPropertyTypeFormatterUtils.getPropertyLocationMapping(propertyName, node))
48 |       .sort(([, location1], [, location2]) => location1 - location2)
49 |       .map(([property, location], idx, entries) => {
50 |         if (idx === entries.length - 1) {
51 |           return [property, value.slice(location)];
52 |         }
53 | 
54 |         return [property, value.slice(location, entries[idx + 1][1] - 1)];
55 |       })
56 |       .reduce((longhandMap, [longhandPropertyName, longhandPropertyValue]) => (
57 |         Object.assign({ [longhandPropertyName]: longhandPropertyValue }, longhandMap)
58 |       ), {});
59 |   }
60 | };
61 | 


--------------------------------------------------------------------------------
/src/formatters/shorthandPropertyTypeFormatters/FontPropertyFormatter.js:
--------------------------------------------------------------------------------
 1 | const ShorthandPropertyTypeFormatterUtils = require('../../utils/ShorthandPropertyTypeFormatterUtils');
 2 | const shorthandIdentToLonghandPropertyMap = require('../../constants/shorthandIdentToLonghandPropertyMap.json');
 3 | 
 4 | 
 5 | module.exports = class FontPropertyFormatter {
 6 |   /**
 7 |    * Formats a parser tree generated from feeding a shorthand property value to nearley, into an object mapping
 8 |    * longhand property names to their values.
 9 |    *
10 |    * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/font} for more info.
11 |    *
12 |    * @param {string} propertyName - the css property name. For example, 'font'.
13 |    * @param {Object} node - the root node of the nearley parser tree
14 |    * @param {string} value - the property value string. For example, '2em "Open Sans", sans-serif'.
15 |    * @returns {Object} - a mapping between longhand property names to their longhand values.
16 |    */
17 |   static format(propertyName, node, value) {
18 |     const lineHeight = shorthandIdentToLonghandPropertyMap[propertyName].LineHeight;
19 |     const fontSize = shorthandIdentToLonghandPropertyMap[propertyName].FontSize;
20 |     const longhandValueMap = Object
21 |       .entries(ShorthandPropertyTypeFormatterUtils.getPropertyLocationMapping(propertyName, node))
22 |       .sort(([, location1], [, location2]) => location1 - location2)
23 |       .map(([property, location], idx, entries) => {
24 |         if (idx === entries.length - 1) {
25 |           return [property, value.slice(location)];
26 |         }
27 | 
28 |         return [property, value.slice(location, entries[idx + 1][1] - 1)];
29 |       })
30 |       .reduce((longhandMap, [longhandPropertyName, longhandPropertyValue]) => (
31 |         Object.assign({ [longhandPropertyName]: longhandPropertyValue }, longhandMap)
32 |       ), {});
33 | 
34 |     // line-height must immediately follow font-size, preceded by "/", like this: "16px/3". So font-size
35 |     // may have an extra "/" character at the end that we need to remove.
36 |     if (longhandValueMap[lineHeight] && longhandValueMap[fontSize]) {
37 |       longhandValueMap[fontSize] = longhandValueMap[fontSize].replace(/\/$/, '').trim();
38 |     }
39 | 
40 |     return longhandValueMap;
41 |   }
42 | };
43 | 


--------------------------------------------------------------------------------
/src/formatters/shorthandPropertyTypeFormatters/TrblPropertyFormatter.js:
--------------------------------------------------------------------------------
 1 | const shorthandIdentToLonghandPropertyMap = require('../../constants/shorthandIdentToLonghandPropertyMap.json');
 2 | const ShorthandPropertyTypeFormatterUtils = require('../../utils/ShorthandPropertyTypeFormatterUtils');
 3 | 
 4 | // maps the length of the property value to an array mapping the property value index that should be used for each
 5 | // computed property.
 6 | const valueLengthToTrblPropertyIndexMap = {
 7 |   1: [1, 1, 1, 1],
 8 |   2: [1, 2, 1, 2],
 9 |   3: [1, 2, 3, 2],
10 |   4: [1, 2, 3, 4],
11 | };
12 | 
13 | module.exports = class TrblPropertyFormatter {
14 |   /**
15 |    * Formats a parser tree generated from feeding a shorthand property value to nearley, into an object mapping
16 |    * longhand property names to their values.
17 |    *
18 |    * @param {string} propertyName - the css property name. For example, 'border' or 'flex-flow'.
19 |    * @param {Object} node - the root node of the nearley parser tree
20 |    * @returns {Object} - a mapping between longhand property names to their longhand values.
21 |    */
22 |   static format(propertyName, node) {
23 |     const trblProperties = shorthandIdentToLonghandPropertyMap[propertyName];
24 |     const propertyValues = node[0]
25 |       .filter(Boolean)
26 |       .map(node => ShorthandPropertyTypeFormatterUtils.getTokensFromNode(node).map(token => token.text).join(''));
27 | 
28 |     return valueLengthToTrblPropertyIndexMap[propertyValues.length]
29 |       .reduce((expandedPropertyMap, propertyValueIndex, idx) => (
30 |         Object.assign({ [trblProperties[idx]]: propertyValues[propertyValueIndex - 1] }, expandedPropertyMap)
31 |       ), {});
32 |   }
33 | };
34 | 


--------------------------------------------------------------------------------
/src/formatters/shorthandPropertyTypeFormatters/UnorderedOptionalListPropertyFormatter.js:
--------------------------------------------------------------------------------
 1 | const ShorthandPropertyTypeFormatterUtils = require('../../utils/ShorthandPropertyTypeFormatterUtils');
 2 | const ArrayUtils = require('../../utils/ArrayUtils');
 3 | 
 4 | module.exports = class UnorderedOptionalListPropertyFormatter {
 5 |   /**
 6 |    * Formats a parser tree generated from feeding a shorthand property value to nearley, into an object mapping
 7 |    * longhand property names to their values.
 8 |    *
 9 |    * @param {string} propertyName - the css property name. For example, 'border' or 'flex-flow'.
10 |    * @param {Object} node - the root node of the nearley parser tree
11 |    * @returns {Object} - a mapping between longhand property names to their longhand values.
12 |    */
13 |   static format(propertyName, node) {
14 |     return Object.entries(
15 |       ShorthandPropertyTypeFormatterUtils.getPropertyNodeMappingCommaSeparatedList(propertyName, node)
16 |     )
17 |       .reduce(
18 |         ArrayUtils.entriesToObject(
19 |           ArrayUtils.identityFunction,
20 |           node => ShorthandPropertyTypeFormatterUtils.getTokensFromNode(node).map(token => token.text).join('')
21 |         ),
22 |         {}
23 |       );
24 |   }
25 | };
26 | 


--------------------------------------------------------------------------------
/src/formatters/shorthandPropertyTypeFormatters/index.js:
--------------------------------------------------------------------------------
 1 | const BackgroundPropertyFormatter = require('./BackgroundPropertyFormatter');
 2 | const BorderRadiusPropertyFormatter = require('./BorderRadiusPropertyFormatter');
 3 | const CommaSeparatedListPropertyFormatter = require('./CommaSeparatedListPropertyFormatter');
 4 | const FlexPropertyFormatter = require('./FlexPropertyFormatter');
 5 | const FontPropertyFormatter = require('./FontPropertyFormatter');
 6 | const TrblPropertyFormatter = require('./TrblPropertyFormatter');
 7 | const UnorderedOptionalListPropertyFormatter = require('./UnorderedOptionalListPropertyFormatter');
 8 | 
 9 | module.exports = {
10 |   BackgroundPropertyFormatter,
11 |   BorderRadiusPropertyFormatter,
12 |   CommaSeparatedListPropertyFormatter,
13 |   FlexPropertyFormatter,
14 |   FontPropertyFormatter,
15 |   TrblPropertyFormatter,
16 |   UnorderedOptionalListPropertyFormatter,
17 | };
18 | 


--------------------------------------------------------------------------------
/src/getShorthandComputedProperties.js:
--------------------------------------------------------------------------------
 1 | const properties = require('./formatted-data/properties.json');
 2 | 
 3 | /**
 4 |  * Given a shorthand property, returns an array of the computed properties for that shorthand property. If given
 5 |  * a known property that is not a shorthand, simply returns the given property. If given an unknown property,
 6 |  * returns an empty array.
 7 |  *
 8 |  * @param {string} shorthandProperty - the shorthand property name. For example, "background" or "border".
 9 |  * @param {boolean} [recursivelyResolve=false] - recursively resolve additional longhand properties if the shorthands
10 |  *                                              expand to additional shorthands. For example, the border property
11 |  *                                              expands to border-width, which expands further to border-left-width,
12 |  *                                              border-right-width, etc.
13 |  * @returns {Array} - an array containing the computed properties for the given shorthand property. Returns an
14 |  *                    empty array if the given property is not a valid property.
15 |  *
16 |  * @example
17 |  * getShorthandComputedProperties('background') ->
18 |  * [
19 |  *   "background-image",
20 |  *   "background-position",
21 |  *   "background-size",
22 |  *   "background-repeat",
23 |  *   "background-origin",
24 |  *   "background-clip",
25 |  *   "background-attachment",
26 |  *   "background-color"
27 |  * ]
28 |  *
29 |  * @example
30 |  * getShorthandComputedProperties('border', true) ->
31 |  * [
32 |  *     "border-width",
33 |  *     "border-style",
34 |  *     "border-color",
35 |  *     "border-bottom-width",
36 |  *     "border-left-width",
37 |  *     "border-right-width",
38 |  *     "border-top-width",
39 |  *     "border-bottom-style",
40 |  *     "border-left-style",
41 |  *     "border-right-style",
42 |  *     "border-top-style",
43 |  *     "border-bottom-color",
44 |  *     "border-left-color",
45 |  *     "border-right-color",
46 |  *     "border-top-color",
47 |  * ]
48 |  *
49 |  * @example
50 |  * getShorthandComputedProperties('color') ->
51 |  * ["color"]
52 |  *
53 |  * @example
54 |  * getShorthandComputedProperties('unknownProperty') ->
55 |  * []
56 |  */
57 | module.exports = function getShorthandComputedProperties(shorthandProperty, recursivelyResolve = false) {
58 |   if (properties[shorthandProperty]) {
59 |     if (Array.isArray(properties[shorthandProperty].computed)) {
60 |       const computedProperties = properties[shorthandProperty].computed;
61 | 
62 |       return recursivelyResolve
63 |         ? computedProperties.concat(...computedProperties
64 |           .filter(property => Array.isArray(properties[property].computed))
65 |           .map(property => getShorthandComputedProperties(property, true))
66 |         )
67 |         : computedProperties;
68 |     }
69 | 
70 |     return [shorthandProperty];
71 |   }
72 | 
73 |   return [];
74 | };
75 | 


--------------------------------------------------------------------------------
/src/getShorthandsForProperty.js:
--------------------------------------------------------------------------------
 1 | const shortHandProperties = require('./formatted-data/shorthand-properties.json');
 2 | const properties = require('./formatted-data/properties.json');
 3 | 
 4 | /**
 5 |  * @type {Object}
 6 |  */
 7 | const inverseMapping = {};
 8 | 
 9 | function computeInverseMapping() {
10 |   const shorthands = Object.keys(shortHandProperties);
11 |   shorthands.forEach((shorthand) => {
12 |     const longhands = shortHandProperties[shorthand].computed;
13 |     longhands.forEach((longhand) => {
14 |       if (inverseMapping[longhand]) {
15 |         inverseMapping[longhand].push(shorthand);
16 |       } else {
17 |         inverseMapping[longhand] = [shorthand];
18 |       }
19 |     });
20 |   });
21 |   const longhands = Object.keys(inverseMapping);
22 |   longhands.forEach((longhand) => {
23 |     inverseMapping[longhand].forEach((shorthand) => {
24 |       if (inverseMapping[shorthand]) {
25 |         inverseMapping[longhand].push(...inverseMapping[shorthand]);
26 |       }
27 |     });
28 |   });
29 | }
30 | 
31 | /**
32 |  * Return a list of all properties that set the given property.
33 |  * Includes at least the value provided, plus any other shorthands that can
34 |  * set it.
35 |  * @param {string} property - the property name
36 |  * @return {Array<string>} all properties that set this property.
37 |  * @example
38 |  *   console.log(getShorthandsForProperty('border-left-width'));
39 |  *   // => [ 'border-left-width', 'border-left', 'border-width', 'border' ]
40 |  */
41 | module.exports = function getShorthandsForProperty(property) {
42 |   if (!inverseMapping['background-image']) computeInverseMapping();
43 |   if (!properties[property]) return [];
44 |   return [property, ...(inverseMapping[property] || [])];
45 | };
46 | 


--------------------------------------------------------------------------------
/src/grammars/LICENSE:
--------------------------------------------------------------------------------
1 | This Source Code Form is subject to the terms of the Mozilla Public License,
2 | v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
3 | one at https://mozilla.org/MPL/2.0/.


--------------------------------------------------------------------------------
/src/grammars/js/formalSyntax.js:
--------------------------------------------------------------------------------
  1 | // Generated automatically by nearley, version 2.11.1
  2 | // http://github.com/Hardmath123/nearley
  3 | (function () {
  4 | function id(x) { return x[0]; }
  5 | var grammar = {
  6 |     Lexer: undefined,
  7 |     ParserRules: [
  8 |     {"name": "_$ebnf$1", "symbols": []},
  9 |     {"name": "_$ebnf$1", "symbols": ["_$ebnf$1", "wschar"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 10 |     {"name": "_", "symbols": ["_$ebnf$1"], "postprocess": function(d) {return null;}},
 11 |     {"name": "__$ebnf$1", "symbols": ["wschar"]},
 12 |     {"name": "__$ebnf$1", "symbols": ["__$ebnf$1", "wschar"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 13 |     {"name": "__", "symbols": ["__$ebnf$1"], "postprocess": function(d) {return null;}},
 14 |     {"name": "wschar", "symbols": [/[ \t\n\v\f]/], "postprocess": id},
 15 |     {"name": "unsigned_int$ebnf$1", "symbols": [/[0-9]/]},
 16 |     {"name": "unsigned_int$ebnf$1", "symbols": ["unsigned_int$ebnf$1", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 17 |     {"name": "unsigned_int", "symbols": ["unsigned_int$ebnf$1"], "postprocess": 
 18 |         function(d) {
 19 |             return parseInt(d[0].join(""));
 20 |         }
 21 |         },
 22 |     {"name": "int$ebnf$1$subexpression$1", "symbols": [{"literal":"-"}]},
 23 |     {"name": "int$ebnf$1$subexpression$1", "symbols": [{"literal":"+"}]},
 24 |     {"name": "int$ebnf$1", "symbols": ["int$ebnf$1$subexpression$1"], "postprocess": id},
 25 |     {"name": "int$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
 26 |     {"name": "int$ebnf$2", "symbols": [/[0-9]/]},
 27 |     {"name": "int$ebnf$2", "symbols": ["int$ebnf$2", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 28 |     {"name": "int", "symbols": ["int$ebnf$1", "int$ebnf$2"], "postprocess": 
 29 |         function(d) {
 30 |             if (d[0]) {
 31 |                 return parseInt(d[0][0]+d[1].join(""));
 32 |             } else {
 33 |                 return parseInt(d[1].join(""));
 34 |             }
 35 |         }
 36 |         },
 37 |     {"name": "unsigned_decimal$ebnf$1", "symbols": [/[0-9]/]},
 38 |     {"name": "unsigned_decimal$ebnf$1", "symbols": ["unsigned_decimal$ebnf$1", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 39 |     {"name": "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1", "symbols": [/[0-9]/]},
 40 |     {"name": "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1", "symbols": ["unsigned_decimal$ebnf$2$subexpression$1$ebnf$1", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 41 |     {"name": "unsigned_decimal$ebnf$2$subexpression$1", "symbols": [{"literal":"."}, "unsigned_decimal$ebnf$2$subexpression$1$ebnf$1"]},
 42 |     {"name": "unsigned_decimal$ebnf$2", "symbols": ["unsigned_decimal$ebnf$2$subexpression$1"], "postprocess": id},
 43 |     {"name": "unsigned_decimal$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},
 44 |     {"name": "unsigned_decimal", "symbols": ["unsigned_decimal$ebnf$1", "unsigned_decimal$ebnf$2"], "postprocess": 
 45 |         function(d) {
 46 |             return parseFloat(
 47 |                 d[0].join("") +
 48 |                 (d[1] ? "."+d[1][1].join("") : "")
 49 |             );
 50 |         }
 51 |         },
 52 |     {"name": "decimal$ebnf$1", "symbols": [{"literal":"-"}], "postprocess": id},
 53 |     {"name": "decimal$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
 54 |     {"name": "decimal$ebnf$2", "symbols": [/[0-9]/]},
 55 |     {"name": "decimal$ebnf$2", "symbols": ["decimal$ebnf$2", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 56 |     {"name": "decimal$ebnf$3$subexpression$1$ebnf$1", "symbols": [/[0-9]/]},
 57 |     {"name": "decimal$ebnf$3$subexpression$1$ebnf$1", "symbols": ["decimal$ebnf$3$subexpression$1$ebnf$1", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 58 |     {"name": "decimal$ebnf$3$subexpression$1", "symbols": [{"literal":"."}, "decimal$ebnf$3$subexpression$1$ebnf$1"]},
 59 |     {"name": "decimal$ebnf$3", "symbols": ["decimal$ebnf$3$subexpression$1"], "postprocess": id},
 60 |     {"name": "decimal$ebnf$3", "symbols": [], "postprocess": function(d) {return null;}},
 61 |     {"name": "decimal", "symbols": ["decimal$ebnf$1", "decimal$ebnf$2", "decimal$ebnf$3"], "postprocess": 
 62 |         function(d) {
 63 |             return parseFloat(
 64 |                 (d[0] || "") +
 65 |                 d[1].join("") +
 66 |                 (d[2] ? "."+d[2][1].join("") : "")
 67 |             );
 68 |         }
 69 |         },
 70 |     {"name": "percentage", "symbols": ["decimal", {"literal":"%"}], "postprocess": 
 71 |         function(d) {
 72 |             return d[0]/100;
 73 |         }
 74 |         },
 75 |     {"name": "jsonfloat$ebnf$1", "symbols": [{"literal":"-"}], "postprocess": id},
 76 |     {"name": "jsonfloat$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
 77 |     {"name": "jsonfloat$ebnf$2", "symbols": [/[0-9]/]},
 78 |     {"name": "jsonfloat$ebnf$2", "symbols": ["jsonfloat$ebnf$2", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 79 |     {"name": "jsonfloat$ebnf$3$subexpression$1$ebnf$1", "symbols": [/[0-9]/]},
 80 |     {"name": "jsonfloat$ebnf$3$subexpression$1$ebnf$1", "symbols": ["jsonfloat$ebnf$3$subexpression$1$ebnf$1", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 81 |     {"name": "jsonfloat$ebnf$3$subexpression$1", "symbols": [{"literal":"."}, "jsonfloat$ebnf$3$subexpression$1$ebnf$1"]},
 82 |     {"name": "jsonfloat$ebnf$3", "symbols": ["jsonfloat$ebnf$3$subexpression$1"], "postprocess": id},
 83 |     {"name": "jsonfloat$ebnf$3", "symbols": [], "postprocess": function(d) {return null;}},
 84 |     {"name": "jsonfloat$ebnf$4$subexpression$1$ebnf$1", "symbols": [/[+-]/], "postprocess": id},
 85 |     {"name": "jsonfloat$ebnf$4$subexpression$1$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
 86 |     {"name": "jsonfloat$ebnf$4$subexpression$1$ebnf$2", "symbols": [/[0-9]/]},
 87 |     {"name": "jsonfloat$ebnf$4$subexpression$1$ebnf$2", "symbols": ["jsonfloat$ebnf$4$subexpression$1$ebnf$2", /[0-9]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
 88 |     {"name": "jsonfloat$ebnf$4$subexpression$1", "symbols": [/[eE]/, "jsonfloat$ebnf$4$subexpression$1$ebnf$1", "jsonfloat$ebnf$4$subexpression$1$ebnf$2"]},
 89 |     {"name": "jsonfloat$ebnf$4", "symbols": ["jsonfloat$ebnf$4$subexpression$1"], "postprocess": id},
 90 |     {"name": "jsonfloat$ebnf$4", "symbols": [], "postprocess": function(d) {return null;}},
 91 |     {"name": "jsonfloat", "symbols": ["jsonfloat$ebnf$1", "jsonfloat$ebnf$2", "jsonfloat$ebnf$3", "jsonfloat$ebnf$4"], "postprocess": 
 92 |         function(d) {
 93 |             return parseFloat(
 94 |                 (d[0] || "") +
 95 |                 d[1].join("") +
 96 |                 (d[2] ? "."+d[2][1].join("") : "") +
 97 |                 (d[3] ? "e" + (d[3][1] || "+") + d[3][2].join("") : "")
 98 |             );
 99 |         }
100 |         },
101 |     {"name": "dqstring$ebnf$1", "symbols": []},
102 |     {"name": "dqstring$ebnf$1", "symbols": ["dqstring$ebnf$1", "dstrchar"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
103 |     {"name": "dqstring", "symbols": [{"literal":"\""}, "dqstring$ebnf$1", {"literal":"\""}], "postprocess": function(d) {return d[1].join(""); }},
104 |     {"name": "sqstring$ebnf$1", "symbols": []},
105 |     {"name": "sqstring$ebnf$1", "symbols": ["sqstring$ebnf$1", "sstrchar"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
106 |     {"name": "sqstring", "symbols": [{"literal":"'"}, "sqstring$ebnf$1", {"literal":"'"}], "postprocess": function(d) {return d[1].join(""); }},
107 |     {"name": "btstring$ebnf$1", "symbols": []},
108 |     {"name": "btstring$ebnf$1", "symbols": ["btstring$ebnf$1", /[^`]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
109 |     {"name": "btstring", "symbols": [{"literal":"`"}, "btstring$ebnf$1", {"literal":"`"}], "postprocess": function(d) {return d[1].join(""); }},
110 |     {"name": "dstrchar", "symbols": [/[^\\"\n]/], "postprocess": id},
111 |     {"name": "dstrchar", "symbols": [{"literal":"\\"}, "strescape"], "postprocess": 
112 |         function(d) {
113 |             return JSON.parse("\""+d.join("")+"\"");
114 |         }
115 |         },
116 |     {"name": "sstrchar", "symbols": [/[^\\'\n]/], "postprocess": id},
117 |     {"name": "sstrchar", "symbols": [{"literal":"\\"}, "strescape"], "postprocess": function(d) { return JSON.parse("\""+d.join("")+"\""); }},
118 |     {"name": "sstrchar$string$1", "symbols": [{"literal":"\\"}, {"literal":"'"}], "postprocess": function joiner(d) {return d.join('');}},
119 |     {"name": "sstrchar", "symbols": ["sstrchar$string$1"], "postprocess": function(d) {return "'"; }},
120 |     {"name": "strescape", "symbols": [/["\\\/bfnrt]/], "postprocess": id},
121 |     {"name": "strescape", "symbols": [{"literal":"u"}, /[a-fA-F0-9]/, /[a-fA-F0-9]/, /[a-fA-F0-9]/, /[a-fA-F0-9]/], "postprocess": 
122 |         function(d) {
123 |             return d.join("");
124 |         }
125 |         },
126 |     {"name": "Exp", "symbols": ["SingleBarList"], "postprocess": id},
127 |     {"name": "Combinator", "symbols": ["Brackets", {"literal":"*"}], "postprocess": function (d) { return { nodeName: 'Asterisk', values: [d[0]] }; }},
128 |     {"name": "Combinator", "symbols": ["Brackets", {"literal":"+"}], "postprocess": function (d) { return { nodeName: 'Plus', values: [d[0]] }; }},
129 |     {"name": "Combinator", "symbols": ["Brackets", {"literal":"?"}], "postprocess": function (d) { return { nodeName: 'QuestionMark', values: [d[0]] }; }},
130 |     {"name": "Combinator$ebnf$1", "symbols": [{"literal":","}], "postprocess": id},
131 |     {"name": "Combinator$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
132 |     {"name": "Combinator$ebnf$2", "symbols": ["unsigned_int"], "postprocess": id},
133 |     {"name": "Combinator$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},
134 |     {"name": "Combinator", "symbols": ["Brackets", {"literal":"{"}, "unsigned_int", "_", "Combinator$ebnf$1", "_", "Combinator$ebnf$2", {"literal":"}"}], "postprocess":  function (d, l, r) {
135 |             if(d[0] && d[0].nodeName === 'HashMark') return r;
136 |         
137 |             return { nodeName: 'CurlyBraces', values: [d[0], d[2], d[4], d[6]] };
138 |         } },
139 |     {"name": "Combinator$string$1", "symbols": [{"literal":"#"}, {"literal":"{"}], "postprocess": function joiner(d) {return d.join('');}},
140 |     {"name": "Combinator$ebnf$3", "symbols": [{"literal":","}], "postprocess": id},
141 |     {"name": "Combinator$ebnf$3", "symbols": [], "postprocess": function(d) {return null;}},
142 |     {"name": "Combinator", "symbols": ["Brackets", "Combinator$string$1", "unsigned_int", "_", "Combinator$ebnf$3", {"literal":"}"}], "postprocess": function (d) { return { nodeName: 'CurlyHash', values: [d[0], d[2], d[4]] }; }},
143 |     {"name": "Combinator", "symbols": ["Brackets", {"literal":"#"}], "postprocess": function (d) { return { nodeName: 'HashMark', values: [d[0]] }; }},
144 |     {"name": "Combinator", "symbols": ["terminal"], "postprocess": id},
145 |     {"name": "SingleBarList$ebnf$1$subexpression$1", "symbols": ["DoubleBarList", "__", {"literal":"|"}, "__"]},
146 |     {"name": "SingleBarList$ebnf$1", "symbols": ["SingleBarList$ebnf$1$subexpression$1"]},
147 |     {"name": "SingleBarList$ebnf$1$subexpression$2", "symbols": ["DoubleBarList", "__", {"literal":"|"}, "__"]},
148 |     {"name": "SingleBarList$ebnf$1", "symbols": ["SingleBarList$ebnf$1", "SingleBarList$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
149 |     {"name": "SingleBarList", "symbols": ["SingleBarList$ebnf$1", "DoubleBarList"], "postprocess":  function (d) {
150 |           return {
151 |             nodeName: 'SingleBarList',
152 |             values: [d[0], d[1]],
153 |           };
154 |         } },
155 |     {"name": "SingleBarList", "symbols": ["DoubleBarList"], "postprocess": id},
156 |     {"name": "DoubleBarList$ebnf$1$subexpression$1$string$1", "symbols": [{"literal":"|"}, {"literal":"|"}], "postprocess": function joiner(d) {return d.join('');}},
157 |     {"name": "DoubleBarList$ebnf$1$subexpression$1", "symbols": ["DoubleAmpersand", "__", "DoubleBarList$ebnf$1$subexpression$1$string$1", "__"]},
158 |     {"name": "DoubleBarList$ebnf$1", "symbols": ["DoubleBarList$ebnf$1$subexpression$1"]},
159 |     {"name": "DoubleBarList$ebnf$1$subexpression$2$string$1", "symbols": [{"literal":"|"}, {"literal":"|"}], "postprocess": function joiner(d) {return d.join('');}},
160 |     {"name": "DoubleBarList$ebnf$1$subexpression$2", "symbols": ["DoubleAmpersand", "__", "DoubleBarList$ebnf$1$subexpression$2$string$1", "__"]},
161 |     {"name": "DoubleBarList$ebnf$1", "symbols": ["DoubleBarList$ebnf$1", "DoubleBarList$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
162 |     {"name": "DoubleBarList", "symbols": ["DoubleBarList$ebnf$1", "DoubleAmpersand"], "postprocess": function (d) { return { nodeName: 'DoubleBarList', values: [d[0], d[1]] }; }},
163 |     {"name": "DoubleBarList", "symbols": ["DoubleAmpersand"], "postprocess": id},
164 |     {"name": "DoubleAmpersand$subexpression$1$string$1", "symbols": [{"literal":"&"}, {"literal":"&"}], "postprocess": function joiner(d) {return d.join('');}},
165 |     {"name": "DoubleAmpersand$subexpression$1", "symbols": ["DoubleAmpersand", "__", "DoubleAmpersand$subexpression$1$string$1", "__", "Juxtaposition"]},
166 |     {"name": "DoubleAmpersand", "symbols": ["DoubleAmpersand$subexpression$1"], "postprocess":  function (d) {
167 |           return {
168 |             nodeName: 'DoubleAmpersand',
169 |             values: [d[0][0], d[0][4]],
170 |           };
171 |         } },
172 |     {"name": "DoubleAmpersand", "symbols": ["Juxtaposition"], "postprocess": id},
173 |     {"name": "Juxtaposition$subexpression$1", "symbols": ["Juxtaposition", "__", "Comma"]},
174 |     {"name": "Juxtaposition", "symbols": ["Juxtaposition$subexpression$1"], "postprocess":  function (d) {
175 |           return {
176 |             nodeName: 'Juxtaposition',
177 |             values: [d[0][0], d[0][2]],
178 |           };
179 |         } },
180 |     {"name": "Juxtaposition", "symbols": ["Comma"], "postprocess": id},
181 |     {"name": "Comma$subexpression$1", "symbols": ["Comma", "_", {"literal":","}, "_", "terminal"]},
182 |     {"name": "Comma", "symbols": ["Comma$subexpression$1"], "postprocess":  function (d) {
183 |           return {
184 |             nodeName: 'Comma',
185 |             values: [d[0][0], d[0][4]],
186 |           };
187 |         } },
188 |     {"name": "Comma", "symbols": ["Brackets"], "postprocess": id},
189 |     {"name": "Brackets", "symbols": [{"literal":"["}, "_", "SingleBarList", "_", {"literal":"]"}], "postprocess":  function (d) {
190 |           return {
191 |             nodeName: 'Brackets',
192 |             values: [d[2]],
193 |           };
194 |         } },
195 |     {"name": "Brackets", "symbols": ["Combinator"], "postprocess": id},
196 |     {"name": "terminal$ebnf$1", "symbols": [{"literal":"'"}], "postprocess": id},
197 |     {"name": "terminal$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
198 |     {"name": "terminal$ebnf$2", "symbols": [{"literal":"'"}], "postprocess": id},
199 |     {"name": "terminal$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},
200 |     {"name": "terminal", "symbols": [{"literal":"<"}, "terminal$ebnf$1", "nodeName", "terminal$ebnf$2", {"literal":">"}], "postprocess":  function (d) {
201 |           return {
202 |             nodeName: 'node',
203 |             values: [d.length === 5 ? d[2] : d[1]],
204 |           };
205 |         } },
206 |     {"name": "terminal$ebnf$3", "symbols": [/[a-zA-Z0-9@\-(),\/{}:;%]/]},
207 |     {"name": "terminal$ebnf$3", "symbols": ["terminal$ebnf$3", /[a-zA-Z0-9@\-(),\/{}:;%]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
208 |     {"name": "terminal", "symbols": ["terminal$ebnf$3"], "postprocess": function (d) { return `"${d[0].join('')}"`; }},
209 |     {"name": "terminal$ebnf$4", "symbols": [/[^'"]/]},
210 |     {"name": "terminal$ebnf$4", "symbols": ["terminal$ebnf$4", /[^'"]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
211 |     {"name": "terminal", "symbols": [/['"']/, "terminal$ebnf$4", /['"']/], "postprocess": function (d) { return { nodeName: 'quotedLiteral', values: [ d[1].join('')] } }},
212 |     {"name": "nodeName$ebnf$1", "symbols": [/[a-zA-Z0-9\-()]/]},
213 |     {"name": "nodeName$ebnf$1", "symbols": ["nodeName$ebnf$1", /[a-zA-Z0-9\-()]/], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
214 |     {"name": "nodeName", "symbols": ["nodeName$ebnf$1"], "postprocess": function (d) { return d[0].join('') }}
215 | ]
216 |   , ParserStart: "Exp"
217 | }
218 | if (typeof module !== 'undefined'&& typeof module.exports !== 'undefined') {
219 |    module.exports = grammar;
220 | } else {
221 |    window.grammar = grammar;
222 | }
223 | })();
224 | 


--------------------------------------------------------------------------------
/src/grammars/json/an-plus-b.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "( an | b | anb )"],
3 |   ["an", "<integer> \"n\""],
4 |   ["b", "<integer>"],
5 |   ["anb", "<integer> \"n\" _ \"+\" _ <integer>"],
6 |   ["<integer>"]
7 | ]


--------------------------------------------------------------------------------
/src/grammars/json/angle.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "<number> <angle-unit>"],
3 |   ["<number>"],
4 |   ["<angle-unit>"]
5 | ]


--------------------------------------------------------------------------------
/src/grammars/json/any-value.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[^ ]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/attr-fallback.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[^ ]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/attr-name.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[^ ]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/background.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   [
 3 |     "Base",
 4 |     "( <bg-layer> _ \",\" _ ):* <final-bg-layer>"
 5 |   ],
 6 |   [
 7 |     "<bg-layer>"
 8 |   ],
 9 |   [
10 |     "<final-bg-layer>"
11 |   ]
12 | ]


--------------------------------------------------------------------------------
/src/grammars/json/color.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   [
 3 |     "Base",
 4 |     "( %color | <named-color> | <deprecated-system-color> | \"currentcolor\" )"
 5 |   ],
 6 |   [
 7 |     "<named-color>"
 8 |   ],
 9 |   [
10 |     "<deprecated-system-color>"
11 |   ]
12 | ]


--------------------------------------------------------------------------------
/src/grammars/json/cubic-bezier-timing-function.json:
--------------------------------------------------------------------------------
1 | [
2 |   [
3 |     "Base",
4 |     "( \"ease\" | \"ease-in\" | \"ease-out\" | \"ease-in-out\" | \"cubic-bezier(\" _ <number> _ \",\" _ <number> _ \",\" _ <number> _ \",\" _ <number> _ \")\" )"
5 |   ],
6 |   [
7 |     "<number>"
8 |   ]
9 | ]


--------------------------------------------------------------------------------
/src/grammars/json/custom-ident.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "%customIdent"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/custom-property-name.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"--\" [a-zA-Z0-9\\-_]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/declaration-list.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[^ ]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/declaration-value.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[^ ]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/declaration.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[^ ]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/dimension.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "( <length> | <frequency> | <angle> | <resolution> | <time> )"],
3 |   ["<length>"],
4 |   ["<frequency>"],
5 |   ["<angle>"],
6 |   ["<resolution>"],
7 |   ["<time>"]
8 | ]


--------------------------------------------------------------------------------
/src/grammars/json/feature-value-declaration.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   [
 3 |     "Base",
 4 |     "<custom-ident> \":\" <integer>:+ \";\""
 5 |   ],
 6 |   [
 7 |     "<custom-ident>"
 8 |   ],
 9 |   [
10 |     "<integer>"
11 |   ]
12 | ]


--------------------------------------------------------------------------------
/src/grammars/json/final-bg-layer.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   [
 3 |     "Base",
 4 |     "( <bg-image> | ( <position> ( _ \"/\" _ <bg-size> ):? ) | <repeat-style> | <attachment> | <box> | <box> | <background-color> ) ( __ ( <bg-image> | ( <position> ( _ \"/\" _ <bg-size> ):? ) | <repeat-style> | <attachment> | <box> | <box> | <background-color> ) ):*"
 5 |   ],
 6 |   [
 7 |     "<bg-image>"
 8 |   ],
 9 |   [
10 |     "<position>"
11 |   ],
12 |   [
13 |     "<bg-size>"
14 |   ],
15 |   [
16 |     "<repeat-style>"
17 |   ],
18 |   [
19 |     "<attachment>"
20 |   ],
21 |   [
22 |     "<box>"
23 |   ],
24 |   [
25 |     "<background-color>"
26 |   ]
27 | ]


--------------------------------------------------------------------------------
/src/grammars/json/flex.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   [
 3 |     "Base",
 4 |     "( oneValueSyntax | twoValueSyntax | threeValueSyntax )"
 5 |   ],
 6 |   [
 7 |     "oneValueSyntax",
 8 |     "( \"auto\" | \"initial\" | \"none\" | <flex-basis> | <flex-grow> )"
 9 |   ],
10 |   [
11 |     "twoValueSyntax",
12 |     "( <flex-grow> __ ( <flex-basis> | <flex-shrink> ) )"
13 |   ],
14 |   [
15 |     "threeValueSyntax",
16 |     "( <flex-grow> __ <flex-shrink> __ <flex-basis> )"
17 |   ],
18 |   [
19 |     "<number>"
20 |   ],
21 |   [
22 |     "<flex-basis>"
23 |   ],
24 |   [
25 |     "<flex-grow>"
26 |   ],
27 |   [
28 |     "<flex-shrink>"
29 |   ]
30 | ]


--------------------------------------------------------------------------------
/src/grammars/json/frames-timing-function.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"frames(\" <integer> \")\""],
3 |   ["<integer>"]
4 | ]


--------------------------------------------------------------------------------
/src/grammars/json/frequency.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "( <number> <frequency-unit> )"],
3 |   ["<number>"],
4 |   ["<frequency-unit>"]
5 | ]


--------------------------------------------------------------------------------
/src/grammars/json/function-token.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[^ ]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/hex-color.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "%color"]
3 | ]
4 | 


--------------------------------------------------------------------------------
/src/grammars/json/hsl().json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"hsl(\" _ ( ( <hue> __ <percentage> __ <percentage> ( _ \"/\" _ <alpha-value> ):? ) | ( <hue> _ \",\" _ <percentage> _ \",\" _ <percentage> ( _ \",\" _ <alpha-value> ):? ) ) _ \")\""],
3 |   ["<hue>"],
4 |   ["<percentage>"],
5 |   ["<alpha-value>"]
6 | ]
7 | 
8 | 


--------------------------------------------------------------------------------
/src/grammars/json/hsla().json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"hsla(\" _ ( ( <hue> __ <percentage> __ <percentage> ( _ \"/\" _ <alpha-value> ):? ) | ( <hue> _ \",\" _ <percentage> _ \",\" _ <percentage> ( _ \",\" _ <alpha-value> ):? ) ) _ \")\""],
3 |   ["<hue>"],
4 |   ["<percentage>"],
5 |   ["<alpha-value>"]
6 | ]
7 | 
8 | 


--------------------------------------------------------------------------------
/src/grammars/json/id-selector.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "( \"#\" [^ ]:+ )"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/ident.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[^ ]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/image().json:
--------------------------------------------------------------------------------
 1 | [
 2 |   [
 3 |     "Base",
 4 |     "\"image(\" _ ( inner1 | inner2 | inner3 ) _ \")\""
 5 |   ],
 6 |   [
 7 |     "inner1",
 8 |     "( <image> | <string> )"
 9 |   ],
10 |   [
11 |     "inner2",
12 |     "<color>"
13 |   ],
14 |   [
15 |     "inner3",
16 |     "( <image> | <string> ) _  \",\" _ <color>"
17 |   ],
18 |   [
19 |     "<image>"
20 |   ],
21 |   [
22 |     "<string>"
23 |   ],
24 |   [
25 |     "<color>"
26 |   ]
27 | ]


--------------------------------------------------------------------------------
/src/grammars/json/integer.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "%integer"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/length.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   [
 3 |     "Base",
 4 |     "( numberWithUnit | \"0\" )"
 5 |   ],
 6 |   [
 7 |     "numberWithUnit",
 8 |     "<number> <length-unit>"
 9 |   ],
10 |   [
11 |     "<number>"
12 |   ],
13 |   [
14 |     "<length-unit>"
15 |   ]
16 | ]


--------------------------------------------------------------------------------
/src/grammars/json/name-repeat.json:
--------------------------------------------------------------------------------
1 | [
2 |   [
3 |     "Base",
4 |     "[a-zA-Z]:+"
5 |   ]
6 | ]


--------------------------------------------------------------------------------
/src/grammars/json/number.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "( %number | <integer> )"],
3 |   ["<integer>"]
4 | ]
5 | 


--------------------------------------------------------------------------------
/src/grammars/json/outline-radius.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "<length> | <percentage>"],
3 |   ["<length>"],
4 |   ["<percentage>"]
5 | ]


--------------------------------------------------------------------------------
/src/grammars/json/path().json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"path(\" \"'\" [^']:+ \"'\" \")\""]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/percentage.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "<number> \"%\""],
3 |   ["<number>"]
4 | ]


--------------------------------------------------------------------------------
/src/grammars/json/positive-integer.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"+\":? [0-9]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/ratio.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "[0-9]:+ \"/\" [0-9]:+"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/resolution.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "<number> <resolution-unit>"],
3 |   ["<number>"],
4 |   ["<resolution-unit>"]
5 | ]


--------------------------------------------------------------------------------
/src/grammars/json/rgb().json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"rgb(\" _ ( ( ( <percentage> __ <percentage> __ <percentage> ) | ( <integer> __ <integer> __ <integer> ) ( _ \"/\" _ <alpha-value> ):? ) |  ( ( <percentage> _ \",\" _ <percentage> _ \",\" _ <percentage> ) | ( <integer> _ \",\" _ <integer> _ \",\" _ <integer> ) ( _ \",\" _ <alpha-value> ):? ) ) _ \")\""],
3 |   ["<integer>"],
4 |   ["<percentage>"],
5 |   ["<alpha-value>"]
6 | ]


--------------------------------------------------------------------------------
/src/grammars/json/rgba().json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"rgba(\" _ ( ( ( <percentage> __ <percentage> __ <percentage> ) | ( <integer> __ <integer> __ <integer> ) ( _ \"/\" _ <alpha-value> ):? ) |  ( ( <percentage> _ \",\" _ <percentage> _ \",\" _ <percentage> ) | ( <integer> _ \",\" _ <integer> _ \",\" _ <integer> ) ( _ \",\" _ <alpha-value> ):? ) ) _ \")\""],
3 |   ["<integer>"],
4 |   ["<percentage>"],
5 |   ["<alpha-value>"]
6 | ]


--------------------------------------------------------------------------------
/src/grammars/json/shape.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "\"rect(\" _ <length> _ \",\" _ <length> _ \",\" _ <length> _ \",\" _ <length> _ \")\""],
3 |   ["<length>"]
4 | ]


--------------------------------------------------------------------------------
/src/grammars/json/string.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "%string"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/time.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "<number> <time-unit>"],
3 |   ["<number>"],
4 |   ["<time-unit>"]
5 | ]


--------------------------------------------------------------------------------
/src/grammars/json/url.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "( \"url(\" [^)]:* \")\" )"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/x.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "( \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" | \"10\" | \"11\" | \"12\" | \"13\" | \"14\" | \"15\" | \"16\" | \"17\" | \"18\" | \"19\" | \"20\" | \"21\" | \"22\" | \"23\" | \"24\" | \"25\" | \"26\" | \"27\" | \"28\" | \"29\" | \"30\" | \"31\" )"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/json/y.json:
--------------------------------------------------------------------------------
1 | [
2 |   ["Base", "( \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" | \"10\" | \"11\" | \"12\" | \"13\" | \"14\" | \"15\" | \"16\" | \"17\" | \"18\" | \"19\" | \"20\" | \"21\" | \"22\" | \"23\" | \"24\" | \"25\" | \"26\" | \"27\" | \"28\" | \"29\" | \"30\" | \"31\" )"]
3 | ]


--------------------------------------------------------------------------------
/src/grammars/nearley/formalSyntax.ne:
--------------------------------------------------------------------------------
 1 | @builtin "whitespace.ne"
 2 | @builtin "number.ne"
 3 | @builtin "string.ne"
 4 | 
 5 | Exp ->  SingleBarList {% id %}
 6 | 
 7 | 
 8 | Combinator ->   Brackets "*" {% function (d) { return { nodeName: 'Asterisk', values: [d[0]] }; } %}
 9 |              |  Brackets "+" {% function (d) { return { nodeName: 'Plus', values: [d[0]] }; } %}
10 |              |  Brackets "?" {% function (d) { return { nodeName: 'QuestionMark', values: [d[0]] }; } %}
11 |              |  Brackets "{" unsigned_int _ ",":? _ unsigned_int:? "}" {% function (d, l, r) {
12 |                                                                             if(d[0] && d[0].nodeName === 'HashMark') return r;
13 | 
14 |                                                                             return { nodeName: 'CurlyBraces', values: [d[0], d[2], d[4], d[6]] };
15 |                                                                         } %}
16 |              |  Brackets "#{" unsigned_int _ ",":? "}" {% function (d) { return { nodeName: 'CurlyHash', values: [d[0], d[2], d[4]] }; } %}
17 |              |  Brackets "#" {% function (d) { return { nodeName: 'HashMark', values: [d[0]] }; } %}
18 |              |  terminal {% id %}
19 | 
20 | SingleBarList -> ( DoubleBarList __ "|" __ ):+ DoubleBarList {% function (d) {
21 |                                                   return {
22 |                                                     nodeName: 'SingleBarList',
23 |                                                     values: [d[0], d[1]],
24 |                                                   };
25 |                                                 } %}
26 |             | DoubleBarList {% id %}
27 | 
28 | DoubleBarList -> (DoubleAmpersand __ "||" __):+ DoubleAmpersand {% function (d) { return { nodeName: 'DoubleBarList', values: [d[0], d[1]] }; } %}
29 |                  | DoubleAmpersand {% id %}
30 | 
31 | DoubleAmpersand -> ( DoubleAmpersand __ "&&" __ Juxtaposition ) {% function (d) {
32 |                                                                   return {
33 |                                                                     nodeName: 'DoubleAmpersand',
34 |                                                                     values: [d[0][0], d[0][4]],
35 |                                                                   };
36 |                                                                 } %}
37 |                    | Juxtaposition {% id %}
38 | 
39 | 
40 | Juxtaposition -> ( Juxtaposition __ Comma ) {% function (d) {
41 |                                                    return {
42 |                                                      nodeName: 'Juxtaposition',
43 |                                                      values: [d[0][0], d[0][2]],
44 |                                                    };
45 |                                                  } %}
46 |                  | Comma {% id %}
47 | 
48 | Comma -> ( Comma _ "," _ terminal ) {% function (d) {
49 |                                      return {
50 |                                        nodeName: 'Comma',
51 |                                        values: [d[0][0], d[0][4]],
52 |                                      };
53 |                                    } %}
54 |         | Brackets {% id %}
55 | 
56 | Brackets -> "[" _ SingleBarList _ "]" {% function (d) {
57 |                                 return {
58 |                                   nodeName: 'Brackets',
59 |                                   values: [d[2]],
60 |                                 };
61 |                               } %}
62 |           | Combinator {% id %}
63 | 
64 | 
65 | terminal -> "<" "'":? nodeName "'":? ">" {% function (d) {
66 |                                            return {
67 |                                              nodeName: 'node',
68 |                                              values: [d.length === 5 ? d[2] : d[1]],
69 |                                            };
70 |                                          } %}
71 |             | [a-zA-Z0-9@\-(),/{}:;%]:+ {% function (d) { return `"${d[0].join('')}"`; } %}
72 |             | ['"'] [^'"]:+ ['"'] {% function (d) { return { nodeName: 'quotedLiteral', values: [ d[1].join('')] } } %}
73 | 
74 | nodeName -> [a-zA-Z0-9\-()]:+ {% function (d) { return d[0].join('') } %}


--------------------------------------------------------------------------------
/src/grammars/nearley/properties/animation.ne:
--------------------------------------------------------------------------------
 1 | @builtin "whitespace.ne"
 2 | 
 3 | @{%
 4 |   const moo = require("moo");
 5 | 
 6 |   const lexer = moo.compile({
 7 |     singleTimingFunction: ["linear", "ease", "ease-in", "ease-out", "ease-in-out"],
 8 |     none: "none",
 9 |     all: "all",
10 |     infinite: "infinite",
11 |     singleAnimationDirection: ["normal", "reverse", "alternate", "alternate-reverse"],
12 |     singleAnimationFillMode: ["none", "forwards", "backwards", "both"],
13 |     singleAnimationPlayState: ["running", "paused"],
14 |     functionStart: /[a-zA-Z\-]+\(/,
15 |     ident: {
16 |       match: /[a-zA-Z_][a-zA-Z0-9\-_]*/,
17 |       keywords: {
18 |         singleTimingFunction: ["linear", "ease", "ease-in", "ease-out", "ease-in-out"],
19 |         none: "none",
20 |         all: "all",
21 |         infinite: "infinite",
22 |         singleAnimationDirection: ["normal", "reverse", "alternate", "alternate-reverse"],
23 |         singleAnimationFillMode: ["none", "forwards", "backwards", "both"],
24 |         singleAnimationPlayState: ["running", "paused"],
25 |         timeUnit: ["s", "ms"],
26 |       }
27 |     },
28 |     string: /(?:"[^"]*")|(?:'[^']*')/,
29 |     number: /(?:\+|\-)?(?:[0-9]+\.[0-9]*)|(?:[0-9]*\.[0-9]+)/,
30 |     integer: /(?:\+|\-)?[0-9]+/,
31 |     timeUnit: ["s", "ms"],
32 |     char: /./,
33 |   });
34 | %}
35 | 
36 | @lexer lexer
37 | 
38 | Base -> ( ( SingleAnimation _ "," _):* SingleAnimation ) {% function (data,location) { return { name: 'Base', values: data.filter(Boolean), location }; } %}
39 | SingleAnimation -> ( Time | SingleTimingFunction | Time | SingleAnimationIterationCount | SingleAnimationDirection | SingleAnimationFillMode | SingleAnimationPlayState | ( ( "none" | KeyframesName ) ) ) ( __ ( Time | SingleTimingFunction | Time | SingleAnimationIterationCount | SingleAnimationDirection | SingleAnimationFillMode | SingleAnimationPlayState | ( ( "none" | KeyframesName ) ) ) ):* {% function (data,location) { return { name: 'SingleAnimation', values: data.filter(Boolean), location }; } %}
40 | Time -> Number %timeUnit {% function (data,location) { return { name: 'Time', values: data.filter(Boolean), location: lexer.index }; } %}
41 | SingleTimingFunction -> ( ( ( "linear" | CubicBezierTimingFunction ) | StepTimingFunction ) | FramesTimingFunction ) {% function (data,location) { return { name: 'SingleTimingFunction', values: data.filter(Boolean), location }; } %}
42 | SingleAnimationIterationCount -> ( "infinite" | Number ) {% function (data,location) { return { name: 'SingleAnimationIterationCount', values: data.filter(Boolean), location }; } %}
43 | SingleAnimationDirection -> ( ( ( "normal" | "reverse" ) | "alternate" ) | "alternate-reverse" ) {% function (data,location) { return { name: 'SingleAnimationDirection', values: data.filter(Boolean), location }; } %}
44 | SingleAnimationFillMode -> ( ( ( "none" | "forwards" ) | "backwards" ) | "both" ) {% function (data,location) { return { name: 'SingleAnimationFillMode', values: data.filter(Boolean), location }; } %}
45 | SingleAnimationPlayState -> ( "running" | "paused" ) {% function (data,location) { return { name: 'SingleAnimationPlayState', values: data.filter(Boolean), location }; } %}
46 | KeyframesName -> ( CustomIdent | String ) {% function (data,location) { return { name: 'KeyframesName', values: data.filter(Boolean), location }; } %}
47 | Number -> ( %number | %integer )
48 | CubicBezierTimingFunction -> ( "ease" | "ease-in" | "ease-out" | "ease-in-out" | "cubic-bezier(" _ Number _ "," _ Number _ "," _ Number _ "," _ Number _ ")" )
49 | StepTimingFunction -> ( ( "step-start" | "step-end" ) | ( ( ( ( "steps(" _ Integer ) _ ( ( "," _ ( ( "start" | "end" ) ) ) ):? ) _ ")" ) ) )
50 | FramesTimingFunction -> "frames(" _ Integer _ ")"
51 | Integer -> %integer
52 | CustomIdent -> %ident
53 | String -> %string


--------------------------------------------------------------------------------
/src/grammars/nearley/properties/background.ne:
--------------------------------------------------------------------------------
 1 | @builtin "whitespace.ne"
 2 | 
 3 | @{%
 4 |   const locationMap = require('../../../utils/LocationIndexTracker');
 5 | %}
 6 | 
 7 | Base -> ( BgLayer _ "," _ ):* FinalBgLayer {% function (data,location) {return { name: 'Base', values: data.filter(Boolean), location }; } %}
 8 | 
 9 | BgLayer -> ( BgImage | ( Position ( _ "/" _ BgSize ):? ) | RepeatStyle | Attachment | ( Box ( __ Box ):? ) ) ( __ ( BgImage | ( Position ( _ "/" _ BgSize ):? ) | RepeatStyle | Attachment | ( Box ( __ Box ):? ) ) ):* {% function(data, location) {
10 |   return { name: 'BgLayer', values: data.filter(Boolean), location };
11 | } %}
12 | 
13 | FinalBgLayer -> ( BgImage | ( Position ( _ "/" _ BgSize ):? ) | RepeatStyle | Attachment | Box | Box | BackgroundColor ) ( __ ( BgImage | ( Position ( _ "/" _ BgSize ):? ) | RepeatStyle | Attachment | Box | Box | BackgroundColor ) ):* {% function(data, location) {
14 |   return { name: 'FinalBgLayer', values: data.filter(Boolean), location };
15 | } %}
16 | 
17 | BgImage -> ( "none" | Image ) {% function (data,location) { return { name: 'BgImage', values: data.filter(Boolean), location }; } %}
18 | 
19 | Position -> ( ( ( ( ( ( ( ( ( "left" | "center" ) | "right" ) | "top" ) | "bottom" ) | LengthPercentage ) ) | ( ( ( ( ( "left" | "center" ) | "right" ) | LengthPercentage ) ) __ ( ( ( ( "top" | "center" ) | "bottom" ) | LengthPercentage ) ) ) ) | ( ( ( ( "center" | ( ( ( "left" | "right" ) ) __ LengthPercentage:? ) ) ) __ ( ( "center" | ( ( ( "top" | "bottom" ) ) __ LengthPercentage:? ) ) ) ) | ( ( ( "center" | ( ( ( "top" | "bottom" ) ) __ LengthPercentage:? ) ) ) __ ( ( "center" | ( ( ( "left" | "right" ) ) __ LengthPercentage:? ) ) ) ) ) ) ) {% function (data, location, reject) {
20 |   if(locationMap.location2 !== -1 && location !==  locationMap.location2) {
21 |     return reject;
22 |   }
23 | 
24 |   locationMap.location2 = location;
25 |   return { name: 'Position', values: data.filter(Boolean), location };
26 | } %}
27 | BgSize -> ( ( ( ( ( LengthPercentage | "auto" ) ) ( __ ( ( LengthPercentage | "auto" ) ) ):? ) | "cover" ) | "contain" ) {% function (data,location) { return { name: 'BgSize', values: data.filter(Boolean), location }; } %}
28 | 
29 | 
30 | RepeatStyle -> ( ( "repeat-x" | "repeat-y" ) | ( ( ( ( ( "repeat" | "space" ) | "round" ) | "no-repeat" ) ) ( __ ( ( ( ( "repeat" | "space" ) | "round" ) | "no-repeat" ) ) ):? ) ) {%
31 | function (data, location, reject) {
32 |   if(locationMap.location1 !== -1 && location !==  locationMap.location1) {
33 |     return reject;
34 |   }
35 | 
36 |   locationMap.location1 = location;
37 |   return { name: 'RepeatStyle', values: data.filter(Boolean), location };
38 | } %}
39 | 
40 | Attachment -> ( ( "scroll" | "fixed" ) | "local" ) {% function (data,location) { return { name: 'Attachment', values: data.filter(Boolean), location }; } %}
41 | 
42 | 
43 | Box -> ( ( "border-box" | "padding-box" ) | "content-box" ) {% function (data,location) { return { name: 'Box', values: data.filter(Boolean), location }; } %}
44 | 
45 | 
46 | 
47 | Image -> ( ( ( ( ( Url | ImageFunc ) | ImageSetFunc ) | ElementFunc ) | CrossFadeFunc ) | Gradient )
48 | Url -> ( "url(" [^)]:* ")" )
49 | ImageFunc -> "image(" _ ( ImageFunc_inner1 | ImageFunc_inner2 | ImageFunc_inner3 ) _ ")"
50 | ImageFunc_inner1 -> ( Image | String )
51 | ImageFunc_inner2 -> Color
52 | ImageFunc_inner3 -> ( Image | String ) _  "," _ Color
53 | ImageSetFunc -> ( ( "image-set(" __ ( ( ImageSetOption _ "," _):* ImageSetOption ) ) __ ")" )
54 | ElementFunc -> ( ( "element(" __ IdSelector ) __ ")" )
55 | CrossFadeFunc -> ( ( ( ( "cross-fade(" __ CfMixingImage ) __ "," ) __ CfFinalImage:? ) __ ")" )
56 | Gradient -> ( ( ( LinearGradientFunc | RepeatingLinearGradientFunc ) | RadialGradientFunc ) | RepeatingRadialGradientFunc )
57 | String -> ( ['"]  [^'"]:*  ['"]  )
58 | Color -> ( ( ( ( ( ( ( RgbFunc | RgbaFunc ) | HslFunc ) | HslaFunc ) | HexColor ) | NamedColor ) | "currentcolor" ) | DeprecatedSystemColor )
59 | RgbFunc -> "rgb(" _ ( ( ( Percentage __ Percentage __ Percentage ) | ( Integer __ Integer __ Integer ) ( _ "/" _ AlphaValue ):? ) |  ( ( Percentage _ "," _ Percentage _ "," _ Percentage ) | ( Integer _ "," _ Integer _ "," _ Integer ) ( _ "," _ AlphaValue ):? ) ) _ ")"
60 | RgbaFunc -> "rgba(" _ ( ( ( Percentage __ Percentage __ Percentage ) | ( Integer __ Integer __ Integer ) ( _ "/" _ AlphaValue ):? ) |  ( ( Percentage _ "," _ Percentage _ "," _ Percentage ) | ( Integer _ "," _ Integer _ "," _ Integer ) ( _ "," _ AlphaValue ):? ) ) _ ")"
61 | HslFunc -> "hsl(" _ ( ( Hue __ Percentage __ Percentage ( _ "/" _ AlphaValue ):? ) | ( Hue _ "," _ Percentage _ "," _ Percentage ( _ "," _ AlphaValue ):? ) ) _ ")"
62 | HslaFunc -> "hsla(" _ ( ( Hue __ Percentage __ Percentage ( _ "/" _ AlphaValue ):? ) | ( Hue _ "," _ Percentage _ "," _ Percentage ( _ "," _ AlphaValue ):? ) ) _ ")"
63 | HexColor -> ( "#" ( HexColor_eight | HexColor_six | HexColor_four | HexColor_three ) )
64 | HexColor_three -> HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit
65 | HexColor_four -> HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit
66 | HexColor_six -> HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit
67 | HexColor_eight -> HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit HexColor_hexDigit
68 | HexColor_hexDigit -> [0-9A-Fa-f]
69 | NamedColor -> ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( "transparent" | "aliceblue" ) | "antiquewhite" ) | "aqua" ) | "aquamarine" ) | "azure" ) | "beige" ) | "bisque" ) | "black" ) | "blanchedalmond" ) | "blue" ) | "blueviolet" ) | "brown" ) | "burlywood" ) | "cadetblue" ) | "chartreuse" ) | "chocolate" ) | "coral" ) | "cornflowerblue" ) | "cornsilk" ) | "crimson" ) | "cyan" ) | "darkblue" ) | "darkcyan" ) | "darkgoldenrod" ) | "darkgray" ) | "darkgreen" ) | "darkgrey" ) | "darkkhaki" ) | "darkmagenta" ) | "darkolivegreen" ) | "darkorange" ) | "darkorchid" ) | "darkred" ) | "darksalmon" ) | "darkseagreen" ) | "darkslateblue" ) | "darkslategray" ) | "darkslategrey" ) | "darkturquoise" ) | "darkviolet" ) | "deeppink" ) | "deepskyblue" ) | "dimgray" ) | "dimgrey" ) | "dodgerblue" ) | "firebrick" ) | "floralwhite" ) | "forestgreen" ) | "fuchsia" ) | "gainsboro" ) | "ghostwhite" ) | "gold" ) | "goldenrod" ) | "gray" ) | "green" ) | "greenyellow" ) | "grey" ) | "honeydew" ) | "hotpink" ) | "indianred" ) | "indigo" ) | "ivory" ) | "khaki" ) | "lavender" ) | "lavenderblush" ) | "lawngreen" ) | "lemonchiffon" ) | "lightblue" ) | "lightcoral" ) | "lightcyan" ) | "lightgoldenrodyellow" ) | "lightgray" ) | "lightgreen" ) | "lightgrey" ) | "lightpink" ) | "lightsalmon" ) | "lightseagreen" ) | "lightskyblue" ) | "lightslategray" ) | "lightslategrey" ) | "lightsteelblue" ) | "lightyellow" ) | "lime" ) | "limegreen" ) | "linen" ) | "magenta" ) | "maroon" ) | "mediumaquamarine" ) | "mediumblue" ) | "mediumorchid" ) | "mediumpurple" ) | "mediumseagreen" ) | "mediumslateblue" ) | "mediumspringgreen" ) | "mediumturquoise" ) | "mediumvioletred" ) | "midnightblue" ) | "mintcream" ) | "mistyrose" ) | "moccasin" ) | "navajowhite" ) | "navy" ) | "oldlace" ) | "olive" ) | "olivedrab" ) | "orange" ) | "orangered" ) | "orchid" ) | "palegoldenrod" ) | "palegreen" ) | "paleturquoise" ) | "palevioletred" ) | "papayawhip" ) | "peachpuff" ) | "peru" ) | "pink" ) | "plum" ) | "powderblue" ) | "purple" ) | "rebeccapurple" ) | "red" ) | "rosybrown" ) | "royalblue" ) | "saddlebrown" ) | "salmon" ) | "sandybrown" ) | "seagreen" ) | "seashell" ) | "sienna" ) | "silver" ) | "skyblue" ) | "slateblue" ) | "slategray" ) | "slategrey" ) | "snow" ) | "springgreen" ) | "steelblue" ) | "tan" ) | "teal" ) | "thistle" ) | "tomato" ) | "turquoise" ) | "violet" ) | "wheat" ) | "white" ) | "whitesmoke" ) | "yellow" ) | "yellowgreen" )
70 | DeprecatedSystemColor -> ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( "ActiveBorder" | "ActiveCaption" ) | "AppWorkspace" ) | "Background" ) | "ButtonFace" ) | "ButtonHighlight" ) | "ButtonShadow" ) | "ButtonText" ) | "CaptionText" ) | "GrayText" ) | "Highlight" ) | "HighlightText" ) | "InactiveBorder" ) | "InactiveCaption" ) | "InactiveCaptionText" ) | "InfoBackground" ) | "InfoText" ) | "Menu" ) | "MenuText" ) | "Scrollbar" ) | "ThreeDDarkShadow" ) | "ThreeDFace" ) | "ThreeDHighlight" ) | "ThreeDLightShadow" ) | "ThreeDShadow" ) | "Window" ) | "WindowFrame" ) | "WindowText" )
71 | Integer -> ( ("+" | "-"):?  [0-9]:+ )
72 | Percentage -> Number "%"
73 | AlphaValue -> ( Number | Percentage )
74 | Number -> ( "+" | "-" ):?  ( Number_simple | Number_float )
75 | Number_simple -> [0-9]:+
76 | Number_float -> [0-9]:* "." [0-9]:+
77 | Hue -> ( Number | Angle )
78 | Angle -> Number AngleUnit
79 | AngleUnit -> ( "deg" | "grad" | "rad" | "turn" )
80 | ImageSetOption -> ( ( ( Image | String ) ) __ Resolution )
81 | Resolution -> Number ResolutionUnit
82 | ResolutionUnit -> ( "dpcm" | "dpi" | "dppx" )
83 | IdSelector -> ( "#" [^ ]:+ )
84 | CfMixingImage -> ( ( Percentage:? __ Image ) | ( Image ( __ Percentage:? ):? ) )
85 | CfFinalImage -> ( Image | Color )
86 | LinearGradientFunc -> ( ( "linear-gradient(" __ ( ( Angle | ( "to" __ SideOrCorner ) ) ):? ColorStopList ) __ ")" )
87 | RepeatingLinearGradientFunc -> ( ( "repeating-linear-gradient(" __ ( ( Angle | ( "to" __ SideOrCorner ) ) ):? ColorStopList ) __ ")" )
88 | RadialGradientFunc -> ( ( ( "radial-gradient(" __ ( ( EndingShape | Size ) ( __ ( EndingShape | Size ) ):* ):? ) __ ( ( "at" __ Position ) ):? ColorStopList ) __ ")" )
89 | RepeatingRadialGradientFunc -> ( ( ( "repeating-radial-gradient(" __ ( ( EndingShape | Size ) ( __ ( EndingShape | Size ) ):* ):? ) __ ( ( "at" __ Position ) ):? ColorStopList ) __ ")" )
90 | SideOrCorner -> ( ( ( "left" | "right" ) ) | ( ( "top" | "bottom" ) ) ) ( __ ( ( ( "left" | "right" ) ) | ( ( "top" | "bottom" ) ) ) ):*
91 | ColorStopList -> ( ColorStop _ "," _ ColorStop ( _ "," _ ColorStop ):* )
92 | ColorStop -> ( Color __ LengthPercentage:? )
93 | LengthPercentage -> ( Length | Percentage )
94 | Length -> ( Length_numberWithUnit | "0" )
95 | Length_numberWithUnit -> Number LengthUnit
96 | LengthUnit -> ( "ch" | "cm" | "em" | "ex" | "fr" | "in" | "mm" | "pc" | "pt" | "px" | "q" | "rem" | "vh" | "vmax" | "vmin" | "vw" )
97 | EndingShape -> ( "circle" | "ellipse" )
98 | Size -> ( ( ( ( ( "closest-side" | "farthest-side" ) | "closest-corner" ) | "farthest-corner" ) | Length ) | ( LengthPercentage __ LengthPercentage ) )
99 | BackgroundColor -> Color {% function (data,location) { return { name: 'BackgroundColor', values: data.filter(Boolean), location }; } %}


--------------------------------------------------------------------------------
/src/grammars/nearley/properties/font.ne:
--------------------------------------------------------------------------------
 1 | @builtin "whitespace.ne"
 2 | 
 3 | Base ->  ( ( ( ( ( ( ( ( FontStyle | FontVariantCss21 | FontWeight | FontStretch ) ( __ ( FontStyle | FontVariantCss21 | FontWeight | FontStretch ) ):* ):? __ FontSize ) | FontSize ) ( ( _ "/" _ LineHeight ) ):? ) __ FontFamily ) ) | "caption"  | "icon"  | "menu"  | "message-box"  | "small-caption"  | "status-bar" ) {% function (data,location) { return { name: 'Base', values: data.filter(Boolean), location }; } %}
 4 | FontStyle -> ( ( "normal" | "italic" ) | "oblique" ) {% function (data,location) { return { name: 'FontStyle', values: data.filter(Boolean), location }; } %}
 5 | FontVariantCss21 -> ( ( "normal" | "small-caps" ) ) {% function (data,location) { return { name: 'FontVariantCss21', values: data.filter(Boolean), location }; } %}
 6 | FontWeight -> ( ( ( ( ( ( ( ( ( ( ( ( "normal" | "bold" ) | "bolder" ) | "lighter" ) | "100" ) | "200" ) | "300" ) | "400" ) | "500" ) | "600" ) | "700" ) | "800" ) | "900" ) {% function (data,location) { return { name: 'FontWeight', values: data.filter(Boolean), location }; } %}
 7 | FontStretch -> ( ( ( ( ( ( ( ( "normal" | "ultra-condensed" ) | "extra-condensed" ) | "condensed" ) | "semi-condensed" ) | "semi-expanded" ) | "expanded" ) | "extra-expanded" ) | "ultra-expanded" ) {% function (data,location) { return { name: 'FontStretch', values: data.filter(Boolean), location }; } %}
 8 | FontSize -> ( ( AbsoluteSize | RelativeSize ) | LengthPercentage ) {% function (data,location) { return { name: 'FontSize', values: data.filter(Boolean), location }; } %}
 9 | LineHeight -> ( ( ( "normal" | Number ) | Length ) | Percentage ) {% function (data,location) { return { name: 'LineHeight', values: data.filter(Boolean), location }; } %}
10 | FontFamily -> ( ( ( ( FamilyName | GenericFamily ) ) _ "," _):* ( ( FamilyName | GenericFamily ) ) ) {% function (data,location) { return { name: 'FontFamily', values: data.filter(Boolean), location }; } %}
11 | AbsoluteSize -> ( ( ( ( ( ( "xx-small" | "x-small" ) | "small" ) | "medium" ) | "large" ) | "x-large" ) | "xx-large" )
12 | RelativeSize -> ( "larger" | "smaller" )
13 | LengthPercentage -> ( Length | Percentage )
14 | Length -> ( Length_numberWithUnit | "0" )
15 | Length_numberWithUnit -> Number LengthUnit
16 | Percentage -> Number "%"
17 | Number -> ( "+" | "-" ):?  ( Number_simple | Number_float )
18 | Number_simple -> [0-9]:+
19 | Number_float -> [0-9]:* "." [0-9]:+
20 | LengthUnit -> ( "ch" | "cm" | "em" | "ex" | "fr" | "in" | "mm" | "pc" | "pt" | "px" | "q" | "rem" | "vh" | "vmax" | "vmin" | "vw" )
21 | FamilyName -> ( String | ( CustomIdent ( __ CustomIdent ):* ) )
22 | GenericFamily -> ( ( ( ( "serif" | "sans-serif" ) | "cursive" ) | "fantasy" ) | "monospace" )
23 | String -> ( ['"]  [^'"]:*  ['"]  )
24 | CustomIdent -> [^0-9-] [a-zA-Z0-9\-_]:* 


--------------------------------------------------------------------------------
/src/grammars/nearley/properties/transition.ne:
--------------------------------------------------------------------------------
 1 | @builtin "whitespace.ne"
 2 | 
 3 | @{%
 4 |   const moo = require("moo");
 5 | 
 6 |   const lexer = moo.compile({
 7 |     singleTimingFunction: ["linear", "ease", "ease-in", "ease-out", "ease-in-out"],
 8 |     none: "none",
 9 |     all: "all",
10 |     functionStart: /[a-zA-Z\-]+\(/,
11 |     ident: {
12 |       match: /[a-zA-Z_][a-zA-Z0-9\-_]*/,
13 |       keywords: {
14 |         singleTimingFunction: ["linear", "ease", "ease-in", "ease-out", "ease-in-out"],
15 |         none: "none",
16 |         all: "all",
17 |         timeUnit: ["s", "ms"]
18 |       }
19 |     },
20 |     timeUnit: ["s", "ms"],
21 |     number: /(?:\+|\-)?(?:[0-9]+\.[0-9]*)|(?:[0-9]*\.[0-9]+)/,
22 |     integer: /(?:\+|\-)?[0-9]+/,
23 |     char: /./,
24 |   });
25 | %}
26 | 
27 | @lexer lexer
28 | 
29 | Base -> ( ( SingleTransition _ "," _):* SingleTransition ) {% function (data,location) { return { name: 'Base', values: data.filter(Boolean), location: lexer.index }; } %}
30 | SingleTransition -> ( Time | SingleTransitionTimingFunction | ( ( "none" | SingleTransitionProperty ) ) ) ( __ ( Time | SingleTransitionTimingFunction | ( ( "none" | SingleTransitionProperty ) ) ) ):* {% function (data,location) {
31 |   return { name: 'SingleTransition', values: data.filter(Boolean), location: lexer.index };
32 | } %}
33 | Time -> Number %timeUnit {% function (data,location) { return { name: 'Time', values: data.filter(Boolean), location: lexer.index }; } %}
34 | SingleTransitionTimingFunction -> SingleTimingFunction {% function (data,location) { return { name: 'SingleTransitionTimingFunction', values: data.filter(Boolean), location: lexer.inder }; } %}
35 | SingleTransitionProperty -> ( "all" | CustomIdent ) {% function (data, location) {
36 |   return { name: 'SingleTransitionProperty', values: data.filter(Boolean), location: lexer.index };
37 | } %}
38 | Number -> ( %number | %integer )
39 | SingleTimingFunction -> ( ( ( CubicBezierTimingFunction ) | StepTimingFunction ) | FramesTimingFunction )
40 | CubicBezierTimingFunction -> ( "linear" | "ease" | "ease-in" | "ease-out" | "ease-in-out" | "cubic-bezier(" _ Number _ "," _ Number _ "," _ Number _ "," _ Number _ ")" )
41 | StepTimingFunction -> ( ( "step-start" | "step-end" ) | ( ( ( ( "steps(" _ Integer ) _ ( ( "," _ ( ( "start" | "end" ) ) ) ):? ) _ ")" ) ) )
42 | FramesTimingFunction -> "frames(" _ Integer _ ")"
43 | Integer -> %integer
44 | CustomIdent -> %ident
45 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
 1 | const expandShorthandProperty = require('./expandShorthandProperty');
 2 | const getShorthandComputedProperties = require('./getShorthandComputedProperties');
 3 | const isShorthandProperty = require('./isShorthandProperty');
 4 | const getShorthandsForProperty = require('./getShorthandsForProperty');
 5 | const isValidDeclaration = require('./isValidDeclaration');
 6 | const {
 7 |   ParseError,
 8 |   UnsupportedPropertyError,
 9 |   UnknownPropertyError,
10 | } = require('./errors');
11 | const isInitialValue = require('./isInitialValue');
12 | const {
13 |   computeInitialValues,
14 |   initialValues,
15 |   initialValue,
16 | } = require('./initialValueMap');
17 | 
18 | module.exports = {
19 |   computeInitialValues,
20 |   expandShorthandProperty,
21 |   getShorthandComputedProperties,
22 |   getShorthandsForProperty,
23 |   initialValue,
24 |   initialValues,
25 |   isInitialValue,
26 |   isShorthandProperty,
27 |   isValidDeclaration,
28 |   ParseError,
29 |   UnsupportedPropertyError,
30 |   UnknownPropertyError,
31 | };
32 | 


--------------------------------------------------------------------------------
/src/initialValueMap.js:
--------------------------------------------------------------------------------
  1 | const properties = require('./formatted-data/properties.json');
  2 | const getShorthandComputedProperties = require('./getShorthandComputedProperties');
  3 | const isShorthandProperty = require('./isShorthandProperty');
  4 | 
  5 | /**
  6 |  * Initial values are highly cacheable since they are just a function of the
  7 |  * css specification so this module stores all values in a singleton. By
  8 |  * default we cache initial values lazily when each property's initial value is
  9 |  * first requested. A function `computeInitialValues` is provided to warm the
 10 |  * entire cache on demand if needed.
 11 |  *
 12 |  * In addition, the data for initial values is incomplete or ambiguous
 13 |  * per the spec so we synthesize initial values for shorthand properties.
 14 |  * The values chosen are typical values that developers use when disabling
 15 |  * a set of properties via shorthand.
 16 |  *
 17 |  * Since initial values are ambiguous, the `isInitialValue` function
 18 |  * is provided as a public api. It's in a different file because it
 19 |  * depends on file that depends on this one and circular dependencies
 20 |  * are bad.
 21 |  */
 22 | 
 23 | /**
 24 |  * Map of property names to the initial string value for that property.
 25 |  * @type {Object}
 26 |  */
 27 | const initialValueMap = {};
 28 | 
 29 | /**
 30 |  * These fix broken or bad data and allows us to set a different
 31 |  * initial value if we want to.
 32 |  */
 33 | const initialValueOverrides = {
 34 |    // border-image-outset is set to `0s` in the data which is invalid. The
 35 |    // ILLEGAL_INITIAL_VALUES regex can't be used because here because that can
 36 |    // be a legal initial value for some properties.
 37 |   'border-image-outset': '0',
 38 | };
 39 | 
 40 | /**
 41 |  * Map of property names all the properties
 42 |  * that it sets, including itself and other shorthands.
 43 |  * @type {Object}
 44 |  */
 45 | const initialValueRecursiveMap = {};
 46 | 
 47 | /**
 48 |  * Map of property names to concrete longhand initial values. (no intermediate
 49 |  * shorthands) This is a subset of the values stored in
 50 |  * `initialValueRecursiveMap` and supports the `includeShorthands` property of
 51 |  * the `initialValues` function when it is set to false.
 52 |  * @type {Object}
 53 |  */
 54 | const initialValueConcreteMap = {};
 55 | 
 56 | const canonicalShorthandInitialValues = {
 57 |   border: 'none',
 58 |   'border-color': 'currentcolor',
 59 |   'border-style': 'none',
 60 |   'border-width': 'medium',
 61 |   'border-left': 'none',
 62 |   'border-right': 'none',
 63 |   'border-top': 'none',
 64 |   'border-bottom': 'none',
 65 |   transition: 'all',
 66 |   'text-emphasis': 'none',
 67 |   'text-decoration': 'none',
 68 |   padding: '0',
 69 |   outline: 'none',
 70 |   offset: 'none',
 71 |   mask: 'border-box',
 72 |   margin: '0',
 73 |   'list-style': 'disc',
 74 |   'grid-template': 'none',
 75 |   'grid-row': 'auto',
 76 |   'grid-gap': '0',
 77 |   'grid-column': 'auto',
 78 |   'grid-area': 'auto',
 79 |   grid: 'none',
 80 |   font: 'medium initial',
 81 |   'flex-flow': 'row',
 82 |   flex: '0 1 auto',
 83 |   columns: 'auto',
 84 |   'column-rule': 'none',
 85 |   'border-radius': '0',
 86 |   'border-inline-start': 'medium',
 87 |   'border-inline-end': 'none',
 88 |   'border-image': 'none',
 89 |   'border-block-start': 'none',
 90 |   'border-block-end': 'none',
 91 |   background: 'none',
 92 |   animation: 'none',
 93 |   '-webkit-text-stroke': '0',
 94 |   '-webkit-mask': 'none',
 95 |   '-webkit-border-before': 'none',
 96 |   '-moz-outline-radius': '0',
 97 | };
 98 | 
 99 | /**
100 |  * The mdn data has some quirky values for initial in some cases
101 |  * because they're trying to encode browser differences somehow.
102 |  * It's bad data design, this should be stored in a different property.
103 |  * This regex is a work around to keep that bad data out of our
104 |  * css values.
105 |  */
106 | const ILLEGAL_INITIAL_VALUES = /XUL|UserAgent|Browser|noPracticalInitialValue|startOrNamelessValueIfLTRRightIfRTL/;
107 | 
108 | /**
109 |  * Warms up the cache for a single property.
110 |  *
111 |  * @private
112 |  * @param {string} propertyName - the property name to warm up.
113 |  * @returns {void} this function runs for its side effects only.
114 |  */
115 | function computeInitialValue(propertyName) {
116 |   if (properties[propertyName] === undefined) return; // unknown property
117 |   if (initialValueMap[propertyName]) return; // value is cached.
118 |   let initialValue = properties[propertyName].initial;
119 |   if (Array.isArray(initialValue)) {
120 |     // it's a shorthand
121 |     initialValue.forEach(computeInitialValue);
122 |     initialValueMap[propertyName] =
123 |       canonicalShorthandInitialValues[propertyName]
124 |       || initialValue.map(v => initialValueMap[v]).join(' ');
125 |   } else {
126 |     // it's a string with the initial value.
127 |     // the value may be nonsense though.
128 |     if (ILLEGAL_INITIAL_VALUES.test(initialValue)) {
129 |       initialValue = 'initial'; // safest legal value.
130 |     }
131 |     initialValueMap[propertyName] =
132 |       initialValueOverrides[propertyName] || initialValue;
133 |   }
134 |   const propertyNames = getShorthandComputedProperties(propertyName, true);
135 |   initialValueRecursiveMap[propertyName] = { [propertyName]: initialValueMap[propertyName] };
136 |   initialValueConcreteMap[propertyName] = { };
137 |   // In theory, the recursive calls to `computeInitialValue` above should be
138 |   // enough to populate the cache for these calls. However, in the case of data
139 |   // corruption of the initial property this could be a bad assumption.
140 |   propertyNames.forEach((prop) => {
141 |     initialValueRecursiveMap[propertyName][prop] = initialValueMap[prop];
142 |     if (!isShorthandProperty(prop)) {
143 |       initialValueConcreteMap[propertyName][prop] = initialValueMap[prop];
144 |     }
145 |   });
146 | }
147 | 
148 | /**
149 |  * Warms up the initial value cache for all known css properties.
150 |  * It is not usually necessary to call this function but
151 |  * may be useful in some performance testing scenarios.
152 |  * @return {void} runs for side-effects only.
153 |  */
154 | function computeInitialValues() {
155 |   Object.keys(properties).forEach(computeInitialValue);
156 | }
157 | 
158 | /**
159 |  * Get the initial values for a property.
160 |  * @param {string} property - the property name
161 |  * @param {boolean} recursivelyResolve - when given a shorthand property,
162 |  *   causes the result to include long hand values.
163 |  * @param {boolean} includeShorthands - when resolving recursively, causes the
164 |  *   the result to include the specified shorthand property as well as any
165 |  *   intermediate shorthands of this property to to the initial value.
166 |  * @return {Object} the initial value or values a property has by
167 |  *   default according the CSS specification. If the property's initial
168 |  *   value(s) is/are unknown, the global keyword `initial` is returned.
169 |  * @example
170 |  *   console.log(initialValues('border-width'));
171 |  *   // => { 'border-width': 'medium' }
172 |  *   console.log(initialValues('border-width', true));
173 |  *   // => {
174 |  *     'border-bottom-width': 'medium',
175 |  *     'border-left-width': 'medium',
176 |  *     'border-right-width': 'medium',
177 |  *     'border-top-width': 'medium',
178 |  *     'border-width': 'medium'
179 |  *   }
180 |  */
181 | function initialValues(property, recursivelyResolve = false, includeShorthands = false) {
182 |   computeInitialValue(property);
183 |   if (recursivelyResolve) {
184 |     const initials = includeShorthands ? initialValueRecursiveMap[property] : initialValueConcreteMap[property];
185 |     if (!initials) {
186 |       // It's an unknown property, return initial and hope the caller knows what
187 |       // they are doing.
188 |       return { [property]: 'initial' };
189 |     }
190 |     // we make a copy here to prevent the caller from corrupting our cache.
191 |     return Object.assign({}, initials);
192 |   }
193 |   return { [property]: initialValueMap[property] || 'initial' };
194 | }
195 | 
196 | /**
197 |  * Get the initial value for a property. the property can be a shorthand or a
198 |  * longhand.
199 |  * @param {string} property - the property name
200 |  * @return {string} the initial value has by default according the CSS
201 |   * specification. If the property's initial value is unknown, the global
202 |   * keyword `initial` is returned.
203 |  * @example
204 |  *   console.log(initialValue('border-width'));
205 |  *   // => 'medium'
206 |  */
207 | function initialValue(property) {
208 |   computeInitialValue(property);
209 |   return initialValueMap[property] || 'initial';
210 | }
211 | 
212 | module.exports = {
213 |   computeInitialValues,
214 |   initialValues,
215 |   initialValue,
216 | };
217 | 


--------------------------------------------------------------------------------
/src/isInitialValue.js:
--------------------------------------------------------------------------------
 1 | const expandShorthandProperty = require('./expandShorthandProperty');
 2 | const isShorthandProperty = require('./isShorthandProperty');
 3 | const { initialValue } = require('./initialValueMap');
 4 | 
 5 | /**
 6 |  * Because of the `initial` keyword and shorthand expansion,
 7 |  * there are many possible values that are equivalently identical
 8 |  * with the initial value of a css property. This function
 9 |  * returns true for all possible values that have the effect of
10 |  * setting a property to its initial value.
11 |  *
12 |  * @param {string} property the property to which  the value is assigned
13 |  * @param {string} value the value to check
14 |  * @return {boolean} whether the value is equivalent to the initial value.
15 |  */
16 | function isInitialValue(property, value) {
17 |   const expanded = expandShorthandProperty(property, value, true, true);
18 |   return Object.entries(expanded).every(([prop, val]) => {
19 |     // eslint-disable-next-line no-param-reassign
20 |     val = val.toLowerCase();
21 |     if (isShorthandProperty(prop)) return true;
22 |     if (val === 'initial') return true;
23 |     const canonicalInitialValue = initialValue(prop).toLowerCase();
24 |     if (val === canonicalInitialValue) return true;
25 |     if (canonicalInitialValue === '0') { // all lengths
26 |       if (/^0(px|mm|cm|in|pt|pc|q|mozmm)$/.test(val)) {
27 |         return true;
28 |       }
29 |     }
30 |     return false;
31 |   });
32 | }
33 | 
34 | module.exports = isInitialValue;
35 | 


--------------------------------------------------------------------------------
/src/isShorthandProperty.js:
--------------------------------------------------------------------------------
 1 | const shortHandProperties = require('./formatted-data/shorthand-properties.json');
 2 | 
 3 | /**
 4 |  * Checks if a given property is a shorthand property
 5 |  * @param {String} property - the property name
 6 |  * @returns {boolean} - true if property is a shorthand, false otherwise
 7 |  */
 8 | module.exports = function isShorthandProperty(property) {
 9 |   return Object.keys(shortHandProperties).includes(property);
10 | };
11 | 


--------------------------------------------------------------------------------
/src/isValidDeclaration.js:
--------------------------------------------------------------------------------
 1 | const nearley = require('nearley');
 2 | const properties = require('./formatted-data/properties.json');
 3 | const { CSS } = require('./constants');
 4 | const grammars = require('./grammars/generated');
 5 | 
 6 | /**
 7 |  * Checks if the given property, value pair is valid.
 8 |  *
 9 |  * @param {String} property - the property name. For example, 'border' or 'color'.
10 |  * @param {String} value - the property value. For example, '1px solid black'.
11 |  * @return {boolean} - true if the given value is valid for the property. Else, false.
12 |  */
13 | module.exports = function isValidDeclaration(property, value) {
14 |   if (!properties[property]) {
15 |     return false;
16 |   } else if (CSS.globalValues.includes(value) || CSS.variableRegex.test(value)) {
17 |     return true;
18 |   }
19 | 
20 |   const propertyGrammar = grammars[property];
21 | 
22 |   try {
23 |     const parser = new nearley.Parser(nearley.Grammar.fromCompiled(propertyGrammar)).feed(value);
24 |     return !!parser.results.length;
25 |   } catch (parseError) {
26 |     return false;
27 |   }
28 | };
29 | 


--------------------------------------------------------------------------------
/src/scripts/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "env": {
3 |     "node": true
4 |   },
5 |   "rules": {
6 |     "no-console": "off",
7 |     "import/no-extraneous-dependencies": "off"
8 |   }
9 | }


--------------------------------------------------------------------------------
/src/scripts/extractProperties.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Takes raw data from MDN, filters out the shorthand properties, and decorates the data with additional properties.
 3 |  * Writes the formatted data to FORMATTED_DATA_PATH.
 4 |  */
 5 | const fs = require('fs-extra');
 6 | const path = require('path');
 7 | const { css: { properties } } = require('mdn-data');
 8 | const PATHS = require('../constants/paths');
 9 | 
10 | const ALL_PROPERTIES_DATA_FILE_NAME = 'properties.json';
11 | const OUTPUT_FILE = path.join(PATHS.FORMATTED_DATA_PATH, ALL_PROPERTIES_DATA_FILE_NAME);
12 | fs.writeJson(OUTPUT_FILE, properties, { spaces: 2 })
13 |   .then(() => (
14 |     console.log(`Successfully extracted properties to ${OUTPUT_FILE}`)
15 |   ));
16 | 


--------------------------------------------------------------------------------
/src/scripts/formatData.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Takes raw data from MDN, filters out the shorthand properties, and decorates the data with additional properties.
 3 |  * Writes the formatted data to FORMATTED_DATA_PATH.
 4 |  */
 5 | const fs = require('fs-extra');
 6 | const path = require('path');
 7 | const { css: { properties } } = require('mdn-data');
 8 | const ShorthandPropertyClassifierUtils = require('../utils/ShorthandPropertyClassifierUtils');
 9 | const PATHS = require('../constants/paths');
10 | 
11 | const SHORTHAND_FORMATTED_DATA_FILE_NAME = 'shorthand-properties.json';
12 | const formattedData = Object.entries(properties)
13 | // properties that have an array as their computed value, are shorthand properties
14 |   .filter(([, data]) => Array.isArray(data.computed))
15 |   // add the shorthandType property to the data
16 |   .map(([prop, data]) => [
17 |     prop,
18 |     Object.assign({
19 |       shorthandType: ShorthandPropertyClassifierUtils.classifyLonghandProperty(prop, data.syntax),
20 |     }, data),
21 |   ])
22 |   // reduce it down to an object again so we can write it to a file
23 |   .reduce((propertyMap, [property, data]) => Object.assign({ [property]: data }, propertyMap), {});
24 | 
25 | fs.writeJson(path.join(PATHS.FORMATTED_DATA_PATH, SHORTHAND_FORMATTED_DATA_FILE_NAME), formattedData, { spaces: 2 })
26 |   .then(() => {
27 |     const fdPath = path.join(PATHS.FORMATTED_DATA_PATH, SHORTHAND_FORMATTED_DATA_FILE_NAME);
28 |     console.log(`Successfully formatted data to ${fdPath}`);
29 |   });
30 | 


--------------------------------------------------------------------------------
/src/scripts/formatFormalSyntaxes.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Format each formal syntax into a json grammar
 3 |  */
 4 | const fs = require('fs-extra');
 5 | const path = require('path');
 6 | const { css: { properties, syntaxes } } = require('mdn-data');
 7 | const { PATHS, SYNTAX_OVERRIDES } = require('../constants/index');
 8 | const JsonGrammarFormatter = require('../formatters/grammarFormatters/JsonGrammarFormatter');
 9 | 
10 | // array of syntax/property names that require manual generation.
11 | const manualSyntaxes = [
12 |   'image()',
13 |   'offset',
14 |   'shape',
15 |   'frames-timing-function',
16 |   'feature-value-declaration',
17 |   'cubic-bezier-timing-function',
18 |   'rgb()',
19 |   'rgba()',
20 |   'hsl()',
21 |   'hsla()',
22 |   'color',
23 |   'flex',
24 |   'background',
25 |   'final-bg-layer',
26 | ];
27 | 
28 | // combine properties and syntaxes into one object mapping property names to syntaxes
29 | const syntaxesSyntaxMap = Object.entries(syntaxes)
30 |   .reduce((syntaxMap, [name, { syntax }]) => Object.assign({ [name]: syntax }, syntaxMap), {});
31 | const propertySyntaxMap = Object.entries(properties).reduce((syntaxMap, [propertyName, { syntax }]) => (
32 |   Object.assign({ [propertyName]: syntax }, syntaxMap)
33 | ), syntaxesSyntaxMap);
34 | const overriddenPropertySyntaxMap = Object.assign(propertySyntaxMap, SYNTAX_OVERRIDES);
35 | 
36 | // make the json grammar directory if needed
37 | if (!fs.existsSync(PATHS.GENERATED_JSON_GRAMMAR_PATH)) {
38 |   fs.mkdirSync(PATHS.GENERATED_JSON_GRAMMAR_PATH);
39 | }
40 | 
41 | Object.entries(overriddenPropertySyntaxMap)
42 | // filter out any entries that we need to do manually
43 |   .filter(([grammarName]) => !manualSyntaxes.includes(grammarName))
44 |   .forEach(([grammarName, formalSyntax]) => {
45 |     const safeName = grammarName.replace('*', 'STAR');
46 |     const filename = path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, `${safeName}.json`);
47 |     console.log(`creating ${filename}`);
48 |     const jsonGrammar = JsonGrammarFormatter.format(formalSyntax);
49 |     fs.writeJson(filename, jsonGrammar, { spaces: 2 });
50 |   });
51 | 


--------------------------------------------------------------------------------
/src/scripts/formatGrammars.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Format each JSON grammar into a Nearley grammar
 3 |  */
 4 | const fs = require('fs-extra');
 5 | const path = require('path');
 6 | const NearleyGrammarFormatter = require('../formatters/grammarFormatters/NearleyGrammarFormatter');
 7 | const PATHS = require('../constants/paths');
 8 | const GRAMMAR_CONSTANTS = require('../constants/grammars');
 9 | const { exec } = require('child_process');
10 | const async = require('async');
11 | 
12 | const MAX_PARALLEL_PROCESSES = 20;
13 | const JAVASCRIPT_FILE_EXTENSION = 'js';
14 | const NEARLEY_COMPILER_FILE_NAME = 'nearleyc.js';
15 | 
16 | // make the nearley grammar directory if needed
17 | if (!fs.existsSync(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH)) {
18 |   fs.mkdirSync(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH);
19 | }
20 | 
21 | // make the js grammar directory if needed
22 | if (!fs.existsSync(PATHS.GENERATED_JS_GRAMMAR_PATH)) {
23 |   fs.mkdirSync(PATHS.GENERATED_JS_GRAMMAR_PATH);
24 | }
25 | 
26 | // move manual json grammars into generated folder for grammar resolution
27 | fs.readdirSync(PATHS.JSON_GRAMMAR_PATH)
28 |   .forEach((fileName) => {
29 |     const fullSrc = path.join(PATHS.JSON_GRAMMAR_PATH, fileName);
30 |     const fullDest = path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, fileName);
31 |     fs.copySync(fullSrc, fullDest);
32 |   });
33 | 
34 | // read each json grammar and format it into an nearley grammar
35 | fs.readdirSync(PATHS.GENERATED_JSON_GRAMMAR_PATH)
36 |   .map(fileName => [fileName, fs.readJsonSync(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, fileName))])
37 |   .forEach(([fileName, jsonGrammar]) => {
38 |     console.log(`creating ${fileName}`);
39 | 
40 |     const grammarName = fileName.replace('.json', '');
41 |     const nearleyGrammar = NearleyGrammarFormatter.format(jsonGrammar, grammarName);
42 |     const fileToWrite = path.join(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH, fileName.replace('.json', `.${GRAMMAR_CONSTANTS.GRAMMAR_FILE_EXTENSION}`));
43 | 
44 |     fs.createFileSync(fileToWrite);
45 |     fs.writeFileSync(fileToWrite, nearleyGrammar);
46 |   });
47 | 
48 | // copy over overridden grammars
49 | fs.readdirSync(PATHS.NEARLEY_PROPERTY_GRAMMAR_PATH)
50 |   .forEach((fileName) => {
51 |     const fullSrc = path.join(PATHS.NEARLEY_PROPERTY_GRAMMAR_PATH, fileName);
52 |     const fullDest = path.join(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH, fileName);
53 |     fs.copySync(fullSrc, fullDest);
54 |   });
55 | 
56 | console.log('...Successfully created nearley grammars...');
57 | 
58 | // read each nearley grammar and use the nearley compiler to convert it into its js representation
59 | const compilationQueue = async.queue((task, callback) => {
60 |   console.log(task);
61 |   exec(task, callback);
62 | }, MAX_PARALLEL_PROCESSES);
63 | 
64 | const jsModules = [];
65 | const compilationCommands = fs.readdirSync(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH)
66 |   .map((fileName) => {
67 |     const propName = fileName.replace(`.${GRAMMAR_CONSTANTS.GRAMMAR_FILE_EXTENSION}`, '');
68 |     const safeFileName = propName.replace('*', 'STAR');
69 |     const jsFileName = `${safeFileName}.${JAVASCRIPT_FILE_EXTENSION}`;
70 |     const nearleyFilePath = JSON.stringify(path.join(PATHS.GENERATED_NEARLEY_GRAMMAR_PATH, fileName.replace('*', 'STAR')));
71 |     const jsFilePath = JSON.stringify(
72 |       path.join(PATHS.GENERATED_JS_GRAMMAR_PATH, jsFileName)
73 |     );
74 | 
75 |     jsModules.push(`  '${propName}': require('./js/${jsFileName}')`);
76 | 
77 |     return `node ${path.join(PATHS.NEARLEY_BIN_ROOT, NEARLEY_COMPILER_FILE_NAME)} ${nearleyFilePath} > ${jsFilePath}`;
78 |   });
79 | 
80 | const jsExportsFile = `module.exports = {\n${jsModules.join(',\n')}\n}`;
81 | 
82 | fs.writeFileSync(path.resolve(PATHS.GENERATED_JS_GRAMMAR_PATH, '..', 'index.js'), jsExportsFile);
83 | 
84 | compilationQueue.push(compilationCommands, (err) => {
85 |   if (err) {
86 |     console.error(err);
87 |   }
88 | });
89 | 


--------------------------------------------------------------------------------
/src/scripts/updateBasicDataUnits.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Takes all of the units in data/units.json and writes standard json grammars for each type of unit.
 3 |  * Each type of unit is defined in the TYPE_MAP below, which maps the unit type to the grammar file name.
 4 |  * For example, CSS Length units will be written to the file 'length-units.json'.
 5 |  */
 6 | const { css: { units } } = require('mdn-data');
 7 | const fs = require('fs-extra');
 8 | const path = require('path');
 9 | const PATHS = require('../constants/paths');
10 | const GRAMMAR_CONSTANTS = require('../constants/grammars');
11 | 
12 | const TYPE_MAP = {
13 |   'CSS Lengths': 'length-unit',
14 |   'CSS Angles': 'angle-unit',
15 |   'CSS Resolutions': 'resolution-unit',
16 |   'CSS Frequencies': 'frequency-unit',
17 |   'CSS Times': 'time-unit',
18 | };
19 | 
20 | const unitToTypesMap = Object.entries(units).reduce((unitMap, [unit, { groups }]) => {
21 |   const unitKey = groups.map(group => TYPE_MAP[group]).find(Boolean) || 'other-unit';
22 | 
23 |   if (unitMap[unitKey]) {
24 |     return Object.assign(unitMap, { [unitKey]: unitMap[unitKey].concat(unit) });
25 |   }
26 | 
27 |   return Object.assign(unitMap, { [unitKey]: [unit] });
28 | }, {});
29 | 
30 | Promise.all(
31 |   Object.entries(unitToTypesMap).map(([fileName, unitList]) => (
32 |     fs.writeJson(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, `${fileName}.json`), [
33 |       [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, `( ${unitList.map(unit => `"${unit}"`).join(' | ')} )`],
34 |     ], { spaces: 2 })
35 |   )))
36 |   .then(() => console.log(`Successfully wrote to ${PATHS.GENERATED_JSON_GRAMMAR_PATH}`))
37 |   .catch(err => console.log(`Failure in writing unit grammars to ${PATHS.GENERATED_JSON_GRAMMAR_PATH}`, err));
38 | 


--------------------------------------------------------------------------------
/src/utils/ArrayUtils.js:
--------------------------------------------------------------------------------
 1 | module.exports = class ArrayUtils {
 2 |   /**
 3 |    * Creates a reduction function to be used in an {@link Array#reduce}, which reduces an array of an object's entries
 4 |    * to an object. Optionally, takes in keyMapper and valueMapper functions to transform the object's keys/values. If
 5 |    * no keyMapper/valueMapper is provided, defaults to the identity function.
 6 |    * @param {Function} [keyMapper=ArrayUtils.identityFunction] - a function to transform the keys in the returned object
 7 |    * @param {Function} [valueMapper=ArrayUtils.identityFunction] - a function to transform the values in the returned
 8 |    *                                                               object
 9 |    * @returns {function(Object, Array): Object} - the reduction function
10 |    * @static
11 |    *
12 |    * @example
13 |    * Object.entries({ a: 1 }).reduce(ArrayUtils.entriesToObject(), {})
14 |    * -> { a: 1 }
15 |    *
16 |    * @example
17 |    * Object.entries({ a: 1 }).reduce(ArrayUtils.entriesToObject((key) => key.toUpperCase(), (value) => value + 1), {})
18 |    * -> { A: 2 }
19 |    */
20 |   static entriesToObject(keyMapper = ArrayUtils.identityFunction, valueMapper = ArrayUtils.identityFunction) {
21 |     return (object, [key, value], idx) => (
22 |       Object.assign({ [keyMapper(key, value, idx)]: valueMapper(value, key, idx) }, object)
23 |     );
24 |   }
25 | 
26 |   /**
27 |    * Returns the value provided, unmodified.
28 |    * @param {*} value - the value
29 |    * @returns {*} - the value
30 |    * @static
31 |    */
32 |   static identityFunction(value) {
33 |     return value;
34 |   }
35 | };
36 | 


--------------------------------------------------------------------------------
/src/utils/CaseConverterUtils.js:
--------------------------------------------------------------------------------
 1 | const GRAMMAR_CONSTANTS = require('../constants/grammars');
 2 | 
 3 | /**
 4 |  * Class that holds util functions to convert one case to another. All methods should be of form <case>To<case>()
 5 |  */
 6 | module.exports = class CaseConverterUtils {
 7 |   /**
 8 |    * Given a string in kebab-case, returns the string in camelCase.
 9 |    * @param {string} kebabString - the kebab-case string
10 |    * @return {string} - the camelCase string
11 |    */
12 |   static kebabToCamel(kebabString) {
13 |     return kebabString.replace(/(-\w)/g, ([, match]) => match.toUpperCase());
14 |   }
15 | 
16 |   /**
17 |    * Given a string in camelCase, returns the string in kebab-case.
18 |    * @param {string} camelString - the camelCase string
19 |    * @return {string} - the kebab-case string
20 |    */
21 |   static camelToKebab(camelString) {
22 |     return camelString.replace(/([A-Z])/g, ([match]) => `-${match.toLowerCase()}`);
23 |   }
24 | 
25 |   /**
26 |    * Given a string in kebab-case, returns the string in PascalCase.
27 |    * @param {string} kebabString - the kebab-case string
28 |    * @returns {string} - the PascalCase string
29 |    */
30 |   static kebabToPascal(kebabString) {
31 |     return kebabString
32 |       .replace(/(-\w)/g, ([, match]) => match.toUpperCase())
33 |       .replace(/^(\w)/, ([match]) => match.toUpperCase());
34 |   }
35 | 
36 |   /**
37 |    * Takes the given string and capitalizes the first letter
38 |    * @param {string} string - any string
39 |    * @returns {string} - the capitalized string or the empty string if the given string is empty
40 |    */
41 |   static anyToCapitalized(string) {
42 |     return string.length ? `${string[0].toUpperCase()}${string.slice(1)}` : string;
43 |   }
44 | 
45 |   /**
46 |    * Takes the given string and lowercases the first letter
47 |    * @param {string} string - any string
48 |    * @returns {string} - the lowercased string or the empty string if the given string is empty
49 |    */
50 |   static anyToUnCapitalized(string) {
51 |     return string.length ? `${string[0].toLowerCase()}${string.slice(1)}` : string;
52 |   }
53 | 
54 |   /**
55 |    * Formats the given formal syntax ident into a string that is compatible with Nearley. Normal kebab-case strings will
56 |    * be camelCased. Strings with a "()" will have "Func" suffix.
57 |    *
58 |    * @example formalSyntaxIdentToNearleyIdent("some-string") -> "someString"
59 |    * @example formalSyntaxIdentToNearleyIdent("some-string()") -> "someStringFunc"
60 |    *
61 |    * @param {string} formalSyntaxIdent - the JSON grammar rule name
62 |    * @returns {string} - the formatted rule name in camelCase/pascalCase format, with an optional Func suffix
63 |    */
64 |   static formalSyntaxIdentToNearleyIdent(formalSyntaxIdent) {
65 |     return formalSyntaxIdent
66 |       .replace(GRAMMAR_CONSTANTS.R_GRAMMAR_IDENT_NAME_GLOBAL, (fullMatch, innerIdent, identName, parens) => (
67 |         `${CaseConverterUtils.kebabToPascal(identName)}${parens ? 'Func' : ''}`
68 |       ));
69 |   }
70 | };
71 | 


--------------------------------------------------------------------------------
/src/utils/LocationIndexTracker.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * A basic index tracker for CSS grammars like background. This is a shared object between the application code
 3 |  * and the grammar. It should be reset between parsings. Use the index tracker in a grammar to reject certain parsings
 4 |  * in the postprocessing function. See the background nearley grammar for example usage.
 5 |  * @type {{location1: number, location2: number, reset: (function())}}
 6 |  */
 7 | module.exports = {
 8 |   location1: -1,
 9 |   location2: -1,
10 |   reset() {
11 |     this.location1 = -1;
12 |     this.location2 = -1;
13 |   },
14 | };
15 | 


--------------------------------------------------------------------------------
/src/utils/ShorthandPropertyClassifierUtils.js:
--------------------------------------------------------------------------------
 1 | const { R_CLASSIFICATION_MAP, CLASSIFICATIONS, OTHER_PROPERTY_CLASSIFICATION_MAP } = require('../constants/shorthandProperties');
 2 | 
 3 | module.exports = class ShorthandPropertyClassifierUtils {
 4 |   /**
 5 |    * Given a shorthand property name and its formal syntax, returns its classification.
 6 |    *
 7 |    * @param {string} propertyName - the shorthand property name
 8 |    * @param {string} formalSyntax - the shorthand property's formal syntax
 9 |    * @returns {string} - a string indicating the classification of the shorthand property. See enum
10 |    *                     {@link CLASSIFICATIONS} for possible classification.
11 |    */
12 |   static classifyLonghandProperty(propertyName, formalSyntax) {
13 |     const [otherClassification] = Object.entries(OTHER_PROPERTY_CLASSIFICATION_MAP)
14 |       .find(([, properties]) => properties.includes(propertyName)) || [];
15 |     const [standardClassification = CLASSIFICATIONS.OTHER] = Object.entries(R_CLASSIFICATION_MAP)
16 |       .find(([, regex]) => regex.test(formalSyntax)) || [];
17 | 
18 |     return otherClassification || standardClassification;
19 |   }
20 | };
21 | 


--------------------------------------------------------------------------------
/src/utils/ShorthandPropertyTypeFormatterUtils.js:
--------------------------------------------------------------------------------
  1 | const shorthandIdentToLonghandPropertyMap = require('../constants/shorthandIdentToLonghandPropertyMap.json');
  2 | 
  3 | module.exports = class ShorthandPropertyTypeFormatterUtils {
  4 |   /**
  5 |    * Given the root node of a nearley parse tree, returns an array of nodes whose name is in the given nodeNames array.
  6 |    * @param {Object} baseNode - the root node of the parse tree
  7 |    * @param {[String]} nodeNames - array of node names to keep
  8 |    * @return {Array} - array of filtered nodes
  9 |    */
 10 |   static filterNodesByName(baseNode, nodeNames) {
 11 |     return (function recurseParseTree(node, filteredNodes = []) {
 12 |       if (typeof node !== 'object' || node === null) {
 13 |         return filteredNodes;
 14 |       } else if (node.type && node.value) {
 15 |         return filteredNodes;
 16 |       } else if (nodeNames.includes(node.name)) {
 17 |         return filteredNodes.concat(node);
 18 |       } else if (Array.isArray(node)) {
 19 |         return node.length
 20 |           ? [].concat(...node.map(inner => recurseParseTree(inner, filteredNodes)))
 21 |           : filteredNodes;
 22 |       }
 23 | 
 24 |       return [].concat(...node.values.map(child => recurseParseTree(child, filteredNodes)));
 25 |     }(baseNode));
 26 |   }
 27 | 
 28 |   /**
 29 |    * Given a parse tree node, returns an array of all of the tokens in the node. The tokens are the tokens returned
 30 |    * by the Moo Lexer, used in the nearley grammar.
 31 |    *
 32 |    * @param {Object} node - the parse tree node
 33 |    * @return {Array} - array of tokens
 34 |    */
 35 |   static getTokensFromNode(node) {
 36 |     return (function recurseParseTree(node, tokens = []) {
 37 |       if (typeof node !== 'object' || node === null) {
 38 |         return tokens;
 39 |       } else if (node.type && node.value) {
 40 |         return tokens.concat(node);
 41 |       } else if (Array.isArray(node)) {
 42 |         return node.length
 43 |           ? [].concat(...node.map(inner => recurseParseTree(inner, tokens)))
 44 |           : tokens;
 45 |       }
 46 | 
 47 |       return [].concat(...node.values.map(child => recurseParseTree(child, tokens)));
 48 |     }(node));
 49 |   }
 50 | 
 51 |   /**
 52 |    * Given a shorthand property name and a shorthand property node, returns an object mapping the longhand properties
 53 |    * to the their values in the property node.
 54 |    * @param {string} propertyName - the shorthand property name. For example, 'border'.
 55 |    * @param {Object} propertyNode - the shorthand property node
 56 |    * @returns {Object} - mapping between longhand property names and their corresponding index in the original property
 57 |    *                     value string.
 58 |    */
 59 |   static getPropertyLocationMapping(propertyName, propertyNode) {
 60 |     const longhandRuleNameToPropertyNameMap = shorthandIdentToLonghandPropertyMap[propertyName];
 61 |     const longhandRuleNames = Object.keys(longhandRuleNameToPropertyNameMap);
 62 | 
 63 |     return (function recurseLonghandPropertyNode(node, obj = {}) {
 64 |       if (typeof node !== 'object' || node === null) {
 65 |         return obj;
 66 |       } else if (longhandRuleNames.includes(node.name)) {
 67 |         return { [longhandRuleNameToPropertyNameMap[node.name]]: node.location };
 68 |       } else if (Array.isArray(node)) {
 69 |         return node.length
 70 |           ? Object.assign(...node.map(inner => recurseLonghandPropertyNode(inner, obj)))
 71 |           : obj;
 72 |       }
 73 | 
 74 |       return Object.assign(...node.values.map(child => recurseLonghandPropertyNode(child, obj)));
 75 |     }(propertyNode));
 76 |   }
 77 | 
 78 |   /**
 79 |    * Given a shorthand property name and a shorthand property node, returns an object mapping the longhand properties
 80 |    * to the their nodes in the parse tree. This should only be used for comma separated list shorthand properties.
 81 |    *
 82 |    * @param {string} propertyName - the shorthand property name. For example, 'animation'.
 83 |    * @param {Object} propertyNode - the shorthand property node
 84 |    * @returns {Object} - mapping between longhand property names and their corresponding nodes in the parse tree
 85 |    */
 86 |   static getPropertyNodeMappingCommaSeparatedList(propertyName, propertyNode) {
 87 |     const longhandRuleNameToPropertyNameMap = shorthandIdentToLonghandPropertyMap[propertyName];
 88 |     const longhandRuleNames = Object.keys(longhandRuleNameToPropertyNameMap)
 89 |       .filter(ruleName => longhandRuleNameToPropertyNameMap[ruleName] !== '');
 90 | 
 91 |     // for rule names, such as "time" in animation and transition that are mapped to an array of properties, we need
 92 |     // to keep track of which instance of "time" we have seen. Thus we create a mapping between the rule name and
 93 |     // how many times we encounter the rule name. For example, for animation this would be: { "time": 0 }. Then,
 94 |     // we map the first instance of "time" to "animation-duration" and the second occurrence of "time" to
 95 |     // "animation-delay"
 96 |     const arrayPropertyIndexMap = Object.entries(longhandRuleNameToPropertyNameMap)
 97 |       .filter(([, value]) => Array.isArray(value))
 98 |       .reduce((propertyMap, [propName]) => Object.assign({ [propName]: 0 }, propertyMap), {});
 99 |     const arrayPropertyRuleNames = Object.keys(arrayPropertyIndexMap);
100 | 
101 |     return (function recurseLonghandPropertyNode(node, obj = {}) {
102 |       if (typeof node !== 'object' || node === null) {
103 |         return obj;
104 |       } else if (node.type && node.value) {
105 |         return obj;
106 |       } else if (arrayPropertyRuleNames.includes(node.name)) {
107 |         const propertyObject = {
108 |           [longhandRuleNameToPropertyNameMap[node.name][arrayPropertyIndexMap[node.name]]]: node,
109 |         };
110 |         arrayPropertyIndexMap[node.name] += 1;
111 |         return propertyObject;
112 |       } else if (longhandRuleNames.includes(node.name)) {
113 |         return { [longhandRuleNameToPropertyNameMap[node.name]]: node };
114 |       } else if (Array.isArray(node)) {
115 |         return node.length
116 |           ? Object.assign(...node.map(inner => recurseLonghandPropertyNode(inner, obj)))
117 |           : obj;
118 |       }
119 | 
120 |       return Object.assign(...node.values.map(child => recurseLonghandPropertyNode(child, obj)));
121 |     }(propertyNode));
122 |   }
123 | 
124 |   /**
125 |    * Given an array of property maps, mapping property names to their values, returns an object mapping the property
126 |    * names to property values joined by the given delimiter.
127 |    * @param {[Object]} propertyMaps - an array of objects mapping property names to their values
128 |    * @param {String} [delimiter=", "] - the delimiter to join the property values by
129 |    * @returns {Object} - merged object mapping property names to joined values
130 |    */
131 |   static mergePropertyMaps(propertyMaps, delimiter = ', ') {
132 |     return Object.keys(Object.assign({}, ...propertyMaps))
133 |       .reduce((joinedPropertyMap, propertyName) => Object.assign({
134 |         [propertyName]: propertyMaps.map(propertyMap => propertyMap[propertyName]).filter(Boolean).join(delimiter),
135 |       }, joinedPropertyMap), {});
136 |   }
137 | };
138 | 


--------------------------------------------------------------------------------
/test/.eslintrc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "env": {
 3 |     "mocha": true,
 4 |     "node": true
 5 |   },
 6 |   "rules": {
 7 |     "prefer-arrow-callback": "off",
 8 |     "func-names": "off",
 9 |     "max-len": "off",
10 |     "import/no-dynamic-require": "off"
11 |   }
12 | }


--------------------------------------------------------------------------------
/test/BaseGrammarsTest.js:
--------------------------------------------------------------------------------
 1 | const { assert } = require('chai');
 2 | const nearley = require('nearley');
 3 | 
 4 | /**
 5 |  * Tests for {@link isValidDeclaration}
 6 |  */
 7 | describe('baseGrammars', function () {
 8 |   // TODO: add support for scientific notation
 9 |   describe('number', function () {
10 |     const propertyGrammar = require('../src/grammars/generated').number;
11 | 
12 |     [
13 |       '1',
14 |       '22',
15 |       '200',
16 |       '+1',
17 |       '-1',
18 |       '.4',
19 |       '.5',
20 |       '-.4',
21 |       '+.4',
22 |       '1.0',
23 |       '1.04',
24 |       '12.04',
25 |     ].forEach((val) => {
26 |       it(`should match ${val}`, function () {
27 |         const parser = new nearley.Parser(nearley.Grammar.fromCompiled(propertyGrammar)).feed(val);
28 | 
29 |         assert.equal(parser.results.length, 1);
30 |       });
31 |     });
32 |   });
33 | 
34 |   describe('length', function () {
35 |     const propertyGrammar = require('../src/grammars/generated').length;
36 | 
37 |     [
38 |       '1px',
39 |       '1em',
40 |       '0',
41 |       '2rem',
42 |     ].forEach((val) => {
43 |       it(`should match ${val}`, function () {
44 |         const parser = new nearley.Parser(nearley.Grammar.fromCompiled(propertyGrammar)).feed(val);
45 | 
46 |         assert.equal(parser.results.length, 1);
47 |       });
48 |     });
49 |   });
50 | });
51 | 


--------------------------------------------------------------------------------
/test/GetShorthandComputedPropertiesTest.js:
--------------------------------------------------------------------------------
 1 | const { assert } = require('chai');
 2 | const getShorthandComputedProperties = require('../src/getShorthandComputedProperties');
 3 | 
 4 | /**
 5 |  * Tests for {@link getShorthandComputedProperties}
 6 |  */
 7 | describe('getShorthandComputedProperties', function () {
 8 |   it('should return an empty array for an unknown property', function () {
 9 |     assert.deepEqual(getShorthandComputedProperties('foo'), []);
10 |   });
11 | 
12 |   it('should return an empty array for a non shorthand property', function () {
13 |     assert.deepEqual(getShorthandComputedProperties('color'), ['color']);
14 |   });
15 | 
16 |   it('should return an array of computed properties for background', function () {
17 |     assert.deepEqual(getShorthandComputedProperties('background'), [
18 |       'background-image',
19 |       'background-position',
20 |       'background-size',
21 |       'background-repeat',
22 |       'background-origin',
23 |       'background-clip',
24 |       'background-attachment',
25 |       'background-color',
26 |     ]);
27 |   });
28 | 
29 |   it('should not recursively resolve properties by default', function () {
30 |     assert.deepEqual(getShorthandComputedProperties('border'), [
31 |       'border-width',
32 |       'border-style',
33 |       'border-color',
34 |     ]);
35 |   });
36 | 
37 |   it('should recursively resolve properties', function () {
38 |     assert.deepEqual(getShorthandComputedProperties('border', true), [
39 |       'border-width',
40 |       'border-style',
41 |       'border-color',
42 |       'border-bottom-width',
43 |       'border-left-width',
44 |       'border-right-width',
45 |       'border-top-width',
46 |       'border-bottom-style',
47 |       'border-left-style',
48 |       'border-right-style',
49 |       'border-top-style',
50 |       'border-bottom-color',
51 |       'border-left-color',
52 |       'border-right-color',
53 |       'border-top-color',
54 |     ]);
55 |   });
56 | });
57 | 


--------------------------------------------------------------------------------
/test/GetShorthandsForPropertyTest.js:
--------------------------------------------------------------------------------
 1 | const { assert } = require('chai');
 2 | const getShorthandsForProperty = require('../src/getShorthandsForProperty.js');
 3 | /**
 4 |  * Tests for {@link getShorthandsForProperty}
 5 |  */
 6 | describe('getShorthandsForProperty', function () {
 7 |   it('should return an empty array for an unknown property', function () {
 8 |     assert.deepEqual(getShorthandsForProperty('foo'), []);
 9 |   });
10 | 
11 |   it('should return itself for a property that has no shorthands', function () {
12 |     assert.deepEqual(getShorthandsForProperty('float'), ['float']);
13 |   });
14 | 
15 |   it('should return a property when passed a longhand', function () {
16 |     assert.deepEqual(getShorthandsForProperty('background-image'), [
17 |       'background-image',
18 |       'background',
19 |     ]);
20 |   });
21 | 
22 |   it('should return all shorthands if more than one', function () {
23 |     assert.deepEqual(getShorthandsForProperty('border-left-color'), [
24 |       'border-left-color',
25 |       'border-left',
26 |       'border-color',
27 |       'border',
28 |     ]);
29 |   });
30 | });
31 | 


--------------------------------------------------------------------------------
/test/InitialValuesTest.js:
--------------------------------------------------------------------------------
 1 | const { assert } = require('chai');
 2 | const properties = require('../src/formatted-data/properties.json');
 3 | const {
 4 |    initialValue,
 5 |    initialValues,
 6 |    isInitialValue,
 7 |    isValidDeclaration,
 8 |    expandShorthandProperty,
 9 | } = require('../src');
10 | 
11 | /**
12 |  * Tests for {@link initialValues}
13 |  */
14 | describe('Initial values', function () {
15 |   it('are legal values', () => {
16 |     // TODO figure out why these legal values don't validate.
17 |     const buggyValues = new Set([
18 |       'background-position-x',
19 |       'background-position-y',
20 |       'border-radius',
21 |       'border-spacing',
22 |       'cursor',
23 |       'display-inside',
24 |       'display-outside',
25 |       'grid-area',
26 |       'grid-column',
27 |       'grid-gap',
28 |       'grid-row',
29 |       'offset',
30 |       'outline-color',
31 |       'position',
32 |       'transform-box',
33 |     ]);
34 |     Object.keys(properties).forEach((prop) => {
35 |       if (prop.startsWith('-') || buggyValues.has(prop)) return; // bug in grammar data
36 |       let initial = initialValue(prop);
37 |       assert(isValidDeclaration(prop, initial), `${prop}: ${initial} is not a legal initial value`);
38 |     });
39 |   });
40 |   it('expand recursively with intermediate shorthands', () => {
41 |     const values = initialValues('background', true, true);
42 |     assert.deepEqual(values, {
43 |       background: 'none',
44 |       'background-attachment': 'scroll',
45 |       'background-clip': 'border-box',
46 |       'background-color': 'transparent',
47 |       'background-image': 'none',
48 |       'background-origin': 'padding-box',
49 |       'background-position': '0% 0%',
50 |       'background-repeat': 'repeat',
51 |       'background-size': 'auto auto',
52 |     })
53 |   });
54 |   it('expand recursively without intermediate shorthands', () => {
55 |     const values = initialValues('border', true, false);
56 |     assert.deepEqual(values, {
57 |       'border-bottom-color': 'currentcolor',
58 |       'border-bottom-style': 'none',
59 |       'border-bottom-width': 'medium',
60 |       'border-left-color': 'currentcolor',
61 |       'border-left-style': 'none',
62 |       'border-left-width': 'medium',
63 |       'border-right-color': 'currentcolor',
64 |       'border-right-style': 'none',
65 |       'border-right-width': 'medium',
66 |       'border-top-color': 'currentcolor',
67 |       'border-top-style': 'none',
68 |       'border-top-width': 'medium',
69 |     })
70 |   });
71 |   it('can check if a value is an initial value', () => {
72 |     assert(isInitialValue('border-bottom-width', 'medium'));
73 |     assert(isInitialValue('border-bottom-width', 'initial'));
74 |     assert(isInitialValue('border-bottom-width', 'MEDIUM'));
75 |     assert(isInitialValue('padding', '0'));
76 |     assert(isInitialValue('padding', '0px'));
77 |     assert(isInitialValue('padding', '0PX'));
78 |     assert(isInitialValue('padding', '0 0'));
79 |     assert(isInitialValue('padding', '0 0 0 0'));
80 |     assert(isInitialValue('padding', 'initial'));
81 |   });
82 |   it('can check if a value is not an initial value', () => {
83 |     assert(!isInitialValue('border-bottom-width', '1px'));
84 |     assert(!isInitialValue('padding', '1px'));
85 |     assert(!isInitialValue('padding', '2%'));
86 |   });
87 | });


--------------------------------------------------------------------------------
/test/benchmark.js:
--------------------------------------------------------------------------------
 1 | const Benchmark = require('benchmark');
 2 | 
 3 | const expandShorthandProperty = require('../src/expandShorthandProperty');
 4 | const cssValues = require("css-values").default;
 5 | 
 6 | let suite = new Benchmark.Suite;
 7 | 
 8 | function ms(n) {
 9 |     return Math.round(n * 100000) / 100;
10 | }
11 | 
12 | function dumbBorderImpl(prop, val) {
13 |     let vals = val.split(/\s+/);
14 |     return {
15 |         "border-width": vals.unshift(),
16 |         "border-style": vals.unshift(),
17 |         "border-color": vals.unshift(),
18 |     };
19 | }
20 | const borderDefaults = {
21 |     "border-width": "medium",
22 |     "border-style": "none",
23 |     "border-color": "currentcolor",
24 | };
25 | const borderKeys = Object.keys(borderDefaults);
26 | 
27 | function cssValuesBorderImpl(prop, val) {
28 |     let vals = val.split(/\s+/);
29 |     let rv = {};
30 |     for (let i = 0; i < vals.length; i++) {
31 |         for (let j = 0; j < vals.length; j++) {
32 |             let k = borderKeys[j];
33 |             let taken = [];
34 |             if (cssValues(k, vals[i]) === true) {
35 |                 if (taken.indexOf(k) >= 0) {
36 |                     throw new Error(`invalid value for ${prop}: ${val}`);
37 |                 } else {
38 |                     rv[k] = vals[i];
39 |                     taken.push(k);
40 |                 }
41 |             }
42 |         }
43 |     }
44 |     return Object.assign({}, borderDefaults, rv);
45 | }
46 | 
47 | // add tests
48 | suite.add('border: 1px solid black;', function() {
49 |     expandShorthandProperty('border', '1px solid black')
50 | }).add('border: 1px;', function() {
51 |     expandShorthandProperty('border', '1px')
52 | }).add('border: solid;', function() {
53 |     expandShorthandProperty('border', 'solid')
54 | }).add('border: black;', function() {
55 |     expandShorthandProperty('border', 'black')
56 | }).add('dumb impl of border: 1px solid black;', function() {
57 |     dumbBorderImpl('border', '1px solid black')
58 | }).add('css-values impl of border: 1px solid black;', function() {
59 |     cssValuesBorderImpl('border', '1px solid black');
60 | }).on('complete', function () {
61 |     for (let i = 0; i < this.length; i++) {
62 |         let stats = this[i].stats;
63 |         console.log(`"${this[i].name}" expanded ${this[i].count} times. Average: ${ms(stats.mean)}ms +/- ${ms(stats.deviation)}ms`);
64 |     }
65 | })
66 | // run async
67 | .run({ 'async': true });
68 | 


--------------------------------------------------------------------------------
/test/formatters/JsonGrammarFormatterTest.js:
--------------------------------------------------------------------------------
  1 | const { assert } = require('chai');
  2 | const JsonGrammarFormatter = require('../../src/formatters/grammarFormatters/JsonGrammarFormatter');
  3 | 
  4 | /**
  5 |  * Tests for {@link JsonGrammarFormatter}
  6 |  */
  7 | describe('JsonGrammarFormatter#formatFormalSyntax', function () {
  8 |   describe('single bar', function () {
  9 |     it('should handle simple or', function () {
 10 |       const result = JsonGrammarFormatter.format('foo | bar');
 11 | 
 12 |       assert.deepEqual(result, [['Base', '( "foo" | "bar" )']]);
 13 |     });
 14 | 
 15 |     it('should not create intermediate rules for terminal nodes', function () {
 16 |       const result = JsonGrammarFormatter.format('foo | bar | baz');
 17 | 
 18 |       assert.deepEqual(result, [['Base', '( "foo" | "bar" | "baz" )']]);
 19 |     });
 20 |   });
 21 | 
 22 |   describe('curly', function () {
 23 |     it('should handle single number case', function () {
 24 |       const result = JsonGrammarFormatter.format('foo{3}');
 25 | 
 26 |       assert.deepEqual(result, [['Base', '( "foo" __ "foo" __ "foo" )']]);
 27 |     });
 28 | 
 29 |     it.skip('should handle single number with comma case', function () {
 30 |       const result = JsonGrammarFormatter.format('foo{3,}');
 31 | 
 32 |       assert.deepEqual(result, [['Base', '( "foo" __ "foo" __ "foo" ( __ "foo"):* )']]);
 33 |     });
 34 | 
 35 |     it('should handle both number case', function () {
 36 |       const result = JsonGrammarFormatter.format('foo{3,5}');
 37 | 
 38 |       assert.deepEqual(result, [['Base', '( "foo" __ "foo" __ "foo" ( __ "foo" ):? ( __ "foo" ):? )']]);
 39 |     });
 40 | 
 41 |     it('should handle hash curly case', function () {
 42 |       const result = JsonGrammarFormatter.format('foo#{3}');
 43 | 
 44 |       assert.deepEqual(result, [['Base', '( "foo" _ "," _ "foo" _ "," _ "foo" )']]);
 45 |     });
 46 |   });
 47 | 
 48 |   describe('double bar', function () {
 49 |     it('should handle simple double bar', function () {
 50 |       const result = JsonGrammarFormatter.format('foo || bar');
 51 | 
 52 |       assert.deepEqual(result, [['Base', '( "foo" | "bar" ) ( __ ( "foo" | "bar" ) ):*']]);
 53 |     });
 54 | 
 55 |     it.skip('should handle complex double bar list', function () {
 56 |       const result = JsonGrammarFormatter.format('foo || bar || baz || willow');
 57 | 
 58 |       assert.deepEqual(result, [['Base', '( ( "foo" | "bar" | "baz" | "willow" ) ( __ ( "foo" | "bar" | "baz" | "willow" ) ):* )']]);
 59 |     });
 60 |   });
 61 | 
 62 |   describe('real use cases', function () {
 63 |     const tests = [
 64 |       {
 65 |         args: ['flow | flow-root | table | flex | grid | subgrid | ruby'],
 66 |         expected: [['Base', '( "flow" | "flow-root" | "table" | "flex" | "grid" | "subgrid" | "ruby" )']],
 67 |       },
 68 |       {
 69 |         args: ['<angle> | <percentage>'],
 70 |         expected: [
 71 |           ['Base', '( <angle> | <percentage> )'],
 72 |           ['<angle>'],
 73 |           ['<percentage>'],
 74 |         ],
 75 |       },
 76 |       {
 77 |         args: ['[ <length-percentage> | auto ]{1,2} | cover | contain'],
 78 |         expected: [
 79 |           ['Base', '( ( ( ( <length-percentage> | "auto" ) ) ( __ ( ( <length-percentage> | "auto" ) ) ):? ) | "cover" | "contain" )'],
 80 |           ['<length-percentage>'],
 81 |         ],
 82 |       },
 83 |       {
 84 |         args: ['[ left | right ] | [ top | bottom ]'],
 85 |         expected: [
 86 |           ['Base', '( ( ( "left" | "right" ) ) | ( ( "top" | "bottom" ) ) )'],
 87 |         ],
 88 |       },
 89 |       {
 90 |         args: ['<color-stop>#{2,}'],
 91 |         expected: [
 92 |           ['Base', '( <color-stop> _ "," _ <color-stop> ( _ "," _ <color-stop> ):* )'],
 93 |           ['<color-stop>'],
 94 |         ],
 95 |       },
 96 |     ];
 97 | 
 98 |     tests.forEach(({ args, expected }) => {
 99 |       it(`should handle ${args[0]}`, function () {
100 |         assert.deepEqual(JsonGrammarFormatter.format(...args), expected);
101 |       });
102 |     });
103 |   });
104 | });
105 | 


--------------------------------------------------------------------------------
/test/formatters/NearleyGrammarFormatterTest.js:
--------------------------------------------------------------------------------
 1 | const sinon = require('sinon');
 2 | const fs = require('fs-extra');
 3 | const path = require('path');
 4 | const { assert } = require('chai');
 5 | const PATHS = require('../../src/constants/paths');
 6 | const GRAMMAR_CONSTANTS = require('../../src/constants/grammars');
 7 | const NearleyGrammarFormatter = require('../../src/formatters/grammarFormatters/NearleyGrammarFormatter');
 8 | 
 9 | /**
10 |  * Tests for {@link NearleyGrammarFormatter}
11 |  */
12 | describe('NearleyGrammarFormatter#format', function () {
13 |   let sandbox;
14 | 
15 |   beforeEach(function () {
16 |     sandbox = sinon.sandbox.create();
17 |   });
18 | 
19 |   afterEach(function () {
20 |     sandbox.restore();
21 |   });
22 | 
23 |   describe('simple base key conversions', function () {
24 |     it('should convert base key correctly', function () {
25 |       const result = NearleyGrammarFormatter.format([
26 |         [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '( "test" )'],
27 |       ], 'test');
28 | 
29 |       assert.equal(result, '@builtin "whitespace.ne"\n@{%\n  const lexer = require("../../../constants/genericLexer");\n%}\n\n@lexer lexer\n\n\nBase -> ( "test" )');
30 |     });
31 |   });
32 | 
33 |   describe('rule body conversion', function () {
34 |     it('should convert kebab to pascal case', function () {
35 |       const result = NearleyGrammarFormatter.format([
36 |         [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '( <test-test> )'],
37 |       ], 'test');
38 | 
39 |       assert.equal(result, '@builtin "whitespace.ne"\n@{%\n  const lexer = require("../../../constants/genericLexer");\n%}\n\n@lexer lexer\n\n\nBase -> ( TestTest )');
40 |     });
41 | 
42 |     it('should convert kebab with parens to pascal case with Func prefix', function () {
43 |       const result = NearleyGrammarFormatter.format([
44 |         [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '( <test-test()> )'],
45 |       ], 'test');
46 | 
47 |       assert.equal(result, '@builtin "whitespace.ne"\n@{%\n  const lexer = require("../../../constants/genericLexer");\n%}\n\n@lexer lexer\n\n\nBase -> ( TestTestFunc )');
48 |     });
49 | 
50 |     it('should not do any conversion with tokens', function() {
51 |       const result = NearleyGrammarFormatter.format([
52 |         [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '( <test-test()> %customIdent )'],
53 |       ], 'test');
54 | 
55 |       assert.equal(result, '@builtin "whitespace.ne"\n@{%\n  const lexer = require("../../../constants/genericLexer");\n%}\n\n@lexer lexer\n\n\nBase -> ( TestTestFunc %customIdent )');
56 |     });
57 |   });
58 | 
59 |   describe('recursive cases', function () {
60 |     it('should handle deeply recursive cases', function () {
61 |       sandbox.stub(fs, 'readJsonSync')
62 |         .withArgs(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, 'ra.json'))
63 |         .returns([
64 |           [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '<rb>'],
65 |           ['<rb>'],
66 |         ])
67 |         .withArgs(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, 'rb.json'))
68 |         .returns([
69 |           [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '<rc>'],
70 |           ['<rc>'],
71 |         ])
72 |         .withArgs(path.join(PATHS.GENERATED_JSON_GRAMMAR_PATH, 'rc.json'))
73 |         .returns([
74 |           [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '"d"'],
75 |         ]);
76 | 
77 |       const result = NearleyGrammarFormatter.format([
78 |         [GRAMMAR_CONSTANTS.BASE_GRAMMAR_RULE_NAME, '<ra>'],
79 |         ['<ra>'],
80 |       ], 'r');
81 | 
82 |       assert.equal(result, '@builtin "whitespace.ne"\n@{%\n  const lexer = require("../../../constants/genericLexer");\n%}\n\n@lexer lexer\n\n\n' +
83 |         'Base -> Ra\n' +
84 |         'Ra -> Rb\n' +
85 |         'Rb -> Rc\n' +
86 |         'Rc -> "d"');
87 |     });
88 | 
89 |     it('should filter out duplicate recursively resolved keys', function () {
90 | 
91 |     });
92 |   });
93 | });
94 | 


--------------------------------------------------------------------------------
/test/isValidDeclarationTest.js:
--------------------------------------------------------------------------------
 1 | const { assert } = require('chai');
 2 | const isValidDeclaration = require('../src/isValidDeclaration');
 3 | 
 4 | /**
 5 |  * Tests for {@link isValidDeclaration}
 6 |  */
 7 | describe('isValidDeclaration', function () {
 8 |   describe('color', function () {
 9 |     ['currentcolor', 'red', 'orange', 'tan', 'rebeccapurple', '#0f0', '#00ff00', '#0f0a', '#ABC117',
10 |       '#00ff0080', 'rgb(34, 12, 64, 0.3)', 'rgb(34,12,64,0.3)', 'rgba(34, 12, 64, 0.3)',
11 |       'rgb(34 12 64 / 0.3)', 'rgba(34 12 64 / 0.3)',
12 |       'hsl(30, 100%, 50%, 0.3)', 'hsla(30, 100%, 50%, 0.3)', 'hsl(30 100% 50% / 0.3)',
13 |       'hsla(30 100% 50% / 0.3)', 'inherit', 'initial', 'unset', 'var(--hello)']
14 |       .forEach((value) => {
15 |         it(`should return true for ${value}`, function () {
16 |           assert(isValidDeclaration('color', value));
17 |         });
18 |       });
19 |   });
20 | 
21 |   describe('border', function () {
22 |     ['1px', 'solid', 'black', 'Black', 'bLaCk', '1px solid', 'solid 1px', '1px solid black', 'medium dashed green', 'gReeN mEdiuM DasHed', 'green medium dashed']
23 |       .forEach((value) => {
24 |         it(`should return true for ${value}`, function () {
25 |           assert(isValidDeclaration('border', value));
26 |         });
27 |       });
28 |   });
29 | 
30 |   describe('margin', function () {
31 |     ['0', 'auto', '1px', '1em', '0 auto', '1px 1px', '1px 1em', '20% auto 1px', '20% 1px 20em -2%', 'var(--hello09-a)', '1Px', '2PX', '0 aUto']
32 |       .forEach((value) => {
33 |         it(`should return true for ${value}`, function () {
34 |           assert(isValidDeclaration('margin', value));
35 |         });
36 |       });
37 |   });
38 | 
39 | 
40 |   describe('z-index', function () {
41 |     ['auto', '1', '-1', '-100', '999']
42 |       .forEach((value) => {
43 |         it(`should return true for ${value}`, function () {
44 |           assert(isValidDeclaration('z-index', value));
45 |         });
46 |       });
47 |   });
48 | 
49 |   describe('width', function () {
50 |     ['1px', '2em', '20%', '1vh', '1vw', '20rem', '0', '300px', '25em', '75%', '25em border-box', '75% content-box', 'max-content', 'min-content', 'available',
51 |       'fit-content', 'auto']
52 |       .forEach((value) => {
53 |         it(`should return true for ${value}`, function () {
54 |           assert(isValidDeclaration('width', value));
55 |         });
56 |       });
57 |   });
58 | });
59 | 


--------------------------------------------------------------------------------
/updateCSSData.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | function realpath()
 3 | {
 4 |     f=$@
 5 |     if [ -d "$f" ]; then
 6 |         base=""
 7 |         dir="$f"
 8 |     else
 9 |         base="/$(basename "$f")"
10 |         dir=$(dirname "$f")
11 |     fi
12 |     dir=$(cd "$dir" && /bin/pwd)
13 |     echo "$dir$base"
14 | }
15 | cd "$(dirname "$(realpath "$0")")";
16 | rm -rf src/formatted-data src/grammars/generated/json
17 | mkdir -p src/formatted-data src/grammars/generated/json
18 | node ./node_modules/nearley/bin/nearleyc.js ./src/grammars/nearley/formalSyntax.ne > ./src/grammars/js/formalSyntax.js || exit 1
19 | node ./src/scripts/updateBasicDataUnits.js || exit 1
20 | node ./src/scripts/formatData.js || exit 1
21 | node ./src/scripts/formatFormalSyntaxes.js || exit 1
22 | node ./src/scripts/formatGrammars.js || exit 1
23 | node ./src/scripts/extractProperties.js || exit 1


--------------------------------------------------------------------------------