With start token being the first non-ignorable token inside the declaration
block, iterate issuing CssDeclaration objects until the block ends.
198542
private void handleDeclarationBlock(CssToken start, CssTokenIterator iter,
      final CssContentHandler doc, CssErrorHandler err) throws
      CssException
  {

    while (true)
    {
      if (MATCH_CLOSEBRACE.apply(start))
      {
        return;
      }
      CssDeclaration decl = handleDeclaration(start, iter, doc, err, false);
      try
      {
        if (decl != null)
        {
          doc.declaration(decl);
          if (debug)
          {
            checkState(MATCH_SEMI_CLOSEBRACE.apply(iter.last));
          }

          // continue or return: we may be at "; next decl" or "}" or ";}"
          if (MATCH_CLOSEBRACE.apply(iter.last))
          {
            return;
          }
          else if (MATCH_SEMI.apply(iter.last) && MATCH_CLOSEBRACE.apply(iter.peek()))
          {
            iter.next();
            return;
          }
          else
          {
            if (debug)
            {
              checkState(MATCH_SEMI.apply(iter.last));
            }
            // we have ';', expect another decl
            start = iter.next(); // first token after ';'
          }

        }
        else
        {
          // #handleDeclaration returned null to signal error
          // #handleDeclaration has issued errors, we forward
          start = iter.next(MATCH_SEMI_CLOSEBRACE);
          if (MATCH_SEMI.apply(start))
          {
            start = iter.next();
          }
        }
      }
      catch (NoSuchElementException nse)
      {
        err.error(new CssGrammarException(GRAMMAR_PREMATURE_EOF, iter.last.location,
            messages.getLocale(), "';' " + messages.get("or") + " '}'"));
        throw new PrematureEOFException();
      }
    }
  }
963130
void startBlock( String[] selectors , StringBuilder output  ) {
        this.results.add( new CssRuleOutput( selectors, output, isReference ) );
    }
87829
private static Block block(final String comment, final int nameStart) {
      int attrIndex = comment.indexOf('{');
      if(attrIndex != -1) {
         return new Block(comment.substring(nameStart, attrIndex).trim(),
                 comment.substring(attrIndex).trim());
      } else {
         return new Block(comment.substring(nameStart).trim());
      }
   }
795079
private static Node getNextSiblingOfType(Node first, Token ... types) {
    for (Node c = first; c != null; c = c.getNext()) {
      for (Token type : types) {
        if (c.getToken() == type) {
          return c;
        }
      }
    }
    return null;
  }
29668
void startBlockImpl( String[] selectors ) {
        for( int i=0; i<selectors.length; i++ ) {
            if( i > 0 ) {
                output.append( ',' );
                newline();
            }
            insets();
            append( selectors[i] );
        }
        space();
        output.append( '{' );
        newline();
        incInsets();
    }
1074795
function()
		{
			var startContainer = this.startContainer,
				startOffset = this.startOffset;

			// If the starting node is a text node, and non-empty before the offset,
			// then we're surely not at the start of block.
			if ( startOffset && startContainer.type == CKEDITOR.NODE_TEXT )
			{
				var textBefore = CKEDITOR.tools.ltrim( startContainer.substring( 0, startOffset ) );
				if ( textBefore.length )
					return false;
			}

			// Antecipate the trim() call here, so the walker will not make
			// changes to the DOM, which would not get reflected into this
			// range otherwise.
			this.trim();

			// We need to grab the block element holding the start boundary, so
			// let's use an element path for it.
			var path = new CKEDITOR.dom.elementPath( this.startContainer );

			// Creates a range starting at the block start until the range start.
			var walkerRange = this.clone();
			walkerRange.collapse( true );
			walkerRange.setStartAt( path.block || path.blockLimit, CKEDITOR.POSITION_AFTER_START );

			var walker = new CKEDITOR.dom.walker( walkerRange );
			walker.evaluator = getCheckStartEndBlockEvalFunction( true );

			return walker.checkBackward();
		}
912495
public synchronized byte[] firstToken() {
    if (saslClient != null && saslClient.hasInitialResponse()) {
      try {
        return saslClient.evaluateChallenge(new byte[0]);
      } catch (SaslException e) {
        throw Throwables.propagate(e);
      }
    } else {
      return new byte[0];
    }
  }
1366241
private boolean notAllowedStart(String startTag) {
		errorState = errorState && startElements.containsKey(startTag)
				&& forbiddenIdStartElements.containsKey(startTag);
		return errorState;
	}
562834
function startsWithNoLookaheadToken(node, forbidFunctionClassAndDoExpr) {
  node = getLeftMost(node);
  switch (node.type) {
    case "FunctionExpression":
    case "ClassExpression":
    case "DoExpression":
      return forbidFunctionClassAndDoExpr;
    case "ObjectExpression":
      return true;
    case "MemberExpression":
      return startsWithNoLookaheadToken(
        node.object,
        forbidFunctionClassAndDoExpr
      );
    case "TaggedTemplateExpression":
      if (node.tag.type === "FunctionExpression") {
        // IIFEs are always already parenthesized
        return false;
      }
      return startsWithNoLookaheadToken(node.tag, forbidFunctionClassAndDoExpr);
    case "CallExpression":
      if (node.callee.type === "FunctionExpression") {
        // IIFEs are always already parenthesized
        return false;
      }
      return startsWithNoLookaheadToken(
        node.callee,
        forbidFunctionClassAndDoExpr
      );
    case "ConditionalExpression":
      return startsWithNoLookaheadToken(
        node.test,
        forbidFunctionClassAndDoExpr
      );
    case "UpdateExpression":
      return (
        !node.prefix &&
        startsWithNoLookaheadToken(node.argument, forbidFunctionClassAndDoExpr)
      );
    case "BindExpression":
      return (
        node.object &&
        startsWithNoLookaheadToken(node.object, forbidFunctionClassAndDoExpr)
      );
    case "SequenceExpression":
      return startsWithNoLookaheadToken(
        node.expressions[0],
        forbidFunctionClassAndDoExpr
      );
    case "TSAsExpression":
      return startsWithNoLookaheadToken(
        node.expression,
        forbidFunctionClassAndDoExpr
      );
    default:
      return false;
  }
}
912566
protected void handleDeferredStartElement(EXIBodyDecoder decoder,
			QNameContext deferredStartElement, final AttributesImpl attributes)
			throws SAXException, IOException, EXIException {

		if (namespaces) {
			List<NamespaceDeclaration> prefixes = decoder
					.getDeclaredPrefixDeclarations();
			if (prefixes != null) {
				for (int i = 0; i < prefixes.size(); i++) {
					NamespaceDeclaration ns = prefixes.get(i);
					contentHandler.startPrefixMapping(ns.prefix,
							ns.namespaceURI);
				}
			}
		}

		/*
		 * the qualified name is required when the namespace-prefixes property
		 * is true, and is optional when the namespace-prefixes property is
		 * false (the default).
		 */
		// String seQNameAsString = Constants.EMPTY_STRING;
		// if (namespacePrefixes) {
		// seQNameAsString = decoder.getElementQNameAsString();
		// }
		/*
		 * Note: it looks like widely used APIs (Xerces, Saxon, ..) provide the
		 * textual qname even when
		 * http://xml.org/sax/features/namespace-prefixes is set to false
		 * http:// sourceforge.net/projects/exificient/forums/forum/856596/topic
		 * /5839494
		 */
		String seQNameAsString = decoder.getElementQNameAsString();

		// start so far deferred start element
		contentHandler.startElement(deferredStartElement.getNamespaceUri(),
				deferredStartElement.getLocalName(), seQNameAsString,
				attributes);

		// clear AT information
		attributes.clear();
	}
868785
@FFDCIgnore({ InvalidBundleContextException.class, LaunchException.class })
    protected void innerLaunchFramework(boolean isClient) {
        try {
            // Register services
            registerInstrumentationService(systemBundleCtx);
            registerLibertyProcessService(systemBundleCtx, config);
            preRegisterMBeanServerPipelineService(systemBundleCtx);
            openThreadIdentityTracker(systemBundleCtx);
            registerPauseableComponentController(systemBundleCtx);

            // Initialize the repo registry: we can use caches AND logging for messages
            BundleRepositoryRegistry.initializeDefaults(config.getProcessName(), true, isClient);

            Provisioner provisioner = new ProvisionerImpl();
            provisioner.initialProvisioning(systemBundleCtx, config);

            // All of our kernel provisioning activities are complete!
            config.getKernelResolver().dispose();
        } catch (LaunchException le) {
            // this is one of ours, no need to wrap again, just rethrow
            throw le;
        } catch (InvalidBundleContextException e) {
            // no-op: the framework was shutdown while bundles were being
            // installed -- things should stop gracefully w/ no ugly error
            // messages.
        }
    }
303299
function checkAtruler(i) {
  const start = i;
  let l;

  if (i >= tokensLength) return 0;

  if (l = checkAtkeyword(i)) i += l;
  else return 0;

  if (l = checkTsets(i)) i += l;

  if (i < tokensLength && tokens[i].type === TokenType.LeftCurlyBracket) i++;
  else return 0;

  if (l = checkAtrulers(i)) i += l;

  if (i < tokensLength && tokens[i].type === TokenType.RightCurlyBracket) i++;
  else return 0;

  return i - start;
}
87920
private void markPendingInitialization(JvmDeclaredTypeImplCustom type) {
		type.setPendingInitialization(true);
		for (JvmMember member : type.basicGetMembers()) {
			if (member instanceof JvmDeclaredTypeImplCustom) {
				markPendingInitialization((JvmDeclaredTypeImplCustom) member);
			}
		}
	}
584036
function isCommentAtParentStart(token, nodeType) {
            const parent = getParentNodeOfToken(token);

            return parent && isParentNodeType(parent, nodeType) &&
                    token.loc.start.line - parent.loc.start.line === 1;
        }
1322150
function iterizeForOf(node, path) {
        if (node.body.type !== 'BlockStatement') {
            node.body = {
                type: 'BlockStatement',
                body: [node.body]
            };
        }
        var index, iterator, initIterator = parsePart("[$0[Symbol.iterator]()]", [node.right]).expr;
        if (node.left.type === 'VariableDeclaration') {
            if (node.left.kind === 'const') 
                node.left.kind = 'let';
            if (node.left.kind === 'let') { 
            	    node.update = literal(null) ;
                node.update.$EmptyExpression = true ;
            }
            index = node.left.declarations[0].id;
            var decls = getDeclNames(node.left.declarations[0].id);
            iterator = ident(generateSymbol("iterator_" + decls.join('_')));
            node.left.declarations = decls.map(function (name) {
                return {
                    type: "VariableDeclarator",
                    id: ident(name)
                };
            });
            node.left.declarations.push({
                type: "VariableDeclarator",
                id: iterator,
                init: initIterator
            });
            node.init = node.left;
        } else {
            index = node.left;
            iterator = ident(generateSymbol("iterator_" + index.name));
            var declaration = {
                type: 'VariableDeclaration',
                kind: 'var',
                declarations: [{
                    type: "VariableDeclarator",
                    id: iterator,
                    init: initIterator
                }]
            };
            node.init = declaration;
        }
        node.type = 'ForStatement';
        node.test = parsePart("!($0[1] = $0[0].next()).done && (($1 = $0[1].value) || true)", [iterator,
            index]).expr;
        delete node.left;
        delete node.right;
    }
850668
public final void entryRuleTerminalTokenElement() throws RecognitionException {
        try {
            // InternalXtext.g:1196:1: ( ruleTerminalTokenElement EOF )
            // InternalXtext.g:1197:1: ruleTerminalTokenElement EOF
            {
             before(grammarAccess.getTerminalTokenElementRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTerminalTokenElement();

            state._fsp--;

             after(grammarAccess.getTerminalTokenElementRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1131463
function checkTypeSelector(i) {
  if (i >= tokensLength) return 0;

  const start = i;
  let l;

  if (l = checkNamePrefix(i)) i += l;

  if (l = checkIdentOrInterpolation(i)) i += l;
  else return 0;

  return i - start;
}