You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3623 lines
111 KiB
3623 lines
111 KiB
!(function r(e, n, t) {
|
|
function o(i, f) {
|
|
if (!n[i]) {
|
|
if (!e[i]) {
|
|
var c = 'function' == typeof require && require;
|
|
if (!f && c) return c(i, !0);
|
|
if (u) return u(i, !0);
|
|
var a = new Error("Cannot find module '" + i + "'");
|
|
throw ((a.code = 'MODULE_NOT_FOUND'), a);
|
|
}
|
|
var p = (n[i] = { exports: {} });
|
|
e[i][0].call(
|
|
p.exports,
|
|
function(r) {
|
|
return o(e[i][1][r] || r);
|
|
},
|
|
p,
|
|
p.exports,
|
|
r,
|
|
e,
|
|
n,
|
|
t,
|
|
);
|
|
}
|
|
return n[i].exports;
|
|
}
|
|
for (
|
|
var u = 'function' == typeof require && require, i = 0;
|
|
i < t.length;
|
|
i++
|
|
)
|
|
o(t[i]);
|
|
return o;
|
|
})(
|
|
{
|
|
1: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = function(index, output) {
|
|
let menu;
|
|
function closeMenu(e) {
|
|
const left = parseInt(menu.style.left, 10),
|
|
top = parseInt(menu.style.top, 10);
|
|
(e.x < left ||
|
|
e.x > left + menu.offsetWidth ||
|
|
e.y < top ||
|
|
e.y > top + menu.offsetHeight) &&
|
|
(menu.parentNode.removeChild(menu),
|
|
document.body.removeEventListener('mousedown', closeMenu, !1));
|
|
}
|
|
const div = document.getElementById(output + index);
|
|
div.childNodes[0].addEventListener(
|
|
'contextmenu',
|
|
function(e) {
|
|
(menu = document.createElement('div')),
|
|
(menu.className = 'wavedromMenu'),
|
|
(menu.style.top = e.y + 'px'),
|
|
(menu.style.left = e.x + 'px');
|
|
const list = document.createElement('ul'),
|
|
savePng = document.createElement('li');
|
|
(savePng.innerHTML = 'Save as PNG'), list.appendChild(savePng);
|
|
const saveSvg = document.createElement('li');
|
|
(saveSvg.innerHTML = 'Save as SVG'),
|
|
list.appendChild(saveSvg),
|
|
menu.appendChild(list),
|
|
document.body.appendChild(menu),
|
|
savePng.addEventListener(
|
|
'click',
|
|
function() {
|
|
let html = '';
|
|
if (0 !== index) {
|
|
const firstDiv = document.getElementById(output + 0);
|
|
html += firstDiv.innerHTML.substring(
|
|
166,
|
|
firstDiv.innerHTML.indexOf('<g id="waves_0">'),
|
|
);
|
|
}
|
|
html = [
|
|
div.innerHTML.slice(0, 166),
|
|
html,
|
|
div.innerHTML.slice(166),
|
|
].join('');
|
|
const svgdata = 'data:image/svg+xml;base64,' + btoa(html),
|
|
img = new Image();
|
|
img.src = svgdata;
|
|
const canvas = document.createElement('canvas');
|
|
(canvas.width = img.width), (canvas.height = img.height);
|
|
canvas.getContext('2d').drawImage(img, 0, 0);
|
|
const pngdata = canvas.toDataURL('image/png'),
|
|
a = document.createElement('a');
|
|
(a.href = pngdata),
|
|
(a.download = 'wavedrom.png'),
|
|
a.click(),
|
|
menu.parentNode.removeChild(menu),
|
|
document.body.removeEventListener(
|
|
'mousedown',
|
|
closeMenu,
|
|
!1,
|
|
);
|
|
},
|
|
!1,
|
|
),
|
|
saveSvg.addEventListener(
|
|
'click',
|
|
function() {
|
|
let html = '';
|
|
if (0 !== index) {
|
|
const firstDiv = document.getElementById(output + 0);
|
|
html += firstDiv.innerHTML.substring(
|
|
166,
|
|
firstDiv.innerHTML.indexOf('<g id="waves_0">'),
|
|
);
|
|
}
|
|
html = [
|
|
div.innerHTML.slice(0, 166),
|
|
html,
|
|
div.innerHTML.slice(166),
|
|
].join('');
|
|
const svgdata = 'data:image/svg+xml;base64,' + btoa(html),
|
|
a = document.createElement('a');
|
|
(a.href = svgdata),
|
|
(a.download = 'wavedrom.svg'),
|
|
a.click(),
|
|
menu.parentNode.removeChild(menu),
|
|
document.body.removeEventListener(
|
|
'mousedown',
|
|
closeMenu,
|
|
!1,
|
|
);
|
|
},
|
|
!1,
|
|
),
|
|
menu.addEventListener(
|
|
'contextmenu',
|
|
function(ee) {
|
|
ee.preventDefault();
|
|
},
|
|
!1,
|
|
),
|
|
document.body.addEventListener('mousedown', closeMenu, !1),
|
|
e.preventDefault();
|
|
},
|
|
!1,
|
|
);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
2: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = function(Edge, from, to) {
|
|
const dx = to.x - from.x,
|
|
dy = to.y - from.y;
|
|
let lx = (from.x + to.x) / 2;
|
|
const ly = (from.y + to.y) / 2;
|
|
let d, style;
|
|
switch (Edge.shape) {
|
|
case '-':
|
|
break;
|
|
case '~':
|
|
d =
|
|
'M ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' c ' +
|
|
0.7 * dx +
|
|
', 0 ' +
|
|
0.3 * dx +
|
|
', ' +
|
|
dy +
|
|
' ' +
|
|
dx +
|
|
', ' +
|
|
dy;
|
|
break;
|
|
case '-~':
|
|
(d =
|
|
'M ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' c ' +
|
|
0.7 * dx +
|
|
', 0 ' +
|
|
dx +
|
|
', ' +
|
|
dy +
|
|
' ' +
|
|
dx +
|
|
', ' +
|
|
dy),
|
|
Edge.label && (lx = from.x + 0.75 * (to.x - from.x));
|
|
break;
|
|
case '~-':
|
|
(d =
|
|
'M ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' c 0, 0 ' +
|
|
0.3 * dx +
|
|
', ' +
|
|
dy +
|
|
' ' +
|
|
dx +
|
|
', ' +
|
|
dy),
|
|
Edge.label && (lx = from.x + 0.25 * (to.x - from.x));
|
|
break;
|
|
case '-|':
|
|
(d = 'm ' + from.x + ',' + from.y + ' ' + dx + ',0 0,' + dy),
|
|
Edge.label && (lx = to.x);
|
|
break;
|
|
case '|-':
|
|
(d = 'm ' + from.x + ',' + from.y + ' 0,' + dy + ' ' + dx + ',0'),
|
|
Edge.label && (lx = from.x);
|
|
break;
|
|
case '-|-':
|
|
d =
|
|
'm ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' ' +
|
|
dx / 2 +
|
|
',0 0,' +
|
|
dy +
|
|
' ' +
|
|
dx / 2 +
|
|
',0';
|
|
break;
|
|
case '->':
|
|
style =
|
|
'marker-end:url(#arrowhead);stroke:#0041c4;stroke-width:1;fill:none';
|
|
break;
|
|
case '~>':
|
|
(style =
|
|
'marker-end:url(#arrowhead);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d =
|
|
'M ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' c ' +
|
|
0.7 * dx +
|
|
', 0 ' +
|
|
0.3 * dx +
|
|
', ' +
|
|
dy +
|
|
' ' +
|
|
dx +
|
|
', ' +
|
|
dy);
|
|
break;
|
|
case '-~>':
|
|
(style =
|
|
'marker-end:url(#arrowhead);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d =
|
|
'M ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' c ' +
|
|
0.7 * dx +
|
|
', 0 ' +
|
|
dx +
|
|
', ' +
|
|
dy +
|
|
' ' +
|
|
dx +
|
|
', ' +
|
|
dy),
|
|
Edge.label && (lx = from.x + 0.75 * (to.x - from.x));
|
|
break;
|
|
case '~->':
|
|
(style =
|
|
'marker-end:url(#arrowhead);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d =
|
|
'M ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' c 0, 0 ' +
|
|
0.3 * dx +
|
|
', ' +
|
|
dy +
|
|
' ' +
|
|
dx +
|
|
', ' +
|
|
dy),
|
|
Edge.label && (lx = from.x + 0.25 * (to.x - from.x));
|
|
break;
|
|
case '-|>':
|
|
(style =
|
|
'marker-end:url(#arrowhead);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d = 'm ' + from.x + ',' + from.y + ' ' + dx + ',0 0,' + dy),
|
|
Edge.label && (lx = to.x);
|
|
break;
|
|
case '|->':
|
|
(style =
|
|
'marker-end:url(#arrowhead);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d =
|
|
'm ' + from.x + ',' + from.y + ' 0,' + dy + ' ' + dx + ',0'),
|
|
Edge.label && (lx = from.x);
|
|
break;
|
|
case '-|->':
|
|
(style =
|
|
'marker-end:url(#arrowhead);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d =
|
|
'm ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' ' +
|
|
dx / 2 +
|
|
',0 0,' +
|
|
dy +
|
|
' ' +
|
|
dx / 2 +
|
|
',0');
|
|
break;
|
|
case '<->':
|
|
style =
|
|
'marker-end:url(#arrowhead);marker-start:url(#arrowtail);stroke:#0041c4;stroke-width:1;fill:none';
|
|
break;
|
|
case '<~>':
|
|
(style =
|
|
'marker-end:url(#arrowhead);marker-start:url(#arrowtail);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d =
|
|
'M ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' c ' +
|
|
0.7 * dx +
|
|
', 0 ' +
|
|
0.3 * dx +
|
|
', ' +
|
|
dy +
|
|
' ' +
|
|
dx +
|
|
', ' +
|
|
dy);
|
|
break;
|
|
case '<-~>':
|
|
(style =
|
|
'marker-end:url(#arrowhead);marker-start:url(#arrowtail);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d =
|
|
'M ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' c ' +
|
|
0.7 * dx +
|
|
', 0 ' +
|
|
dx +
|
|
', ' +
|
|
dy +
|
|
' ' +
|
|
dx +
|
|
', ' +
|
|
dy),
|
|
Edge.label && (lx = from.x + 0.75 * (to.x - from.x));
|
|
break;
|
|
case '<-|>':
|
|
(style =
|
|
'marker-end:url(#arrowhead);marker-start:url(#arrowtail);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d = 'm ' + from.x + ',' + from.y + ' ' + dx + ',0 0,' + dy),
|
|
Edge.label && (lx = to.x);
|
|
break;
|
|
case '<-|->':
|
|
(style =
|
|
'marker-end:url(#arrowhead);marker-start:url(#arrowtail);stroke:#0041c4;stroke-width:1;fill:none'),
|
|
(d =
|
|
'm ' +
|
|
from.x +
|
|
',' +
|
|
from.y +
|
|
' ' +
|
|
dx / 2 +
|
|
',0 0,' +
|
|
dy +
|
|
' ' +
|
|
dx / 2 +
|
|
',0');
|
|
break;
|
|
case '+':
|
|
style =
|
|
'marker-end:url(#tee);marker-start:url(#tee);fill:none;stroke:#00F;stroke-width:1';
|
|
break;
|
|
default:
|
|
style = 'fill:none;stroke:#F00;stroke-width:1';
|
|
}
|
|
return { lx: lx, ly: ly, d: d, style: style };
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
3: [
|
|
function(require, module, exports) {
|
|
module.exports = {
|
|
chars: [
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
34,
|
|
47,
|
|
74,
|
|
74,
|
|
118,
|
|
89,
|
|
25,
|
|
44,
|
|
44,
|
|
52,
|
|
78,
|
|
37,
|
|
44,
|
|
37,
|
|
37,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
37,
|
|
37,
|
|
78,
|
|
78,
|
|
78,
|
|
74,
|
|
135,
|
|
89,
|
|
89,
|
|
96,
|
|
96,
|
|
89,
|
|
81,
|
|
103,
|
|
96,
|
|
37,
|
|
67,
|
|
89,
|
|
74,
|
|
109,
|
|
96,
|
|
103,
|
|
89,
|
|
103,
|
|
96,
|
|
89,
|
|
81,
|
|
96,
|
|
89,
|
|
127,
|
|
89,
|
|
87,
|
|
81,
|
|
37,
|
|
37,
|
|
37,
|
|
61,
|
|
74,
|
|
44,
|
|
74,
|
|
74,
|
|
67,
|
|
74,
|
|
74,
|
|
37,
|
|
74,
|
|
74,
|
|
30,
|
|
30,
|
|
67,
|
|
30,
|
|
112,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
44,
|
|
67,
|
|
37,
|
|
74,
|
|
67,
|
|
95,
|
|
66,
|
|
65,
|
|
67,
|
|
44,
|
|
34,
|
|
44,
|
|
78,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
37,
|
|
43,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
34,
|
|
74,
|
|
44,
|
|
98,
|
|
49,
|
|
74,
|
|
78,
|
|
0,
|
|
98,
|
|
73,
|
|
53,
|
|
73,
|
|
44,
|
|
44,
|
|
44,
|
|
77,
|
|
71,
|
|
37,
|
|
44,
|
|
44,
|
|
49,
|
|
74,
|
|
111,
|
|
111,
|
|
111,
|
|
81,
|
|
89,
|
|
89,
|
|
89,
|
|
89,
|
|
89,
|
|
89,
|
|
133,
|
|
96,
|
|
89,
|
|
89,
|
|
89,
|
|
89,
|
|
37,
|
|
37,
|
|
37,
|
|
37,
|
|
96,
|
|
96,
|
|
103,
|
|
103,
|
|
103,
|
|
103,
|
|
103,
|
|
78,
|
|
103,
|
|
96,
|
|
96,
|
|
96,
|
|
96,
|
|
87,
|
|
89,
|
|
81,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
118,
|
|
67,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
36,
|
|
36,
|
|
36,
|
|
36,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
73,
|
|
81,
|
|
74,
|
|
74,
|
|
74,
|
|
74,
|
|
65,
|
|
74,
|
|
65,
|
|
89,
|
|
74,
|
|
89,
|
|
74,
|
|
89,
|
|
74,
|
|
96,
|
|
67,
|
|
96,
|
|
67,
|
|
96,
|
|
67,
|
|
96,
|
|
67,
|
|
96,
|
|
82,
|
|
96,
|
|
74,
|
|
89,
|
|
74,
|
|
89,
|
|
74,
|
|
89,
|
|
74,
|
|
89,
|
|
74,
|
|
89,
|
|
74,
|
|
103,
|
|
74,
|
|
103,
|
|
74,
|
|
103,
|
|
74,
|
|
103,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
37,
|
|
36,
|
|
37,
|
|
36,
|
|
37,
|
|
36,
|
|
37,
|
|
30,
|
|
37,
|
|
36,
|
|
98,
|
|
59,
|
|
67,
|
|
30,
|
|
89,
|
|
67,
|
|
67,
|
|
74,
|
|
30,
|
|
74,
|
|
30,
|
|
74,
|
|
39,
|
|
74,
|
|
44,
|
|
74,
|
|
30,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
80,
|
|
96,
|
|
74,
|
|
103,
|
|
74,
|
|
103,
|
|
74,
|
|
103,
|
|
74,
|
|
133,
|
|
126,
|
|
96,
|
|
44,
|
|
96,
|
|
44,
|
|
96,
|
|
44,
|
|
89,
|
|
67,
|
|
89,
|
|
67,
|
|
89,
|
|
67,
|
|
89,
|
|
67,
|
|
81,
|
|
38,
|
|
81,
|
|
50,
|
|
81,
|
|
37,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
127,
|
|
95,
|
|
87,
|
|
65,
|
|
87,
|
|
81,
|
|
67,
|
|
81,
|
|
67,
|
|
81,
|
|
67,
|
|
30,
|
|
84,
|
|
97,
|
|
91,
|
|
84,
|
|
91,
|
|
84,
|
|
94,
|
|
92,
|
|
73,
|
|
104,
|
|
109,
|
|
91,
|
|
84,
|
|
81,
|
|
84,
|
|
100,
|
|
82,
|
|
76,
|
|
74,
|
|
103,
|
|
91,
|
|
131,
|
|
47,
|
|
40,
|
|
99,
|
|
77,
|
|
37,
|
|
79,
|
|
130,
|
|
100,
|
|
84,
|
|
104,
|
|
114,
|
|
87,
|
|
126,
|
|
101,
|
|
87,
|
|
84,
|
|
93,
|
|
84,
|
|
69,
|
|
84,
|
|
46,
|
|
52,
|
|
82,
|
|
52,
|
|
82,
|
|
114,
|
|
89,
|
|
102,
|
|
96,
|
|
100,
|
|
98,
|
|
91,
|
|
70,
|
|
88,
|
|
88,
|
|
77,
|
|
70,
|
|
85,
|
|
89,
|
|
77,
|
|
67,
|
|
84,
|
|
39,
|
|
65,
|
|
61,
|
|
39,
|
|
189,
|
|
173,
|
|
153,
|
|
111,
|
|
105,
|
|
61,
|
|
123,
|
|
123,
|
|
106,
|
|
89,
|
|
74,
|
|
37,
|
|
30,
|
|
103,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
96,
|
|
74,
|
|
81,
|
|
91,
|
|
81,
|
|
91,
|
|
81,
|
|
130,
|
|
131,
|
|
102,
|
|
84,
|
|
103,
|
|
84,
|
|
87,
|
|
78,
|
|
104,
|
|
81,
|
|
104,
|
|
81,
|
|
88,
|
|
76,
|
|
37,
|
|
189,
|
|
173,
|
|
153,
|
|
103,
|
|
84,
|
|
148,
|
|
90,
|
|
100,
|
|
84,
|
|
89,
|
|
74,
|
|
133,
|
|
118,
|
|
103,
|
|
81,
|
|
],
|
|
other: 114,
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
4: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const stringify = require('onml/stringify.js'),
|
|
w3 = require('./w3.js');
|
|
module.exports = function(arr) {
|
|
(arr[1].xmlns = w3.svg), (arr[1]['xmlns:xlink'] = w3.xlink);
|
|
const s1 = stringify(arr);
|
|
return new DOMParser().parseFromString(s1, 'image/svg+xml')
|
|
.firstChild;
|
|
};
|
|
},
|
|
{ './w3.js': 33, 'onml/stringify.js': 42 },
|
|
],
|
|
5: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const eva = require('./eva.js'),
|
|
renderWaveForm = require('./render-wave-form.js');
|
|
module.exports = function() {
|
|
renderWaveForm(0, eva('InputJSON_0'), 'WaveDrom_Display_');
|
|
};
|
|
},
|
|
{ './eva.js': 6, './render-wave-form.js': 30 },
|
|
],
|
|
6: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
function erra(e) {
|
|
console.log('Error in WaveJS: ', e);
|
|
const msg = [
|
|
'tspan',
|
|
['tspan', { class: 'error h5' }, 'Error: '],
|
|
e.message,
|
|
];
|
|
return (msg.textWidth = 1e3), { signal: [{ name: msg }] };
|
|
}
|
|
function eva(id) {
|
|
const TheTextBox = document.getElementById(id);
|
|
let source;
|
|
if (TheTextBox.type && 'textarea' === TheTextBox.type)
|
|
try {
|
|
source = eval('(' + TheTextBox.value + ')');
|
|
} catch (e) {
|
|
return erra(e);
|
|
}
|
|
else
|
|
try {
|
|
source = eval('(' + TheTextBox.innerHTML + ')');
|
|
} catch (e) {
|
|
return erra(e);
|
|
}
|
|
if ('[object Object]' !== Object.prototype.toString.call(source))
|
|
return erra({
|
|
message:
|
|
'[Semantic]: The root has to be an Object: "{signal:[...]}"',
|
|
});
|
|
if (source.signal) {
|
|
if (!Array.isArray(source.signal))
|
|
return erra({
|
|
message:
|
|
'[Semantic]: "signal" object has to be an Array "signal:[]"',
|
|
});
|
|
} else if (source.assign) {
|
|
if (!Array.isArray(source.assign))
|
|
return erra({
|
|
message:
|
|
'[Semantic]: "assign" object hasto be an Array "assign:[]"',
|
|
});
|
|
} else if (!source.reg)
|
|
return erra({
|
|
message:
|
|
'[Semantic]: "signal:[...]" or "assign:[...]" property is missing inside the root Object',
|
|
});
|
|
return source;
|
|
}
|
|
module.exports = eva;
|
|
},
|
|
{},
|
|
],
|
|
7: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = function(lanetext) {
|
|
let gcount = 0,
|
|
lcount = 0;
|
|
const ret = [];
|
|
return (
|
|
lanetext.forEach(function(e) {
|
|
'vvv-2' === e ||
|
|
'vvv-3' === e ||
|
|
'vvv-4' === e ||
|
|
'vvv-5' === e ||
|
|
'vvv-6' === e ||
|
|
'vvv-7' === e ||
|
|
'vvv-8' === e ||
|
|
'vvv-9' === e
|
|
? (lcount += 1)
|
|
: 0 !== lcount &&
|
|
(ret.push(gcount - (lcount + 1) / 2), (lcount = 0)),
|
|
(gcount += 1);
|
|
}),
|
|
0 !== lcount && ret.push(gcount - (lcount + 1) / 2),
|
|
ret
|
|
);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
8: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = (texts, extra, times) => {
|
|
const R = [];
|
|
if ((Array.isArray(texts) || (texts = [texts]), 4 === texts.length)) {
|
|
for (let j = 0; j < times; j += 1) {
|
|
R.push(texts[0]);
|
|
for (let i = 0; i < extra; i += 1) R.push(texts[1]);
|
|
R.push(texts[2]);
|
|
for (let i = 0; i < extra; i += 1) R.push(texts[3]);
|
|
}
|
|
return R;
|
|
}
|
|
1 === texts.length && texts.push(texts[0]), R.push(texts[0]);
|
|
for (let i = 0; i < times * (2 * (extra + 1)) - 1; i += 1)
|
|
R.push(texts[1]);
|
|
return R;
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
9: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const genBrick = require('./gen-brick.js'),
|
|
lookUpTable = {
|
|
p: ['pclk', '111', 'nclk', '000'],
|
|
n: ['nclk', '000', 'pclk', '111'],
|
|
P: ['Pclk', '111', 'nclk', '000'],
|
|
N: ['Nclk', '000', 'pclk', '111'],
|
|
l: '000',
|
|
L: '000',
|
|
0: '000',
|
|
h: '111',
|
|
H: '111',
|
|
1: '111',
|
|
'=': 'vvv-2',
|
|
2: 'vvv-2',
|
|
3: 'vvv-3',
|
|
4: 'vvv-4',
|
|
5: 'vvv-5',
|
|
6: 'vvv-6',
|
|
7: 'vvv-7',
|
|
8: 'vvv-8',
|
|
9: 'vvv-9',
|
|
d: 'ddd',
|
|
u: 'uuu',
|
|
z: 'zzz',
|
|
default: 'xxx',
|
|
};
|
|
module.exports = (text, extra, times) =>
|
|
genBrick(lookUpTable[text] || lookUpTable.default, extra, times);
|
|
},
|
|
{ './gen-brick.js': 8 },
|
|
],
|
|
10: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const genBrick = require('./gen-brick.js');
|
|
module.exports = function(text, extra, times) {
|
|
const x2 = {
|
|
0: '0',
|
|
1: '1',
|
|
x: 'x',
|
|
d: 'd',
|
|
u: 'u',
|
|
z: 'z',
|
|
'=': 'v',
|
|
2: 'v',
|
|
3: 'v',
|
|
4: 'v',
|
|
5: 'v',
|
|
6: 'v',
|
|
7: 'v',
|
|
8: 'v',
|
|
9: 'v',
|
|
},
|
|
x3 = {
|
|
0: '',
|
|
1: '',
|
|
x: '',
|
|
d: '',
|
|
u: '',
|
|
z: '',
|
|
'=': '-2',
|
|
2: '-2',
|
|
3: '-3',
|
|
4: '-4',
|
|
5: '-5',
|
|
6: '-6',
|
|
7: '-7',
|
|
8: '-8',
|
|
9: '-9',
|
|
},
|
|
y1 = {
|
|
p: '0',
|
|
n: '1',
|
|
P: '0',
|
|
N: '1',
|
|
h: '1',
|
|
l: '0',
|
|
H: '1',
|
|
L: '0',
|
|
0: '0',
|
|
1: '1',
|
|
x: 'x',
|
|
d: 'd',
|
|
u: 'u',
|
|
z: 'z',
|
|
'=': 'v',
|
|
2: 'v',
|
|
3: 'v',
|
|
4: 'v',
|
|
5: 'v',
|
|
6: 'v',
|
|
7: 'v',
|
|
8: 'v',
|
|
9: 'v',
|
|
},
|
|
y2 = {
|
|
p: '',
|
|
n: '',
|
|
P: '',
|
|
N: '',
|
|
h: '',
|
|
l: '',
|
|
H: '',
|
|
L: '',
|
|
0: '',
|
|
1: '',
|
|
x: '',
|
|
d: '',
|
|
u: '',
|
|
z: '',
|
|
'=': '-2',
|
|
2: '-2',
|
|
3: '-3',
|
|
4: '-4',
|
|
5: '-5',
|
|
6: '-6',
|
|
7: '-7',
|
|
8: '-8',
|
|
9: '-9',
|
|
},
|
|
x5 = { p: 'nclk', n: 'pclk', P: 'nclk', N: 'pclk' },
|
|
x6 = { p: '000', n: '111', P: '000', N: '111' },
|
|
xclude = {
|
|
hp: '111',
|
|
Hp: '111',
|
|
ln: '000',
|
|
Ln: '000',
|
|
nh: '111',
|
|
Nh: '111',
|
|
pl: '000',
|
|
Pl: '000',
|
|
},
|
|
atext = text.split(''),
|
|
tmp0 = {
|
|
p: '111',
|
|
n: '000',
|
|
P: '111',
|
|
N: '000',
|
|
h: '111',
|
|
l: '000',
|
|
H: '111',
|
|
L: '000',
|
|
0: '000',
|
|
1: '111',
|
|
x: 'xxx',
|
|
d: 'ddd',
|
|
u: 'uuu',
|
|
z: 'zzz',
|
|
'=': 'vvv-2',
|
|
2: 'vvv-2',
|
|
3: 'vvv-3',
|
|
4: 'vvv-4',
|
|
5: 'vvv-5',
|
|
6: 'vvv-6',
|
|
7: 'vvv-7',
|
|
8: 'vvv-8',
|
|
9: 'vvv-9',
|
|
}[atext[1]];
|
|
let tmp1 = {
|
|
p: 'pclk',
|
|
n: 'nclk',
|
|
P: 'Pclk',
|
|
N: 'Nclk',
|
|
h: 'pclk',
|
|
l: 'nclk',
|
|
H: 'Pclk',
|
|
L: 'Nclk',
|
|
}[atext[1]];
|
|
if (void 0 === tmp1) {
|
|
const tmp2 = x2[atext[1]];
|
|
if (void 0 === tmp2) return genBrick('xxx', extra, times);
|
|
{
|
|
const tmp3 = y1[atext[0]];
|
|
return genBrick(
|
|
void 0 === tmp3
|
|
? 'xxx'
|
|
: [tmp3 + 'm' + tmp2 + y2[atext[0]] + x3[atext[1]], tmp0],
|
|
extra,
|
|
times,
|
|
);
|
|
}
|
|
}
|
|
{
|
|
const tmp4 = xclude[text];
|
|
void 0 !== tmp4 && (tmp1 = tmp4);
|
|
const tmp5 = x5[atext[1]];
|
|
return genBrick(
|
|
void 0 === tmp5 ? [tmp1, tmp0] : [tmp1, tmp0, tmp5, x6[atext[1]]],
|
|
extra,
|
|
times,
|
|
);
|
|
}
|
|
};
|
|
},
|
|
{ './gen-brick.js': 8 },
|
|
],
|
|
11: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tt = require('onml/tt.js'),
|
|
w3 = require('./w3.js');
|
|
module.exports = function(
|
|
index,
|
|
source,
|
|
lane,
|
|
waveSkin,
|
|
content,
|
|
lanes,
|
|
groups,
|
|
notFirstSignal,
|
|
) {
|
|
const waveSkinNames = Object.keys(waveSkin);
|
|
let skin = waveSkin.default || waveSkin[waveSkinNames[0]];
|
|
source &&
|
|
source.config &&
|
|
source.config.skin &&
|
|
waveSkin[source.config.skin] &&
|
|
(skin = waveSkin[source.config.skin]);
|
|
const e = notFirstSignal
|
|
? [
|
|
'svg',
|
|
{ id: 'svg', xmlns: w3.svg, 'xmlns:xlink': w3.xlink },
|
|
['g'],
|
|
]
|
|
: skin,
|
|
width = lane.xg + lane.xs * (lane.xmax + 1),
|
|
height =
|
|
content.length * lane.yo +
|
|
lane.yh0 +
|
|
lane.yh1 +
|
|
lane.yf0 +
|
|
lane.yf1,
|
|
body = e[e.length - 1];
|
|
(body[1] = { id: 'waves_' + index }),
|
|
(body[2] = [
|
|
'g',
|
|
tt(lane.xg + 0.5, lane.yh0 + lane.yh1 + 0.5, {
|
|
id: 'lanes_' + index,
|
|
}),
|
|
].concat(lanes)),
|
|
(body[3] = ['g', { id: 'groups_' + index }, groups]);
|
|
const head = e[1];
|
|
return (
|
|
(head.id = 'svgcontent_' + index),
|
|
(head.height = height),
|
|
(head.width = width),
|
|
(head.viewBox = '0 0 ' + width + ' ' + height),
|
|
(head.overflow = 'hidden'),
|
|
e
|
|
);
|
|
};
|
|
},
|
|
{ './w3.js': 33, 'onml/tt.js': 43 },
|
|
],
|
|
12: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = {
|
|
xs: 20,
|
|
ys: 20,
|
|
xg: 120,
|
|
yh0: 0,
|
|
yh1: 0,
|
|
yf0: 0,
|
|
yf1: 0,
|
|
y0: 5,
|
|
yo: 30,
|
|
tgo: -10,
|
|
ym: 15,
|
|
xlabel: 6,
|
|
xmax: 1,
|
|
scale: 1,
|
|
head: {},
|
|
foot: {},
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
13: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = function(source, lane) {
|
|
if (
|
|
((lane.hscale = 1),
|
|
lane.hscale0 && (lane.hscale = lane.hscale0),
|
|
source && source.config && source.config.hscale)
|
|
) {
|
|
let hscale = Math.round(
|
|
(x = source.config.hscale) > 0 ? Math.round(x) : 1,
|
|
);
|
|
hscale > 0 &&
|
|
(hscale > 100 && (hscale = 100), (lane.hscale = hscale));
|
|
}
|
|
var x;
|
|
(lane.yh0 = 0),
|
|
(lane.yh1 = 0),
|
|
(lane.head = source.head),
|
|
(lane.xmin_cfg = 0),
|
|
(lane.xmax_cfg = 1e12),
|
|
source &&
|
|
source.config &&
|
|
source.config.hbounds &&
|
|
2 == source.config.hbounds.length &&
|
|
((source.config.hbounds[0] = Math.floor(
|
|
source.config.hbounds[0],
|
|
)),
|
|
(source.config.hbounds[1] = Math.ceil(source.config.hbounds[1])),
|
|
source.config.hbounds[0] < source.config.hbounds[1] &&
|
|
((lane.xmin_cfg = 2 * Math.floor(source.config.hbounds[0])),
|
|
(lane.xmax_cfg = 2 * Math.floor(source.config.hbounds[1])))),
|
|
source &&
|
|
source.head &&
|
|
((source.head.tick ||
|
|
0 === source.head.tick ||
|
|
source.head.tock ||
|
|
0 === source.head.tock) &&
|
|
(lane.yh0 = 20),
|
|
(source.head.tick || 0 === source.head.tick) &&
|
|
(source.head.tick = source.head.tick + lane.xmin_cfg / 2),
|
|
(source.head.tock || 0 === source.head.tock) &&
|
|
(source.head.tock = source.head.tock + lane.xmin_cfg / 2),
|
|
source.head.text &&
|
|
((lane.yh1 = 46), (lane.head.text = source.head.text))),
|
|
(lane.yf0 = 0),
|
|
(lane.yf1 = 0),
|
|
(lane.foot = source.foot),
|
|
source &&
|
|
source.foot &&
|
|
((source.foot.tick ||
|
|
0 === source.foot.tick ||
|
|
source.foot.tock ||
|
|
0 === source.foot.tock) &&
|
|
(lane.yf0 = 20),
|
|
(source.foot.tick || 0 === source.foot.tick) &&
|
|
(source.foot.tick = source.foot.tick + lane.xmin_cfg / 2),
|
|
(source.foot.tock || 0 === source.foot.tock) &&
|
|
(source.foot.tock = source.foot.tock + lane.xmin_cfg / 2),
|
|
source.foot.text &&
|
|
((lane.yf1 = 46), (lane.foot.text = source.foot.text)));
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
14: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const genFirstWaveBrick = require('./gen-first-wave-brick.js'),
|
|
genWaveBrick = require('./gen-wave-brick.js'),
|
|
findLaneMarkers = require('./find-lane-markers.js');
|
|
module.exports = function(src, extra, lane) {
|
|
const Stack = src.split('');
|
|
let Next = Stack.shift(),
|
|
Repeats = 1;
|
|
for (; '.' === Stack[0] || '|' === Stack[0]; )
|
|
Stack.shift(), (Repeats += 1);
|
|
let Top,
|
|
R = [];
|
|
R = R.concat(genFirstWaveBrick(Next, extra, Repeats));
|
|
let subCycle = !1;
|
|
for (; Stack.length; ) {
|
|
for (
|
|
Top = Next,
|
|
Next = Stack.shift(),
|
|
'<' === Next && ((subCycle = !0), (Next = Stack.shift())),
|
|
'>' === Next && ((subCycle = !1), (Next = Stack.shift())),
|
|
Repeats = 1;
|
|
'.' === Stack[0] || '|' === Stack[0];
|
|
|
|
)
|
|
Stack.shift(), (Repeats += 1);
|
|
R = subCycle
|
|
? R.concat(genWaveBrick(Top + Next, 0, Repeats - lane.period))
|
|
: R.concat(genWaveBrick(Top + Next, extra, Repeats));
|
|
}
|
|
const unseen_bricks = [];
|
|
for (let i = 0; i < lane.phase; i += 1) unseen_bricks.push(R.shift());
|
|
let num_unseen_markers;
|
|
return (
|
|
unseen_bricks.length > 0
|
|
? ((num_unseen_markers = findLaneMarkers(unseen_bricks).length),
|
|
1 ==
|
|
findLaneMarkers([unseen_bricks[unseen_bricks.length - 1]])
|
|
.length &&
|
|
1 == findLaneMarkers([R[0]]).length &&
|
|
(num_unseen_markers -= 1))
|
|
: (num_unseen_markers = 0),
|
|
[R, num_unseen_markers]
|
|
);
|
|
};
|
|
},
|
|
{
|
|
'./find-lane-markers.js': 7,
|
|
'./gen-first-wave-brick.js': 9,
|
|
'./gen-wave-brick.js': 10,
|
|
},
|
|
],
|
|
15: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const parseWaveLane = require('./parse-wave-lane.js');
|
|
module.exports = function(sig, lane) {
|
|
const content = [],
|
|
tmp0 = [];
|
|
return (
|
|
sig.map(function(sigx) {
|
|
const current = [];
|
|
content.push(current),
|
|
(lane.period = sigx.period || 1),
|
|
(lane.phase =
|
|
(sigx.phase ? 2 * sigx.phase : 0) + lane.xmin_cfg),
|
|
(tmp0[0] = sigx.name || ' '),
|
|
(tmp0[1] = (sigx.phase || 0) + lane.xmin_cfg / 2);
|
|
let num_unseen_markers,
|
|
content_wave = null;
|
|
if ('string' == typeof sigx.wave) {
|
|
const parsed_wave_lane = parseWaveLane(
|
|
sigx.wave,
|
|
lane.period * lane.hscale - 1,
|
|
lane,
|
|
);
|
|
(content_wave = parsed_wave_lane[0]),
|
|
(num_unseen_markers = parsed_wave_lane[1]);
|
|
}
|
|
current.push(
|
|
tmp0.slice(0),
|
|
content_wave,
|
|
(function(e, num_unseen_markers) {
|
|
let ret_data = e.data;
|
|
return void 0 === ret_data
|
|
? null
|
|
: ('string' == typeof ret_data &&
|
|
(ret_data = ret_data.trim().split(/\s+/)),
|
|
(ret_data = ret_data.slice(num_unseen_markers)),
|
|
ret_data);
|
|
})(sigx, num_unseen_markers),
|
|
sigx,
|
|
);
|
|
}),
|
|
content
|
|
);
|
|
};
|
|
},
|
|
{ './parse-wave-lane.js': 14 },
|
|
],
|
|
16: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const eva = require('./eva.js'),
|
|
appendSaveAsDialog = require('./append-save-as-dialog.js'),
|
|
renderWaveForm = require('./render-wave-form.js');
|
|
module.exports = function() {
|
|
let index = 0;
|
|
const points = document.querySelectorAll('*');
|
|
for (let i = 0; i < points.length; i++)
|
|
if (
|
|
points.item(i).type &&
|
|
'wavedrom' === points.item(i).type.toLowerCase()
|
|
) {
|
|
points.item(i).setAttribute('id', 'InputJSON_' + index);
|
|
const node0 = document.createElement('div');
|
|
(node0.id = 'WaveDrom_Display_' + index),
|
|
points.item(i).parentNode.insertBefore(node0, points.item(i)),
|
|
(index += 1);
|
|
}
|
|
let notFirstSignal = !1;
|
|
for (let i = 0; i < index; i += 1) {
|
|
const obj = eva('InputJSON_' + i);
|
|
renderWaveForm(i, obj, 'WaveDrom_Display_', notFirstSignal),
|
|
obj && obj.signal && !notFirstSignal && (notFirstSignal = !0),
|
|
appendSaveAsDialog(i, 'WaveDrom_Display_');
|
|
}
|
|
document.head.innerHTML +=
|
|
'<style type="text/css">div.wavedromMenu{position:fixed;border:solid 1pt#CCCCCC;background-color:white;box-shadow:0px 10px 20px #808080;cursor:default;margin:0px;padding:0px;}div.wavedromMenu>ul{margin:0px;padding:0px;}div.wavedromMenu>ul>li{padding:2px 10px;list-style:none;}div.wavedromMenu>ul>li:hover{background-color:#b5d5ff;}</style>';
|
|
};
|
|
},
|
|
{
|
|
'./append-save-as-dialog.js': 1,
|
|
'./eva.js': 6,
|
|
'./render-wave-form.js': 30,
|
|
},
|
|
],
|
|
17: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = function rec(tmp, state) {
|
|
let name,
|
|
deltaX = 10;
|
|
('string' != typeof tmp[0] && 'number' != typeof tmp[0]) ||
|
|
((name = tmp[0]), (deltaX = 25)),
|
|
(state.x += deltaX);
|
|
for (let i = 0; i < tmp.length; i++)
|
|
if ('object' == typeof tmp[i])
|
|
if (Array.isArray(tmp[i])) {
|
|
const oldY = state.y;
|
|
(state = rec(tmp[i], state)).groups.push({
|
|
x: state.xx,
|
|
y: oldY,
|
|
height: state.y - oldY,
|
|
name: state.name,
|
|
});
|
|
} else
|
|
state.lanes.push(tmp[i]),
|
|
state.width.push(state.x),
|
|
(state.y += 1);
|
|
return (
|
|
(state.xx = state.x),
|
|
(state.x -= deltaX),
|
|
(state.name = name),
|
|
state
|
|
);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
18: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const renderAssign = require('logidrom/lib/render-assign.js'),
|
|
renderReg = require('./render-reg.js'),
|
|
renderSignal = require('./render-signal.js');
|
|
module.exports = function(index, source, waveSkin, notFirstSignal) {
|
|
const res = source.signal
|
|
? renderSignal(index, source, waveSkin, notFirstSignal)
|
|
: source.assign
|
|
? renderAssign(index, source)
|
|
: source.reg
|
|
? renderReg(index, source)
|
|
: ['div', {}];
|
|
return (res[1].class = 'WaveDrom'), res;
|
|
};
|
|
},
|
|
{
|
|
'./render-reg.js': 27,
|
|
'./render-signal.js': 28,
|
|
'logidrom/lib/render-assign.js': 40,
|
|
},
|
|
],
|
|
19: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const arcShape = require('./arc-shape.js'),
|
|
renderLabel = require('./render-label.js'),
|
|
labeler = (lane, Events) => (element, i) => {
|
|
const text = element.node;
|
|
if (
|
|
((lane.period = element.period ? element.period : 1),
|
|
(lane.phase =
|
|
(element.phase ? 2 * element.phase : 0) + lane.xmin_cfg),
|
|
text)
|
|
) {
|
|
const stack = text.split('');
|
|
let pos = 0;
|
|
for (; stack.length; ) {
|
|
const eventname = stack.shift();
|
|
'.' !== eventname &&
|
|
(Events[eventname] = {
|
|
x:
|
|
lane.xs *
|
|
(2 * pos * lane.period * lane.hscale - lane.phase) +
|
|
lane.xlabel,
|
|
y: i * lane.yo + lane.y0 + 0.5 * lane.ys,
|
|
}),
|
|
(pos += 1);
|
|
}
|
|
}
|
|
},
|
|
archer = (res, Events, arcFontSize) => element => {
|
|
const words = element.trim().split(/\s+/),
|
|
Edge = {
|
|
words: words,
|
|
label: element.substring(words[0].length).substring(1),
|
|
from: words[0].substr(0, 1),
|
|
to: words[0].substr(-1, 1),
|
|
shape: words[0].slice(1, -1),
|
|
},
|
|
from = Events[Edge.from],
|
|
to = Events[Edge.to];
|
|
if (from && to) {
|
|
const shapeProps = arcShape(Edge, from, to),
|
|
lx = shapeProps.lx,
|
|
ly = shapeProps.ly;
|
|
res.push(
|
|
((Edge, from, to, shapeProps) => [
|
|
'path',
|
|
{
|
|
id: 'gmark_' + Edge.from + '_' + Edge.to,
|
|
d:
|
|
shapeProps.d ||
|
|
'M ' + from.x + ',' + from.y + ' ' + to.x + ',' + to.y,
|
|
style:
|
|
shapeProps.style ||
|
|
'fill:none;stroke:#00F;stroke-width:1',
|
|
},
|
|
])(Edge, from, to, shapeProps),
|
|
),
|
|
Edge.label &&
|
|
res.push(
|
|
renderLabel({ x: lx, y: ly }, Edge.label, arcFontSize),
|
|
);
|
|
}
|
|
};
|
|
module.exports = function(lanes, index, source, lane) {
|
|
const arcFontSize =
|
|
source && source.config && source.config.arcFontSize
|
|
? source.config.arcFontSize
|
|
: 11,
|
|
res = ['g', { id: 'wavearcs_' + index }],
|
|
Events = {};
|
|
return (
|
|
Array.isArray(lanes) &&
|
|
(lanes.map(labeler(lane, Events)),
|
|
Array.isArray(source.edge) &&
|
|
source.edge.map(archer(res, Events, arcFontSize)),
|
|
Object.keys(Events).map(function(k) {
|
|
k === k.toLowerCase() &&
|
|
Events[k].x > 0 &&
|
|
res.push(
|
|
renderLabel(
|
|
{ x: Events[k].x, y: Events[k].y },
|
|
k + '',
|
|
arcFontSize,
|
|
),
|
|
);
|
|
})),
|
|
res
|
|
);
|
|
};
|
|
},
|
|
{ './arc-shape.js': 2, './render-label.js': 22 },
|
|
],
|
|
20: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tt = require('onml/tt.js');
|
|
function renderGapUses(text, lane) {
|
|
const res = [],
|
|
Stack = (text || '').split('');
|
|
let pos = 0,
|
|
subCycle = !1;
|
|
for (; Stack.length; ) {
|
|
let next = Stack.shift();
|
|
'<' === next && ((subCycle = !0), (next = Stack.shift())),
|
|
'>' === next && ((subCycle = !1), (next = Stack.shift())),
|
|
(pos += subCycle ? 1 : 2 * lane.period),
|
|
'|' === next &&
|
|
res.push([
|
|
'use',
|
|
tt(
|
|
lane.xs *
|
|
((pos - (subCycle ? 0 : lane.period)) * lane.hscale -
|
|
lane.phase),
|
|
0,
|
|
{ 'xlink:href': '#gap' },
|
|
),
|
|
]);
|
|
}
|
|
return res;
|
|
}
|
|
module.exports = function(lanes, index, source, lane) {
|
|
let res = [];
|
|
if (lanes) {
|
|
const lanesLen = lanes.length,
|
|
vline = x => [
|
|
'line',
|
|
{
|
|
x1: x,
|
|
x2: x,
|
|
y2: lanesLen * lane.yo,
|
|
style: 'stroke:#000;stroke-width:1px',
|
|
},
|
|
],
|
|
lineStyle = 'fill:none;stroke:#000;stroke-width:1px',
|
|
bracket = {
|
|
square: {
|
|
left: [
|
|
'path',
|
|
{
|
|
d: 'M 2 0 h -4 v ' + (lanesLen * lane.yo - 1) + ' h 4',
|
|
style: lineStyle,
|
|
},
|
|
],
|
|
right: [
|
|
'path',
|
|
{
|
|
d: 'M -2 0 h 4 v ' + (lanesLen * lane.yo - 1) + ' h -4',
|
|
style: lineStyle,
|
|
},
|
|
],
|
|
},
|
|
round: {
|
|
left: [
|
|
'path',
|
|
{
|
|
d:
|
|
'M 2 0 a 4 4 0 0 0 -4 4 v ' +
|
|
(lanesLen * lane.yo - 9) +
|
|
' a 4 4 0 0 0 4 4',
|
|
style: lineStyle,
|
|
},
|
|
],
|
|
right: [
|
|
'path',
|
|
{
|
|
d:
|
|
'M -2 0 a 4 4 1 0 1 4 4 v ' +
|
|
(lanesLen * lane.yo - 9) +
|
|
' a 4 4 1 0 1 -4 4',
|
|
style: lineStyle,
|
|
},
|
|
],
|
|
rightLeft: [
|
|
'path',
|
|
{
|
|
d:
|
|
'M -5 0 a 4 4 1 0 1 4 4 v ' +
|
|
(lanesLen * lane.yo - 9) +
|
|
' a 4 4 1 0 1 -4 4M 5 0 a 4 4 0 0 0 -4 4 v ' +
|
|
(lanesLen * lane.yo - 9) +
|
|
' a 4 4 0 0 0 4 4',
|
|
style: lineStyle,
|
|
},
|
|
],
|
|
leftLeft: [
|
|
'path',
|
|
{
|
|
d:
|
|
'M 2 0 a 4 4 0 0 0 -4 4 v ' +
|
|
(lanesLen * lane.yo - 9) +
|
|
' a 4 4 0 0 0 4 4M 5 1 a 3 3 0 0 0 -3 3 v ' +
|
|
(lanesLen * lane.yo - 9) +
|
|
' a 3 3 0 0 0 3 3',
|
|
style: lineStyle,
|
|
},
|
|
],
|
|
rightRight: [
|
|
'path',
|
|
{
|
|
d:
|
|
'M -5 1 a 3 3 1 0 1 3 3 v ' +
|
|
(lanesLen * lane.yo - 9) +
|
|
' a 3 3 1 0 1 -3 3M -2 0 a 4 4 1 0 1 4 4 v ' +
|
|
(lanesLen * lane.yo - 9) +
|
|
' a 4 4 1 0 1 -4 4',
|
|
style: lineStyle,
|
|
},
|
|
],
|
|
},
|
|
},
|
|
backDrop = w => [
|
|
'rect',
|
|
{
|
|
x: -w / 2,
|
|
width: w,
|
|
height: lanesLen * lane.yo,
|
|
style: 'fill:#ffffffcc;stroke:none',
|
|
},
|
|
];
|
|
if (source && 'string' == typeof source.gaps) {
|
|
const scale = lane.hscale * lane.xs * 2,
|
|
gaps = source.gaps.trim().split(/\s+/);
|
|
for (let x = 0; x < gaps.length; x++) {
|
|
const c = gaps[x];
|
|
if (c.match(/^[.]$/)) continue;
|
|
const offset = c === c.toLowerCase() ? 0.5 : 0;
|
|
let marks = [];
|
|
switch (c) {
|
|
case '0':
|
|
marks = [backDrop(4)];
|
|
break;
|
|
case '1':
|
|
case '|':
|
|
marks = [backDrop(4), vline(0)];
|
|
break;
|
|
case '2':
|
|
marks = [backDrop(4), vline(-2), vline(2)];
|
|
break;
|
|
case '3':
|
|
marks = [backDrop(6), vline(-3), vline(0), vline(3)];
|
|
break;
|
|
case '[':
|
|
marks = [backDrop(4), bracket.square.left];
|
|
break;
|
|
case ']':
|
|
marks = [backDrop(4), bracket.square.right];
|
|
break;
|
|
case '(':
|
|
marks = [backDrop(4), bracket.round.left];
|
|
break;
|
|
case ')':
|
|
marks = [backDrop(4), bracket.round.right];
|
|
break;
|
|
case ')(':
|
|
marks = [backDrop(8), bracket.round.rightLeft];
|
|
break;
|
|
case '((':
|
|
marks = [backDrop(8), bracket.round.leftLeft];
|
|
break;
|
|
case '))':
|
|
marks = [backDrop(8), bracket.round.rightRight];
|
|
break;
|
|
case 's':
|
|
for (let idx = 0; idx < lanesLen; idx++)
|
|
lanes[idx] &&
|
|
lanes[idx].wave &&
|
|
lanes[idx].wave.length > x &&
|
|
marks.push([
|
|
'use',
|
|
tt(2, 5 + lane.yo * idx, { 'xlink:href': '#gap' }),
|
|
]);
|
|
}
|
|
res.push(['g', tt(scale * (x + offset))].concat(marks));
|
|
}
|
|
}
|
|
for (let idx = 0; idx < lanesLen; idx++) {
|
|
const val = lanes[idx];
|
|
if (
|
|
((lane.period = val.period ? val.period : 1),
|
|
(lane.phase = (val.phase ? 2 * val.phase : 0) + lane.xmin_cfg),
|
|
'string' == typeof val.wave)
|
|
) {
|
|
const gaps = renderGapUses(val.wave, lane);
|
|
res = res.concat([
|
|
[
|
|
'g',
|
|
tt(0, lane.y0 + idx * lane.yo, {
|
|
id: 'wavegap_' + idx + '_' + index,
|
|
// style:`color:${val.color || "#000"}`
|
|
}),
|
|
].concat(gaps),
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
return ['g', { id: 'wavegaps_' + index }].concat(res);
|
|
};
|
|
},
|
|
{ 'onml/tt.js': 43 },
|
|
],
|
|
21: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tspan = require('tspan'),
|
|
tt = require('onml/tt.js');
|
|
module.exports = function(groups, index, lane) {
|
|
const res = ['g'];
|
|
return (
|
|
groups.map((e, i) => {
|
|
if (
|
|
(res.push([
|
|
'path',
|
|
{
|
|
id: 'group_' + i + '_' + index,
|
|
d:
|
|
'm ' +
|
|
(e.x + 0.5) +
|
|
',' +
|
|
(e.y * lane.yo + 3.5 + lane.yh0 + lane.yh1) +
|
|
' c -3,0 -5,2 -5,5 l 0,' +
|
|
(e.height * lane.yo - 16) +
|
|
' c 0,3 2,5 5,5',
|
|
style: 'stroke:#0041c4;stroke-width:1;fill:none',
|
|
},
|
|
]),
|
|
void 0 === e.name)
|
|
)
|
|
return;
|
|
const x = e.x - 10,
|
|
y = lane.yo * (e.y + e.height / 2) + lane.yh0 + lane.yh1,
|
|
ts = tspan.parse(e.name);
|
|
res.push([
|
|
'g',
|
|
tt(x, y),
|
|
[
|
|
'g',
|
|
{ transform: 'rotate(270)' },
|
|
[
|
|
'text',
|
|
{
|
|
'text-anchor': 'middle',
|
|
class: 'info',
|
|
'xml:space': 'preserve',
|
|
},
|
|
].concat(ts),
|
|
],
|
|
]);
|
|
}),
|
|
res
|
|
);
|
|
};
|
|
},
|
|
{ 'onml/tt.js': 43, tspan: 44 },
|
|
],
|
|
22: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tspan = require('tspan'),
|
|
tt = require('onml/tt.js'),
|
|
textWidth = require('./text-width.js');
|
|
module.exports = function(p, text, fontSize) {
|
|
const w = textWidth(text, (fontSize = fontSize || 11)) + 2;
|
|
return [
|
|
'g',
|
|
tt(p.x, p.y),
|
|
[
|
|
'rect',
|
|
{
|
|
x: -(w >> 1),
|
|
y: -(fontSize >> 1),
|
|
width: w,
|
|
height: fontSize,
|
|
style: 'fill:#FFF;',
|
|
},
|
|
],
|
|
[
|
|
'text',
|
|
{
|
|
'text-anchor': 'middle',
|
|
y: Math.round(0.3 * fontSize),
|
|
style: 'font-size:' + fontSize + 'px;',
|
|
},
|
|
].concat(tspan.parse(text)),
|
|
];
|
|
};
|
|
},
|
|
{ './text-width.js': 32, 'onml/tt.js': 43, tspan: 44 },
|
|
],
|
|
23: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const renderMarks = require('./render-marks.js'),
|
|
renderArcs = require('./render-arcs.js'),
|
|
renderGaps = require('./render-gaps.js'),
|
|
renderPieceWise = require('./render-piece-wise.js');
|
|
module.exports = function(
|
|
index,
|
|
content,
|
|
waveLanes,
|
|
ret,
|
|
source,
|
|
lane,
|
|
) {
|
|
return [
|
|
renderMarks(content, index, lane, source),
|
|
].concat(waveLanes.res, [
|
|
renderArcs(ret.lanes, index, source, lane),
|
|
renderGaps(ret.lanes, index, source, lane),
|
|
renderPieceWise(ret.lanes, index, lane),
|
|
]);
|
|
};
|
|
},
|
|
{
|
|
'./render-arcs.js': 19,
|
|
'./render-gaps.js': 20,
|
|
'./render-marks.js': 24,
|
|
'./render-piece-wise.js': 26,
|
|
},
|
|
],
|
|
24: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tspan = require('tspan');
|
|
function captext(cxt, anchor, y) {
|
|
return cxt[anchor] && cxt[anchor].text
|
|
? [
|
|
[
|
|
'text',
|
|
{
|
|
x: (cxt.xmax * cxt.xs) / 2,
|
|
y: y,
|
|
fill: '#000',
|
|
'text-anchor': 'middle',
|
|
'xml:space': 'preserve',
|
|
},
|
|
].concat(tspan.parse(cxt[anchor].text)),
|
|
]
|
|
: [];
|
|
}
|
|
function ticktock(cxt, ref1, ref2, x, dx, y, len) {
|
|
let offset,
|
|
L = [];
|
|
if (void 0 === cxt[ref1] || void 0 === cxt[ref1][ref2]) return [];
|
|
let val = cxt[ref1][ref2];
|
|
if ('string' == typeof val) val = val.trim().split(/\s+/);
|
|
else if ('number' == typeof val || 'boolean' == typeof val) {
|
|
const offset = Number(val);
|
|
val = [];
|
|
for (let i = 0; i < len; i += 1) val.push(i + offset);
|
|
}
|
|
if (!Array.isArray(val)) return [];
|
|
if (0 === val.length) return [];
|
|
if (1 === val.length)
|
|
if (((offset = Number(val[0])), isNaN(offset))) L = val;
|
|
else for (let i = 0; i < len; i += 1) L[i] = i + offset;
|
|
else if (2 === val.length) {
|
|
offset = Number(val[0]);
|
|
const step = Number(val[1]),
|
|
tmp = val[1].split('.');
|
|
let dp = 0;
|
|
if (
|
|
(2 === tmp.length && (dp = tmp[1].length),
|
|
isNaN(offset) || isNaN(step))
|
|
)
|
|
L = val;
|
|
else {
|
|
offset *= step;
|
|
for (let i = 0; i < len; i += 1)
|
|
L[i] = (step * i + offset).toFixed(dp);
|
|
}
|
|
} else L = val;
|
|
const res = [
|
|
'g',
|
|
{
|
|
class: 'muted',
|
|
'text-anchor': 'middle',
|
|
'xml:space': 'preserve',
|
|
},
|
|
];
|
|
for (let i = 0; i < len; i += 1)
|
|
(cxt[ref1] &&
|
|
cxt[ref1].every &&
|
|
(i + offset) % cxt[ref1].every != 0) ||
|
|
res.push(
|
|
['text', { x: i * dx + x, y: y }].concat(tspan.parse(L[i])),
|
|
);
|
|
return [res];
|
|
}
|
|
module.exports = function(content, index, lane, source) {
|
|
const mstep = 2 * lane.hscale,
|
|
mmstep = mstep * lane.xs,
|
|
marks = lane.xmax / mstep,
|
|
gy = content.length * lane.yo,
|
|
res = ['g', { id: 'gmarks_' + index }],
|
|
gmarkLines = [
|
|
'g',
|
|
{ style: 'stroke:#888;stroke-width:0.5;stroke-dasharray:1,3' },
|
|
];
|
|
if (!source || !source.config || !1 !== source.config.marks) {
|
|
for (let i = 0; i < marks + 1; i += 1)
|
|
gmarkLines.push([
|
|
'line',
|
|
{
|
|
id: 'gmark_' + i + '_' + index,
|
|
x1: i * mmstep,
|
|
y1: 0,
|
|
x2: i * mmstep,
|
|
y2: gy,
|
|
},
|
|
]);
|
|
res.push(gmarkLines);
|
|
}
|
|
return res.concat(
|
|
captext(lane, 'head', lane.yh0 ? -33 : -13),
|
|
captext(lane, 'foot', gy + (lane.yf0 ? 45 : 25)),
|
|
ticktock(lane, 'head', 'tick', 0, mmstep, -5, marks + 1),
|
|
ticktock(lane, 'head', 'tock', mmstep / 2, mmstep, -5, marks),
|
|
ticktock(lane, 'foot', 'tick', 0, mmstep, gy + 15, marks + 1),
|
|
ticktock(lane, 'foot', 'tock', mmstep / 2, mmstep, gy + 15, marks),
|
|
);
|
|
};
|
|
},
|
|
{ tspan: 44 },
|
|
],
|
|
25: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tt = require('onml/tt.js'),
|
|
colors = {
|
|
1: '#000000',
|
|
2: '#e90000',
|
|
3: '#3edd00',
|
|
4: '#0074cd',
|
|
5: '#ff15db',
|
|
6: '#af9800',
|
|
7: '#00864f',
|
|
8: '#a076ff',
|
|
};
|
|
module.exports = function(el, key, lane) {
|
|
const xs = lane.xs,
|
|
ys = lane.ys,
|
|
period = 2 * (el.period || 1) * xs,
|
|
xoffset = 2 * -(el.phase || 0) * xs,
|
|
gap1 = 12;
|
|
let color;
|
|
const y = 'under' === key ? ys : 0;
|
|
let start;
|
|
function line(x) {
|
|
return void 0 === start
|
|
? []
|
|
: [
|
|
[
|
|
'line',
|
|
{
|
|
style: 'stroke:' + color,
|
|
x1: period * start + gap1,
|
|
x2: period * x,
|
|
},
|
|
],
|
|
];
|
|
}
|
|
if (el[key]) {
|
|
let res = ['g', tt(xoffset, y, { style: 'stroke-width:3' })];
|
|
const arr = el[key].split('');
|
|
return (
|
|
arr.map(function(dot, i) {
|
|
'.' !== dot &&
|
|
void 0 !== start &&
|
|
((res = res.concat(line(i))),
|
|
'over' === key &&
|
|
res.push([
|
|
'path',
|
|
{
|
|
style: 'stroke:none;fill:' + color,
|
|
d: 'm' + (period * i - 7) + ' 0 l7 7 v-7 z',
|
|
},
|
|
])),
|
|
'0' === dot
|
|
? (start = void 0)
|
|
: '.' !== dot &&
|
|
((start = i), (color = colors[dot] || colors[1]));
|
|
}),
|
|
void 0 !== start && (res = res.concat(line(arr.length))),
|
|
[res]
|
|
);
|
|
}
|
|
return [];
|
|
};
|
|
},
|
|
{ 'onml/tt.js': 43 },
|
|
],
|
|
26: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tt = require('onml/tt.js'),
|
|
scaled = (d, sx, sy) => {
|
|
void 0 === sy && (sy = sx);
|
|
let i = 0;
|
|
for (; i < d.length; ) {
|
|
switch (d[i].toLowerCase()) {
|
|
case 'h':
|
|
for (; i < d.length && !isNaN(d[i + 1]); )
|
|
(d[i + 1] *= sx), i++;
|
|
break;
|
|
case 'v':
|
|
for (; i < d.length && !isNaN(d[i + 1]); )
|
|
(d[i + 1] *= sy), i++;
|
|
break;
|
|
case 'm':
|
|
case 'l':
|
|
case 't':
|
|
for (; i + 1 < d.length && !isNaN(d[i + 1]); )
|
|
(d[i + 1] *= sx), (d[i + 2] *= sy), (i += 2);
|
|
break;
|
|
case 'q':
|
|
for (; i + 3 < d.length && !isNaN(d[i + 1]); )
|
|
(d[i + 1] *= sx),
|
|
(d[i + 2] *= sy),
|
|
(d[i + 3] *= sx),
|
|
(d[i + 4] *= sy),
|
|
(i += 4);
|
|
break;
|
|
case 'a':
|
|
for (; i + 6 < d.length && !isNaN(d[i + 1]); )
|
|
(d[i + 1] *= sx),
|
|
(d[i + 2] *= sy),
|
|
(d[i + 6] *= sx),
|
|
(d[i + 7] *= sy),
|
|
(i += 7);
|
|
}
|
|
i++;
|
|
}
|
|
return d;
|
|
};
|
|
function renderLane(wave, idx, cfg) {
|
|
if (Array.isArray(wave)) {
|
|
const tag = wave[0],
|
|
attr = wave[1];
|
|
if ('pw' === tag && 'object' == typeof attr) {
|
|
const d = (function(d, cfg) {
|
|
if (
|
|
('string' == typeof d && (d = d.trim().split(/[\s,]+/)),
|
|
Array.isArray(d))
|
|
)
|
|
return scaled(d, 2 * cfg.xs, -cfg.ys);
|
|
})(attr.d, cfg);
|
|
return [
|
|
'g',
|
|
tt(0, cfg.yo * idx + cfg.ys + cfg.y0),
|
|
[
|
|
'path',
|
|
{ style: 'fill:none;stroke:#000;stroke-width:1px;', d: d },
|
|
],
|
|
];
|
|
}
|
|
}
|
|
}
|
|
module.exports = function(lanes, index, cfg) {
|
|
let res = ['g'];
|
|
return (
|
|
lanes.map((row, idx) => {
|
|
const wave = row.wave;
|
|
Array.isArray(wave) && res.push(renderLane(wave, idx, cfg));
|
|
}),
|
|
res
|
|
);
|
|
};
|
|
},
|
|
{ 'onml/tt.js': 43 },
|
|
],
|
|
27: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const render = require('bit-field/lib/render.js');
|
|
module.exports = function(index, source) {
|
|
return render(source.reg, source.config);
|
|
};
|
|
},
|
|
{ 'bit-field/lib/render.js': 35 },
|
|
],
|
|
28: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const rec = require('./rec.js'),
|
|
lane = require('./lane.js'),
|
|
parseConfig = require('./parse-config.js'),
|
|
parseWaveLanes = require('./parse-wave-lanes.js'),
|
|
renderGroups = require('./render-groups.js'),
|
|
renderLanes = require('./render-lanes.js'),
|
|
renderWaveLane = require('./render-wave-lane.js'),
|
|
insertSVGTemplate = require('./insert-svg-template.js');
|
|
module.exports = function(index, source, waveSkin, notFirstSignal) {
|
|
!(function(index, source, lane, waveSkin) {
|
|
if (0 !== index) return;
|
|
const waveSkinNames = Object.keys(waveSkin);
|
|
if (0 === waveSkinNames.length) throw new Error('no skins found');
|
|
let skin = waveSkin.default || waveSkin[waveSkinNames[0]];
|
|
source &&
|
|
source.config &&
|
|
source.config.skin &&
|
|
waveSkin[source.config.skin] &&
|
|
(skin = waveSkin[source.config.skin]);
|
|
const socket = skin[3][1][2][1];
|
|
(lane.xs = Number(socket.width)),
|
|
(lane.ys = Number(socket.height)),
|
|
(lane.xlabel = Number(socket.x)),
|
|
(lane.ym = Number(socket.y));
|
|
})(index, source, lane, waveSkin),
|
|
parseConfig(source, lane);
|
|
const ret = rec(source.signal, {
|
|
x: 0,
|
|
y: 0,
|
|
xmax: 0,
|
|
width: [],
|
|
lanes: [],
|
|
groups: [],
|
|
}),
|
|
content = parseWaveLanes(ret.lanes, lane),
|
|
waveLanes = renderWaveLane(content, index, lane),
|
|
waveGroups = renderGroups(ret.groups, index, lane),
|
|
xmax = waveLanes.glengths.reduce(
|
|
(res, len, i) => Math.max(res, len + ret.width[i]),
|
|
0,
|
|
);
|
|
return (
|
|
(lane.xg = Math.ceil((xmax - lane.tgo) / lane.xs) * lane.xs),
|
|
insertSVGTemplate(
|
|
index,
|
|
source,
|
|
lane,
|
|
waveSkin,
|
|
content,
|
|
renderLanes(index, content, waveLanes, ret, source, lane),
|
|
waveGroups,
|
|
notFirstSignal,
|
|
)
|
|
);
|
|
};
|
|
},
|
|
{
|
|
'./insert-svg-template.js': 11,
|
|
'./lane.js': 12,
|
|
'./parse-config.js': 13,
|
|
'./parse-wave-lanes.js': 15,
|
|
'./rec.js': 17,
|
|
'./render-groups.js': 21,
|
|
'./render-lanes.js': 23,
|
|
'./render-wave-lane.js': 31,
|
|
},
|
|
],
|
|
29: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const renderAny = require('./render-any.js'),
|
|
createElement = require('./create-element.js');
|
|
module.exports = function(
|
|
index,
|
|
source,
|
|
outputElement,
|
|
waveSkin,
|
|
notFirstSignal,
|
|
) {
|
|
for (; outputElement.childNodes.length; )
|
|
outputElement.removeChild(outputElement.childNodes[0]);
|
|
outputElement.insertBefore(
|
|
createElement(renderAny(index, source, waveSkin, notFirstSignal)),
|
|
null,
|
|
);
|
|
};
|
|
},
|
|
{ './create-element.js': 4, './render-any.js': 18 },
|
|
],
|
|
30: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const renderWaveElement = require('./render-wave-element.js');
|
|
module.exports = function(index, source, output, notFirstSignal) {
|
|
renderWaveElement(
|
|
index,
|
|
source,
|
|
document.getElementById(output + index),
|
|
window.WaveSkin,
|
|
notFirstSignal,
|
|
);
|
|
};
|
|
},
|
|
{ './render-wave-element.js': 29 },
|
|
],
|
|
31: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tt = require('onml/tt.js'),
|
|
tspan = require('tspan'),
|
|
textWidth = require('./text-width.js'),
|
|
findLaneMarkers = require('./find-lane-markers.js'),
|
|
renderOverUnder = require('./render-over-under.js');
|
|
function renderLaneUses(cont, lane) {
|
|
const res = [];
|
|
if (
|
|
cont[1] &&
|
|
(cont[1].map(function(ref, i) {
|
|
console.log("ref:",ref,cont)
|
|
res.push([
|
|
'use',
|
|
tt(i * lane.xs, 0, { 'xlink:href': '#' + ref, style:"color:" + ref.color, class:"redll" }),
|
|
]);
|
|
}),
|
|
cont[2] && cont[2].length)
|
|
) {
|
|
const labels = findLaneMarkers(cont[1]);
|
|
labels.length &&
|
|
labels.map(function(label, i) {
|
|
console.log("label:",label,i)
|
|
cont[2] &&
|
|
void 0 !== cont[2][i] &&
|
|
res.push(
|
|
[
|
|
'text',
|
|
{
|
|
x: label * lane.xs + lane.xlabel,
|
|
y: lane.ym,
|
|
'text-anchor': 'middle',
|
|
'xml:space': 'preserve',
|
|
},
|
|
].concat(tspan.parse(cont[2][i])),
|
|
);
|
|
});
|
|
}
|
|
return res;
|
|
}
|
|
module.exports = function(content, index, lane) {
|
|
let xmax = 0;
|
|
const glengths = [],
|
|
res = [];
|
|
return (
|
|
content.map(function(el, j) {
|
|
console.log("el:",el,j)
|
|
const name = el[0][0];
|
|
if (name) {
|
|
let xoffset = el[0][1];
|
|
(xoffset =
|
|
xoffset > 0
|
|
? Math.ceil(2 * xoffset) - 2 * xoffset
|
|
: -2 * xoffset),
|
|
res.push(
|
|
[
|
|
'g',
|
|
tt(0, lane.y0 + j * lane.yo, {
|
|
id: 'wavelane_' + j + '_' + index,
|
|
style:`color:${el[3]["color"] || "#000"}`
|
|
}),
|
|
]
|
|
.concat([
|
|
[
|
|
'text',
|
|
{
|
|
x: lane.tgo,
|
|
y: lane.ym,
|
|
class: 'info',
|
|
'text-anchor': 'end',
|
|
'xml:space': 'preserve',
|
|
},
|
|
].concat(tspan.parse(name)),
|
|
])
|
|
.concat([
|
|
[
|
|
'g',
|
|
tt(xoffset * lane.xs, 0, {
|
|
id: 'wavelane_draw_' + j + '_' + index,
|
|
}),
|
|
].concat(renderLaneUses(el, lane)),
|
|
])
|
|
.concat(
|
|
renderOverUnder(el[3], 'over', lane),
|
|
renderOverUnder(el[3], 'under', lane),
|
|
),
|
|
),
|
|
(xmax = Math.max(xmax, (el[1] || []).length)),
|
|
glengths.push(
|
|
name.textWidth
|
|
? name.textWidth
|
|
: name.charCodeAt
|
|
? textWidth(name, 11)
|
|
: 0,
|
|
);
|
|
}
|
|
}),
|
|
(lane.xmax = Math.min(xmax, lane.xmax_cfg - lane.xmin_cfg)),
|
|
(lane.xg = 20),
|
|
{ glengths: glengths, res: res }
|
|
);
|
|
};
|
|
},
|
|
{
|
|
'./find-lane-markers.js': 7,
|
|
'./render-over-under.js': 25,
|
|
'./text-width.js': 32,
|
|
'onml/tt.js': 43,
|
|
tspan: 44,
|
|
},
|
|
],
|
|
32: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const charWidth = require('./char-width.json');
|
|
module.exports = function(str, size) {
|
|
size = size || 11;
|
|
let width = 0;
|
|
for (let i = 0; i < str.length; i++) {
|
|
const c = str.charCodeAt(i);
|
|
let w = charWidth.chars[c];
|
|
void 0 === w && (w = charWidth.other), (width += w);
|
|
}
|
|
return (width * size) / 100;
|
|
};
|
|
},
|
|
{ './char-width.json': 3 },
|
|
],
|
|
33: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = {
|
|
svg: 'http://www.w3.org/2000/svg',
|
|
xlink: 'http://www.w3.org/1999/xlink',
|
|
xmlns: 'http://www.w3.org/XML/1998/namespace',
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
34: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
window.WaveDrom = window.WaveDrom || {};
|
|
const pkg = require('../package.json'),
|
|
processAll = require('./process-all.js'),
|
|
eva = require('./eva.js'),
|
|
renderWaveForm = require('./render-wave-form.js'),
|
|
editorRefresh = require('./editor-refresh.js');
|
|
(window.WaveDrom.ProcessAll = processAll),
|
|
(window.WaveDrom.RenderWaveForm = renderWaveForm),
|
|
(window.WaveDrom.EditorRefresh = editorRefresh),
|
|
(window.WaveDrom.eva = eva),
|
|
(window.WaveDrom.version = pkg.version);
|
|
},
|
|
{
|
|
'../package.json': 47,
|
|
'./editor-refresh.js': 5,
|
|
'./eva.js': 6,
|
|
'./process-all.js': 16,
|
|
'./render-wave-form.js': 30,
|
|
},
|
|
],
|
|
35: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tspan = require('tspan'),
|
|
round = Math.round,
|
|
tt = (x, y, obj) =>
|
|
Object.assign(
|
|
{ transform: 'translate(' + x + (y ? ',' + y : '') + ')' },
|
|
'object' == typeof obj ? obj : {},
|
|
),
|
|
colors = { 2: 0, 3: 80, 4: 170, 5: 45, 6: 126, 7: 215 },
|
|
typeStyle = t =>
|
|
void 0 !== colors[t] ? ';fill:hsl(' + colors[t] + ',100%,50%)' : '',
|
|
norm = (obj, other) =>
|
|
Object.assign(
|
|
Object.keys(obj).reduce((prev, key) => {
|
|
const val = Number(obj[key]),
|
|
valInt = isNaN(val) ? 0 : Math.round(val);
|
|
return 0 !== valInt && (prev[key] = valInt), prev;
|
|
}, {}),
|
|
other,
|
|
),
|
|
text = (body, x, y, rotate) => {
|
|
const props = { y: 6 };
|
|
return (
|
|
void 0 !== rotate && (props.transform = 'rotate(' + rotate + ')'),
|
|
[
|
|
'g',
|
|
tt(round(x), round(y)),
|
|
['text', props].concat(tspan.parse(body)),
|
|
]
|
|
);
|
|
},
|
|
hline = (len, x, y) => [
|
|
'line',
|
|
norm({ x1: x, x2: x + len, y1: y, y2: y }),
|
|
],
|
|
vline = (len, x, y) => [
|
|
'line',
|
|
norm({ x1: x, x2: x, y1: y, y2: y + len }),
|
|
],
|
|
getLabel = (val, x, y, step, len, rotate) => {
|
|
if ('number' != typeof val) return text(val, x, y, rotate);
|
|
const res = ['g', {}];
|
|
for (let i = 0; i < len; i++)
|
|
res.push(text((val >> i) & 1, x + step * (len / 2 - i - 0.5), y));
|
|
return res;
|
|
},
|
|
labelArr = (desc, opt) => {
|
|
const {
|
|
margin: margin,
|
|
hspace: hspace,
|
|
vspace: vspace,
|
|
mod: mod,
|
|
index: index,
|
|
fontsize: fontsize,
|
|
vflip: vflip,
|
|
trim: trim,
|
|
compact: compact,
|
|
} = opt,
|
|
width = hspace - margin.left - margin.right - 1,
|
|
height = vspace - margin.top - margin.bottom,
|
|
step = width / mod,
|
|
blanks = ['g'],
|
|
bits = ['g', tt(round(step / 2), -round(0.5 * fontsize + 4))],
|
|
names = [
|
|
'g',
|
|
tt(round(step / 2), round(0.5 * height + 0.4 * fontsize - 6)),
|
|
],
|
|
attrs = [
|
|
'g',
|
|
tt(round(step / 2), round(height + 0.7 * fontsize - 2)),
|
|
];
|
|
return (
|
|
desc.map(e => {
|
|
let lsbm = 0,
|
|
msbm = mod - 1,
|
|
lsb = index * mod,
|
|
msb = (index + 1) * mod - 1;
|
|
if ((e.lsb / mod) >> 0 === index)
|
|
(lsbm = e.lsbm),
|
|
(lsb = e.lsb),
|
|
(e.msb / mod) >> 0 === index &&
|
|
((msb = e.msb), (msbm = e.msbm));
|
|
else if ((e.msb / mod) >> 0 === index)
|
|
(msb = e.msb), (msbm = e.msbm);
|
|
else if (!(lsb > e.lsb && msb < e.msb)) return;
|
|
compact ||
|
|
(bits.push(text(lsb, step * (vflip ? lsbm : mod - lsbm - 1))),
|
|
lsbm !== msbm &&
|
|
bits.push(
|
|
text(msb, step * (vflip ? msbm : mod - msbm - 1)),
|
|
)),
|
|
void 0 !== e.name &&
|
|
names.push(
|
|
getLabel(
|
|
trim
|
|
? ((text, availableSpace, charWidth) => {
|
|
if (
|
|
!(
|
|
'string' == typeof text ||
|
|
text instanceof String
|
|
)
|
|
)
|
|
return text;
|
|
const textWidth = text.length * charWidth;
|
|
if (textWidth <= availableSpace) return text;
|
|
var end =
|
|
text.length -
|
|
(textWidth - availableSpace) / charWidth -
|
|
3;
|
|
return end > 0
|
|
? text.substring(0, end) + '...'
|
|
: text.substring(0, 1) + '...';
|
|
})(e.name, step * e.bits, trim)
|
|
: e.name,
|
|
step *
|
|
(vflip
|
|
? (msbm + lsbm) / 2
|
|
: mod - (msbm + lsbm) / 2 - 1),
|
|
0,
|
|
step,
|
|
e.bits,
|
|
e.rotate,
|
|
),
|
|
),
|
|
(void 0 !== e.name && void 0 === e.type) ||
|
|
(opt.compact && void 0 === e.type) ||
|
|
blanks.push([
|
|
'rect',
|
|
norm(
|
|
{
|
|
x: step * (vflip ? lsbm : mod - msbm - 1),
|
|
width: step * (msbm - lsbm + 1),
|
|
height: height,
|
|
},
|
|
{
|
|
field: e.name,
|
|
style: 'fill-opacity:0.1' + typeStyle(e.type),
|
|
},
|
|
),
|
|
]),
|
|
void 0 !== e.attr &&
|
|
attrs.push(
|
|
((e, opt, step, lsbm, msbm) => {
|
|
const x = opt.vflip
|
|
? step * ((msbm + lsbm) / 2)
|
|
: step * (opt.mod - (msbm + lsbm) / 2 - 1);
|
|
return Array.isArray(e.attr)
|
|
? e.attr.reduce(
|
|
(prev, a, i) =>
|
|
null == a
|
|
? prev
|
|
: prev.concat([
|
|
getLabel(
|
|
a,
|
|
x,
|
|
opt.fontsize * i,
|
|
step,
|
|
e.bits,
|
|
),
|
|
]),
|
|
['g', {}],
|
|
)
|
|
: getLabel(e.attr, x, 0, step, e.bits);
|
|
})(e, opt, step, lsbm, msbm),
|
|
);
|
|
}),
|
|
['g', blanks, bits, names, attrs]
|
|
);
|
|
},
|
|
skipDrawingEmptySpace = (
|
|
desc,
|
|
opt,
|
|
laneIndex,
|
|
laneLength,
|
|
globalIndex,
|
|
) => {
|
|
if (!opt.compact) return !1;
|
|
const isEmptyBitfield = bitfield =>
|
|
void 0 === bitfield.name && void 0 === bitfield.type,
|
|
bitfieldIndex = desc.findIndex(
|
|
e =>
|
|
isEmptyBitfield(e) &&
|
|
globalIndex >= e.lsb &&
|
|
globalIndex <= e.msb + 1,
|
|
);
|
|
return (
|
|
-1 !== bitfieldIndex &&
|
|
((globalIndex > desc[bitfieldIndex].lsb &&
|
|
globalIndex < desc[bitfieldIndex].msb + 1) ||
|
|
!(
|
|
globalIndex != desc[bitfieldIndex].lsb ||
|
|
!(
|
|
0 === laneIndex ||
|
|
(bitfieldIndex > 0 &&
|
|
isEmptyBitfield(desc[bitfieldIndex - 1]))
|
|
)
|
|
) ||
|
|
!(
|
|
globalIndex != desc[bitfieldIndex].msb + 1 ||
|
|
!(
|
|
laneIndex === laneLength ||
|
|
(bitfieldIndex < desc.length - 1 &&
|
|
isEmptyBitfield(desc[bitfieldIndex + 1]))
|
|
)
|
|
))
|
|
);
|
|
},
|
|
cage = (desc, opt) => {
|
|
const {
|
|
hspace: hspace,
|
|
vspace: vspace,
|
|
mod: mod,
|
|
margin: margin,
|
|
index: index,
|
|
vflip: vflip,
|
|
} = opt,
|
|
width = hspace - margin.left - margin.right - 1,
|
|
height = vspace - margin.top - margin.bottom,
|
|
res = [
|
|
'g',
|
|
{
|
|
stroke: 'black',
|
|
'stroke-width': 1,
|
|
'stroke-linecap': 'round',
|
|
},
|
|
];
|
|
if (opt.sparse) {
|
|
opt.uneven && opt.bits % 2 == 1 && index === opt.lanes - 1
|
|
? vflip
|
|
? res.push(
|
|
hline(width - width / mod, 0, 0),
|
|
hline(width - width / mod, 0, height),
|
|
)
|
|
: res.push(
|
|
hline(width - width / mod, width / mod, 0),
|
|
hline(width - width / mod, width / mod, height),
|
|
)
|
|
: opt.compact ||
|
|
res.push(
|
|
hline(width, 0, 0),
|
|
hline(width, 0, height),
|
|
vline(height, vflip ? width : 0, 0),
|
|
);
|
|
} else
|
|
res.push(
|
|
hline(width, 0, 0),
|
|
vline(height, vflip ? width : 0, 0),
|
|
hline(width, 0, height),
|
|
);
|
|
let i = index * mod;
|
|
const delta = vflip ? 1 : -1;
|
|
let j = vflip ? 0 : mod;
|
|
if (opt.sparse)
|
|
for (let k = 0; k <= mod; k++) {
|
|
if (skipDrawingEmptySpace(desc, opt, k, mod, i)) {
|
|
i++, (j += delta);
|
|
continue;
|
|
}
|
|
const xj = j * (width / mod);
|
|
0 === k || k === mod || desc.some(e => e.msb + 1 === i)
|
|
? res.push(vline(height, xj, 0))
|
|
: res.push(
|
|
vline(height >>> 3, xj, 0),
|
|
vline(-(height >>> 3), xj, height),
|
|
),
|
|
opt.compact &&
|
|
0 !== k &&
|
|
!skipDrawingEmptySpace(desc, opt, k - 1, mod, i - 1) &&
|
|
res.push(
|
|
hline(width / mod, xj, 0),
|
|
hline(width / mod, xj, height),
|
|
),
|
|
i++,
|
|
(j += delta);
|
|
}
|
|
else
|
|
for (let k = 0; k < mod; k++) {
|
|
const xj = j * (width / mod);
|
|
0 === k || desc.some(e => e.lsb === i)
|
|
? res.push(vline(height, xj, 0))
|
|
: res.push(
|
|
vline(height >>> 3, xj, 0),
|
|
vline(-(height >>> 3), xj, height),
|
|
),
|
|
i++,
|
|
(j += delta);
|
|
}
|
|
return res;
|
|
},
|
|
lane = (desc, opt) => {
|
|
const {
|
|
index: index,
|
|
vspace: vspace,
|
|
hspace: hspace,
|
|
margin: margin,
|
|
hflip: hflip,
|
|
lanes: lanes,
|
|
compact: compact,
|
|
label: label,
|
|
} = opt,
|
|
height = vspace - margin.top - margin.bottom,
|
|
width = hspace - margin.left - margin.right - 1;
|
|
let tx = margin.left;
|
|
const idx = hflip ? index : lanes - index - 1;
|
|
let ty = round(idx * vspace + margin.top);
|
|
compact && (ty = round(idx * height + margin.top));
|
|
const res = ['g', tt(tx, ty), cage(desc, opt), labelArr(desc, opt)];
|
|
if (label && void 0 !== label.left) {
|
|
const lab = label.left;
|
|
let txt = index;
|
|
'string' == typeof lab
|
|
? (txt = lab)
|
|
: 'number' == typeof lab
|
|
? (txt += lab)
|
|
: 'object' == typeof lab && (txt = lab[index] || txt),
|
|
res.push([
|
|
'g',
|
|
{ 'text-anchor': 'end' },
|
|
text(txt, -4, round(height / 2)),
|
|
]);
|
|
}
|
|
if (label && void 0 !== label.right) {
|
|
const lab = label.right;
|
|
let txt = index;
|
|
'string' == typeof lab
|
|
? (txt = lab)
|
|
: 'number' == typeof lab
|
|
? (txt += lab)
|
|
: 'object' == typeof lab && (txt = lab[index] || txt),
|
|
res.push([
|
|
'g',
|
|
{ 'text-anchor': 'start' },
|
|
text(txt, width + 4, round(height / 2)),
|
|
]);
|
|
}
|
|
return res;
|
|
},
|
|
optDefaults = opt => (
|
|
[
|
|
['hspace', 40, 800],
|
|
['lanes', 1, 1],
|
|
['bits', 1, void 0],
|
|
['fontsize', 6, 14],
|
|
].map(
|
|
(opt => row => {
|
|
const [key, min, def] = row,
|
|
val = Math.round(opt[key]);
|
|
opt[key] = 'number' == typeof val && val >= min ? val : def;
|
|
})((opt = 'object' == typeof opt ? opt : {})),
|
|
),
|
|
(opt.fontfamily = opt.fontfamily || 'sans-serif'),
|
|
(opt.fontweight = opt.fontweight || 'normal'),
|
|
(opt.compact = opt.compact || !1),
|
|
(opt.hflip = opt.hflip || !1),
|
|
(opt.uneven = opt.uneven || !1),
|
|
(opt.margin = opt.margin || {}),
|
|
opt
|
|
);
|
|
module.exports = (desc, opt) => {
|
|
opt = optDefaults(opt);
|
|
const maxAttributes = (desc =>
|
|
desc.reduce(
|
|
(prev, field) =>
|
|
Math.max(
|
|
prev,
|
|
void 0 === field.attr
|
|
? 0
|
|
: Array.isArray(field.attr)
|
|
? field.attr.length
|
|
: 1,
|
|
),
|
|
0,
|
|
))(desc);
|
|
(opt.vspace = opt.vspace || (maxAttributes + 4) * opt.fontsize),
|
|
void 0 === opt.bits &&
|
|
(opt.bits = (desc =>
|
|
desc.reduce(
|
|
(prev, field) =>
|
|
prev + (void 0 === field.bits ? 0 : field.bits),
|
|
0,
|
|
))(desc));
|
|
const {
|
|
hspace: hspace,
|
|
vspace: vspace,
|
|
lanes: lanes,
|
|
margin: margin,
|
|
compact: compact,
|
|
fontsize: fontsize,
|
|
bits: bits,
|
|
label: label,
|
|
legend: legend,
|
|
} = opt;
|
|
void 0 === margin.right &&
|
|
(label && void 0 !== label.right
|
|
? (margin.right = round(0.1 * hspace))
|
|
: (margin.right = 4)),
|
|
void 0 === margin.left &&
|
|
(label && void 0 !== label.left
|
|
? (margin.left = round(0.1 * hspace))
|
|
: (margin.left = 4)),
|
|
void 0 === margin.top
|
|
? ((margin.top = 1.5 * fontsize),
|
|
void 0 === margin.bottom &&
|
|
(margin.bottom = fontsize * maxAttributes + 4))
|
|
: void 0 === margin.bottom && (margin.bottom = 4);
|
|
const width = hspace;
|
|
let height = vspace * lanes;
|
|
compact && (height -= (lanes - 1) * (margin.top + margin.bottom));
|
|
const res = [
|
|
'g',
|
|
tt(0.5, legend ? 12.5 : 0.5, {
|
|
'text-anchor': 'middle',
|
|
'font-size': opt.fontsize,
|
|
'font-family': opt.fontfamily,
|
|
'font-weight': opt.fontweight,
|
|
}),
|
|
];
|
|
let lsb = 0;
|
|
const mod = Math.ceil((1 * bits) / lanes);
|
|
(opt.mod = 0 | mod),
|
|
desc.map(e => {
|
|
(e.lsb = lsb),
|
|
(e.lsbm = lsb % mod),
|
|
(lsb += e.bits),
|
|
(e.msb = lsb - 1),
|
|
(e.msbm = e.msb % mod);
|
|
});
|
|
for (let i = 0; i < lanes; i++)
|
|
(opt.index = i), res.push(lane(desc, opt));
|
|
return (
|
|
compact &&
|
|
res.push(
|
|
((desc, opt) => {
|
|
const {
|
|
hspace: hspace,
|
|
margin: margin,
|
|
mod: mod,
|
|
fontsize: fontsize,
|
|
vflip: vflip,
|
|
legend: legend,
|
|
} = opt,
|
|
step = (hspace - margin.left - margin.right - 1) / mod,
|
|
labels = ['g', tt(margin.left, legend ? 0 : -3)],
|
|
mask = ((desc, mod) => {
|
|
const mask = [];
|
|
let idx = 0;
|
|
return (
|
|
desc.map(e => {
|
|
(mask[idx % mod] = !0),
|
|
(idx += e.bits),
|
|
(mask[(idx - 1) % mod] = !0);
|
|
}),
|
|
mask
|
|
);
|
|
})(desc, mod);
|
|
for (let i = 0; i < mod; i++) {
|
|
const idx = vflip ? i : mod - i - 1;
|
|
mask[idx] &&
|
|
labels.push(
|
|
text(idx, step * (i + 0.5), 0.5 * fontsize + 4),
|
|
);
|
|
}
|
|
return labels;
|
|
})(desc, opt),
|
|
),
|
|
legend &&
|
|
res.push(
|
|
(opt => {
|
|
const {
|
|
hspace: hspace,
|
|
margin: margin,
|
|
fontsize: fontsize,
|
|
legend: legend,
|
|
} = opt,
|
|
width = hspace - margin.left - margin.right - 1,
|
|
items = ['g', tt(margin.left, -10)];
|
|
let x = width / 2 - (Object.keys(legend).length / 2) * 60;
|
|
for (const key in legend) {
|
|
const value = legend[key];
|
|
items.push([
|
|
'rect',
|
|
norm(
|
|
{ x: x, width: 12, height: 12 },
|
|
{
|
|
style:
|
|
'fill-opacity:0.15; stroke: #000; stroke-width: 1.2;' +
|
|
typeStyle(value),
|
|
},
|
|
),
|
|
]),
|
|
(x += 36),
|
|
items.push(text(key, x, 0.1 * fontsize + 4)),
|
|
(x += 24);
|
|
}
|
|
return items;
|
|
})(opt),
|
|
),
|
|
((w = width),
|
|
(h = height),
|
|
[
|
|
'svg',
|
|
{
|
|
xmlns: 'http://www.w3.org/2000/svg',
|
|
width: w,
|
|
height: h,
|
|
viewBox: [0, 0, w, h].join(' '),
|
|
},
|
|
]).concat([res])
|
|
);
|
|
var w, h;
|
|
};
|
|
},
|
|
{ tspan: 44 },
|
|
],
|
|
36: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tspan = require('tspan'),
|
|
circle =
|
|
'M 4,0 C 4,1.1 3.1,2 2,2 0.9,2 0,1.1 0,0 c 0,-1.1 0.9,-2 2,-2 1.1,0 2,0.9 2,2 z',
|
|
buf1 = 'M -11,-6 -11,6 0,0 z m -5,6 5,0',
|
|
and2 = 'm -16,-10 5,0 c 6,0 11,4 11,10 0,6 -5,10 -11,10 l -5,0 z',
|
|
or2 =
|
|
'm -18,-10 4,0 c 6,0 12,5 14,10 -2,5 -8,10 -14,10 l -4,0 c 2.5,-5 2.5,-15 0,-20 z',
|
|
xor2 =
|
|
'm -21,-10 c 1,3 2,6 2,10 m 0,0 c 0,4 -1,7 -2,10 m 3,-20 4,0 c 6,0 12,5 14,10 -2,5 -8,10 -14,10 l -4,0 c 1,-3 2,-6 2,-10 0,-4 -1,-7 -2,-10 z',
|
|
circle2 =
|
|
'c 0,4.418278 -3.581722,8 -8,8 -4.418278,0 -8,-3.581722 -8,-8 0,-4.418278 3.581722,-8 8,-8 4.418278,0 8,3.581722 8,8 z',
|
|
gates = {
|
|
'=': buf1,
|
|
'~': buf1 + circle,
|
|
'&': and2,
|
|
'~&': and2 + circle,
|
|
'|': or2,
|
|
'~|': or2 + circle,
|
|
'^': xor2,
|
|
'~^': xor2 + circle,
|
|
'+': 'm -8,5 0,-10 m -5,5 10,0 m 3,0' + circle2,
|
|
'*': 'm -4,4 -8,-8 m 0,8 8,-8 m 4,4' + circle2,
|
|
'-': 'm -3,0 -10,0 m 13,0' + circle2,
|
|
},
|
|
aliasGates = {
|
|
add: '+',
|
|
mul: '*',
|
|
sub: '-',
|
|
and: '&',
|
|
or: '|',
|
|
xor: '^',
|
|
andr: '&',
|
|
orr: '|',
|
|
xorr: '^',
|
|
input: '=',
|
|
};
|
|
Object.keys(aliasGates).reduce(
|
|
(res, key) => ((res[key] = gates[aliasGates[key]]), res),
|
|
gates,
|
|
);
|
|
const gater1 = {
|
|
is: type => void 0 !== gates[type],
|
|
render: type => ['path', { class: 'gate', d: gates[type] }],
|
|
},
|
|
iec = {
|
|
eq: '==',
|
|
ne: '!=',
|
|
slt: '<',
|
|
sle: '<=',
|
|
sgt: '>',
|
|
sge: '>=',
|
|
ult: '<',
|
|
ule: '<=',
|
|
ugt: '>',
|
|
uge: '>=',
|
|
BUF: 1,
|
|
INV: 1,
|
|
AND: '&',
|
|
NAND: '&',
|
|
OR: '≥1',
|
|
NOR: '≥1',
|
|
XOR: '=1',
|
|
XNOR: '=1',
|
|
box: '',
|
|
MUX: 'M',
|
|
},
|
|
circled = { INV: 1, NAND: 1, NOR: 1, XNOR: 1 },
|
|
gater2 = {
|
|
is: type => void 0 !== iec[type],
|
|
render: (type, ymin, ymax) => (
|
|
ymin === ymax && ((ymin = -4), (ymax = 4)),
|
|
[
|
|
'g',
|
|
[
|
|
'path',
|
|
{
|
|
class: 'gate',
|
|
d:
|
|
'm -16,' +
|
|
(ymin - 3) +
|
|
' 16,0 0,' +
|
|
(ymax - ymin + 6) +
|
|
' -16,0 z' +
|
|
(circled[type] ? circle : ''),
|
|
},
|
|
],
|
|
['text', { x: -14, y: 4, class: 'wirename' }].concat(
|
|
tspan.parse(iec[type]),
|
|
),
|
|
]
|
|
),
|
|
};
|
|
module.exports = function(type, ymin, ymax) {
|
|
return gater1.is(type)
|
|
? gater1.render(type)
|
|
: gater2.is(type)
|
|
? gater2.render(type, ymin, ymax)
|
|
: ['text', { x: -14, y: 4, class: 'wirename' }].concat(
|
|
tspan.parse(type),
|
|
);
|
|
};
|
|
},
|
|
{ tspan: 44 },
|
|
],
|
|
37: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tspan = require('tspan'),
|
|
drawGate = require('./draw_gate.js');
|
|
module.exports = function drawBoxes(tree, xmax) {
|
|
const ret = ['g'],
|
|
spec = [];
|
|
if (Array.isArray(tree)) {
|
|
spec.push(tree[0].name),
|
|
spec.push([32 * (xmax - tree[0].x), 8 * tree[0].y]);
|
|
for (let i = 1; i < tree.length; i++) {
|
|
const branch = tree[i];
|
|
Array.isArray(branch)
|
|
? spec.push([32 * (xmax - branch[0].x), 8 * branch[0].y])
|
|
: spec.push([32 * (xmax - branch.x), 8 * branch.y]);
|
|
}
|
|
ret.push(drawGate(spec));
|
|
for (let i = 1; i < tree.length; i++) {
|
|
const branch = tree[i];
|
|
ret.push(drawBoxes(branch, xmax));
|
|
}
|
|
return ret;
|
|
}
|
|
const fname = tree.name,
|
|
fx = 32 * (xmax - tree.x),
|
|
fy = 8 * tree.y;
|
|
return (
|
|
ret.push([
|
|
'g',
|
|
{ transform: 'translate(' + fx + ',' + fy + ')' },
|
|
['title'].concat(tspan.parse(fname)),
|
|
['path', { d: 'M 2,0 a 2,2 0 1 1 -4,0 2,2 0 1 1 4,0 z' }],
|
|
['text', { x: -4, y: 4, class: 'pinname' }].concat(
|
|
tspan.parse(fname),
|
|
),
|
|
]),
|
|
ret
|
|
);
|
|
};
|
|
},
|
|
{ './draw_gate.js': 38, tspan: 44 },
|
|
],
|
|
38: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const tspan = require('tspan'),
|
|
drawBody = require('./draw_body.js');
|
|
module.exports = function(spec) {
|
|
const ilen = spec.length,
|
|
ys = [];
|
|
for (let i = 2; i < ilen; i++) ys.push(spec[i][1]);
|
|
const ret = ['g'],
|
|
ymin = Math.min.apply(null, ys),
|
|
ymax = Math.max.apply(null, ys);
|
|
ret.push([
|
|
'g',
|
|
{ transform: 'translate(16,0)' },
|
|
[
|
|
'path',
|
|
{
|
|
d:
|
|
'M' + spec[2][0] + ',' + ymin + ' ' + spec[2][0] + ',' + ymax,
|
|
class: 'wire',
|
|
},
|
|
],
|
|
]);
|
|
for (let i = 2; i < ilen; i++)
|
|
ret.push([
|
|
'g',
|
|
[
|
|
'path',
|
|
{
|
|
d: 'm' + spec[i][0] + ',' + spec[i][1] + ' 16,0',
|
|
class: 'wire',
|
|
},
|
|
],
|
|
]);
|
|
return (
|
|
ret.push([
|
|
'g',
|
|
{ transform: 'translate(' + spec[1][0] + ',' + spec[1][1] + ')' },
|
|
['title'].concat(tspan.parse(spec[0])),
|
|
drawBody(spec[0], ymin - spec[1][1], ymax - spec[1][1]),
|
|
]),
|
|
ret
|
|
);
|
|
};
|
|
},
|
|
{ './draw_body.js': 36, tspan: 44 },
|
|
],
|
|
39: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = function() {
|
|
return [
|
|
'style',
|
|
'.pinname {font-size:12px; font-style:normal; font-variant:normal; font-weight:500; font-stretch:normal; text-align:center; text-anchor:end; font-family:Helvetica} .wirename {font-size:12px; font-style:normal; font-variant:normal; font-weight:500; font-stretch:normal; text-align:center; text-anchor:start; font-family:Helvetica} .wirename:hover {fill:blue} .gate {color:#000; fill:#ffc; fill-opacity: 1;stroke:#000; stroke-width:1; stroke-opacity:1} .gate:hover {fill:red !important; } .wire {fill:none; stroke:#000; stroke-width:1; stroke-opacity:1} .grid {fill:#fff; fill-opacity:1; stroke:none}',
|
|
];
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
40: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const render = require('./render.js'),
|
|
drawBoxes = require('./draw_boxes.js'),
|
|
insertSVGTemplateAssign = require('./insert-svg-template-assign.js');
|
|
module.exports = function(index, source) {
|
|
let state = { x: 0, y: 2, xmax: 0 };
|
|
const tree = source.assign,
|
|
ilen = tree.length;
|
|
for (let i = 0; i < ilen; i++)
|
|
(state = render(tree[i], state)), state.x++;
|
|
const xmax = state.xmax + 3,
|
|
svg = ['g'];
|
|
for (let i = 0; i < ilen; i++) svg.push(drawBoxes(tree[i], xmax));
|
|
const width = 32 * (xmax + 1) + 1,
|
|
height = 8 * (state.y + 1) - 7;
|
|
return [
|
|
'svg',
|
|
{
|
|
id: 'svgcontent_' + index,
|
|
viewBox: '0 0 ' + width + ' ' + height,
|
|
width: width,
|
|
height: height,
|
|
},
|
|
insertSVGTemplateAssign(),
|
|
['g', { transform: 'translate(0.5, 0.5)' }, svg],
|
|
];
|
|
};
|
|
},
|
|
{
|
|
'./draw_boxes.js': 37,
|
|
'./insert-svg-template-assign.js': 39,
|
|
'./render.js': 41,
|
|
},
|
|
],
|
|
41: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = function render(tree, state) {
|
|
state.xmax = Math.max(state.xmax, state.x);
|
|
const y = state.y,
|
|
ilen = tree.length;
|
|
for (let i = 1; i < ilen; i++) {
|
|
const branch = tree[i];
|
|
Array.isArray(branch)
|
|
? (state = render(branch, {
|
|
x: state.x + 1,
|
|
y: state.y,
|
|
xmax: state.xmax,
|
|
}))
|
|
: ((tree[i] = { name: branch, x: state.x + 1, y: state.y }),
|
|
(state.y += 2));
|
|
}
|
|
return (
|
|
(tree[0] = {
|
|
name: tree[0],
|
|
x: state.x,
|
|
y: Math.round((y + (state.y - 2)) / 2),
|
|
}),
|
|
state.x--,
|
|
state
|
|
);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
42: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
const isObject = o =>
|
|
o && '[object Object]' === Object.prototype.toString.call(o);
|
|
const clean = txt =>
|
|
txt
|
|
.split('\n')
|
|
.filter(e => '' !== e.trim())
|
|
.join('\n');
|
|
module.exports = function(a, indentation) {
|
|
const cr = indentation > 0 ? '\n' : '',
|
|
indent = (function(indentation) {
|
|
if (!(indentation > 0)) return txt => txt;
|
|
var space = ' '.repeat(indentation);
|
|
return txt => {
|
|
if ('string' != typeof txt) return txt;
|
|
const arr = txt.split('\n');
|
|
return 1 === arr.length
|
|
? space + txt
|
|
: arr.map(e => ('' === e.trim() ? e : space + e)).join('\n');
|
|
};
|
|
})(indentation);
|
|
return (function rec(a) {
|
|
let res,
|
|
body = '',
|
|
isFlat = !0;
|
|
return a.some((e, i, arr) => {
|
|
if (0 === i) return (res = '<' + e), 1 === arr.length;
|
|
if (1 === i) {
|
|
if (isObject(e))
|
|
return (
|
|
Object.keys(e).map(key => {
|
|
let val = e[key];
|
|
Array.isArray(val) && (val = val.join(' ')),
|
|
(res += ' ' + key + '="' + val + '"');
|
|
}),
|
|
2 === arr.length || void (res += '>')
|
|
);
|
|
res += '>';
|
|
}
|
|
switch (typeof e) {
|
|
case 'string':
|
|
case 'number':
|
|
case 'boolean':
|
|
case 'undefined':
|
|
return void (body += e + cr);
|
|
}
|
|
(isFlat = !1), (body += rec(e));
|
|
})
|
|
? res + '/>' + cr
|
|
: isFlat
|
|
? res + clean(body) + '</' + a[0] + '>' + cr
|
|
: res + cr + indent(body) + '</' + a[0] + '>' + cr;
|
|
})(a);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
43: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
module.exports = (x, y, obj) => {
|
|
let objt = {};
|
|
if (x || y) {
|
|
objt = {
|
|
transform:
|
|
'translate(' + [x || 0].concat(y ? [y] : []).join(',') + ')',
|
|
};
|
|
}
|
|
return (
|
|
(obj = 'object' == typeof obj ? obj : {}), Object.assign(objt, obj)
|
|
);
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
44: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
var parse = require('./parse'),
|
|
reparse = require('./reparse');
|
|
(exports.parse = parse), (exports.reparse = reparse);
|
|
},
|
|
{ './parse': 45, './reparse': 46 },
|
|
],
|
|
45: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
var escapeMap = {
|
|
'&': '&',
|
|
'"': '"',
|
|
'<': '<',
|
|
'>': '>',
|
|
};
|
|
function xscape(val) {
|
|
return 'string' != typeof val
|
|
? val
|
|
: val.replace(/([&"<>])/g, function(_, e) {
|
|
return escapeMap[e];
|
|
});
|
|
}
|
|
var token = /<o>|<ins>|<s>|<sub>|<sup>|<b>|<i>|<tt>|<\/o>|<\/ins>|<\/s>|<\/sub>|<\/sup>|<\/b>|<\/i>|<\/tt>/;
|
|
function update(s, cmd) {
|
|
cmd.add &&
|
|
cmd.add.split(';').forEach(function(e) {
|
|
var arr = e.split(' ');
|
|
s[arr[0]][arr[1]] = !0;
|
|
}),
|
|
cmd.del &&
|
|
cmd.del.split(';').forEach(function(e) {
|
|
var arr = e.split(' ');
|
|
delete s[arr[0]][arr[1]];
|
|
});
|
|
}
|
|
var trans = {
|
|
'<o>': { add: 'text-decoration overline' },
|
|
'</o>': { del: 'text-decoration overline' },
|
|
'<ins>': { add: 'text-decoration underline' },
|
|
'</ins>': { del: 'text-decoration underline' },
|
|
'<s>': { add: 'text-decoration line-through' },
|
|
'</s>': { del: 'text-decoration line-through' },
|
|
'<b>': { add: 'font-weight bold' },
|
|
'</b>': { del: 'font-weight bold' },
|
|
'<i>': { add: 'font-style italic' },
|
|
'</i>': { del: 'font-style italic' },
|
|
'<sub>': { add: 'baseline-shift sub;font-size .7em' },
|
|
'</sub>': { del: 'baseline-shift sub;font-size .7em' },
|
|
'<sup>': { add: 'baseline-shift super;font-size .7em' },
|
|
'</sup>': { del: 'baseline-shift super;font-size .7em' },
|
|
'<tt>': { add: 'font-family monospace' },
|
|
'</tt>': { del: 'font-family monospace' },
|
|
};
|
|
function dump(s) {
|
|
return Object.keys(s).reduce(function(pre, cur) {
|
|
var keys = Object.keys(s[cur]);
|
|
return keys.length > 0 && (pre[cur] = keys.join(' ')), pre;
|
|
}, {});
|
|
}
|
|
module.exports = function(str) {
|
|
var state, res, i, m, a;
|
|
if (void 0 === str) return [];
|
|
if ('number' == typeof str) return [str + ''];
|
|
if ('string' != typeof str) return [str];
|
|
for (
|
|
res = [],
|
|
state = {
|
|
'text-decoration': {},
|
|
'font-weight': {},
|
|
'font-style': {},
|
|
'baseline-shift': {},
|
|
'font-size': {},
|
|
'font-family': {},
|
|
};
|
|
;
|
|
|
|
) {
|
|
if (-1 === (i = str.search(token)))
|
|
return res.push(['tspan', dump(state), xscape(str)]), res;
|
|
if (
|
|
(i > 0 &&
|
|
((a = str.slice(0, i)),
|
|
res.push(['tspan', dump(state), xscape(a)])),
|
|
(m = str.match(token)[0]),
|
|
update(state, trans[m]),
|
|
0 === (str = str.slice(i + m.length)).length)
|
|
)
|
|
return res;
|
|
}
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
46: [
|
|
function(require, module, exports) {
|
|
'use strict';
|
|
var parse = require('./parse');
|
|
module.exports = function(React) {
|
|
var $ = React.createElement;
|
|
function reTspan(e, i) {
|
|
var tag = e[0],
|
|
attr = e[1],
|
|
newAttr = Object.keys(attr).reduce(function(res, key) {
|
|
var str, m;
|
|
return (
|
|
(res[
|
|
null === (m = (str = key).match(/(\w+)-(\w)(\w+)/))
|
|
? str
|
|
: m[1] + m[2].toUpperCase() + m[3]
|
|
] = attr[key]),
|
|
res
|
|
);
|
|
}, {}),
|
|
body = e[2];
|
|
return (newAttr.key = i), $(tag, newAttr, body);
|
|
}
|
|
return function(str) {
|
|
return parse(str).map(reTspan);
|
|
};
|
|
};
|
|
},
|
|
{ './parse': 45 },
|
|
],
|
|
47: [
|
|
function(require, module, exports) {
|
|
module.exports = {
|
|
name: 'wavedrom',
|
|
version: '3.2.0',
|
|
description: 'Digital timing diagram in your browser',
|
|
homepage: 'http://wavedrom.com',
|
|
author: 'alex.drom@gmail.com',
|
|
license: 'MIT',
|
|
repository: {
|
|
type: 'git',
|
|
url: 'https://github.com/wavedrom/wavedrom.git',
|
|
},
|
|
bugs: { url: 'https://github.com/wavedrom/wavedrom/issues' },
|
|
main: './lib',
|
|
unpkg: 'wavedrom.unpkg.min.js',
|
|
files: [
|
|
'bin/cli.js',
|
|
'wavedrom.js',
|
|
'wavedrom.min.js',
|
|
'wavedrom.unpkg.js',
|
|
'wavedrom.unpkg.min.js',
|
|
'LICENSE',
|
|
'lib/**',
|
|
'skins/**',
|
|
],
|
|
scripts: {
|
|
test: 'npm-run-all eslint nyc',
|
|
eslint: 'eslint lib/*.js',
|
|
nyc: 'nyc -r=lcov -r=text mocha test',
|
|
dist: 'browserify ./lib/wave-drom.js > wavedrom.js',
|
|
'watch.dist': 'watchify ./lib/wave-drom.js -o wavedrom.js -v',
|
|
'dist.min':
|
|
'terser --compress --mengle -- wavedrom.js | node ./bin/header.js > wavedrom.min.js',
|
|
unpkg:
|
|
'browserify --standalone wavedrom lib/index.js > wavedrom.unpkg.js',
|
|
'unpkg.min':
|
|
'terser --compress --mengle -- wavedrom.unpkg.js | node ./bin/header.js > wavedrom.unpkg.min.js',
|
|
cli:
|
|
"{ echo '#!/usr/bin/env node' ; browserify --node bin/cli.js ; } > bin/wavedrom.js ; chmod +x bin/wavedrom.js",
|
|
prepare: 'npm-run-all test dist dist.min unpkg unpkg.min',
|
|
coverage: 'nyc report -r=text-lcov | coveralls',
|
|
clean: 'rm -rf wavedrom.js wavedrom.*.js coverage .nyc_output',
|
|
skins:
|
|
'for S in default narrow dark lowkey ; do node bin/svg2js.js -i unpacked/skins/$S.svg > skins/$S.js ; done',
|
|
},
|
|
keywords: ['waveform', 'verilog', 'RTL'],
|
|
devDependencies: {
|
|
'@drom/eslint-config': '^0.10.0',
|
|
browserify: '^17.0.0',
|
|
chai: '^4.3',
|
|
coveralls: '^3.1.1',
|
|
eslint: '^8.32',
|
|
'fs-extra': '^11.1',
|
|
json5: '^2.2.3',
|
|
mocha: '^10',
|
|
'npm-run-all': '^4.1.5',
|
|
nyc: '^15.1.0',
|
|
terser: '^5.16',
|
|
watchify: '^4.0.0',
|
|
yargs: '^17.6',
|
|
},
|
|
dependencies: {
|
|
'bit-field': '^1.8.0',
|
|
logidrom: '^0.3.1',
|
|
onml: '^2.1.0',
|
|
tspan: '^0.4.0',
|
|
},
|
|
eslintConfig: {
|
|
extends: '@drom/eslint-config/eslint4/node4',
|
|
rules: { camelcase: 0 },
|
|
},
|
|
};
|
|
},
|
|
{},
|
|
],
|
|
},
|
|
{},
|
|
[34],
|
|
);
|