Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/micromark/lib/tokenize/code-text.js
f646e1f695a7paginated-inlines

code-text.js
View Options

			'use strict'

			var assert = require('assert')
			var codes = require('../character/codes.js')
			var markdownLineEnding = require('../character/markdown-line-ending.js')
			var types = require('../constant/types.js')

			function _interopDefaultLegacy(e) {
			return e && typeof e === 'object' && 'default' in e ? e : {default: e}
			}

			var assert__default = /#__PURE__/ _interopDefaultLegacy(assert)

			var codeText = {
			name: 'codeText',
			tokenize: tokenizeCodeText,
			resolve: resolveCodeText,
			previous: previous
			}

			function resolveCodeText(events) {
			var tailExitIndex = events.length - 4
			var headEnterIndex = 3
			var index
			var enter

			// If we start and end with an EOL or a space.
			if (
			(events[headEnterIndex][1].type === types.lineEnding \|\|
			events[headEnterIndex][1].type === 'space') &&
			(events[tailExitIndex][1].type === types.lineEnding \|\|
			events[tailExitIndex][1].type === 'space')
			) {
			index = headEnterIndex

			// And we have data.
			while (++index < tailExitIndex) {
			if (events[index][1].type === types.codeTextData) {
			// Then we have padding.
			events[tailExitIndex][1].type = events[headEnterIndex][1].type =
			types.codeTextPadding
			headEnterIndex += 2
			tailExitIndex -= 2
			break
			}
			}
			}

			// Merge adjacent spaces and data.
			index = headEnterIndex - 1
			tailExitIndex++

			while (++index <= tailExitIndex) {
			if (enter === undefined) {
			if (
			index !== tailExitIndex &&
			events[index][1].type !== types.lineEnding
			) {
			enter = index
			}
			} else if (
			index === tailExitIndex \|\|
			events[index][1].type === types.lineEnding
			) {
			events[enter][1].type = types.codeTextData

			if (index !== enter + 2) {
			events[enter][1].end = events[index - 1][1].end
			events.splice(enter + 2, index - enter - 2)
			tailExitIndex -= index - enter - 2
			index = enter + 2
			}

			enter = undefined
			}
			}

			return events
			}

			function previous(code) {
			// If there is a previous code, there will always be a tail.
			return (
			code !== codes.graveAccent \|\|
			this.events[this.events.length - 1][1].type === types.characterEscape
			)
			}

			function tokenizeCodeText(effects, ok, nok) {
			var self = this
			var sizeOpen = 0
			var size
			var token

			return start

			function start(code) {
			assert__default['default'](code === codes.graveAccent, 'expected `` ` ``')
			assert__default['default'](
			previous.call(self, self.previous),
			'expected correct previous'
			)
			effects.enter(types.codeText)
			effects.enter(types.codeTextSequence)
			return openingSequence(code)
			}

			function openingSequence(code) {
			if (code === codes.graveAccent) {
			effects.consume(code)
			sizeOpen++
			return openingSequence
			}

			effects.exit(types.codeTextSequence)
			return gap(code)
			}

			function gap(code) {
			// EOF.
			if (code === codes.eof) {
			return nok(code)
			}

			// Closing fence?
			// Could also be data.
			if (code === codes.graveAccent) {
			token = effects.enter(types.codeTextSequence)
			size = 0
			return closingSequence(code)
			}

			// Tabs don’t work, and virtual spaces don’t make sense.
			if (code === codes.space) {
			effects.enter('space')
			effects.consume(code)
			effects.exit('space')
			return gap
			}

			if (markdownLineEnding(code)) {
			effects.enter(types.lineEnding)
			effects.consume(code)
			effects.exit(types.lineEnding)
			return gap
			}

			// Data.
			effects.enter(types.codeTextData)
			return data(code)
			}

			// In code.
			function data(code) {
			if (
			code === codes.eof \|\|
			code === codes.space \|\|
			code === codes.graveAccent \|\|
			markdownLineEnding(code)
			) {
			effects.exit(types.codeTextData)
			return gap(code)
			}

			effects.consume(code)
			return data
			}

			// Closing fence.
			function closingSequence(code) {
			// More.
			if (code === codes.graveAccent) {
			effects.consume(code)
			size++
			return closingSequence
			}

			// Done!
			if (size === sizeOpen) {
			effects.exit(types.codeTextSequence)
			effects.exit(types.codeText)
			return ok(code)
			}

			// More or less accents: mark as data.
			token.type = types.codeTextData
			return data(code)
			}
			}

			module.exports = codeText