';
break;
case 'bold':
line.innerHTML = '' + item + '';
break;
default:
line.innerText = item;
break;
}
this._element.appendChild(line);
className = 'sidebar-item-value-line-border';
}
}
}
action(text, callback) {
this._action = this.createElement('div', 'sidebar-item-value-expander');
this._action.innerHTML = text;
this._action.addEventListener('click', () => {
callback();
});
this._element.insertBefore(this._action, this._element.childNodes[0]);
}
render() {
return [this._element];
}
toggle() {
}
};
view.AttributeView = class extends view.Control {
constructor(host, attribute) {
super(host);
this._attribute = attribute;
this._element = this.createElement('div', 'sidebar-item-value');
const type = this._attribute.type;
if (type && type !== 'tensor') {
this._expander = this.createElement('div', 'sidebar-item-value-expander');
this._expander.innerText = '+';
this._expander.addEventListener('click', () => {
this.toggle();
});
this._element.appendChild(this._expander);
}
const value = this._attribute.value;
switch (type) {
case 'graph': {
const line = this.createElement('div', 'sidebar-item-value-line-link');
line.innerHTML = value.name || ' ';
line.addEventListener('click', () => {
this.emit('activate', value);
});
this._element.appendChild(line);
break;
}
case 'function': {
const line = this.createElement('div', 'sidebar-item-value-line-link');
line.innerHTML = value.type.name;
line.addEventListener('click', () => {
this.emit('activate', value);
});
this._element.appendChild(line);
break;
}
case 'tensor': {
throw new view.Error('Attribute view tensor not implemented.');
}
default: {
let content = new view.Formatter(value, type).toString();
if (content && content.length > 1000) {
content = content.substring(0, 1000) + '\u2026';
}
if (content && typeof content === 'string') {
content = content.split('<').join('<').split('>').join('>');
}
const line = this.createElement('div', 'sidebar-item-value-line');
line.innerHTML = content ? content : ' ';
this._element.appendChild(line);
}
}
}
render() {
return [this._element];
}
toggle() {
if (this._expander.innerText == '+') {
this._expander.innerText = '-';
const type = this._attribute.type;
const value = this._attribute.value;
const content = type == 'tensor' && value && value.type ? value.type.toString() : this._attribute.type;
const typeLine = this.createElement('div', 'sidebar-item-value-line-border');
typeLine.innerHTML = 'type: ' + '' + content + '';
this._element.appendChild(typeLine);
const description = this._attribute.description;
if (description) {
const descriptionLine = this.createElement('div', 'sidebar-item-value-line-border');
descriptionLine.innerHTML = description;
this._element.appendChild(descriptionLine);
}
} else {
this._expander.innerText = '+';
while (this._element.childElementCount > 2) {
this._element.removeChild(this._element.lastChild);
}
}
}
};
view.ArgumentView = class extends view.Control {
constructor(host, argument) {
super();
this._argument = argument;
this._elements = [];
this._items = [];
for (const value of argument.value) {
const item = new view.ValueView(host, value);
item.on('export-tensor', (sender, value) => this.emit('export-tensor', value));
item.on('error', (sender, value) => this.emit('error', value));
item.on('activate', (sender, value) => this.emit('activate', value));
item.on('deactivate', (sender, value) => this.emit('deactivate', value));
item.on('select', (sender, value) => this.emit('select', value));
this._items.push(item);
for (const element of item.render()) {
this._elements.push(element);
}
}
}
render() {
return this._elements;
}
toggle() {
for (const item of this._items) {
item.toggle();
}
}
};
view.ValueView = class extends view.Control {
constructor(host, value, name) {
super(host);
this._value = value;
this._element = this.createElement('div', 'sidebar-item-value');
const type = this._value.type;
const initializer = this._value.initializer;
const quantization = this._value.quantization;
const location = this._value.location !== undefined;
if (initializer) {
this._element.classList.add('sidebar-item-value-dark');
}
if (type || initializer || quantization || location || name === undefined) {
this._expander = this.createElement('div', 'sidebar-item-value-expander');
this._expander.innerText = '+';
this._expander.addEventListener('click', () => {
this.toggle();
});
this._element.appendChild(this._expander);
}
const tensor = name !== undefined;
name = this._value.name ? this._value.name.split('\n').shift() : ''; // custom argument id
this._hasId = name && !tensor ? true : false;
this._hasCategory = initializer && initializer.category ? true : false;
if (this._hasId || (!this._hasCategory && !type && !tensor)) {
this._hasId = true;
const nameLine = this.createElement('div', 'sidebar-item-value-line');
if (typeof name !== 'string') {
throw new Error("Invalid value identifier '" + JSON.stringify(name) + "'.");
}
nameLine.innerHTML = '';
nameLine.addEventListener('pointerenter', () => this.emit('activate', this._value));
nameLine.addEventListener('pointerleave', () => this.emit('deactivate', this._value));
if (!initializer) {
nameLine.style.cursor = 'pointer';
nameLine.addEventListener('click', () => this.emit('select', this._value));
}
this._element.appendChild(nameLine);
} else if (this._hasCategory) {
this._bold('category', initializer.category);
} else if (type) {
this._code('tensor', type.toString().split('<').join('<').split('>').join('>'));
}
}
render() {
return [this._element];
}
toggle() {
if (this._expander) {
if (this._expander.innerText == '+') {
this._expander.innerText = '-';
const initializer = this._value.initializer;
if (this._hasId && this._hasCategory) {
this._bold('category', initializer.category);
}
let type = null;
let denotation = null;
if (this._value.type) {
type = this._value.type.toString();
denotation = this._value.type.denotation || null;
}
if (type && (this._hasId || this._hasCategory)) {
this._code('tensor', type.split('<').join('<').split('>').join('>'));
}
if (denotation) {
this._code('denotation', denotation);
}
const description = this._value.description;
if (description) {
const descriptionLine = this.createElement('div', 'sidebar-item-value-line-border');
descriptionLine.innerHTML = description;
this._element.appendChild(descriptionLine);
}
const quantization = this._value.quantization;
if (quantization) {
const quantizationLine = this.createElement('div', 'sidebar-item-value-line-border');
const content = !Array.isArray(quantization) ? quantization : '
' + quantization.map((value) => ' ' + value).join('
');
quantizationLine.innerHTML = '';
this._element.appendChild(quantizationLine);
}
const location = this._value.location;
if (location !== undefined) {
this._bold('location', location);
}
const layout = this._value.type ? this._value.type.layout : null;
if (layout) {
const layouts = new Map([
['sparse', 'sparse'],
['sparse.coo', 'sparse coo'],
['sparse.csr', 'sparse csr'],
['sparse.csc', 'sparse csc'],
['sparse.bsr', 'sparse bsr'],
['sparse.bsc', 'sparse bsc']
]);
this._bold('layout', layouts.get(layout));
}
if (initializer) {
this._tensor(initializer);
}
} else {
this._expander.innerText = '+';
while (this._element.childElementCount > 2) {
this._element.removeChild(this._element.lastChild);
}
}
}
}
_bold(name, value) {
const line = this.createElement('div');
line.innerHTML = name + ': ' + '' + value + '';
this._add(line);
}
_code(name, value) {
const line = this.createElement('div');
line.innerHTML = name + ': ' + '' + value + '';
this._add(line);
}
_add(child) {
child.className = this._element.childNodes.length < 2 ? 'sidebar-item-value-line' : 'sidebar-item-value-line-border';
this._element.appendChild(child);
}
_tensor(value) {
const contentLine = this.createElement('pre');
try {
const tensor = new view.Tensor(value);
if (Array.isArray(tensor.stride) && tensor.stride.length > 0) {
this._code('stride', tensor.stride.join(','));
}
if (tensor.encoding !== '<' && tensor.encoding !== '>' && tensor.encoding !== '|') {
contentLine.innerHTML = "Tensor encoding '" + tensor.layout + "' is not implemented.";
} else if (tensor.layout && (tensor.layout !== 'sparse' && tensor.layout !== 'sparse.coo')) {
contentLine.innerHTML = "Tensor layout '" + tensor.layout + "' is not implemented.";
} else if (tensor.empty) {
contentLine.innerHTML = 'Tensor data is empty.';
} else if (tensor.type && tensor.type.dataType === '?') {
contentLine.innerHTML = 'Tensor data type is not defined.';
} else if (tensor.type && !tensor.type.shape) {
contentLine.innerHTML = 'Tensor shape is not defined.';
} else {
contentLine.innerHTML = tensor.toString();
if (this._host.save &&
value.type.shape && value.type.shape.dimensions &&
value.type.shape.dimensions.length > 0) {
this._saveButton = this.createElement('div', 'sidebar-item-value-expander');
this._saveButton.innerHTML = '💾';
this._saveButton.addEventListener('click', () => {
this.emit('export-tensor', tensor);
});
this._element.appendChild(this._saveButton);
}
}
} catch (err) {
contentLine.innerHTML = err.toString();
this.emit('error', err);
}
const valueLine = this.createElement('div', 'sidebar-item-value-line-border');
valueLine.appendChild(contentLine);
this._element.appendChild(valueLine);
}
};
view.NodeView = class extends view.Control {
constructor(host, node) {
super(host);
this._node = node;
this._element = this.createElement('div', 'sidebar-item-value');
const name = node.name;
const type = node.type ? node.type.name : '';
if (name && type) {
this._expander = this.createElement('div', 'sidebar-item-value-expander');
this._expander.innerText = '+';
this._expander.addEventListener('click', () => {
this.toggle();
});
this._element.appendChild(this._expander);
}
if (type) {
const type = node.type.name;
const element = this.createElement('div', 'sidebar-item-value-line');
element.innerHTML = '';
element.addEventListener('pointerenter', () => this.emit('activate', this._node));
element.addEventListener('pointerleave', () => this.emit('deactivate', this._node));
element.addEventListener('click', () => this.emit('select', this._node));
element.style.cursor = 'pointer';
this._element.appendChild(element);
} else {
const element = this.createElement('div', 'sidebar-item-value-line');
element.innerHTML = '';
element.addEventListener('pointerenter', () => this.emit('activate', this._node));
element.addEventListener('pointerleave', () => this.emit('deactivate', this._node));
element.addEventListener('click', () => this.emit('select', this._node));
element.style.cursor = 'pointer';
this._element.appendChild(element);
}
}
render() {
return [this._element];
}
toggle() {
if (this._expander) {
if (this._expander.innerText == '+') {
this._expander.innerText = '-';
const name = this._node.name;
const element = this.createElement('div', 'sidebar-item-value-line-border');
element.innerHTML = '';
element.addEventListener('pointerenter', () => this.emit('activate', this._node));
element.addEventListener('pointerleave', () => this.emit('deactivate', this._node));
element.addEventListener('click', () => this.emit('select', this._node));
element.style.cursor = 'pointer';
this._element.appendChild(element);
} else {
this._expander.innerText = '+';
while (this._element.childElementCount > 2) {
this._element.removeChild(this._element.lastChild);
}
}
}
}
};
view.NodeListView = class extends view.Control {
constructor(host, list) {
super();
this._host = host;
this._elements = [];
for (const node of list) {
const item = new view.NodeView(host, node);
item.on('activate', (sender, value) => this.emit('activate', value));
item.on('deactivate', (sender, value) => this.emit('deactivate', value));
item.on('select', (sender, value) => this.emit('select', value));
item.toggle();
for (const element of item.render()) {
this._elements.push(element);
}
}
}
render() {
return this._elements;
}
};
view.ConnectionSidebar = class extends view.ObjectSidebar {
constructor(host, value, from, to) {
super(host);
this._host = host;
this._value = value;
this._from = from;
this._to = to;
const [name] = value.name.split('\n');
this.addProperty('name', name);
if (value.type) {
const item = new view.ValueView(this._host, value, '');
this.add('type', item);
item.toggle();
}
if (from) {
this.addHeader('Inputs');
const list = new view.NodeListView(host, [from]);
list.on('activate', (sender, value) => this.emit('activate', value));
list.on('deactivate', (sender, value) => this.emit('deactivate', value));
list.on('select', (sender, value) => this.emit('select', value));
const item = new view.NameValueView(this._host, 'from', list);
this._container.appendChild(item.render());
}
if (Array.isArray(to) && to.length > 0) {
this.addHeader('Outputs');
const list = new view.NodeListView(this._host, to);
list.on('activate', (sender, value) => this.emit('activate', value));
list.on('deactivate', (sender, value) => this.emit('deactivate', value));
list.on('select', (sender, value) => this.emit('select', value));
const item = new view.NameValueView(this._host, 'to', list);
this._container.appendChild(item.render());
}
}
};
view.ModelSidebar = class extends view.ObjectSidebar {
constructor(host, model, graph) {
super(host);
this._model = model;
if (model.format) {
this.addProperty('format', model.format);
}
if (model.producer) {
this.addProperty('producer', model.producer);
}
if (model.name) {
this.addProperty('name', model.name);
}
if (model.version) {
this.addProperty('version', model.version);
}
if (model.description) {
this.addProperty('description', model.description);
}
if (model.domain) {
this.addProperty('domain', model.domain);
}
if (model.imports) {
this.addProperty('imports', model.imports);
}
if (model.runtime) {
this.addProperty('runtime', model.runtime);
}
if (model.metadata) {
for (const entry of model.metadata) {
this.addProperty(entry.name, entry.value);
}
}
const graphs = Array.isArray(model.graphs) ? model.graphs : [];
if (graphs.length === 1 && graphs[0].name) {
this.addProperty('graph', graphs[0].name);
} else if (graphs.length > 1) {
const selector = new view.SelectView(this._host, model.graphs, graph);
selector.on('change', (sender, data) => this.emit('update-active-graph', data));
this.add('graph', selector);
}
if (graph) {
if (graph.version) {
this.addProperty('version', graph.version);
}
if (graph.type) {
this.addProperty('type', graph.type);
}
if (graph.tags) {
this.addProperty('tags', graph.tags);
}
if (graph.description) {
this.addProperty('description', graph.description);
}
if (Array.isArray(graph.inputs) && graph.inputs.length > 0) {
this.addHeader('Inputs');
for (const input of graph.inputs) {
this.addArgument(input.name, input);
}
}
if (Array.isArray(graph.outputs) && graph.outputs.length > 0) {
this.addHeader('Outputs');
for (const output of graph.outputs) {
this.addArgument(output.name, output);
}
}
}
}
render() {
return [this._container];
}
addArgument(name, argument) {
const value = new view.ArgumentView(this._host, argument);
value.toggle();
const item = new view.NameValueView(this._host, name, value);
this._container.appendChild(item.render());
}
};
view.DocumentationSidebar = class extends view.Control {
constructor(host, type) {
super();
this._host = host;
this._type = type;
}
render() {
if (!this._elements) {
this._elements = [];
const type = view.Documentation.format(this._type);
const element = this.createElement('div', 'sidebar-documentation');
this._append(element, 'h1', type.name);
if (type.summary) {
this._append(element, 'p', type.summary);
}
if (type.description) {
this._append(element, 'p', type.description);
}
if (Array.isArray(type.attributes) && type.attributes.length > 0) {
this._append(element, 'h2', 'Attributes');
const attributes = this._append(element, 'dl');
for (const attribute of type.attributes) {
this._append(attributes, 'dt', attribute.name + (attribute.type ? ': ' + attribute.type + '' : ''));
this._append(attributes, 'dd', attribute.description);
}
element.appendChild(attributes);
}
if (Array.isArray(type.inputs) && type.inputs.length > 0) {
this._append(element, 'h2', 'Inputs' + (type.inputs_range ? ' (' + type.inputs_range + ')' : ''));
const inputs = this._append(element, 'dl');
for (const input of type.inputs) {
this._append(inputs, 'dt', input.name + (input.type ? ': ' + input.type + '' : '') + (input.option ? ' (' + input.option + ')' : ''));
this._append(inputs, 'dd', input.description);
}
}
if (Array.isArray(type.outputs) && type.outputs.length > 0) {
this._append(element, 'h2', 'Outputs' + (type.outputs_range ? ' (' + type.outputs_range + ')' : ''));
const outputs = this._append(element, 'dl');
for (const output of type.outputs) {
this._append(outputs, 'dt', output.name + (output.type ? ': ' + output.type + '' : '') + (output.option ? ' (' + output.option + ')' : ''));
this._append(outputs, 'dd', output.description);
}
}
if (Array.isArray(type.type_constraints) && type.type_constraints.length > 0) {
this._append(element, 'h2', 'Type Constraints');
const type_constraints = this._append(element, 'dl');
for (const type_constraint of type.type_constraints) {
this._append(type_constraints, 'dt', type_constraint.type_param_str + ': ' + type_constraint.allowed_type_strs.map((item) => '' + item + '').join(', '));
this._append(type_constraints, 'dd', type_constraint.description);
}
}
if (Array.isArray(type.examples) && type.examples.length > 0) {
this._append(element, 'h2', 'Examples');
for (const example of type.examples) {
this._append(element, 'h3', example.summary);
this._append(element, 'pre', example.code);
}
}
if (Array.isArray(type.references) && type.references.length > 0) {
this._append(element, 'h2', 'References');
const references = this._append(element, 'ul');
for (const reference of type.references) {
this._append(references, 'li', reference.description);
}
}
if (type.domain && type.version && type.support_level) {
this._append(element, 'h2', 'Support');
this._append(element, 'dl', 'In domain ' + type.domain + ' since version ' + type.version + ' at support level ' + type.support_level + '.');
}
this._elements = [element];
}
return this._elements;
}
_append(parent, type, content) {
const element = this.createElement(type);
if (content) {
element.innerHTML = content;
}
parent.appendChild(element);
return element;
}
};
view.FindSidebar = class extends view.Control {
constructor(host, graph) {
super(host);
this._graph = graph;
this._table = new Map();
this._searchElement = this.createElement('input', 'sidebar-find-search');
this._searchElement.setAttribute('id', 'search');
this._searchElement.setAttribute('type', 'text');
this._searchElement.setAttribute('spellcheck', 'false');
this._searchElement.setAttribute('placeholder', 'Search');
this._searchElement.addEventListener('input', (e) => {
this.update(e.target.value);
this.emit('search-text-changed', e.target.value);
});
this._searchElement.addEventListener('keydown', (e) => {
if (e.keyCode === 0x08 && !e.altKey && !e.ctrlKey && !e.shiftKey && !e.metaKey) {
e.stopPropagation();
}
});
this._contentElement = this.createElement('ol', 'sidebar-find-content');
this._contentElement.addEventListener('click', (e) => {
const identifier = e.target.getAttribute('data');
if (this._table.has(identifier)) {
this.emit('select', this._table.get(identifier));
}
});
}
on(event, callback) {
this._events = this._events || {};
this._events[event] = this._events[event] || [];
this._events[event].push(callback);
}
emit(event, data) {
if (this._events && this._events[event]) {
for (const callback of this._events[event]) {
callback(this, data);
}
}
}
focus(searchText) {
this._searchElement.focus();
this._searchElement.value = '';
this._searchElement.value = searchText;
this.update(searchText);
}
update(searchText) {
while (this._contentElement.lastChild) {
this._contentElement.removeChild(this._contentElement.lastChild);
}
this._table.clear();
let index = 0;
const add = (value, content) => {
const key = index.toString();
index++;
this._table.set(key, value);
const element = this.createElement('li');
element.innerText = content;
element.setAttribute('data', key);
element.addEventListener('pointerover', (e) => {
const identifier = e.target.getAttribute('data');
if (this._table.has(identifier)) {
this.emit('focus', this._table.get(identifier));
}
});
element.addEventListener('pointerleave', (e) => {
const identifier = e.target.getAttribute('data');
if (this._table.has(identifier)) {
this.emit('blur', this._table.get(identifier));
}
});
this._contentElement.appendChild(element);
};
let terms = null;
let match = null;
const unquote = searchText.match(new RegExp(/^'(.*)'|"(.*)"$/));
if (unquote) {
const term = unquote[1] || unquote[2];
terms = [term];
match = (name) => {
return term === name;
};
} else {
terms = searchText.trim().toLowerCase().split(' ').map((term) => term.trim()).filter((term) => term.length > 0);
match = (name) => {
return terms.every((term) => name.toLowerCase().indexOf(term) !== -1);
};
}
const edges = new Set();
const matchValue = (value) => {
if (terms.length === 0) {
return true;
}
if (value.name && match(value.name.split('\n').shift())) {
return true;
}
if (value.location && match(value.location)) {
return true;
}
if (value.type) {
for (const term of terms) {
if (value.type.dataType && term === value.type.dataType.toLowerCase()) {
return true;
}
if (value.type.shape) {
if (term === value.type.shape.toString().toLowerCase()) {
return true;
}
if (value.type.shape && Array.isArray(value.type.shape.dimensions)) {
const dimensions = value.type.shape.dimensions.map((dimension) => dimension ? dimension.toString().toLowerCase() : '');
if (term === dimensions.join(',')) {
return true;
}
if (dimensions.some((dimension) => term === dimension)) {
return true;
}
}
}
}
}
return false;
};
const edge = (value) => {
if (value.name && !edges.has(value.name) && matchValue(value)) {
add(value, '\u2192 ' + value.name.split('\n').shift()); // split custom argument id
edges.add(value.name);
}
};
for (const input of this._graph.inputs) {
for (const value of input.value) {
edge(value);
}
}
for (const node of this._graph.nodes) {
const initializers = [];
for (const input of node.inputs) {
for (const value of input.value) {
if (value.initializer) {
initializers.push(value);
} else {
edge(value);
}
}
}
const name = node.name;
const type = node.type.name;
const location = node.location;
if ((name && match(name)) || (type && match(type)) || (location && match(location))) {
add(node, '\u25A2 ' + (name || '[' + type + ']'));
}
for (const value of initializers) {
if (value.name && !edges.has(value.name) && matchValue(value)) {
add(node, '\u25A0 ' + value.name.split('\n').shift()); // split custom argument id
}
}
}
for (const output of this._graph.outputs) {
for (const value of output.value) {
edge(value);
}
}
this._contentElement.style.display = this._contentElement.childNodes.length != 0 ? 'block' : 'none';
}
render() {
return [this._searchElement, this._contentElement];
}
};
view.Tensor = class {
constructor(tensor) {
this._tensor = tensor;
this._type = tensor.type;
this._encoding = tensor.encoding;
this._layout = tensor.type.layout;
this._stride = tensor.stride;
switch (this._encoding) {
case undefined:
case '':
case '<': {
this._data = this._tensor.values;
this._encoding = '<';
this._littleEndian = true;
break;
}
case '>': {
this._data = this._tensor.values;
this._encoding = '>';
this._littleEndian = false;
break;
}
case '|': {
this._values = this._tensor.values;
this._encoding = '|';
break;
}
default: {
throw new view.Error("Unsupported tensor encoding '" + this._encoding + "'.");
}
}
switch (this._layout) {
case 'sparse':
case 'sparse.coo': {
this._indices = this._tensor.indices;
this._values = this._tensor.values;
break;
}
default: {
break;
}
}
view.Tensor.dataTypes = view.Tensor.dataTypeSizes || new Map([
['boolean', 1],
['qint8', 1], ['qint16', 2], ['qint32', 4],
['quint8', 1], ['quint16', 2], ['quint32', 4],
['xint8', 1],
['int8', 1], ['int16', 2], ['int32', 4], ['int64', 8],
['uint8', 1], ['uint16', 2], ['uint32', 4,], ['uint64', 8],
['float16', 2], ['float32', 4], ['float64', 8], ['bfloat16', 2],
['complex64', 8], ['complex128', 16],
['float8e4m3fn', 1], ['float8e4m3fnuz', 1], ['float8e5m2', 1], ['float8e5m2fnuz', 1]
]);
}
get type() {
return this._type;
}
get encoding() {
return this._encoding;
}
get layout() {
return this._layout;
}
get stride() {
return this._stride;
}
get empty() {
switch (this._layout) {
case 'sparse':
case 'sparse.coo': {
return !this._values || this.indices || this._values.values === null || this._values.values.length === 0;
}
default: {
switch (this._encoding) {
case '<':
case '>':
return !(Array.isArray(this._data) || this._data instanceof Uint8Array || this._data instanceof Int8Array) || this._data.length === 0;
case '|':
return !(Array.isArray(this._values) || ArrayBuffer.isView(this._values)) || this._values.length === 0;
default:
throw new Error("Unsupported tensor encoding '" + this._encoding + "'.");
}
}
}
}
get value() {
const context = this._context();
context.limit = Number.MAX_SAFE_INTEGER;
switch (context.encoding) {
case '<':
case '>': {
return this._decodeData(context, 0, 0);
}
case '|': {
return this._decodeValues(context, 0, 0);
}
default: {
throw new Error("Unsupported tensor encoding '" + context.encoding + "'.");
}
}
}
toString() {
const context = this._context();
context.limit = 10000;
switch (context.encoding) {
case '<':
case '>': {
const value = this._decodeData(context, 0, 0);
return view.Tensor._stringify(value, '', ' ');
}
case '|': {
const value = this._decodeValues(context, 0, 0);
return view.Tensor._stringify(value, '', ' ');
}
default: {
throw new Error("Unsupported tensor encoding '" + context.encoding + "'.");
}
}
}
_context() {
if (this._encoding !== '<' && this._encoding !== '>' && this._encoding !== '|') {
throw new Error("Tensor encoding '" + this._encoding + "' is not supported.");
}
if (this._layout && (this._layout !== 'sparse' && this._layout !== 'sparse.coo')) {
throw new Error("Tensor layout '" + this._layout + "' is not supported.");
}
const dataType = this._type.dataType;
const context = {};
context.encoding = this._encoding;
context.dimensions = this._type.shape.dimensions.map((value) => !Number.isInteger(value) && value.toNumber ? value.toNumber() : value);
context.dataType = dataType;
const shape = context.dimensions;
context.stride = this._stride;
if (!Array.isArray(context.stride)) {
context.stride = new Array(shape.length);
let value = 1;
for (let i = shape.length - 1; i >= 0; i--) {
context.stride[i] = value;
value *= shape[i];
}
}
switch (this._layout) {
case 'sparse': {
const indices = new view.Tensor(this._indices).value;
const values = new view.Tensor(this._values).value;
context.data = this._decodeSparse(dataType, context.dimensions, indices, values);
context.encoding = '|';
break;
}
case 'sparse.coo': {
const values = new view.Tensor(this._values).value;
const data = new view.Tensor(this._indices).value;
const dimensions = context.dimensions.length;
let stride = 1;
const strides = context.dimensions.slice().reverse().map((dim) => {
const value = stride;
stride *= dim;
return value;
}).reverse();
const indices = new Uint32Array(values.length);
for (let i = 0; i < dimensions; i++) {
const stride = strides[i];
const dimension = data[i];
for (let i = 0; i < indices.length; i++) {
indices[i] += dimension[i] * stride;
}
}
context.data = this._decodeSparse(dataType, context.dimensions, indices, values);
context.encoding = '|';
break;
}
default: {
switch (this._encoding) {
case '<':
case '>': {
context.data = (this._data instanceof Uint8Array || this._data instanceof Int8Array) ? this._data : this._data.peek();
context.view = new DataView(context.data.buffer, context.data.byteOffset, context.data.byteLength);
if (view.Tensor.dataTypes.has(dataType)) {
const itemsize = view.Tensor.dataTypes.get(dataType);
const length = context.data.length;
const stride = context.stride;
if (length < (itemsize * shape.reduce((a, v) => a * v, 1))) {
const max = stride.reduce((a, v, i) => v > stride[i] ? i : a, 0);
if (length !== (itemsize * stride[max] * shape[max])) {
throw new Error('Invalid tensor data size.');
}
}
context.itemsize = itemsize;
context.stride = stride.map((v) => v * itemsize);
} else if (dataType.startsWith('uint') && !isNaN(parseInt(dataType.substring(4), 10))) {
context.dataType = 'uint';
context.bits = parseInt(dataType.substring(4), 10);
context.itemsize = 1;
} else if (dataType.startsWith('int') && !isNaN(parseInt(dataType.substring(3), 10))) {
context.dataType = 'int';
context.bits = parseInt(dataType.substring(3), 10);
context.itemsize = 1;
} else {
throw new Error("Tensor data type '" + dataType + "' is not implemented.");
}
break;
}
case '|': {
context.data = this._values;
if (!view.Tensor.dataTypes.has(dataType) && dataType !== 'string' && dataType !== 'object') {
throw new Error("Tensor data type '" + dataType + "' is not implemented.");
}
const size = context.dimensions.reduce((a, v) => a * v, 1);
if (size !== this._values.length) {
throw new Error('Invalid tensor data length.');
}
break;
}
default: {
throw new view.Tensor("Unsupported tensor encoding '" + this._encoding + "'.");
}
}
}
}
context.index = 0;
context.count = 0;
return context;
}
_decodeSparse(dataType, dimensions, indices, values) {
const size = dimensions.reduce((a, b) => a * b, 1);
const array = new Array(size);
switch (dataType) {
case 'boolean':
array.fill(false);
break;
default:
array.fill(0);
break;
}
if (indices.length > 0) {
if (Object.prototype.hasOwnProperty.call(indices[0], 'low')) {
for (let i = 0; i < indices.length; i++) {
const index = indices[i];
array[index.high === 0 ? index.low : index.toNumber()] = values[i];
}
} else {
for (let i = 0; i < indices.length; i++) {
array[indices[i]] = values[i];
}
}
}
return array;
}
_decodeData(context, dimension, offset) {
const results = [];
const shape = context.dimensions.length == 0 ? [1] : context.dimensions;
const size = shape[dimension];
const dataType = context.dataType;
const view = context.view;
const stride = context.stride[dimension];
if (dimension == shape.length - 1) {
const ellipsis = (context.count + size) > context.limit;
const length = ellipsis ? context.limit - context.count : size;
const max = offset + (length * context.itemsize);
switch (dataType) {
case 'boolean':
for (; offset < max; offset += stride) {
results.push(view.getUint8(offset) === 0 ? false : true);
}
break;
case 'qint8':
case 'xint8':
case 'int8':
for (; offset < max; offset += stride) {
results.push(view.getInt8(offset));
}
break;
case 'qint16':
case 'int16':
for (; offset < max; offset += stride) {
results.push(view.getInt16(offset, this._littleEndian));
}
break;
case 'qint32':
case 'int32':
for (; offset < max; offset += stride) {
results.push(view.getInt32(offset, this._littleEndian));
}
break;
case 'int64':
for (; offset < max; offset += stride) {
results.push(view.getInt64(offset, this._littleEndian));
}
break;
case 'int':
for (; offset < size; offset += stride) {
results.push(view.getIntBits(offset, context.bits));
}
break;
case 'quint8':
case 'uint8':
for (; offset < max; offset += stride) {
results.push(view.getUint8(offset));
}
break;
case 'quint16':
case 'uint16':
for (; offset < max; offset += stride) {
results.push(view.getUint16(offset, true));
}
break;
case 'quint32':
case 'uint32':
for (; offset < max; offset += stride) {
results.push(view.getUint32(offset, true));
}
break;
case 'uint64':
for (; offset < max; offset += stride) {
results.push(view.getUint64(offset, true));
}
break;
case 'uint':
for (; offset < max; offset += stride) {
results.push(view.getUintBits(offset, context.bits));
}
break;
case 'float16':
for (; offset < max; offset += stride) {
results.push(view.getFloat16(offset, this._littleEndian));
}
break;
case 'float32':
for (; offset < max; offset += stride) {
results.push(view.getFloat32(offset, this._littleEndian));
}
break;
case 'float64':
for (; offset < max; offset += stride) {
results.push(view.getFloat64(offset, this._littleEndian));
}
break;
case 'bfloat16':
for (; offset < max; offset += stride) {
results.push(view.getBfloat16(offset, this._littleEndian));
}
break;
case 'complex64':
for (; offset < max; offset += stride) {
results.push(view.getComplex64(offset, this._littleEndian));
}
break;
case 'complex128':
for (; offset < size; offset += stride) {
results.push(view.getComplex128(offset, this._littleEndian));
}
break;
case 'float8e4m3fn':
for (; offset < size; offset += stride) {
results.push(view.getFloat8e4m3(offset, true, false));
}
break;
case 'float8e4m3fnuz':
for (; offset < size; offset += stride) {
results.push(view.getFloat8e4m3(offset, true, true));
}
break;
case 'float8e5m2':
for (; offset < size; offset += stride) {
results.push(view.getFloat8e5m2(offset, false, false));
}
break;
case 'float8e5m2fnuz':
for (; offset < size; offset += stride) {
results.push(view.getFloat8e5m2(offset, true, true));
}
break;
default:
throw new Error("Unsupported tensor data type '" + dataType + "'.");
}
context.count += length;
if (ellipsis) {
results.push('...');
}
} else {
for (let j = 0; j < size; j++) {
if (context.count >= context.limit) {
results.push('...');
return results;
}
const nextOffset = offset + (j * stride);
results.push(this._decodeData(context, dimension + 1, nextOffset));
}
}
if (context.dimensions.length == 0) {
return results[0];
}
return results;
}
_decodeValues(context, dimension, position) {
const results = [];
const shape = (context.dimensions.length == 0) ? [1] : context.dimensions;
const size = shape[dimension];
const dataType = context.dataType;
const stride = context.stride[dimension];
if (dimension == shape.length - 1) {
const ellipsis = (context.count + size) > context.limit;
const length = ellipsis ? context.limit - context.count : size;
const data = context.data;
for (let i = 0; i < length; i++) {
if (context.count > context.limit) {
results.push('...');
return results;
}
switch (dataType) {
case 'boolean':
results.push(data[position] === 0 ? false : true);
break;
default:
results.push(data[position]);
break;
}
position += stride;
context.count++;
}
} else {
for (let i = 0; i < size; i++) {
if (context.count >= context.limit) {
results.push('...');
return results;
}
const nextPosition = position + (i * stride);
results.push(this._decodeValues(context, dimension + 1, nextPosition));
}
}
if (context.dimensions.length == 0) {
return results[0];
}
return results;
}
static _stringify(value, indentation, indent) {
if (Array.isArray(value)) {
const result = [];
result.push(indentation + '[');
const items = value.map((item) => view.Tensor._stringify(item, indentation + indent, indent));
if (items.length > 0) {
result.push(items.join(',\n'));
}
result.push(indentation + ']');
return result.join('\n');
}
if (value === null) {
return indentation + 'null';
}
switch (typeof value) {
case 'boolean':
return indentation + value.toString();
case 'string':
return indentation + '"' + value + '"';
case 'number':
if (value == Infinity) {
return indentation + 'Infinity';
}
if (value == -Infinity) {
return indentation + '-Infinity';
}
if (isNaN(value)) {
return indentation + 'NaN';
}
return indentation + value.toString();
default:
if (value && value.toString) {
return indentation + value.toString();
}
return indentation + '(undefined)';
}
}
};
view.Documentation = class {
static format(source) {
if (source) {
const generator = new markdown.Generator();
const target = {};
if (source.name !== undefined) {
target.name = source.name;
}
if (source.module !== undefined) {
target.module = source.module;
}
if (source.category !== undefined) {
target.category = source.category;
}
if (source.summary !== undefined) {
target.summary = generator.html(source.summary);
}
if (source.description !== undefined) {
target.description = generator.html(source.description);
}
if (Array.isArray(source.attributes)) {
target.attributes = source.attributes.map((source) => {
const target = {};
target.name = source.name;
if (source.type !== undefined) {
target.type = source.type;
}
if (source.option !== undefined) {
target.option = source.option;
}
if (source.optional !== undefined) {
target.optional = source.optional;
}
if (source.required !== undefined) {
target.required = source.required;
}
if (source.minimum !== undefined) {
target.minimum = source.minimum;
}
if (source.src !== undefined) {
target.src = source.src;
}
if (source.src_type !== undefined) {
target.src_type = source.src_type;
}
if (source.description !== undefined) {
target.description = generator.html(source.description);
}
if (source.default !== undefined) {
target.default = source.default;
}
if (source.visible !== undefined) {
target.visible = source.visible;
}
return target;
});
}
if (Array.isArray(source.inputs)) {
target.inputs = source.inputs.map((source) => {
const target = {};
target.name = source.name;
if (source.type !== undefined) {
target.type = source.type;
}
if (source.description !== undefined) {
target.description = generator.html(source.description);
}
if (source.default !== undefined) {
target.default = source.default;
}
if (source.src !== undefined) {
target.src = source.src;
}
if (source.list !== undefined) {
target.list = source.list;
}
if (source.isRef !== undefined) {
target.isRef = source.isRef;
}
if (source.typeAttr !== undefined) {
target.typeAttr = source.typeAttr;
}
if (source.numberAttr !== undefined) {
target.numberAttr = source.numberAttr;
}
if (source.typeListAttr !== undefined) {
target.typeListAttr = source.typeListAttr;
}
if (source.option !== undefined) {
target.option = source.option;
}
if (source.optional !== undefined) {
target.optional = source.optional;
}
if (source.visible !== undefined) {
target.visible = source.visible;
}
return target;
});
}
if (Array.isArray(source.outputs)) {
target.outputs = source.outputs.map((source) => {
const target = {};
target.name = source.name;
if (source.type) {
target.type = source.type;
}
if (source.description !== undefined) {
target.description = generator.html(source.description);
}
if (source.list !== undefined) {
target.list = source.list;
}
if (source.typeAttr !== undefined) {
target.typeAttr = source.typeAttr;
}
if (source.typeListAttr !== undefined) {
target.typeListAttr = source.typeAttr;
}
if (source.numberAttr !== undefined) {
target.numberAttr = source.numberAttr;
}
if (source.isRef !== undefined) {
target.isRef = source.isRef;
}
if (source.option !== undefined) {
target.option = source.option;
}
return target;
});
}
if (Array.isArray(source.references)) {
target.references = source.references.map((source) => {
if (source) {
target.description = generator.html(source.description);
}
return target;
});
}
if (source.version !== undefined) {
target.version = source.version;
}
if (source.operator !== undefined) {
target.operator = source.operator;
}
if (source.identifier !== undefined) {
target.identifier = source.identifier;
}
if (source.package !== undefined) {
target.package = source.package;
}
if (source.support_level !== undefined) {
target.support_level = source.support_level;
}
if (source.min_input !== undefined) {
target.min_input = source.min_input;
}
if (source.max_input !== undefined) {
target.max_input = source.max_input;
}
if (source.min_output !== undefined) {
target.min_output = source.min_output;
}
if (source.max_input !== undefined) {
target.max_output = source.max_output;
}
if (source.inputs_range !== undefined) {
target.inputs_range = source.inputs_range;
}
if (source.outputs_range !== undefined) {
target.outputs_range = source.outputs_range;
}
if (source.examples !== undefined) {
target.examples = source.examples;
}
if (source.constants !== undefined) {
target.constants = source.constants;
}
if (source.type_constraints !== undefined) {
target.type_constraints = source.type_constraints;
}
return target;
}
return '';
}
};
view.Formatter = class {
constructor(value, type, quote) {
this._value = value;
this._type = type;
this._quote = quote;
this._values = new Set();
}
toString() {
return this._format(this._value, this._type, this._quote);
}
_format(value, type, quote) {
if (value && value.__class__ && value.__class__.__module__ === 'builtins' && value.__class__.__name__ === 'type') {
return value.__module__ + '.' + value.__name__;
}
if (value && value.__class__ && value.__class__.__module__ === 'builtins' && value.__class__.__name__ === 'function') {
return value.__module__ + '.' + value.__name__;
}
if (typeof value === 'function') {
return value();
}
if (value && Number.isInteger(value)) {
return value.toString();
}
if (Number.isNaN(value)) {
return 'NaN';
}
switch (type) {
case 'shape':
return value ? value.toString() : '(null)';
case 'shape[]':
if (value && !Array.isArray(value)) {
throw new Error("Invalid shape '" + JSON.stringify(value) + "'.");
}
return value ? value.map((item) => item.toString()).join(', ') : '(null)';
case 'graph':
return value ? value.name : '(null)';
case 'graph[]':
return value ? value.map((graph) => graph.name).join(', ') : '(null)';
case 'tensor':
if (value && value.type && value.type.shape && value.type.shape.dimensions && value.type.shape.dimensions.length == 0) {
return value.toString();
}
return '[...]';
case 'object':
case 'function':
return value.type.name;
case 'object[]':
case 'function[]':
return value ? value.map((item) => item.type.name).join(', ') : '(null)';
case 'type':
return value ? value.toString() : '(null)';
case 'type[]':
return value ? value.map((item) => item.toString()).join(', ') : '(null)';
default:
break;
}
if (typeof value === 'string' && (!type || type != 'string')) {
return quote ? '"' + value + '"' : value;
}
if (Array.isArray(value)) {
if (value.length == 0) {
return quote ? '[]' : '';
}
let ellipsis = false;
if (value.length > 1000) {
value = value.slice(0, 1000);
ellipsis = true;
}
const itemType = (type && type.endsWith('[]')) ? type.substring(0, type.length - 2) : null;
const array = value.map((item) => {
if (item && Number.isInteger(item)) {
return item.toString();
}
if (Number.isNaN(item)) {
return 'NaN';
}
const quote = !itemType || itemType === 'string';
return this._format(item, itemType, quote);
});
if (ellipsis) {
array.push('\u2026');
}
return quote ? ['[', array.join(', '), ']'].join(' ') : array.join(', ');
}
if (value === null) {
return quote ? 'null' : '';
}
if (value === undefined) {
return 'undefined';
}
if (value !== Object(value)) {
return value.toString();
}
if (this._values.has(value)) {
return '\u2026';
}
this._values.add(value);
let list = null;
const entries = Object.entries(value).filter(([name]) => !name.startsWith('__') && !name.endsWith('__'));
if (entries.length == 1) {
list = [this._format(entries[0][1], null, true)];
} else {
list = entries.map(([name, value]) => name + ': ' + this._format(value, null, true));
}
let objectType = value.__type__;
if (!objectType && value.constructor.name && value.constructor.name !== 'Object') {
objectType = value.constructor.name;
}
if (objectType) {
return objectType + (list.length == 0 ? '()' : ['(', list.join(', '), ')'].join(''));
}
switch (list.length) {
case 0:
return quote ? '()' : '';
case 1:
return list[0];
default:
return quote ? ['(', list.join(', '), ')'].join(' ') : list.join(', ');
}
}
};
markdown.Generator = class {
constructor() {
this._newlineRegExp = /^\n+/;
this._codeRegExp = /^( {4}[^\n]+\n*)+/;
this._fencesRegExp = /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?:\n+|$)|$)/;
this._hrRegExp = /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/;
this._headingRegExp = /^ {0,3}(#{1,6}) +([^\n]*?)(?: +#+)? *(?:\n+|$)/;
this._blockquoteRegExp = /^( {0,3}> ?(([^\n]+(?:\n(?! {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)| {0,3}#{1,6} | {0,3}>| {0,3}(?:`{3,}(?=[^`\n]*\n)|~{3,})[^\n]*\n| {0,3}(?:[*+-]|1[.)]) |<\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\n|\/?>)|<(?:script|pre|style|!--))[^\n]+)*)|[^\n]*)(?:\n|$))+/;
this._listRegExp = /^( {0,3})((?:[*+-]|\d{1,9}[.)])) [\s\S]+?(?:\n+(?=\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$))|\n+(?= {0,3}\[((?!\s*\])(?:\\[[\]]|[^[\]])+)\]: *\n? *]+)>?(?:(?: +\n? *| *\n *)((?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))))? *(?:\n+|$))|\n{2,}(?! )(?!\1(?:[*+-]|\d{1,9}[.)]) )\n*|\s*$)/;
this._htmlRegExp = /^ {0,3}(?:<(script|pre|style)[\s>][\s\S]*?(?:<\/\1>[^\n]*\n+|$)||$)[^\n]*(\n+|$)|<\?[\s\S]*?(?:\?>\n*|$)|\n*|$)|\n*|$)|<\/?(address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\n|\/?>)[\s\S]*?(?:\n{2,}|$)|<(?!script|pre|style)([a-z][\w-]*)(?: +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?)*? *\/?>(?=[ \t]*(?:\n|$))[\s\S]*?(?:\n{2,}|$)|<\/(?!script|pre|style)[a-z][\w-]*\s*>(?=[ \t]*(?:\n|$))[\s\S]*?(?:\n{2,}|$))/i;
this._defRegExp = /^ {0,3}\[((?!\s*\])(?:\\[[\]]|[^[\]])+)\]: *\n? *]+)>?(?:(?: +\n? *| *\n *)((?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))))? *(?:\n+|$)/;
this._nptableRegExp = /^ *([^|\n ].*\|.*)\n {0,3}([-:]+ *\|[-| :]*)(?:\n((?:(?!\n| {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)| {0,3}#{1,6} | {0,3}>| {4}[^\n]| {0,3}(?:`{3,}(?=[^`\n]*\n)|~{3,})[^\n]*\n| {0,3}(?:[*+-]|1[.)]) |<\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\n|\/?>)|<(?:script|pre|style|!--)).*(?:\n|$))*)\n*|$)/;
this._tableRegExp = /^ *\|(.+)\n {0,3}\|?( *[-:]+[-| :]*)(?:\n *((?:(?!\n| {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)| {0,3}#{1,6} | {0,3}>| {4}[^\n]| {0,3}(?:`{3,}(?=[^`\n]*\n)|~{3,})[^\n]*\n| {0,3}(?:[*+-]|1[.)]) |<\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\n|\/?>)|<(?:script|pre|style|!--)).*(?:\n|$))*)\n*|$)/;
this._lheadingRegExp = /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/;
this._textRegExp = /^[^\n]+/;
this._bulletRegExp = /(?:[*+-]|\d{1,9}[.)])/;
this._itemRegExp = /^( *)((?:[*+-]|\d{1,9}[.)])) ?[^\n]*(?:\n(?!\1(?:[*+-]|\d{1,9}[.)]) ?)[^\n]*)*/gm;
this._paragraphRegExp = /^([^\n]+(?:\n(?! {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)| {0,3}#{1,6} | {0,3}>| {0,3}(?:`{3,}(?=[^`\n]*\n)|~{3,})[^\n]*\n| {0,3}(?:[*+-]|1[.)]) |<\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\n|\/?>)|<(?:script|pre|style|!--))[^\n]+)*)/;
this._backpedalRegExp = /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/;
this._escapeRegExp = /^\\([!"#$%&'()*+,\-./:;<=>?@[\]\\^_`{|}~~|])/;
this._escapesRegExp = /\\([!"#$%&'()*+,\-./:;<=>?@[\]\\^_`{|}~])/g;
/* eslint-disable no-control-regex */
this._autolinkRegExp = /^<([a-zA-Z][a-zA-Z0-9+.-]{1,31}:[^\s\x00-\x1f<>]*|[a-zA-Z0-9.!#$%&'*+/=?_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_]))>/;
this._linkRegExp = /^!?\[((?:\[(?:\\.|[^[\]\\])*\]|\\.|`[^`]*`|[^[\]\\`])*?)\]\(\s*(<(?:\\[<>]?|[^\s<>\\])*>|[^\s\x00-\x1f]*)(?:\s+("(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)))?\s*\)/;
/* eslint-enable no-control-regex */
this._urlRegExp = /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9-]+\.?)+[^\s<]*|^[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/i;
this._tagRegExp = /^|^<\/[a-zA-Z][\w:-]*\s*>|^<[a-zA-Z][\w-]*(?:\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?)*?\s*\/?>|^<\?[\s\S]*?\?>|^|^/;
this._reflinkRegExp = /^!?\[((?:\[(?:\\.|[^[\]\\])*\]|\\.|`[^`]*`|[^[\]\\`])*?)\]\[(?!\s*\])((?:\\[[\]]?|[^[\]\\])+)\]/;
this._nolinkRegExp = /^!?\[(?!\s*\])((?:\[[^[\]]*\]|\\[[\]]|[^[\]])*)\](?:\[\])?/;
this._reflinkSearchRegExp = /!?\[((?:\[(?:\\.|[^[\]\\])*\]|\\.|`[^`]*`|[^[\]\\`])*?)\]\[(?!\s*\])((?:\\[[\]]?|[^[\]\\])+)\]|!?\[(?!\s*\])((?:\[[^[\]]*\]|\\[[\]]|[^[\]])*)\](?:\[\])?(?!\()/g;
this._strongStartRegExp = /^(?:(\*\*(?=[*!"#$%&'()+\-.,/:;<=>?@[\]`{|}~]))|\*\*)(?![\s])|__/;
this._strongMiddleRegExp = /^\*\*(?:(?:(?!__[^_]*?__|\*\*\[^\*\]*?\*\*)(?:[^*]|\\\*)|__[^_]*?__|\*\*\[^\*\]*?\*\*)|\*(?:(?!__[^_]*?__|\*\*\[^\*\]*?\*\*)(?:[^*]|\\\*)|__[^_]*?__|\*\*\[^\*\]*?\*\*)*?\*)+?\*\*$|^__(?![\s])((?:(?:(?!__[^_]*?__|\*\*\[^\*\]*?\*\*)(?:[^_]|\\_)|__[^_]*?__|\*\*\[^\*\]*?\*\*)|_(?:(?!__[^_]*?__|\*\*\[^\*\]*?\*\*)(?:[^_]|\\_)|__[^_]*?__|\*\*\[^\*\]*?\*\*)*?_)+?)__$/;
this._strongEndAstRegExp = /[^!"#$%&'()+\-.,/:;<=>?@[\]`{|}~\s]\*\*(?!\*)|[!"#$%&'()+\-.,/:;<=>?@[\]`{|}~]\*\*(?!\*)(?:(?=[!"#$%&'()+\-.,/:;<=>?@[\]`{|}~_\s]|$))/g;
this._strongEndUndRegExp = /[^\s]__(?!_)(?:(?=[!"#$%&'()+\-.,/:;<=>?@[\]`{|}~*\s])|$)/g;
this._emStartRegExp = /^(?:(\*(?=[!"#$%&'()+\-.,/:;<=>?@[\]`{|}~]))|\*)(?![*\s])|_/;
this._emMiddleRegExp = /^\*(?:(?:(?!__[^_]*?__|\*\*\[^\*\]*?\*\*)(?:[^*]|\\\*)|__[^_]*?__|\*\*\[^\*\]*?\*\*)|\*(?:(?!__[^_]*?__|\*\*\[^\*\]*?\*\*)(?:[^*]|\\\*)|__[^_]*?__|\*\*\[^\*\]*?\*\*)*?\*)+?\*$|^_(?![_\s])(?:(?:(?!__[^_]*?__|\*\*\[^\*\]*?\*\*)(?:[^_]|\\_)|__[^_]*?__|\*\*\[^\*\]*?\*\*)|_(?:(?!__[^_]*?__|\*\*\[^\*\]*?\*\*)(?:[^_]|\\_)|__[^_]*?__|\*\*\[^\*\]*?\*\*)*?_)+?_$/;
this._emEndAstRegExp = /[^!"#$%&'()+\-.,/:;<=>?@[\]`{|}~\s]\*(?!\*)|[!"#$%&'()+\-.,/:;<=>?@[\]`{|}~]\*(?!\*)(?:(?=[!"#$%&'()+\-.,/:;<=>?@[\]`{|}~_\s]|$))/g;
this._emEndUndRegExp = /[^\s]_(?!_)(?:(?=[!"#$%&'()+\-.,/:;<=>?@[\]`{|}~*\s])|$)/g;
this._codespanRegExp = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
this._brRegExp = /^( {2,}|\\)\n(?!\s*$)/;
this._delRegExp = /^~+(?=\S)([\s\S]*?\S)~+/;
this._textspanRegExp = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\?@[\]`{|}~])/;
this._blockSkipRegExp = /\[[^\]]*?\]\([^)]*?\)|`[^`]*?`|<[^>]*?>/g;
this._escapeTestRegExp = /[&<>"']/;
this._escapeReplaceRegExp = /[&<>"']/g;
this._escapeTestNoEncodeRegExp = /[<>"']|&(?!#?\w+;)/;
this._escapeReplaceNoEncodeRegExp = /[<>"']|&(?!#?\w+;)/g;
this._escapeReplacementsMap = { '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' };
}
html(source) {
const tokens = [];
const links = new Map();
source = source.replace(/\r\n|\r/g, '\n').replace(/\t/g, ' ');
this._tokenize(source, tokens, links, true);
this._tokenizeBlock(tokens, links);
const result = this._render(tokens, true);
return result;
}
_tokenize(source, tokens, links, top) {
source = source.replace(/^ +$/gm, '');
while (source) {
let match = this._newlineRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
if (match[0].length > 1) {
tokens.push({ type: 'space' });
}
continue;
}
match = this._codeRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
const lastToken = tokens[tokens.length - 1];
if (lastToken && lastToken.type === 'paragraph') {
lastToken.text += '\n' + match[0].trimRight();
} else {
const text = match[0].replace(/^ {4}/gm, '').replace(/\n*$/, '');
tokens.push({ type: 'code', text: text });
}
continue;
}
match = this._fencesRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
const language = match[2] ? match[2].trim() : match[2];
let content = match[3] || '';
const matchIndent = match[0].match(/^(\s+)(?:```)/);
if (matchIndent !== null) {
const [, indent] = matchIndent;
content = content.split('\n').map((node) => {
const match = node.match(/^\s+/);
return (match !== null && match[0].length >= indent.length) ? node.slice(indent.length) : node;
}).join('\n');
}
tokens.push({ type: 'code', language: language, text: content });
continue;
}
match = this._headingRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
tokens.push({ type: 'heading', depth: match[1].length, text: match[2] });
continue;
}
match = this._nptableRegExp.exec(source);
if (match) {
const header = this._splitCells(match[1].replace(/^ *| *\| *$/g, ''));
const align = match[2].replace(/^ *|\| *$/g, '').split(/ *\| */);
if (header.length === align.length) {
const cells = match[3] ? match[3].replace(/\n$/, '').split('\n') : [];
const token = { type: 'table', header: header, align: align, cells: cells, raw: match[0] };
for (let i = 0; i < token.align.length; i++) {
if (/^ *-+: *$/.test(token.align[i])) {
token.align[i] = 'right';
} else if (/^ *:-+: *$/.test(token.align[i])) {
token.align[i] = 'center';
} else if (/^ *:-+ *$/.test(token.align[i])) {
token.align[i] = 'left';
} else {
token.align[i] = null;
}
}
token.cells = token.cells.map((cell) => this._splitCells(cell, token.header.length));
source = source.substring(token.raw.length);
tokens.push(token);
continue;
}
}
match = this._hrRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
tokens.push({ type: 'hr' });
continue;
}
match = this._blockquoteRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
const text = match[0].replace(/^ *> ?/gm, '');
tokens.push({ type: 'blockquote', text: text, tokens: this._tokenize(text, [], links, top) });
continue;
}
match = this._listRegExp.exec(source);
if (match) {
const [value, , bull] = match;
const ordered = bull.length > 1;
const parent = bull[bull.length - 1] === ')';
let raw = value;
const list = { type: 'list', raw: raw, ordered: ordered, start: ordered ? +bull.slice(0, -1) : '', loose: false, items: [] };
const itemMatch = value.match(this._itemRegExp);
let next = false;
const length = itemMatch.length;
for (let i = 0; i < length; i++) {
let item = itemMatch[i];
raw = item;
let space = item.length;
item = item.replace(/^ *([*+-]|\d+[.)]) ?/, '');
if (~item.indexOf('\n ')) {
space -= item.length;
item = item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '');
}
if (i !== length - 1) {
const [bullet] = this._bulletRegExp.exec(itemMatch[i + 1]);
if (ordered ? bullet.length === 1 || (!parent && bullet[bullet.length - 1] === ')') : (bullet.length > 1)) {
const addBack = itemMatch.slice(i + 1).join('\n');
list.raw = list.raw.substring(0, list.raw.length - addBack.length);
i = length - 1;
}
}
let loose = next || /\n\n(?!\s*$)/.test(item);
if (i !== length - 1) {
next = item.charAt(item.length - 1) === '\n';
if (!loose) {
loose = next;
}
}
if (loose) {
list.loose = true;
}
const task = /^\[[ xX]\] /.test(item);
let checked = undefined;
if (task) {
checked = item[1] !== ' ';
item = item.replace(/^\[[ xX]\] +/, '');
}
list.items.push({ type: 'list_item', raw, task: task, checked: checked, loose: loose, text: item });
}
source = source.substring(list.raw.length);
for (const item of list.items) {
item.tokens = this._tokenize(item.text, [], links, false);
}
tokens.push(list);
continue;
}
match = this._htmlRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
tokens.push({ type: 'html', pre: (match[1] === 'pre' || match[1] === 'script' || match[1] === 'style'), text: match[0] });
continue;
}
if (top) {
match = this._defRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
match[3] = match[3] ? match[3].substring(1, match[3].length - 1) : match[3];
const tag = match[1].toLowerCase().replace(/\s+/g, ' ');
if (!links.has(tag)) {
links.set(tag, { href: match[2], title: match[3] });
}
continue;
}
}
match = this._tableRegExp.exec(source);
if (match) {
const header = this._splitCells(match[1].replace(/^ *| *\| *$/g, ''));
const align = match[2].replace(/^ *|\| *$/g, '').split(/ *\| */);
if (header.length === align.length) {
const cells = match[3] ? match[3].replace(/\n$/, '').split('\n') : [];
const token = { type: 'table', header: header, align: align, cells: cells, raw: match[0] };
for (let i = 0; i < token.align.length; i++) {
if (/^ *-+: *$/.test(token.align[i])) {
token.align[i] = 'right';
} else if (/^ *:-+: *$/.test(token.align[i])) {
token.align[i] = 'center';
} else if (/^ *:-+ *$/.test(token.align[i])) {
token.align[i] = 'left';
} else {
token.align[i] = null;
}
}
token.cells = token.cells.map((cell) => this._splitCells(cell.replace(/^ *\| *| *\| *$/g, ''), token.header.length));
source = source.substring(token.raw.length);
tokens.push(token);
continue;
}
}
match = this._lheadingRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
tokens.push({ type: 'heading', depth: match[2].charAt(0) === '=' ? 1 : 2, text: match[1] });
continue;
}
if (top) {
match = this._paragraphRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
tokens.push({ type: 'paragraph', text: match[1].charAt(match[1].length - 1) === '\n' ? match[1].slice(0, -1) : match[1] });
continue;
}
}
match = this._textRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
const lastToken = tokens[tokens.length - 1];
if (lastToken && lastToken.type === 'text') {
lastToken.text += '\n' + match[0];
} else {
tokens.push({ type: 'text', text: match[0] });
}
continue;
}
throw new Error("Unexpected '" + source.charCodeAt(0) + "'.");
}
return tokens;
}
_tokenizeInline(source, links, inLink, inRawBlock, prevChar) {
const tokens = [];
let maskedSource = source;
if (links.size > 0) {
while (maskedSource) {
const match = this._reflinkSearchRegExp.exec(maskedSource);
if (match) {
if (links.has(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {
maskedSource = maskedSource.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSource.slice(this._reflinkSearchRegExp.lastIndex);
}
continue;
}
break;
}
}
while (maskedSource) {
const match = this._blockSkipRegExp.exec(maskedSource);
if (match) {
maskedSource = maskedSource.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSource.slice(this._blockSkipRegExp.lastIndex);
continue;
}
break;
}
while (source) {
let match = this._escapeRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
tokens.push({ type: 'escape', text: this._escape(match[1]) });
continue;
}
match = this._tagRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
if (!inLink && /^/i.test(match[0])) {
inLink = false;
}
if (!inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(match[0])) {
inRawBlock = true;
} else if (inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(match[0])) {
inRawBlock = false;
}
tokens.push({ type: 'html', raw: match[0], text: match[0] });
continue;
}
match = this._linkRegExp.exec(source);
if (match) {
let index = -1;
const [, , ref] = match;
if (ref.indexOf(')') !== -1) {
let level = 0;
for (let i = 0; i < ref.length; i++) {
switch (ref[i]) {
case '\\':
i++;
break;
case '(':
level++;
break;
case ')':
level--;
if (level < 0) {
index = i;
i = ref.length;
}
break;
default:
break;
}
}
}
if (index > -1) {
const length = (match[0].indexOf('!') === 0 ? 5 : 4) + match[1].length + index;
match[2] = match[2].substring(0, index);
match[0] = match[0].substring(0, length).trim();
match[3] = '';
}
const title = (match[3] ? match[3].slice(1, -1) : '').replace(this._escapesRegExp, '$1');
const href = match[2].trim().replace(/^<([\s\S]*)>$/, '$1').replace(this._escapesRegExp, '$1');
const token = this._outputLink(match, href, title);
source = source.substring(match[0].length);
if (token.type === 'link') {
token.tokens = this._tokenizeInline(token.text, links, true, inRawBlock, '');
}
tokens.push(token);
continue;
}
match = this._reflinkRegExp.exec(source) || this._nolinkRegExp.exec(source);
if (match) {
let link = (match[2] || match[1]).replace(/\s+/g, ' ');
link = links.get(link.toLowerCase());
if (!link || !link.href) {
const text = match[0].charAt(0);
source = source.substring(text.length);
tokens.push({ type: 'text', text: text });
} else {
source = source.substring(match[0].length);
const token = this._outputLink(match, link);
if (token.type === 'link') {
token.tokens = this._tokenizeInline(token.text, links, true, inRawBlock, '');
}
tokens.push(token);
}
continue;
}
match = this._strongStartRegExp.exec(source);
if (match && (!match[1] || (match[1] && (prevChar === '' || this._punctuationRegExp.exec(prevChar))))) {
const masked = maskedSource.slice(-1 * source.length);
const endReg = match[0] === '**' ? this._strongEndAstRegExp : this._strongEndUndRegExp;
endReg.lastIndex = 0;
let cap;
while ((match = endReg.exec(masked)) != null) {
cap = this._strongMiddleRegExp.exec(masked.slice(0, match.index + 3));
if (cap) {
break;
}
}
if (cap) {
const text = source.substring(2, cap[0].length - 2);
source = source.substring(cap[0].length);
tokens.push({ type: 'strong', text: text, tokens: this._tokenizeInline(text, links, inLink, inRawBlock, '') });
continue;
}
}
match = this._emStartRegExp.exec(source);
if (match && (!match[1] || (match[1] && (prevChar === '' || this._punctuationRegExp.exec(prevChar))))) {
const masked = maskedSource.slice(-1 * source.length);
const endReg = match[0] === '*' ? this._emEndAstRegExp : this._emEndUndRegExp;
endReg.lastIndex = 0;
let cap;
while ((match = endReg.exec(masked)) != null) {
cap = this._emMiddleRegExp.exec(masked.slice(0, match.index + 2));
if (cap) {
break;
}
}
if (cap) {
const text = source.slice(1, cap[0].length - 1);
source = source.substring(cap[0].length);
tokens.push({ type: 'em', text: text, tokens: this._tokenizeInline(text, links, inLink, inRawBlock, '') });
continue;
}
}
match = this._codespanRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
let content = match[2].replace(/\n/g, ' ');
if (/[^ ]/.test(content) && content.startsWith(' ') && content.endsWith(' ')) {
content = content.substring(1, content.length - 1);
}
tokens.push({ type: 'codespan', text: this._encode(content) });
continue;
}
match = this._brRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
tokens.push({ type: 'br' });
continue;
}
match = this._delRegExp.exec(source);
if (match) {
const [value, text] = match;
source = source.substring(value.length);
tokens.push({ type: 'del', text: text, tokens: this._tokenizeInline(text, links, inLink, inRawBlock, '') });
continue;
}
match = this._autolinkRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
const text = this._escape(match[1]);
const href = match[2] === '@' ? 'mailto:' + text : text;
tokens.push({ type: 'link', text: text, href: href, tokens: [{ type: 'text', raw: text, text }] });
continue;
}
if (!inLink) {
match = this._urlRegExp.exec(source);
if (match) {
const email = match[2] === '@';
let [value] = match;
if (!email) {
let prevCapZero;
do {
prevCapZero = value;
[value] = this._backpedalRegExp.exec(value);
} while (prevCapZero !== value);
}
const text = this._escape(value);
const href = email ? ('mailto:' + text) : (match[1] === 'www.' ? 'http://' + text : text);
source = source.substring(value.length);
tokens.push({ type: 'link', text: text, href: href, tokens: [{ type: 'text', text: text }] });
continue;
}
}
match = this._textspanRegExp.exec(source);
if (match) {
source = source.substring(match[0].length);
prevChar = match[0].slice(-1);
tokens.push({ type: 'text', text: inRawBlock ? match[0] : this._escape(match[0]) });
continue;
}
throw new Error("Unexpected '" + source.charCodeAt(0) + "'.");
}
return tokens;
}
_tokenizeBlock(tokens, links) {
for (const token of tokens) {
switch (token.type) {
case 'paragraph':
case 'text':
case 'heading': {
token.tokens = this._tokenizeInline(token.text, links, false, false, '');
break;
}
case 'table': {
token.tokens = {};
token.tokens.header = token.header.map((header) => this._tokenizeInline(header, links, false, false, ''));
token.tokens.cells = token.cells.map((cell) => cell.map((row) => this._tokenizeInline(row, links, false, false, '')));
break;
}
case 'blockquote': {
this._tokenizeBlock(token.tokens, links);
break;
}
case 'list': {
for (const item of token.items) {
this._tokenizeBlock(item.tokens, links);
}
break;
}
default: {
break;
}
}
}
}
_render(tokens, top) {
let html = '';
while (tokens.length > 0) {
const token = tokens.shift();
switch (token.type) {
case 'space': {
continue;
}
case 'hr': {
html += '
\n';
continue;
}
case 'heading': {
const level = token.depth;
html += '' + this._renderInline(token.tokens) + ' \n';
continue;
}
case 'code': {
const code = token.text;
const [language] = (token.language || '').match(/\S*/);
html += '' + (token.escaped ? code : this._encode(code)) + '
\n';
continue;
}
case 'table': {
let header = '';
let cell = '';
for (let j = 0; j < token.header.length; j++) {
const content = this._renderInline(token.tokens.header[j]);
const align = token.align[j];
cell += '\n' + this._render(token.tokens, true) + '\n'; continue; } case 'list': { const ordered = token.ordered; const start = token.start; const loose = token.loose; let body = ''; for (const item of token.items) { let itemBody = ''; if (item.task) { const checkbox = ' '; if (loose) { if (item.tokens.length > 0 && item.tokens[0].type === 'text') { item.tokens[0].text = checkbox + ' ' + item.tokens[0].text; if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') { item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text; } } else { item.tokens.unshift({ type: 'text', text: checkbox }); } } else { itemBody += checkbox; } } itemBody += this._render(item.tokens, loose); body += '
' + this._renderInline(token.tokens) + '
\n'; continue; } case 'text': { html += top ? '' : ''; html += token.tokens ? this._renderInline(token.tokens) : token.text; while (tokens.length > 0 && tokens[0].type === 'text') { const token = tokens.shift(); html += '\n' + (token.tokens ? this._renderInline(token.tokens) : token.text); } html += top ? '
\n' : ''; continue; } default: { throw new Error("Unexpected token type '" + token.type + "'."); } } } return html; } _renderInline(tokens) { let html = ''; for (const token of tokens) { switch (token.type) { case 'escape': case 'html': case 'text': { html += token.text; break; } case 'link': { const text = this._renderInline(token.tokens); html += '' + text + ''; break; } case 'image': { html += '' + token.text + '';
break;
}
case 'br': {
html += ''; break; } case 'del': { const text = this._renderInline(token.tokens); html += '