/im);
33 | contents.shift();
34 | return contents
35 | .map((c, i) => {
36 | // 生成 attr
37 | const html = `
38 | ${slideTag[i]}
39 |
40 | ${mdRender(c)}
41 |
42 |
43 | `;
44 | // 生成 content ast
45 | return posthtml(buildInPosthtmlPlugins.concat(posthtmlPlugins)).process(html, {sync: true}).html;
46 | })
47 | .join('\n');
48 | };
49 | };
50 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/cite.js:
--------------------------------------------------------------------------------
1 | module.exports = function ins_plugin(md) {
2 | // https://github.com/markdown-it/markdown-it-mark/blob/master/index.js
3 | function tokenize(state, silent) {
4 | var i,
5 | scanned,
6 | token,
7 | len,
8 | ch,
9 | start = state.pos,
10 | marker = state.src.charCodeAt(start);
11 |
12 | if (silent) {
13 | return false;
14 | }
15 |
16 | if (marker !== 0x3d /* = */) {
17 | return false;
18 | }
19 |
20 | scanned = state.scanDelims(state.pos, true);
21 | len = scanned.length;
22 | ch = String.fromCharCode(marker);
23 |
24 | if (len < 2) {
25 | return false;
26 | }
27 |
28 | if (len % 2) {
29 | token = state.push('text', '', 0);
30 | token.content = ch;
31 | len--;
32 | }
33 |
34 | for (i = 0; i < len; i += 2) {
35 | token = state.push('text', '', 0);
36 | token.content = ch + ch;
37 |
38 | state.delimiters.push({
39 | marker: marker,
40 | jump: i,
41 | token: state.tokens.length - 1,
42 | level: state.level,
43 | end: -1,
44 | open: scanned.can_open,
45 | close: scanned.can_close
46 | });
47 | }
48 |
49 | state.pos += scanned.length;
50 |
51 | return true;
52 | }
53 |
54 | // Walk through delimiter list and replace text tokens with tags
55 | //
56 | function postProcess(state) {
57 | var i,
58 | j,
59 | startDelim,
60 | endDelim,
61 | token,
62 | loneMarkers = [],
63 | delimiters = state.delimiters,
64 | max = state.delimiters.length;
65 |
66 | for (i = 0; i < max; i++) {
67 | startDelim = delimiters[i];
68 |
69 | if (startDelim.marker !== 0x3d /* = */) {
70 | continue;
71 | }
72 |
73 | if (startDelim.end === -1) {
74 | continue;
75 | }
76 |
77 | endDelim = delimiters[startDelim.end];
78 |
79 | token = state.tokens[startDelim.token];
80 | token.type = 'cite_open';
81 | token.tag = 'cite';
82 | token.nesting = 1;
83 | token.markup = '==';
84 | token.content = '';
85 |
86 | token = state.tokens[endDelim.token];
87 | token.type = 'cite_close';
88 | token.tag = 'cite';
89 | token.nesting = -1;
90 | token.markup = '==';
91 | token.content = '';
92 |
93 | if (state.tokens[endDelim.token - 1].type === 'text' && state.tokens[endDelim.token - 1].content === '=') {
94 | loneMarkers.push(endDelim.token - 1);
95 | }
96 | }
97 |
98 | // If a marker sequence has an odd number of characters, it's splitted
99 | // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the
100 | // start of the sequence.
101 | //
102 | // So, we have to move all those markers after subsequent s_close tags.
103 | //
104 | while (loneMarkers.length) {
105 | i = loneMarkers.pop();
106 | j = i + 1;
107 |
108 | while (j < state.tokens.length && state.tokens[j].type === 'cite_close') {
109 | j++;
110 | }
111 |
112 | j--;
113 |
114 | if (i !== j) {
115 | token = state.tokens[j];
116 | state.tokens[j] = state.tokens[i];
117 | state.tokens[i] = token;
118 | }
119 | }
120 | }
121 |
122 | md.inline.ruler.before('emphasis', 'cite', tokenize);
123 | md.inline.ruler2.before('emphasis', 'cite', postProcess);
124 | };
125 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/containers/blink.js:
--------------------------------------------------------------------------------
1 | const name = 'blink';
2 |
3 | module.exports = {
4 | validate(params) {
5 | return params.trim().match(new RegExp('^' + name + '\\s*(.*)$'));
6 | },
7 | handler(state, opts, start) {
8 | function getOpenToken(tag, level) {
9 | const token = new state.Token('container_' + name + '_' + tag + '_open', tag, 1);
10 | token.block = true;
11 | token.level = 1 + level;
12 | return token;
13 | }
14 | function getCloseToken(tag, level) {
15 | const token = new state.Token('container_' + name + '_' + tag + '_close', tag, -1);
16 | token.block = true;
17 | token.level = 1 + level;
18 | return token;
19 | }
20 | // tokens
21 | const tokens = state.tokens;
22 |
23 | let open = false;
24 | let done = 0;
25 | for (let i = start; i < tokens.length; i++) {
26 | const token = tokens[i];
27 | if (token.type === 'container_' + name + '_open') {
28 | // 在 open 后面插入
29 | tokens.splice(i + 1, 0, getOpenToken('li', token.level), getOpenToken('a', token.level + 1));
30 | open = true;
31 | i = i + 2;
32 | } else if (token.type === 'container_' + name + '_close') {
33 | // 在 close 之前插入
34 | tokens.splice(i, 0, getCloseToken('a', token.level + 1), getCloseToken('li', token.level));
35 | open = false;
36 | i = i + 2;
37 | } else if (open && 'hr' === token.type && done === 0) {
38 | // 第一层的 Hr 需要替换
39 | tokens.splice(
40 | i,
41 | 1,
42 | getCloseToken('a', token.level),
43 | getCloseToken('li', token.level - 1),
44 | getOpenToken('li', token.level - 1),
45 | getOpenToken('a', token.level)
46 | );
47 | i = i + 3;
48 | } else if (open) {
49 | if (token.type === 'paragraph_close' || token.type === 'paragraph_open') {
50 | tokens.splice(i, 1);
51 | i--;
52 | continue;
53 | }
54 | // 加深一层，因为外面多套了一层div
55 | token.level = token.level + 2;
56 | // 保证hr 是最贴近 container 的一层
57 | if (/_open$/.test(token.type)) {
58 | done++;
59 | } else if (/_close$/.test(token.type)) {
60 | done--;
61 | }
62 | }
63 | }
64 | return state;
65 | },
66 | render(tokens, idx) {
67 | const token = tokens[idx];
68 |
69 | if (token.nesting === 1) {
70 | const cmIndex = token.attrIndex('css-module');
71 | let clsIndex = token.attrIndex('class');
72 | let attrs = token.attrs || [];
73 |
74 | if (clsIndex >= 0) {
75 | attrs[clsIndex][1] +=
76 | cmIndex >= 0 ? ` flexblock blink border ${attrs[cmIndex][1]}` : ` flexblock blink border`;
77 | } else {
78 | attrs.push([
79 | 'class',
80 | cmIndex >= 0 ? `flexblock blink border ${attrs[cmIndex][1]}` : `flexblock blink border`
81 | ]);
82 | }
83 |
84 | attrs = attrs.map(([key, value]) => {
85 | return `${key}="${value}"`;
86 | });
87 | // opening tag
88 | return `\n`;
89 | } else {
90 | // closing tag
91 | return '
\n';
92 | }
93 | }
94 | };
95 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/containers/column.js:
--------------------------------------------------------------------------------
1 | const name = 'column';
2 |
3 | module.exports = {
4 | validate(params) {
5 | return params.trim().match(/^column\s*(.*)$/);
6 | },
7 | handler(state, opts) {
8 | function getOpenToken(level) {
9 | const token = new state.Token('container_' + name + '_item_open', 'div', 1);
10 | token.block = true;
11 | token.level = 1 + level;
12 | token.attrs = [['class', name]];
13 | return token;
14 | }
15 | function getCloseToken(level) {
16 | const token = new state.Token('container_' + name + '_item_close', 'div', -1);
17 | token.block = true;
18 | token.level = 1 + level;
19 | return token;
20 | }
21 | // tokens
22 | const tokens = state.tokens;
23 |
24 | let open = false;
25 | let done = 0;
26 | for (let i = 0; i < tokens.length; i++) {
27 | const token = tokens[i];
28 | if (token.type === 'container_' + name + '_open') {
29 | // 在 open 后面插入
30 | tokens.splice(i + 1, 0, getOpenToken(token.level));
31 | open = true;
32 | i++;
33 | } else if (token.type === 'container_' + name + '_close') {
34 | // 在 close 之前插入
35 | tokens.splice(i, 0, getCloseToken(token.level));
36 | open = false;
37 | i++;
38 | } else if (open && 'hr' === token.type && done === 0) {
39 | // 第一层的 Hr 需要替换
40 | tokens.splice(i, 1, getCloseToken(token.level - 1), getOpenToken(token.level - 1));
41 | i++;
42 | } else if (open) {
43 | // 加深一层，因为外面多套了一层div
44 | token.level = token.level + 1;
45 | // 保证hr 是最贴近 container 的一层
46 | if (/_open$/.test(token.type)) {
47 | done++;
48 | } else if (/_close$/.test(token.type)) {
49 | done--;
50 | }
51 | }
52 | }
53 | return state;
54 | },
55 | render(tokens, idx) {
56 | const token = tokens[idx];
57 |
58 | if (token.nesting === 1) {
59 | const cmIndex = token.attrIndex('css-module');
60 | let clsIndex = token.attrIndex('class');
61 | let attrs = token.attrs || [];
62 |
63 | if (clsIndex >= 0) {
64 | attrs[clsIndex][1] += cmIndex >= 0 ? ` grid ${attrs[cmIndex][1]}` : ' grid';
65 | } else {
66 | attrs.push(['class', cmIndex >= 0 ? `grid ${attrs[cmIndex][1]}` : 'grid']);
67 | }
68 |
69 | attrs = attrs.map(([key, value]) => {
70 | return `${key}="${value}"`;
71 | });
72 | // opening tag
73 | return `\n`;
74 | } else {
75 | // closing tag
76 | return '
\n';
77 | }
78 | }
79 | };
80 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/containers/cta.js:
--------------------------------------------------------------------------------
1 | const name = 'cta';
2 | module.exports = {
3 | validate(params) {
4 | return params.trim().match(new RegExp('^' + name + '\\s*(.*)$'));
5 | },
6 | handler(state, opts) {
7 | function getOpenToken(tag, level) {
8 | const token = new state.Token('container_' + name + '_' + tag + '_open', tag, 1);
9 | token.block = true;
10 | token.level = 1 + level;
11 | return token;
12 | }
13 | function getCloseToken(tag, level) {
14 | const token = new state.Token('container_' + name + '_' + tag + '_close', tag, -1);
15 | token.block = true;
16 | token.level = 1 + level;
17 | return token;
18 | }
19 | // tokens
20 | const tokens = state.tokens;
21 |
22 | let open = false;
23 | let done = 0;
24 | let count = 1;
25 | let level = 1;
26 | let imgStart = 0,
27 | imgEnd = 0;
28 | let ctxStart = 0,
29 | ctxEnd = 0;
30 |
31 | let img = [],
32 | context = [];
33 | for (let i = 0; i < tokens.length; i++) {
34 | let token = tokens[i];
35 | if (token.type === 'container_' + name + '_open') {
36 | // 在 open 后面插入
37 | open = true;
38 | level = token.level + 1;
39 | } else if (token.type === 'container_' + name + '_close') {
40 | // 在 close 之前插入
41 | open = false;
42 | } else if (open && 'hr' === token.type && done === 0) {
43 | tokens.splice(i, 1);
44 | i--;
45 | count++;
46 | } else if (open) {
47 | // 加深一层，因为外面多套了一层div
48 | // token.level = token.level + 2;
49 | // 保证hr 是最贴近 container 的一层
50 | if (/_open$/.test(token.type)) {
51 | done++;
52 | } else if (/_close$/.test(token.type)) {
53 | done--;
54 | }
55 | if (count === 1) {
56 | if (!imgStart) {
57 | imgStart = i;
58 | } else {
59 | imgEnd = i;
60 | }
61 | img.push(token);
62 | } else {
63 | if (!ctxStart) {
64 | ctxStart = i;
65 | } else {
66 | ctxEnd = i;
67 | }
68 | token.level = token.level + 1;
69 | context.push(token);
70 | }
71 | }
72 | }
73 | // 分组完成
74 | const divNumber = getOpenToken('div', level - 1);
75 | divNumber.attrPush(['class', 'number']);
76 | tokens.splice(imgStart, imgEnd - imgStart + 1, divNumber, ...img, getCloseToken('div', level - 1));
77 |
78 | const divToken = getOpenToken('div', level - 1);
79 | divToken.attrPush(['class', 'benefit']);
80 | tokens.splice(ctxStart + 2, ctxEnd - ctxStart + 3, divToken, ...context, getCloseToken('div', level - 1));
81 | return state;
82 | },
83 | render(tokens, idx) {
84 | const token = tokens[idx];
85 | if (token.nesting === 1) {
86 | const cmIndex = token.attrIndex('css-module');
87 | let clsIndex = token.attrIndex('class');
88 | let attrs = token.attrs || [];
89 |
90 | if (clsIndex >= 0) {
91 | attrs[clsIndex][1] += cmIndex >= 0 ? ` cta ${attrs[cmIndex][1]}` : ` cta`;
92 | } else {
93 | attrs.push(['class', cmIndex >= 0 ? ` cta ${attrs[cmIndex][1]}` : ` cta`]);
94 | }
95 |
96 | attrs = attrs.map(([key, value]) => {
97 | return `${key}="${value}"`;
98 | });
99 | // opening tag
100 | return `\n`;
101 | } else {
102 | // closing tag
103 | return '
\n';
104 | }
105 | }
106 | };
107 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/containers/div.js:
--------------------------------------------------------------------------------
1 | const {getAttrs, getAttrsString} = require('../attrs/utils');
2 |
3 | module.exports = {
4 | validate(params) {
5 | return true;
6 | },
7 | handler(state, opts) {
8 | return state;
9 | },
10 | render(tokens, idx) {
11 | const token = tokens[idx];
12 | let tag = 'div';
13 | if (['footer', 'note', 'header'].includes(token.info)) {
14 | tag = token.info;
15 | }
16 | if (token.nesting === 1) {
17 | let attrs = token.attrs || [];
18 | attrs = attrs.map(([key, value]) => {
19 | return `${key}="${value}"`;
20 | });
21 | // opening tag
22 | return `<${tag} ${attrs.join(' ')}>\n`;
23 | } else {
24 | // closing tag
25 | return `\n`;
26 | }
27 | }
28 | };
29 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/containers/features.js:
--------------------------------------------------------------------------------
1 | const name = 'features';
2 |
3 | module.exports = {
4 | validate(params) {
5 | return params.trim().match(new RegExp('^' + name + '\\s*(.*)$'));
6 | },
7 | handler(state, opts, start) {
8 | function getOpenToken(tag, level) {
9 | const token = new state.Token('container_' + name + '_' + tag + '_open', tag, 1);
10 | token.block = true;
11 | token.level = 1 + level;
12 | return token;
13 | }
14 | function getCloseToken(tag, level) {
15 | const token = new state.Token('container_' + name + '_' + tag + '_close', tag, -1);
16 | token.block = true;
17 | token.level = 1 + level;
18 | return token;
19 | }
20 | // tokens
21 | const tokens = state.tokens;
22 |
23 | let open = false;
24 | let done = 0;
25 | for (let i = start; i < tokens.length; i++) {
26 | const token = tokens[i];
27 | if (token.type === 'container_' + name + '_open') {
28 | // 在 open 后面插入
29 | tokens.splice(i + 1, 0, getOpenToken('li', token.level), getOpenToken('div', token.level + 1));
30 | open = true;
31 | i = i + 2;
32 | } else if (token.type === 'container_' + name + '_close') {
33 | // 在 close 之前插入
34 | tokens.splice(i, 0, getCloseToken('div', token.level + 1), getCloseToken('li', token.level));
35 | open = false;
36 | i = i + 2;
37 | } else if (open && 'hr' === token.type && done === 0) {
38 | // 第一层的 Hr 需要替换
39 | tokens.splice(
40 | i,
41 | 1,
42 | getCloseToken('div', token.level),
43 | getCloseToken('li', token.level - 1),
44 | getOpenToken('li', token.level - 1),
45 | getOpenToken('div', token.level)
46 | );
47 | i = i + 3;
48 | } else if (open) {
49 | // 加深一层，因为外面多套了一层div
50 | token.level = token.level + 2;
51 | // 保证hr 是最贴近 container 的一层
52 | if (/_open$/.test(token.type)) {
53 | done++;
54 | } else if (/_close$/.test(token.type)) {
55 | done--;
56 | }
57 | }
58 | }
59 | return state;
60 | },
61 | render(tokens, idx) {
62 | const token = tokens[idx];
63 |
64 | if (token.nesting === 1) {
65 | const cmIndex = token.attrIndex('css-module');
66 | let clsIndex = token.attrIndex('class');
67 | let attrs = token.attrs || [];
68 |
69 | if (clsIndex >= 0) {
70 | attrs[clsIndex][1] +=
71 | cmIndex >= 0 ? ` flexblock features ${attrs[cmIndex][1]}` : ` flexblock features`;
72 | } else {
73 | attrs.push([
74 | 'class',
75 | cmIndex >= 0 ? `flexblock features ${attrs[cmIndex][1]}` : `flexblock features`
76 | ]);
77 | }
78 |
79 | attrs = attrs.map(([key, value]) => {
80 | return `${key}="${value}"`;
81 | });
82 | // opening tag
83 | return `\n`;
84 | } else {
85 | // closing tag
86 | return '
\n';
87 | }
88 | }
89 | };
90 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/containers/flexbox.js:
--------------------------------------------------------------------------------
1 | module.exports = (name, clss) => {
2 | if (!clss) {
3 | // 默认是 name
4 | clss = name;
5 | }
6 | return {
7 | validate(params) {
8 | return params.trim().match(new RegExp('^' + name + '\\s*(.*)$'));
9 | },
10 | handler(state, opts, start, end) {
11 | function getOpenToken(level) {
12 | const token = new state.Token('container_' + name + '_item_open', 'li', 1);
13 | token.block = true;
14 | token.level = 1 + level;
15 | return token;
16 | }
17 | function getCloseToken(level) {
18 | const token = new state.Token('container_' + name + '_item_close', 'li', -1);
19 | token.block = true;
20 | token.level = 1 + level;
21 | return token;
22 | }
23 | // tokens
24 | const tokens = state.tokens;
25 | let open = false;
26 | let done = 0;
27 | // console.log(5555,opts, tokens)
28 | for (let i = start; i < tokens.length; i++) {
29 | const token = tokens[i];
30 | if (token.type === 'container_' + name + '_open') {
31 | // 在 open 后面插入
32 | tokens.splice(i + 1, 0, getOpenToken(token.level));
33 | i++;
34 | // console.log(666666);
35 | open = true;
36 | continue;
37 | } else if (token.type === 'container_' + name + '_close') {
38 | // 在 close 之前插入
39 | tokens.splice(i, 0, getCloseToken(token.level));
40 | i++;
41 | open = false;
42 | continue;
43 | } else if (open && 'hr' === token.type && done === 0) {
44 | // 第一层的 Hr 需要替换
45 | // console.log(77777);
46 | tokens.splice(i, 1, getCloseToken(token.level - 1), getOpenToken(token.level - 1));
47 | i++;
48 | } else if (open) {
49 | if (token.type === 'paragraph_close' || token.type === 'paragraph_open') {
50 | tokens.splice(i, 1);
51 | i--;
52 | continue;
53 | }
54 | // 加深一层，因为外面多套了一层div
55 | token.level = token.level + 1;
56 | // 保证hr 是最贴近 container 的一层
57 | if (/_open$/.test(token.type)) {
58 | done++;
59 | } else if (/_close$/.test(token.type)) {
60 | done--;
61 | }
62 | }
63 | }
64 | // console.log(tokens);
65 | return state;
66 | },
67 | render(tokens, idx) {
68 | const token = tokens[idx];
69 |
70 | if (token.nesting === 1) {
71 | const cmIndex = token.attrIndex('css-module');
72 | let clsIndex = token.attrIndex('class');
73 | let attrs = token.attrs || [];
74 |
75 | if (clsIndex >= 0) {
76 | attrs[clsIndex][1] +=
77 | cmIndex >= 0 ? ` flexblock ${clss} ${attrs[cmIndex][1]}` : ` flexblock ${clss}`;
78 | } else {
79 | attrs.push([
80 | 'class',
81 | cmIndex >= 0 ? `flexblock ${clss} ${attrs[cmIndex][1]}` : `flexblock ${clss}`
82 | ]);
83 | }
84 |
85 | attrs = attrs.map(([key, value]) => {
86 | return `${key}="${value}"`;
87 | });
88 | // opening tag
89 | return `\n`;
90 | } else {
91 | // closing tag
92 | return '
\n';
93 | }
94 | }
95 | };
96 | };
97 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/containers/shadow.js:
--------------------------------------------------------------------------------
1 | const name = 'shadowbox';
2 |
3 | module.exports = {
4 | validate(params) {
5 | return params.trim().match(/^shadowbox\s*(.*)$/);
6 | },
7 | handler(state, opts) {
8 | function getOpenToken(level) {
9 | const token = new state.Token('container_' + name + '_item_open', 'li', 1);
10 | token.block = true;
11 | token.level = 1 + level;
12 | return token;
13 | }
14 | function getCloseToken(level) {
15 | const token = new state.Token('container_' + name + '_item_close', 'li', -1);
16 | token.block = true;
17 | token.level = 1 + level;
18 | return token;
19 | }
20 | // tokens
21 | const tokens = state.tokens;
22 |
23 | let open = false;
24 | let done = 0;
25 | for (let i = 0; i < tokens.length; i++) {
26 | const token = tokens[i];
27 | if (token.type === 'container_' + name + '_open') {
28 | // 在 open 后面插入
29 | tokens.splice(i + 1, 0, getOpenToken(token.level));
30 | open = true;
31 | i++;
32 | } else if (token.type === 'container_' + name + '_close') {
33 | // 在 close 之前插入
34 | tokens.splice(i, 0, getCloseToken(token.level));
35 | open = false;
36 | i++;
37 | } else if (open && 'hr' === token.type && done === 0) {
38 | // 第一层的 Hr 需要替换
39 | tokens.splice(i, 1, getCloseToken(token.level - 1), getOpenToken(token.level - 1));
40 | i++;
41 | } else if (open) {
42 | // 加深一层，因为外面多套了一层div
43 | token.level = token.level + 1;
44 | // 保证hr 是最贴近 container 的一层
45 | if (/_open$/.test(token.type)) {
46 | done++;
47 | } else if (/_close$/.test(token.type)) {
48 | done--;
49 | }
50 | }
51 | }
52 | return state;
53 | },
54 | render(tokens, idx) {
55 | const token = tokens[idx];
56 |
57 | if (token.nesting === 1) {
58 | const cmIndex = token.attrIndex('css-module');
59 | let clsIndex = token.attrIndex('class');
60 | let attrs = token.attrs || [];
61 |
62 | if (clsIndex >= 0) {
63 | attrs[clsIndex][1] += cmIndex >= 0 ? ` bg-white shadow ${attrs[cmIndex][1]}` : ' bg-white shadow';
64 | } else {
65 | attrs.push(['class', cmIndex >= 0 ? `bg-white shadow ${attrs[cmIndex][1]}` : 'bg-white shadow']);
66 | }
67 |
68 | attrs = attrs.map(([key, value]) => {
69 | return `${key}="${value}"`;
70 | });
71 | // opening tag
72 | return `\n`;
73 | } else {
74 | // closing tag
75 | return '
\n`;
84 | } else {
85 | // closing tag
86 | return '
\n';
87 | }
88 | }
89 | };
90 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/containers/steps.js:
--------------------------------------------------------------------------------
1 | const name = 'steps';
2 |
3 | module.exports = {
4 | validate(params) {
5 | return params.trim().match(new RegExp('^' + name + '\\s*(.*)$'));
6 | },
7 | handler(state, opts, start) {
8 | function getOpenToken(tag, level) {
9 | const token = new state.Token('container_' + name + '_' + tag + '_open', tag, 1);
10 | token.block = true;
11 | token.level = 1 + level;
12 | return token;
13 | }
14 | function getCloseToken(tag, level) {
15 | const token = new state.Token('container_' + name + '_' + tag + '_close', tag, -1);
16 | token.block = true;
17 | token.level = 1 + level;
18 | return token;
19 | }
20 | // tokens
21 | const tokens = state.tokens;
22 |
23 | let open = false;
24 | let done = 0;
25 | let step = 1;
26 | for (let i = start; i < tokens.length; i++) {
27 | const token = tokens[i];
28 | if (token.type === 'container_' + name + '_open') {
29 | // 在 open 后面插入
30 | tokens.splice(i + 1, 0, getOpenToken('li', token.level));
31 | open = true;
32 | i++;
33 | } else if (token.type === 'container_' + name + '_close') {
34 | // 在 close 之前插入
35 | tokens.splice(i, 0, getCloseToken('li', token.level));
36 | open = false;
37 | i++;
38 | } else if (open && 'hr' === token.type && done === 0) {
39 | // 第一层的 Hr 需要替换
40 | tokens.splice(i, 1, getCloseToken('li', token.level - 1), getOpenToken('li', token.level - 1));
41 | i++;
42 |
43 | step++;
44 | if (step >= 2) {
45 | let t1 = getOpenToken('div', token.level);
46 | t1.attrPush(['class', `process step-${step}`]);
47 | tokens.splice(i + 1, 0, t1, getCloseToken('div', token.level));
48 | i = i + 2;
49 | }
50 | } else if (open) {
51 | // 加深一层，因为外面多套了一层div
52 | token.level = token.level + 2;
53 | // 保证hr 是最贴近 container 的一层
54 | if (/_open$/.test(token.type)) {
55 | done++;
56 | } else if (/_close$/.test(token.type)) {
57 | done--;
58 | }
59 | }
60 | }
61 | return state;
62 | },
63 | render(tokens, idx) {
64 | const token = tokens[idx];
65 |
66 | if (token.nesting === 1) {
67 | const cmIndex = token.attrIndex('css-module');
68 | let clsIndex = token.attrIndex('class');
69 | let attrs = token.attrs || [];
70 |
71 | if (clsIndex >= 0) {
72 | attrs[clsIndex][1] += cmIndex >= 0 ? ` flexblock steps ${attrs[cmIndex][1]}` : ` flexblock steps`;
73 | } else {
74 | attrs.push(['class', cmIndex >= 0 ? `flexblock steps ${attrs[cmIndex][1]}` : `flexblock steps`]);
75 | }
76 |
77 | attrs = attrs.map(([key, value]) => {
78 | return `${key}="${value}"`;
79 | });
80 | // opening tag
81 | return `\n`;
82 | } else {
83 | // closing tag
84 | return '
\n';
85 | }
86 | }
87 | };
88 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/echarts.js:
--------------------------------------------------------------------------------
1 | module.exports = md => {
2 | const temp = md.renderer.rules.fence.bind(md.renderer.rules);
3 | md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
4 | const token = tokens[idx];
5 | const code = token.content.trim();
6 | if (token.info === 'echarts') {
7 | try {
8 | // 这里特殊处理下！
9 | const json = (1, eval)(`(function(){return ${code};})()`);
10 | let attrs = token.attrs || [];
11 | attrs = attrs.map(([key, value]) => {
12 | return `${key}="${value}"`;
13 | }).join(' ')
14 | return `${JSON.stringify(
15 | json
16 | )}
`;
17 | } catch (err) {
18 | return `${err}`;
19 | }
20 | }
21 | return temp(tokens, idx, options, env, slf);
22 | };
23 | };
24 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/fa.js:
--------------------------------------------------------------------------------
1 | const mditr = require('./regexp');
2 |
3 | module.exports = md => {
4 | // FA4 style.
5 | md.use(
6 | mditr(
7 | /\:fa-(.+?)\:/,
8 | (match, utils) => {
9 | return '';
10 | },
11 | 'fa_inline'
12 | )
13 | );
14 |
15 | md.use(
16 | mditr(
17 | /\:\~fa-(.+?)~\:/,
18 | (match, utils) => {
19 | return '';
20 | },
21 | 'fa_span'
22 | )
23 | );
24 |
25 | md.use(
26 | mditr(
27 | /\:\:fa-(.+?)\:\:/,
28 | (match, utils) => {
29 | return '';
30 | },
31 | 'fa_block'
32 | )
33 | );
34 |
35 | md.core.ruler.push('fa_blockify', function(state) {
36 | var paragraphTokensToRemove = [];
37 |
38 | var lastInlineTokenSeen;
39 | for (var blkIdx = 0; blkIdx < state.tokens.length; blkIdx++) {
40 | if (state.tokens[blkIdx].type !== 'paragraph_open') {
41 | continue;
42 | }
43 |
44 | var nextBlkToken = state.tokens[blkIdx + 1];
45 | if (nextBlkToken.type !== 'inline') {
46 | continue;
47 | }
48 |
49 | // FIXME Incorrect and a hack:
50 | // ...
will also get stripped.
51 | var paragraphOpens = 0;
52 | for (var i = blkIdx + 1; i < state.tokens.length; i++) {
53 | if (state.tokens[i].type === 'paragraph_open') {
54 | paragraphOpens++;
55 | continue;
56 | } else if (state.tokens[i].type !== 'paragraph_close') {
57 | continue;
58 | }
59 |
60 | if (paragraphOpens > 0) {
61 | paragraphOpens--;
62 | continue;
63 | }
64 |
65 | // OK, this is the paragraph_close matching the open we started on.
66 | // What came right before here?
67 | var prevBlkToken = state.tokens[i - 1];
68 |
69 | if (prevBlkToken.type !== 'inline') {
70 | break;
71 | }
72 | var prevInlineToken = prevBlkToken.children[prevBlkToken.children.length - 1];
73 |
74 | if (prevInlineToken.type !== 'fa_block' && prevInlineToken.type !== 'fa_span') {
75 | break;
76 | }
77 |
78 | // If we got this far, we're stripping the surrounding paragraph.
79 |
80 | // FIXME Also a hack. The 'inline' JSX that's inside the paragraph should
81 | // now get a linebreak after it in the generated HTML. Easier to test
82 | // and looks better in the HTML.
83 | prevInlineToken.content += '\n';
84 | paragraphTokensToRemove.push(blkIdx, i);
85 | break;
86 | }
87 | }
88 |
89 | state.tokens = state.tokens.filter(function(blkToken, idx) {
90 | return paragraphTokensToRemove.indexOf(idx) === -1;
91 | });
92 | });
93 | };
94 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/img.js:
--------------------------------------------------------------------------------
1 | const mditr = require('./regexp');
2 |
3 | const {getAttrs, getAttrsString} = require('./attrs/utils');
4 |
5 | module.exports = md => {
6 | md.use(
7 | mditr(
8 | /!!\[(\w+|)(.*?)?]\((.+?)\)/,
9 | (match, utils) => {
10 | let attrs = match[2] || '';
11 | if (attrs) {
12 | attrs = getAttrsString(
13 | getAttrs(`{${attrs}}`, 0, {
14 | leftDelimiter: '{',
15 | rightDelimiter: '}'
16 | })
17 | );
18 | }
19 | let src = match[3];
20 | let srcs = src.split(' ');
21 | src = srcs.shift();
22 | let imgAttrs = '';
23 | if (srcs.length) {
24 | imgAttrs = getAttrsString(
25 | getAttrs(`{${srcs.join(' ')}}`, 0, {
26 | leftDelimiter: '{',
27 | rightDelimiter: '}'
28 | })
29 | );
30 | }
31 | if (match[1]) {
32 | return `<${match[1]} ${attrs}>
`;
33 | } else {
34 | return ``;
35 | }
36 | },
37 | 'img_block'
38 | )
39 | );
40 |
41 | md.core.ruler.push('img_blockify', function(state) {
42 | var paragraphTokensToRemove = [];
43 |
44 | var lastInlineTokenSeen;
45 | for (var blkIdx = 0; blkIdx < state.tokens.length; blkIdx++) {
46 | if (state.tokens[blkIdx].type !== 'paragraph_open') {
47 | continue;
48 | }
49 |
50 | var nextBlkToken = state.tokens[blkIdx + 1];
51 | if (nextBlkToken.type !== 'inline') {
52 | continue;
53 | }
54 |
55 | // FIXME Incorrect and a hack:
56 | // ...
will also get stripped.
57 | var paragraphOpens = 0;
58 | for (var i = blkIdx + 1; i < state.tokens.length; i++) {
59 | if (state.tokens[i].type === 'paragraph_open') {
60 | paragraphOpens++;
61 | continue;
62 | } else if (state.tokens[i].type !== 'paragraph_close') {
63 | continue;
64 | }
65 |
66 | if (paragraphOpens > 0) {
67 | paragraphOpens--;
68 | continue;
69 | }
70 |
71 | var prevBlkToken = state.tokens[i - 1];
72 | if (prevBlkToken.type !== 'inline') {
73 | break;
74 | }
75 | // console.log(prevBlkToken.content)
76 | var prevInlineToken = prevBlkToken.children[prevBlkToken.children.length - 1];
77 | if (prevInlineToken.type !== 'img_block') {
78 | break;
79 | }
80 |
81 | prevInlineToken.content += '\n';
82 | paragraphTokensToRemove.push(blkIdx, i);
83 | break;
84 | }
85 | }
86 |
87 | state.tokens = state.tokens.filter((blkToken, idx) => {
88 | return paragraphTokensToRemove.indexOf(idx) === -1;
89 | });
90 | });
91 | };
92 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/jsx.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | // from https://github.com/osnr/markdown-it-jsx/
3 | var jsx_inline = require('markdown-it-jsx/lib/jsx_inline');
4 | var escape_code = require('markdown-it-jsx/lib/escape_code');
5 |
6 | module.exports = function jsx_plugin(md) {
7 | md.set({xhtmlOut: true});
8 |
9 | // JSX should entirely replace embedded HTML.
10 | md.inline.ruler.before('html_inline', 'jsx_inline', jsx_inline);
11 | md.disable('html_inline');
12 | // We'll parse blocks as inline and then strip the surrounding paragraph at the end; it's easier.
13 | md.disable('html_block');
14 |
15 | md.core.ruler.push('jsx_blockify', function(state) {
16 | // Look for things like ...
and strip the ,
there.
17 | // FIXME Quadratic time in worst case, I think?
18 | var paragraphTokensToRemove = [];
19 |
20 | var lastInlineTokenSeen;
21 | for (var blkIdx = 0; blkIdx < state.tokens.length; blkIdx++) {
22 | if (state.tokens[blkIdx].type !== 'paragraph_open') {
23 | continue;
24 | }
25 |
26 | var nextBlkToken = state.tokens[blkIdx + 1];
27 | if (nextBlkToken.type !== 'inline' || nextBlkToken.children[0].type !== 'jsx_inline') {
28 | continue;
29 | }
30 |
31 | // FIXME Incorrect and a hack:
32 | // ...
will also get stripped.
33 | var paragraphOpens = 0;
34 | for (var i = blkIdx + 1; i < state.tokens.length; i++) {
35 | if (state.tokens[i].type === 'paragraph_open') {
36 | paragraphOpens++;
37 | continue;
38 | } else if (state.tokens[i].type !== 'paragraph_close') {
39 | continue;
40 | }
41 |
42 | if (paragraphOpens > 0) {
43 | paragraphOpens--;
44 | continue;
45 | }
46 |
47 | // OK, this is the paragraph_close matching the open we started on.
48 | // What came right before here?
49 | var prevBlkToken = state.tokens[i - 1];
50 | if (prevBlkToken.type !== 'inline') {
51 | break;
52 | }
53 | var prevInlineToken = prevBlkToken.children[prevBlkToken.children.length - 1];
54 | if (prevInlineToken.type !== 'jsx_inline') {
55 | break;
56 | }
57 |
58 | // If we got this far, we're stripping the surrounding paragraph.
59 |
60 | // FIXME Also a hack. The 'inline' JSX that's inside the paragraph should
61 | // now get a linebreak after it in the generated HTML. Easier to test
62 | // and looks better in the HTML.
63 | prevInlineToken.content += '\n';
64 | paragraphTokensToRemove.push(blkIdx, i);
65 | break;
66 | }
67 | }
68 |
69 | state.tokens = state.tokens.filter(function(blkToken, idx) {
70 | return paragraphTokensToRemove.indexOf(idx) === -1;
71 | });
72 | });
73 |
74 | // 去掉代码注释
75 | // md.renderer.rules.fence = escape_code(md.renderer.rules.fence)
76 | // md.renderer.rules.code_inline = escape_code(md.renderer.rules.code_inline)
77 | // md.renderer.rules.code_block = escape_code(md.renderer.rules.code_block)
78 |
79 | md.renderer.rules['jsx_inline'] = function(tokens, idx) {
80 | // If the span is JSX, just pass the original source for the span
81 | // through to output.
82 | return tokens[idx].content;
83 | };
84 | };
85 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/link.js:
--------------------------------------------------------------------------------
1 | module.exports = md => {
2 | const defLinkOpen =
3 | md.renderer.rules.link_open ||
4 | function(tokens, idx, options, env, self) {
5 | return self.renderToken(tokens, idx, options);
6 | };
7 |
8 | md.renderer.rules.link_open = function(tokens, idx, options, env, self) {
9 | // 增加 target
10 | const aIndex = tokens[idx].attrIndex('target');
11 | const hrefIndex = tokens[idx].attrIndex('href');
12 | if (hrefIndex >= 0) {
13 | // 从在 hrefIndex
14 | const href = tokens[idx].attrs[hrefIndex][1];
15 | if (href && href !== '#') {
16 | if (aIndex < 0) {
17 | if (/^http[s]?:\/\//.test(href)) {
18 | // 只是添加外链
19 | tokens[idx].attrPush(['target', '_blank']); // add new attribute
20 | }
21 | } else {
22 | tokens[idx].attrs[aIndex][1] = '_blank'; // replace value of existing attr
23 | }
24 | } else {
25 | // 空连接不增加 _blank 替换成 JavaScript：void
26 | tokens[idx].attrs[hrefIndex][1] = 'javascript:void(0)';
27 | }
28 | }
29 |
30 | // pass token to default renderer.
31 | return defLinkOpen(tokens, idx, options, env, self);
32 | };
33 | };
34 |
35 | // module.exports = md => {
36 | // md.use(
37 | // mditr(
38 | // /\[\!(\.\w+\s+)?(.+?)]\((.*?)\)/,
39 | // (match, utils) => {
40 | // let cls = match[1] ? match[1].slice(1).trim() : ''
41 | // if (cls) {
42 | // cls = cls.split('.').join(' ')
43 | // }
44 | // let content = match[2]
45 | // content = md.render(content)
46 |
47 | // return `${content}`
50 | // },
51 | // 'button_inline'
52 | // )
53 | // )
54 | // }
55 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/mermaid.js:
--------------------------------------------------------------------------------
1 | module.exports = md => {
2 | const temp = md.renderer.rules.fence.bind(md.renderer.rules);
3 | md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
4 | const token = tokens[idx];
5 | const code = token.content;
6 | if (token.info === 'mermaid') {
7 | token.attrJoin('class', 'lang-mermaid no-style');
8 | let attrs = token.attrs || [];
9 | attrs = attrs
10 | .map(([key, value]) => {
11 | return `${key}="${value}"`;
12 | })
13 | .join(' ');
14 | // 增加对 mermaidjs 支持，这样就可以画流程图了哦~
15 | return `
16 |
19 | `;
20 | }
21 | return temp(tokens, idx, options, env, slf);
22 | };
23 | };
24 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/plus-list.js:
--------------------------------------------------------------------------------
1 | function findChecklists(state) {
2 | // console.log(state.tokens);
3 | state.tokens.forEach((token, i) => {
4 | if (token.type === 'bullet_list_open' && token.markup === '+') {
5 | // console.log(state.tokens[i + 1]);
6 | // applyClass(token);
7 | }
8 | });
9 | }
10 |
11 | /**
12 | * Adds class to token
13 | *
14 | * @param {any} token
15 | * @param {string} className
16 | */
17 | function applyClass(token) {
18 | // init attributes
19 | token.attrs = token.attrs || [];
20 |
21 | // get index of class attribute
22 | let keys = token.attrs.map(arr => arr[0]);
23 | let idx = keys.indexOf('class');
24 |
25 | if (idx === -1) {
26 | // Add class attribute if not defined
27 | token.attrs.push(['class', className]);
28 | } else {
29 | // Get the current class list to append.
30 | // Watch out for duplicates
31 | let classStr = token.attrs[idx][1] || '';
32 | let classList = classStr.split(' ');
33 |
34 | // Add the class if we don't already have it
35 | if (classList.indexOf(className) === -1) {
36 | token.attrs[idx][1] = classStr += ' ' + className;
37 | }
38 | }
39 | }
40 |
41 | module.exports = function plugin(md) {
42 | // Default class name
43 | md.block.ruler.after('list', 'list-checkmarks', state => {
44 | findChecklists(state);
45 | });
46 | };
47 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/regexp/index.js:
--------------------------------------------------------------------------------
1 | /*!
2 | * markdown-it-regexp
3 | * Copyright (c) 2014 Alex Kocharin
4 | * MIT Licensed
5 | */
6 |
7 | /**
8 | * Module dependencies.
9 | */
10 |
11 | var util = require('util');
12 | var stuff = require('./utils');
13 |
14 | /**
15 | * Counter for multi usage.
16 | */
17 | var counter = 0;
18 |
19 | /**
20 | * Expose `Plugin`
21 | */
22 |
23 | module.exports = Plugin;
24 |
25 | /**
26 | * Constructor function
27 | */
28 |
29 | function Plugin(regexp, replacer, id) {
30 | // return value should be a callable function
31 | // with strictly defined options passed by markdown-it
32 | var self = function(md, options) {
33 | self.options = options;
34 | self.init(md);
35 | };
36 |
37 | // initialize plugin object
38 | self.__proto__ = Plugin.prototype;
39 |
40 | // clone regexp with all the flags
41 | var flags = (regexp.global ? 'g' : '') + (regexp.multiline ? 'm' : '') + (regexp.ignoreCase ? 'i' : '');
42 |
43 | self.regexp = RegExp('^' + regexp.source, flags);
44 |
45 | // copy init options
46 | self.replacer = replacer;
47 |
48 | // this plugin can be inserted multiple times,
49 | // so we're generating unique name for it
50 | self.id = id ? id : 'regexp-' + counter;
51 | counter++;
52 |
53 | return self;
54 | }
55 |
56 | util.inherits(Plugin, Function);
57 |
58 | // function that registers plugin with markdown-it
59 | Plugin.prototype.init = function(md) {
60 | md.inline.ruler.push(this.id, this.parse.bind(this));
61 |
62 | md.renderer.rules[this.id] = this.render.bind(this);
63 | };
64 |
65 | Plugin.prototype.parse = function(state, silent) {
66 | // slowwww... maybe use an advanced regexp engine for this
67 | var match = this.regexp.exec(state.src.slice(state.pos));
68 | if (!match) return false;
69 |
70 | // valid match found, now we need to advance cursor
71 | state.pos += match[0].length;
72 |
73 | // don't insert any tokens in silent mode
74 | if (silent) return true;
75 |
76 | var token = state.push(this.id, '', 0);
77 | token.meta = {match: match};
78 |
79 | return true;
80 | };
81 |
82 | Plugin.prototype.render = function(tokens, id, options, env) {
83 | return this.replacer(tokens[id].meta.match, stuff);
84 | };
85 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/markdown/regexp/utils.js:
--------------------------------------------------------------------------------
1 | /*!
2 | * markdown-it-regexp
3 | * Copyright (c) 2014 Alex Kocharin
4 | * MIT Licensed
5 | */
6 |
7 | /**
8 | * Escape special characters in the given string of html.
9 | *
10 | * Borrowed from escape-html component, MIT-licensed
11 | */
12 | exports.escape = function(html) {
13 | return String(html)
14 | .replace(/&/g, '&')
15 | .replace(/"/g, '"')
16 | .replace(/'/g, ''')
17 | .replace(//g, '>');
19 | };
20 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/tags/attrs.js:
--------------------------------------------------------------------------------
1 | const {mergeAttrs} = require('../utils');
2 |
3 | module.exports = tree => {
4 | tree.walk(node => {
5 | if (
6 | node &&
7 | node.tag &&
8 | node.content &&
9 | node.content.find &&
10 | node.content.find(child => {
11 | if (child && child.tag && child.attrs && child.attrs['css-module']) {
12 | return true;
13 | }
14 | return false;
15 | })
16 | ) {
17 | // 说明是有子节点的父节点
18 | // 查找三层数据，用于处理
19 | const parentNode = node;
20 |
21 | node.content.forEach(node => {
22 | if (node.tag && node.attrs && node.attrs['css-module']) {
23 | let ca = node.attrs['css-module'].split(/\s+/);
24 | let rs = {};
25 | let ex = /^([\w\-]+)=('|"){1}(.+)\2/;
26 | parentNode.attrs = parentNode.attrs || {};
27 | ca = ca.filter(attr => {
28 | let m = ex.exec(attr);
29 | if (m && m[1]) {
30 | parentNode.attrs[m[1]] = m[3];
31 | return false;
32 | }
33 | return true;
34 | });
35 | parentNode.attrs = mergeAttrs({class: ca.join(' ')}, parentNode.attrs);
36 | delete node.attrs['css-module'];
37 | }
38 | });
39 | }
40 |
41 | return node;
42 | });
43 | };
44 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/tags/header-footer.js:
--------------------------------------------------------------------------------
1 | const utils = require('./utils');
2 |
3 | module.exports = tree => {
4 | let {slideNode, wrapNode} = utils(tree);
5 |
6 | if (wrapNode.content && wrapNode.content.length) {
7 | // console.log(wrapNode.content)
8 |
9 | wrapNode.content = wrapNode.content.map(n => {
10 | if (n.tag === 'footer' || n.tag === 'header') {
11 | n.content = [
12 | {
13 | tag: 'div',
14 | attrs: {
15 | class: 'wrap'
16 | },
17 | content: n.content
18 | }
19 | ];
20 | if (n.tag === 'header') {
21 | slideNode.content.unshift(n);
22 | } else {
23 | slideNode.content.push(n);
24 | }
25 | return false;
26 | }
27 | return n;
28 | });
29 | }
30 | };
31 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/tags/note.js:
--------------------------------------------------------------------------------
1 | const utils = require('./utils');
2 |
3 | module.exports = tree => {
4 | let {slideNode, wrapNode} = utils(tree);
5 |
6 | if (wrapNode.content && wrapNode.content.length) {
7 | // console.log(wrapNode.content)
8 |
9 | wrapNode.content = wrapNode.content.map(n => {
10 | if (n.tag === 'note') {
11 | n.tag = 'div';
12 | let cls = '';
13 | if (n.attrs) {
14 | cls = n.attrs.class || '';
15 | }
16 | n.attrs = n.attrs || {};
17 | cls = cls.split(/\s+/);
18 | cls.push('speaker-note');
19 |
20 | n.attrs.class = cls.join(' ');
21 | n.content = [
22 | {
23 | tag: 'div',
24 | attrs: {
25 | class: 'wrap'
26 | },
27 | content: n.content
28 | }
29 | ];
30 | slideNode.content.push(n);
31 | return false;
32 | }
33 | return n;
34 | });
35 | }
36 | };
37 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/tags/utils.js:
--------------------------------------------------------------------------------
1 | module.exports = tree => {
2 | let slide;
3 | tree.match({tag: 'section'}, node => {
4 | if (node.attrs && node.attrs.slide) {
5 | slide = node;
6 | }
7 | return node;
8 | });
9 | let wrap;
10 | tree.match({tag: 'div'}, node => {
11 | if (node.attrs && node.attrs.wrap) {
12 | wrap = node;
13 | }
14 | return node;
15 | });
16 |
17 | return {
18 | slideNode: slide,
19 | wrapNode: wrap
20 | };
21 | };
22 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/utils.js:
--------------------------------------------------------------------------------
1 | exports.mergeAttrs = (attrs1, attrs2 = {}) => {
2 | for (let i in attrs2) {
3 | switch (i) {
4 | case 'class':
5 | attrs1[i] = attrs1[i] ? [attrs1[i], attrs2[i]].join(' ') : attrs2[i];
6 | break;
7 | case 'style':
8 | attrs1[i] = attrs1[i] ? [attrs1[i], attrs2[i]].join(';') : attrs2[i];
9 | break;
10 | default:
11 | attrs1[i] = attrs2[i];
12 | }
13 | }
14 | return attrs1;
15 | };
16 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/lib/yaml-parser.js:
--------------------------------------------------------------------------------
1 | const yaml = require('js-yaml');
2 | function getSettings(str) {
3 | const settings = yaml.load(str);
4 | const pluginSettings = {};
5 | if (settings.plugins && Array.isArray(settings.plugins)) {
6 | settings.plugins = settings.plugins.map(p => {
7 | if (typeof p === 'string') {
8 | return p;
9 | } else if (typeof p === 'object') {
10 | const key = Object.keys(p)[0];
11 | pluginSettings[key] = p[key];
12 | return key;
13 | }
14 | });
15 | }
16 | settings.pluginsOptions = pluginSettings;
17 | return settings;
18 | }
19 |
20 | module.exports = getSettings;
21 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "nodeppt-parser",
3 | "version": "2.2.1",
4 | "description": "",
5 | "main": "index.js",
6 | "scripts": {
7 | "test": "echo \"Error: no test specified\" && exit 1"
8 | },
9 | "keywords": [
10 | "presentation",
11 | "powerpoint",
12 | "slideshow",
13 | "keynote",
14 | "ppt",
15 | "slide",
16 | "revealjs",
17 | "impressjs",
18 | "markdown-it",
19 | "posthtml",
20 | "webpack",
21 | "nodeppt",
22 | "markdown"
23 | ],
24 | "author": {
25 | "name": "Theo Wang",
26 | "email": "ksky521@gmail.com"
27 | },
28 | "repository": {
29 | "type": "git",
30 | "url": "git://github.com/ksky521/nodeppt"
31 | },
32 | "license": "MIT",
33 | "dependencies": {
34 | "ejs": "^3.0.1",
35 | "fs-extra": "^8.1.0",
36 | "js-yaml": "^3.12.1",
37 | "loader-utils": "^1.2.3",
38 | "lodash.defaultsdeep": "^4.6.0",
39 | "markdown-it": "^10.0.0",
40 | "markdown-it-br": "^1.0.0",
41 | "markdown-it-jsx": "1.1.0",
42 | "@ksky521/markdown-it-katex":"^2.1.3",
43 | "markdown-it-span": "^1.0.0",
44 | "markdown-it-sup": "^1.0.0",
45 | "posthtml": "^0.12.0",
46 | "posthtml-parser": "^0.4.1",
47 | "posthtml-render": "^1.1.4",
48 | "prismjs": "^1.15.0"
49 | },
50 | "gitHead": "9fba34ba1a8cc3ab149c2447c313e25b1e25093e"
51 | }
52 |
--------------------------------------------------------------------------------
/packages/nodeppt-parser/template/index.ejs:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 | <%= title %> - By <%= speaker %>
10 |
11 |
12 |
13 | <% if (hasOwnProperty('prismTheme') && ['dark', 'coy', 'funky', 'okaidia', 'tomorrow', 'solarizedlight', 'twilight'].includes(prismTheme)) { %>
14 |
15 | <% } %>
16 |
17 | <% if (hasOwnProperty('css') && css.length) { %>
18 | <% for (var i = 0;i
19 |
20 | <% } %>
21 | <% } %>
22 |
23 | <% if (hasOwnProperty('plugins') && plugins && plugins.indexOf && ~plugins.indexOf('katex')) { %>
24 |
25 | <% } %>
26 |
27 |
28 |
29 |
30 | <%- content %>
31 |
32 |