@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/json/to-csn.js

@@ -23,15 +23,16 @@ const normalizedKind = {
   param: 'param',
   action: 'action',
   function: 'action',
+  enum: 'enum',
 };
 
 /** @type {boolean|string} */
 let gensrcFlavor = true;       // good enough here...
 let universalCsn = false;
 let strictMode = false;        // whether to dump with unknown properties (in standard)
-let parensAsStrings = false;
 let projectionAsQuery = false;
 let withLocations = false;
+let structXpr = false;
 let dictionaryPrototype = null;
 
 // Properties for dictionaries, set in compileX() and TODO: parseX(), must be
@@ -92,7 +93,7 @@ const transformers = {
   where: condition,             // also pathItem after 'cardinality' before 'args'
   having: condition,
   args,                        // also pathItem after 'where', before 'on'/'orderBy'
-  suffix: node => [].concat( ...node.suffix.map( xprArg ) ),
+  suffix: ignore,              // handled in exprInternal()
   orderBy: arrayOf( orderBy ), // TODO XSN: make `sort` and `nulls` sibling properties
   sort: value,
   nulls: value,
@@ -190,41 +191,6 @@ const typeProperties = [
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
 ];
 
-const operators = {
-  // standard is: binary infix (and corresponding n-ary), unary prefix
-  isNot: [ 'is', 'not' ],       // TODO XSN: 'is not'
-  isNull: postfix( [ 'is', 'null' ] ),
-  isNotNull: postfix( [ 'is', 'not', 'null' ] ),
-  in: binaryRightParen( [ 'in' ] ),
-  notIn: binaryRightParen( [ 'not', 'in' ] ),
-  between: ternary( [ 'between' ], [ 'and' ] ),
-  notBetween: ternary( [ 'not', 'between' ], [ 'and' ] ),
-  like: ternary( [ 'like' ], [ 'escape' ] ),
-  notLike: ternary( [ 'not', 'like' ], [ 'escape' ] ),
-  when: exprs => [ 'when', ...exprs[0], 'then', ...exprs[1] ],
-  case: exprs => [ 'case' ].concat( ...exprs, [ 'end' ] ),
-  over: exprs => [ 'over', { xpr: [].concat( ...exprs ) } ],
-  orderBy: exprs => [ // ORDER BY in generic functions
-    ...exprs[0], ...operators.overOrderBy(exprs.slice(1)),
-  ],
-  overOrderBy: exprs => [ // ORDER BY in OVER() clause
-    'order', 'by', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
-  ],
-  partitionBy: exprs => [
-    'partition', 'by', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
-  ],
-  rows: exprs => [
-    'rows', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
-  ],
-  preceding: postfix( [ 'preceding' ] ),
-  unboundedPreceding: [ 'unbounded', 'preceding' ],
-  currentRow: [ 'current', 'row' ],
-  unboundedFollowing: [ 'unbounded', 'following' ],
-  following: postfix( [ 'following' ] ),
-  frameBetween: exprs => [ 'between', ...exprs[0], 'and', ...exprs[1] ],
-  ixpr: exprs => [].concat( ...exprs ), // xpr extra, due to extra parentheses
-};
-
 const csnDictionaries = [
   'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions',
 ];
@@ -280,7 +246,7 @@ function sortCsn( csn, cloneOptions = false ) {
   return r;
 }
 
-function cloneAnnotationValue(val) {
+function cloneAnnotationValue( val ) {
   if (typeof val !== 'object') // scalar
     return val;
   return JSON.parse( JSON.stringify( val ) );
@@ -295,7 +261,7 @@ function cloneAnnotationValue(val) {
  * @param {string} property
  * @returns
  */
-function hasNonEnumerable(object, property) {
+function hasNonEnumerable( object, property ) {
   return {}.hasOwnProperty.call( object, property ) &&
     !{}.propertyIsEnumerable.call( object, property );
 }
@@ -345,7 +311,7 @@ function compactModel( model, options = model.options || {} ) {
   for (const first in srcDict) {
     const { namespace } = srcDict[first];
     if (namespace && namespace.path)
-      csn.namespace = namespace.path.map( i => i.id ).join('.');
+      csn.namespace = pathName( namespace.path );
     break;
   }
   set( 'definitions', csn, model );
@@ -429,21 +395,10 @@ function extensions( node, csn, model ) {
     }
     else if (gensrcFlavor) {
       // From definitions (without redefinitions) with potential inferred elements:
-      const annotate = { annotate: name };
-      if (art.$inferred)
-        Object.assign( annotate, annotationsAndDocComment( art, true ) );
-      if (art.$expand === 'annotate') {
-        if (art.actions)
-          attachAnnotations( annotate, 'actions', art.actions, art.$inferred );
-        else if (art.params)
-          attachAnnotations( annotate, 'params', art.params, art.$inferred );
-        const obj = art.returns || art;
-        const elems = (obj.items || obj).elements; // no targetAspect here
-        if (elems)
-          attachAnnotations( annotate, 'elements', elems, art.$inferred, art.returns );
-      }
-      if (Object.keys( annotate ).length > 1)
-        exts.push( annotate );
+      const result = { annotate: Object.create(null) };
+      attachAnnotations(result, 'annotate', { [name]: art }, art.$inferred );
+      if (result.annotate[name])
+        exts.push({ annotate: name, ...result.annotate[name] } );
     }
   }
 
@@ -470,7 +425,7 @@ function extensions( node, csn, model ) {
         const par = art.params[name];
         if (!inferredParent && !par.$inferred && par.$expand !== 'annotate')
           continue;
-        const render = annotationsAndDocComment( par, true );
+        const render = annotationsAndDocComment( par );
         const subElems = par.$expand !== 'origin' && (par.items || par).elements;
         if (subElems) {
           const sub = inferred( subElems, par.$inferred );
@@ -487,7 +442,7 @@ function extensions( node, csn, model ) {
       const par = art.returns;
       if (!inferredParent && !par.$inferred && par.$expand !== 'annotate')
         return;
-      const render = annotationsAndDocComment( par, true );
+      const render = annotationsAndDocComment( par );
       const subElems = par.$expand !== 'origin' && (par.items || par).elements;
       if (subElems) {
         const sub = inferred( subElems, par.$inferred );
@@ -508,7 +463,7 @@ function extensions( node, csn, model ) {
     const name = art.name.absolute;
     // 'true' because annotations on namespaces and builtins can only
     // happen through extensions.
-    const annos = annotationsAndDocComment( art, true );
+    const annos = annotationsAndDocComment( art );
     const annotate = Object.assign( { annotate: name }, annos );
     if (Object.keys( annotate ).length > 1) {
       const loc = locationForAnnotationExtension();
@@ -567,16 +522,21 @@ function sources( srcDict, csn ) {
 function attachAnnotations( annotate, prop, dict, inferred, insideReturns = false ) {
   const annoDict = Object.create( dictionaryPrototype );
   for (const name in dict) {
-    const elem = dict[name];
-    const inf = inferred || elem.$inferred; // is probably always inferred if parent was
-    const sub = (inf) ? annotationsAndDocComment( elem, true ) : {};
-    if (elem.$expand === 'annotate') {
-      if (elem.params)
-        attachAnnotations( sub, 'params', elem.params, inf );
-      const obj = elem.returns || elem;
-      const elems = (obj.items || obj.targetAspect || obj).elements;
+    const entry = dict[name];
+    const inf = inferred || entry.$inferred; // is probably always inferred if parent was
+    const sub = (inf) ? annotationsAndDocComment( entry ) : {};
+    if (entry.$expand === 'annotate') {
+      if (entry.actions)
+        attachAnnotations( sub, 'actions', entry.actions, inf );
+      else if (entry.params)
+        attachAnnotations( sub, 'params', entry.params, inf );
+      const obj = entry.returns || entry;
+      const many = obj.items || obj;
+      const elems = (many.targetAspect || many).elements;
       if (elems)
-        attachAnnotations( sub, 'elements', elems, inf, elem.returns );
+        attachAnnotations( sub, 'elements', elems, inf, entry.returns );
+      if (many.enum)
+        attachAnnotations( sub, 'enum', many.enum, inf );
     }
     if (Object.keys( sub ).length)
       annoDict[name] = sub;
@@ -723,10 +683,14 @@ function keepElements( node, line ) {
   return false;                 // no need to render elements
 }
 
-// for gensrcFlavor and namespace/builtin annotation extraction:
-// return annotations from definition (annotated==false)
-// or annotations (annotated==true)
-function annotationsAndDocComment( node, annotated ) {
+/**
+ * For gensrcFlavor and namespace/builtin annotation extraction:
+ * return annotations from definition and annotations.
+ * The call side should check that node.$inferred is truthy.
+ *
+ * @param {object} node
+ */
+function annotationsAndDocComment( node ) {
   const csn = {};
   const transformer = transformers['@'];
   const keys = Object.keys( node ).filter( a => a.charAt(0) === '@' ).sort();
@@ -734,18 +698,18 @@ function annotationsAndDocComment( node, annotated ) {
     const val = node[prop];
     // val.$priority isn't set for computed annotations like @Core.Computed
     // and @odata.containment.ignore
-    // TODO: use $inferred instead special $priority value
-    if (val.$priority !== undefined && (!!val.$priority) === annotated) {
-      // transformer (= value) takes care to exclude $inferred annotation assignments
-      const sub = transformer( val );
-      // As value() just has one value, so we do not provide ( val, csn, node, prop )
-      // which would be more robust, but makes some JS checks unhappy
-      if (sub !== undefined)
-        csn[prop] = sub;
-    }
+    // transformer (= value) takes care to exclude $inferred annotation assignments
+    const sub = transformer( val );
+    // As value() just has one value, so we do not provide ( val, csn, node, prop )
+    // which would be more robust, but makes some JS checks unhappy
+    if (sub !== undefined)
+      csn[prop] = sub;
+  }
+  if (node.doc) {
+    const doc = transformers.doc(node.doc);
+    if (doc !== undefined)
+      csn.doc = doc;
   }
-  if (node.doc)
-    csn.doc = transformers.doc(node.doc);
   return csn;
 }
 
@@ -833,21 +797,18 @@ function dictionary( dict, keys, prop ) {
 }
 
 function foreignKeys( dict, csn, node ) {
-  if (universalCsn) {
-    if (!target( node.target, csn, node ) || dict[$inferred] === 'keys')
-      return;
-  }
-  if (gensrcFlavor && node._origin && node._origin.$inferred === 'REDIRECTED')
-    dict = node._origin.foreignKeys;
-  const keys = [];
-  for (const n in dict) {
-    const d = definition( dict[n] );
-    if (d !== undefined)
-      keys.push( d );
-    else
+  if (universalCsn && dict[$inferred] === 'keys' || !target( node.target, csn, node ) )
+    return;
+
+  if (gensrcFlavor) {
+    if (node._origin?.$inferred === 'REDIRECTED')
+      dict = node._origin.foreignKeys;
+    if (dict[$inferred])
       return;
   }
-  csn.keys = keys;
+  csn.keys = [];
+  for (const n in dict)
+    csn.keys.push( definition( dict[n] ) );
 }
 
 function returns( art, csn, _node, prop ) {
@@ -1235,7 +1196,7 @@ function renderArtifactPath( node, path, terse, scope ) {
     const name = item._artifact && item._artifact.name;
     // In localization views, the _artifact link of `item` is important
     const id = name && name.absolute ||
-               path.slice( 0, scope ).map( i => i.id ).join('.');
+               pathName( path.slice( 0, scope ) );
     path = [ Object.assign( {}, item, { id } ), ...path.slice( scope ) ];
   }
   const ref = path.map( pathItem );
@@ -1259,7 +1220,7 @@ function args( node ) {
     return node.map( expression );
   const dict = Object.create( dictionaryPrototype );
   for (const param in node)
-    dict[param] = expression( node[param], true );
+    dict[param] = expression( node[param] );
   return dict;
 }
 
@@ -1302,7 +1263,7 @@ function enumValue( v, csn, node ) {
     return;
   // (with gensrc, the symbol itself would not make it into the CSN)
   if (node.kind === 'enum' || node._parent && node._parent.kind === 'extend')
-    Object.assign( csn, expression( v, true ) );
+    Object.assign( csn, expression( v ) );
 }
 
 
@@ -1317,128 +1278,89 @@ function onCondition( cond, csn, node ) {
 }
 
 function condition( node ) {
-  const expr = expression( node );
-  // we do not set a hidden $parens on array - we could still do it if requested
-  return !expr.cast && !expr.func && expr.xpr || [ expr ];
+  const expr = exprInternal( node, 'no' );
+  return (Array.isArray( expr ))
+    ? flattenenInternalXpr( expr )
+    : !expr.cast && !expr.func && expr.xpr || [ expr ];
+}
+
+function expression( node ) {
+  const expr = exprInternal( node, 'no' );
+  return (Array.isArray( expr ))
+    ? { xpr: flattenenInternalXpr( expr ) }
+    : expr;
 }
 
-function expression( node, dollarExtra ) {
-  const dollarExtraNode = dollarExtra !== 'ignoreExtra' && node;
+function exprInternal( node, xprParens ) {
   if (typeof node === 'string')
     return node;
   if (!node)                    // make to-csn robst
     return {};
   if (node.scope === 'param') {
     if (node.path)
-      return extra( { ref: node.path.map( pathItem ), param: true }, dollarExtraNode );
+      return extra( { ref: node.path.map( pathItem ), param: true }, node );
     return { ref: [ node.param.val ], param: true }; // CDL rule for runtimes
   }
   if (node.path) {
     const ref = node.path.map( pathItem );
-    if (node.path.$prefix)
+    if (node.path.$prefix)      // auto-corrected ORDER BY refs without table alias
       ref.unshift( node.path.$prefix );
     // we would need to consider node.global here if we introduce that
-    return extra( { ref }, dollarExtraNode );
+    return extra( { ref }, node );
   }
   if (node.literal) {
     if (typeof node.val === node.literal || node.val === null)
-      return extra( { val: node.val }, dollarExtraNode );
+      return extra( { val: node.val }, node );
     else if (node.literal === 'enum')
-      return extra( { '#': node.sym.id }, dollarExtraNode );
+      return extra( { '#': node.sym.id }, node );
     else if (node.literal === 'token')
       return node.val;          // * in COUNT(*)
-    return extra( { val: node.val, literal: node.literal }, dollarExtraNode );
+    return extra( { val: node.val, literal: node.literal }, node );
   }
   if (node.func) {              // TODO XSN: remove op: 'call', func is no path
     const call = { func: node.func.path[0].id };
-    if (node.args) {       // no args from CSN input for CURRENT_DATE etc
+    if (node.args)       // no args from CSN input for CURRENT_DATE etc
       call.args = args( node.args );
-      const arg0 = call.args[0];
-      const { quantifier } = node.func.path[0];
-      if (arg0 && quantifier) {
-        if (typeof arg0 !== 'object' || !arg0.xpr)
-          call.args[0] = { xpr: [ quantifier.val, arg0 ] };
-        else
-          arg0.xpr.unshift( quantifier.val );
-      }
-    }
     if (node.suffix)
-      call.xpr = [].concat( ...node.suffix.map( xprArg ) );
-    return extra( call, dollarExtraNode );
+      call.xpr = condition( { op: { val: 'ixpr' }, args: node.suffix } );
+    // remark: node.suffix.map( expression ) would add $parens: 1 for xpr after "over"
+    return extra( call, node );
   }
   if (node.query)
     return query( node.query, null, null, null, 1 );
   if (!node.op)                 // parse error
     return { xpr: [] };
-  else if (node.op.val === 'xpr')
-    // do not use xpr() for xpr, as it would flatten inner xpr's
-    return extra({ xpr: node.args.map( expression ) }, dollarExtraNode, 1 );
-  else if (node.op.val === 'cast')
-    return cast( expression( node.args[0] ), dollarExtraNode );
-  // from here on: CDL input (no $extra possible - but $parens)
-  else if (node.op.val !== ',')
-    return extra( { xpr: xpr( node ) }, dollarExtraNode, (dollarExtra === 'sub-xpr' ? 1 : 0) );
-  return (parensAsStrings)
-    ? { xpr: [ '(', ...xpr( node ), ')' ] }
-    // the inner parens belong to the tuple construct, i.e. won't count as parens
-    : extra( { list: node.args.map( expression ) }, dollarExtraNode, 0 );
-}
-
-function xpr( node ) {
-  // if (!node.op) console.log(node)
-  const op = operators[node.op.val] || node.op.val.split(' ');
-  const exprs = node.args.map( xprArg );
-  if (op instanceof Function)
-    return op( exprs );
-  if (node.quantifier)
-    op.push( node.quantifier.val );
-  if (exprs.length < 2)
-    return [ ...op, ...exprs[0] || [] ];
-  return exprs[0].concat( ...exprs.slice(1).map( a => [ ...op, ...a ] ) );
-}
-
-function xprArg( sub ) {
-  const realXpr = sub.op && sub.op.val === 'xpr';
-  const expr = expression( sub, 'sub-xpr' );
-  // `sort`/`nulls` will be attached to arguments of orderBy
-  // which might be either `path`s or `xpr`s
-  const sortAndNulls = [];
-  if (sub.sort)
-    sortAndNulls.push( sub.sort.val );
-  if (sub.nulls)
-    sortAndNulls.push( ...[ 'nulls', sub.nulls.val ] );
-  // return !sub.$parens && !expr.cast && !expr.func && expr.xpr || [ expr ];
-  // if parensAsStrings is gone
-  if (realXpr || expr.cast || expr.func || !expr.xpr || sub.$parens && !parensAsStrings)
-    return [ expr, ...sortAndNulls ];
-  else if (sub.$parens && sub.op.val !== ',')
-    return [ '(', ...expr.xpr, ')' ];
-
-  expr.xpr.push( ...sortAndNulls );
-  return expr.xpr;
-}
-
-function ternary( op1, op2 ) {
-  return function ternaryOp( exprs ) {
-    return (exprs[2])
-      ? [ ...exprs[0], ...op1, ...exprs[1], ...op2, ...exprs[2] ]
-      : [ ...exprs[0], ...op1, ...exprs[1] ];
-  };
-}
 
-function postfix( op ) {
-  return function postfixOp( exprs ) {
-    return [ ...exprs[0], ...op ];
-  };
+  const { val } = node.op;
+  switch (val) {
+    case 'ixpr':
+    case 'xpr':
+      break;
+    case 'cast':
+      return cast( expression( node.args[0] ), node );
+    case 'list':
+      return extra( { list: node.args.map( expression ) }, node, 0 );
+    default: {          // '=', 'and', CSN v0 input: binary (n-ary) and unary prefix
+      if (!node.args.length)
+        return { xpr: [] };
+      const nary = [];
+      for (const item of node.args)
+        nary.push( { val, literal: 'token' }, item );
+      node = {
+        op: { val: 'ixpr' },
+        args: (nary.length > 2 ? nary.slice(1) : nary),
+        $parens: node.$parens,
+      };
+    }
+  }
+  const rargs = node.args.map( exprInternal );
+  if (val === 'xpr' || node.$parens)
+    return extra( { xpr: flattenenInternalXpr( rargs ) }, node, (xprParens === 'no' ? 0 : 1) );
+  return rargs.length === 1 ? rargs[0] : rargs;
 }
 
-function binaryRightParen( op ) {
-  return ( exprs ) => {
-    const right = exprs[1].length === 1 ? exprs[1][0] : {};
-    return (right.xpr || right.list || !right.$parens)
-      ? [ ...exprs[0], ...op, ...exprs[1] ]
-      : [ ...exprs[0], ...op, { xpr: exprs[1] } ];
-  };
+function flattenenInternalXpr( array ) {
+  return (structXpr) ? array : array.flat( Infinity );
 }
 
 function query( node, csn, xsn, _prop, expectedParens = 0 ) {
@@ -1534,7 +1456,7 @@ function addElementAsColumn( elem, cols ) {
   if (elem.$inferred === '*')
     return;
   // only list annotations here which are provided directly with definition
-  const col = (gensrcFlavor) ? annotationsAndDocComment( elem, false ) : {};
+  const col = (gensrcFlavor) ? annotationsAndDocComment( elem ) : {};
   // with `client` flavor, assignments are available at the element
   const gensrcSaved = gensrcFlavor;
 
@@ -1542,7 +1464,7 @@ function addElementAsColumn( elem, cols ) {
     gensrcFlavor = gensrcFlavor || 'column';
     set( 'virtual', col, elem );
     set( 'key', col, elem );
-    const expr = expression( elem.value, true );
+    const expr = expression( elem.value );
     Object.assign( col, (expr.cast ? { xpr: [ expr ] } : expr) );
     gensrcFlavor = gensrcSaved; // for not having annotations in inline etc
     if (elem.expand)
@@ -1578,7 +1500,7 @@ function orderBy( node ) {
     expr.sort = node.sort.val;
   if (node.nulls)
     expr.nulls = node.nulls.val;
-  return extra( expr, node );   // extra properties after sort/nulls
+  return expr;              // extra properties are before sort/nulls - who cares?
 }
 
 function extra( csn, node, expectedParens = 0 ) {
@@ -1643,19 +1565,18 @@ function compactQuery( q ) {    // TODO: options
 
 function compactExpr( e ) {     // TODO: options
   initModuleVars();
-  return e && expression( e, true );
+  return e && expression( e );
 }
 
 /**
  * @param {CSN.Options} options
  */
 function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
-  gensrcFlavor = options.parseCdl || options.csnFlavor === 'gensrc' ||
-               ( options.toCsn && options.toCsn.flavor === 'gensrc');
-  universalCsn = ( options.csnFlavor === 'universal' ||
-                   ( options.toCsn && options.toCsn.flavor === 'universal') ) &&
-                  isBetaEnabled( options, 'enableUniversalCsn' ) &&
-                  !options.parseCdl;
+  const flavor = options.csnFlavor || options.toCsn?.flavor;
+  gensrcFlavor = options.parseCdl || flavor === 'gensrc';
+  universalCsn = flavor === 'universal' &&
+                 isBetaEnabled( options, 'enableUniversalCsn' ) &&
+                 !options.parseCdl;
   strictMode = options.testMode;
   const proto = options.dictionaryPrototype;
   // eslint-disable-next-line no-nested-ternary
@@ -1663,7 +1584,7 @@ function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
     ? proto
     : (proto) ? Object.prototype : null;
   withLocations = options.withLocations;
-  parensAsStrings = isDeprecatedEnabled( options, '_parensAsStrings' );
+  structXpr = options.structXpr;
   projectionAsQuery = isDeprecatedEnabled( options, '_projectionAsQuery' );
 }
 

package/lib/language/antlrParser.js

@@ -164,8 +164,11 @@ function parse( source, filename = '<undefined>.cds',
   if (options.docComment !== false) {
     for (const token of tokenStream.tokens) {
       if (token.type === parser.constructor.DocComment && !token.isUsed) {
-        messageFunctions.info('syntax-ignoring-doc-comment', parser.tokenLocation(token), {},
-                              'Ignoring doc comment as it does not belong to any artifact');
+        // TODO: think of 'syntax-unexpected-doc-comment'
+        messageFunctions.info( 'syntax-ignoring-doc-comment', parser.tokenLocation(token), {},
+                               'Ignoring doc comment as it is not written at a defined position' );
+        // this is also for position inside some artifact definition, i.e. previous text
+        // "does not belong to any artifact" might be confusing
       }
     }
   }

package/lib/language/docCommentParser.js

@@ -16,7 +16,7 @@ const {
  * @returns {string|null} Parsed contents or if the comment has an invalid format or
  *                        does not have any content, null is returned.
  */
-function parseDocComment(comment) {
+function parseDocComment( comment ) {
   // Also return "null" for empty doc comments so that doc comment propagation
   // can be stopped.
   if (comment.length <= 5) // at least "/***/"
@@ -83,7 +83,7 @@ function parseDocComment(comment) {
  * @param {string[]} lines String split into lines.
  * @param {boolean} ignoreFirstLine Whether to ignore the first line for indentation counting.
  */
-function stripCommentIndentation(lines, ignoreFirstLine) {
+function stripCommentIndentation( lines, ignoreFirstLine ) {
   const n = lines.length;
 
   const minIndent = lines.reduce((min, line, index) => {
@@ -114,7 +114,7 @@ function stripCommentIndentation(lines, ignoreFirstLine) {
  * @param {string} line
  * @returns {string} line without fence
  */
-function removeFence(line) {
+function removeFence( line ) {
   return line.replace(/^\s*[*]\s?/, '');
 }
 
@@ -125,7 +125,7 @@ function removeFence(line) {
  * @param {string} line
  * @returns {string} Header without fence.
  */
-function removeHeaderFence(line) {
+function removeHeaderFence( line ) {
   return line.replace(/^\/[*]{2,}\s?/, '');
 }
 
@@ -138,7 +138,7 @@ function removeHeaderFence(line) {
  * @param {string} line
  * @returns {string} header without fence
  */
-function removeFooterFence(line) {
+function removeFooterFence( line ) {
   return line.replace(/\s*[*]+\/$/, '');
 }
 
@@ -148,7 +148,7 @@ function removeFooterFence(line) {
  *
  * @param {string[]} lines
  */
-function isFencedComment(lines) {
+function isFencedComment( lines ) {
   const index = lines.findIndex((line, i) => {
     const exclude = (i === 0 || i === lines.length - 1);
     return !exclude && !(/^\s*[*]/.test(line));