tungsten 0.3.2 → 0.3.3

package/dist/innerHtmlFromProps.sxyt.js

@@ -1,99 +0,0 @@
-import { describe } from 'sxy-test-runner';
-import { expect } from 'chai';
-import { innerHtmlFromProps } from "./innerHtmlFromProps.js";
-import { renderingNodeToHtml } from "./render/renderingTreeToHtml.js";
-import { $props, $type } from "./contentNodeSymbols.js";
-const props = value => value;
-// `found: true` short-circuits the <head> handling, which is all these
-// element-level tests need from HeadData.
-// eslint-disable-next-line no-type-assertion/no-type-assertion
-const noHeadData = {
-  found: true
-};
-const renderHtml = (type, nodeProps) => renderingNodeToHtml(
-// eslint-disable-next-line no-type-assertion/no-type-assertion
-{
-  [$type]: type,
-  [$props]: nodeProps
-}, false, noHeadData, null);
-describe('innerHtmlFromProps()', ({
-  it
-}) => {
-  it('returns null when the element does not use dangerouslySetInnerHTML', () => {
-    expect(innerHtmlFromProps('div', props({
-      children: 'hello'
-    }), true)).to.equal(null);
-  });
-  it('returns the raw markup', () => {
-    expect(innerHtmlFromProps('div', props({
-      dangerouslySetInnerHTML: {
-        __html: '<b>hi</b>'
-      }
-    }), false)).to.equal('<b>hi</b>');
-  });
-  it('rejects an element carrying both raw markup and children', () => {
-    expect(() => innerHtmlFromProps('div', props({
-      dangerouslySetInnerHTML: {
-        __html: '<b>hi</b>'
-      },
-      children: 'hello'
-    }), true)).to.throw(/both dangerouslySetInnerHTML and children/);
-  });
-  it('rejects a prop that is not of the form { __html }', () => {
-    // eslint-disable-next-line no-type-assertion/no-type-assertion
-    const bad = {
-      dangerouslySetInnerHTML: '<b>hi</b>'
-    };
-    expect(() => innerHtmlFromProps('div', bad, false)).to.throw(/{ __html: '...' }/);
-  });
-  it('rejects a null or undefined __html', () => {
-    // eslint-disable-next-line no-type-assertion/no-type-assertion
-    const nulled = {
-      dangerouslySetInnerHTML: {
-        __html: null
-      }
-    };
-    expect(() => innerHtmlFromProps('div', nulled, false)).to.throw(/__html is null/);
-  });
-});
-describe('dangerouslySetInnerHTML rendering', ({
-  it
-}) => {
-  it('writes the markup into the element unescaped', async () => {
-    expect(await renderHtml('div', {
-      dangerouslySetInnerHTML: {
-        __html: '<p>Bonuses.</p>'
-      }
-    })).to.equal('<div><p>Bonuses.</p></div>');
-  });
-  it('does not leak the prop into the markup as an attribute', async () => {
-    const html = await renderHtml('div', {
-      id: 'tip',
-      dangerouslySetInnerHTML: {
-        __html: '<b>hi</b>'
-      }
-    });
-    expect(html).to.not.include('dangerouslySetInnerHTML');
-    expect(html).to.not.include('[object Object]');
-    expect(html).to.equal('<div id="tip"><b>hi</b></div>');
-  });
-  it('escapes ordinary children, so the switch is per element', async () => {
-    expect(await renderHtml('div', {
-      children: '<p>Bonuses.</p>'
-    })).to.equal('<div>&lt;p&gt;Bonuses.&lt;/p&gt;</div>');
-  });
-  it('rejects raw markup on a void element', async () => {
-    let thrown = null;
-    try {
-      await renderHtml('br', {
-        dangerouslySetInnerHTML: {
-          __html: '<b>hi</b>'
-        }
-      });
-    } catch (error) {
-      thrown = error;
-    }
-    expect(thrown).to.be.an('error');
-    expect(thrown.message).to.include('void type');
-  });
-});

package/dist/postcssPlugins/parseSelectors.sxyt.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=parseSelectors.sxyt.d.ts.map

package/dist/postcssPlugins/parseSelectors.sxyt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseSelectors.sxyt.d.ts","sourceRoot":"","sources":["../../src/postcssPlugins/parseSelectors.sxyt.ts"],"names":[],"mappings":""}

package/dist/postcssPlugins/parseSelectors.sxyt.js

@@ -1,62 +0,0 @@
-import { describe } from 'sxy-test-runner';
-import { parseSelectors } from "./parseSelectors.js";
-describe('parseSelectors()', ({
-  it
-}) => {
-  const input = 'html';
-  it(`parses out a tag selector from '${input}'`, () => {
-    const selectors = parseSelectors(input);
-    selectors.should.deep.equal(['html']);
-  });
-  const input2 = 'html body';
-  it(`parses out two tag selectors from '${input2}'`, () => {
-    const selectors = parseSelectors(input2);
-    selectors.should.deep.equal(['html', 'body']);
-  });
-  const input3 = '.foo';
-  it(`parses out a class selector from '${input3}'`, () => {
-    const selectors = parseSelectors(input3);
-    selectors.should.deep.equal(['.foo']);
-  });
-  const input4 = '  .foo ';
-  it(`parses out a class selector with whitespace from '${input4}'`, () => {
-    const selectors = parseSelectors(input4);
-    selectors.should.deep.equal(['.foo']);
-  });
-  const input5 = '.foo .bar';
-  it(`parses out a two class selectors from '${input5}'`, () => {
-    const selectors = parseSelectors(input5);
-    selectors.should.deep.equal(['.foo', '.bar']);
-  });
-  const input6 = 'html.bar';
-  it(`parses out connected tag and class '${input6}'`, () => {
-    const selectors = parseSelectors(input6);
-    selectors.should.deep.equal(['html', '.bar']);
-  });
-  const input7 = '.foo.bar';
-  it(`parses out connected classes '${input7}'`, () => {
-    const selectors = parseSelectors(input7);
-    selectors.should.deep.equal(['.foo', '.bar']);
-  });
-  const input8 = 'html#foo.bar';
-  it(`parses out connected tag, id and class '${input8}'`, () => {
-    const selectors = parseSelectors(input8);
-    selectors.should.deep.equal(['html', '#foo', '.bar']);
-  });
-  const input9 = 'html[lang="en"]';
-  it(`parses out tag with attribute selector from '${input9}'`, () => {
-    const selectors = parseSelectors(input9);
-    selectors.should.deep.equal(['html', '[lang="en"]']);
-  });
-  const input10 = ':i(div)';
-  it(`parses out :i pseudo '${input10}'`, () => {
-    const selectors = parseSelectors(input10);
-    selectors.should.deep.equal([':i(div)']);
-  });
-  const input11 = 'html :i(div)';
-  it(`parses out tag then :i pseudo '${input11}'`, () => {
-    const selectors = parseSelectors(input11);
-    //console.log('selectors', selectors)
-    selectors.should.deep.equal(['html', ':i(div)']);
-  });
-});

package/dist/postcssPlugins/parseSelectorsRich.sxyt.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=parseSelectorsRich.sxyt.d.ts.map

package/dist/postcssPlugins/parseSelectorsRich.sxyt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseSelectorsRich.sxyt.d.ts","sourceRoot":"","sources":["../../src/postcssPlugins/parseSelectorsRich.sxyt.ts"],"names":[],"mappings":""}

package/dist/postcssPlugins/parseSelectorsRich.sxyt.js

@@ -1,155 +0,0 @@
-import { describe } from 'sxy-test-runner';
-import { parseSelectorsRich } from "./parseSelectorsRich.js";
-function tagSelector(tag) {
-  return {
-    type: 'tag',
-    content: tag,
-    valid: true
-  };
-}
-function idSelector(id) {
-  return {
-    type: 'id',
-    content: id,
-    valid: true
-  };
-}
-function classSelector(className) {
-  return {
-    type: 'class',
-    content: className,
-    valid: true
-  };
-}
-function pseudoSelector(pesudo) {
-  return {
-    type: 'pseudo-class',
-    content: pesudo,
-    valid: true
-  };
-}
-function pseudoElementSelector(pseudoElement) {
-  return {
-    type: 'pseudo-element',
-    content: pseudoElement,
-    valid: true
-  };
-}
-function attributeSelector(attribute) {
-  return {
-    type: 'attribute',
-    content: attribute,
-    valid: true
-  };
-}
-function whitespace() {
-  return {
-    type: 'whitespace',
-    content: ' ',
-    valid: true
-  };
-}
-describe('parseSelectorsRich()', ({
-  it
-}) => {
-  const input = 'html';
-  it(`parses out a tag selector from '${input}'`, () => {
-    const selectors = parseSelectorsRich(input);
-    selectors.should.deep.equal([tagSelector('html')]);
-  });
-  const input2 = 'html body';
-  it(`parses out two tag selectors from '${input2}'`, () => {
-    const selectors = parseSelectorsRich(input2);
-    // console.log('selectors', selectors)
-    // console.log('expected', [
-    //     tagSelector('html'),
-    //     tagSelector('body')
-    // ])
-    selectors.should.deep.equal([tagSelector('html'), whitespace(), tagSelector('body')]);
-  });
-  const input3 = '.foo';
-  it(`parses out a class selector from '${input3}'`, () => {
-    const selectors = parseSelectorsRich(input3);
-    selectors.should.deep.equal([classSelector('.foo')]);
-  });
-  const input4 = '  .foo ';
-  it(`parses out a class selector with whitespace from '${input4}'`, () => {
-    const selectors = parseSelectorsRich(input4);
-    selectors.should.deep.equal([whitespace(), classSelector('.foo'), whitespace()]);
-  });
-  const input5 = '.foo .bar';
-  it(`parses out a two class selectors from '${input5}'`, () => {
-    const selectors = parseSelectorsRich(input5);
-    selectors.should.deep.equal([classSelector('.foo'), whitespace(), classSelector('.bar')]);
-  });
-  const input6 = 'html.bar';
-  it(`parses out connected tag and class '${input6}'`, () => {
-    const selectors = parseSelectorsRich(input6);
-    selectors.should.deep.equal([tagSelector('html'), classSelector('.bar')]);
-  });
-  const input7 = '.foo.bar';
-  it(`parses out connected classes '${input7}'`, () => {
-    const selectors = parseSelectorsRich(input7);
-    selectors.should.deep.equal([classSelector('.foo'), classSelector('.bar')]);
-  });
-  const input8 = 'html#foo.bar';
-  it(`parses out connected tag, id and class '${input8}'`, () => {
-    const selectors = parseSelectorsRich(input8);
-    selectors.should.deep.equal([tagSelector('html'), idSelector('#foo'), classSelector('.bar')]);
-  });
-  const input9 = 'html[lang="en"]';
-  it(`parses out tag with attribute selector from '${input9}'`, () => {
-    const selectors = parseSelectorsRich(input9);
-    // console.log(JSON.stringify(selectors))
-    // console.log(JSON.stringify([
-    //     tagSelector('html'),
-    //     attributeSelector('[lang="en"]')
-    // ]))
-    selectors.should.deep.equal([tagSelector('html'), attributeSelector('[lang="en"]')]);
-  });
-  const input10 = 'html[lang="en"]';
-  it(`parses out tag with attribute selector from '${input10}'`, () => {
-    const selectors = parseSelectorsRich(input10);
-    // console.log(JSON.stringify(selectors))
-    // console.log(JSON.stringify([
-    //     tagSelector('html'),
-    //     attributeSelector('[lang="en"]')
-    // ]))
-    selectors.should.deep.equal([tagSelector('html'), attributeSelector('[lang="en"]')]);
-  });
-  const input11 = 'a:hover';
-  it(`parses out :hover pseudo on an anchor in '${input11}'`, () => {
-    const selectors = parseSelectorsRich(input11);
-    // console.log(JSON.stringify(selectors))
-    // console.log(JSON.stringify([
-    //     tagSelector('a'),
-    //     pseudoSelector(':hover')
-    // ]))
-    selectors.should.deep.equal([tagSelector('a'), pseudoSelector(':hover')]);
-  });
-  const input12 = ':i(div)';
-  it(`parses out :i pseudo '${input12}'`, () => {
-    const selectors = parseSelectorsRich(input12);
-    selectors.should.deep.equal([pseudoSelector(':i(div)')]);
-  });
-  const input13 = 'html :i(div)';
-  it(`parses out tag then :i pseudo '${input13}'`, () => {
-    const selectors = parseSelectorsRich(input13);
-    selectors.should.deep.equal([tagSelector('html'), whitespace(), pseudoSelector(':i(div)')]);
-  });
-  const input14 = 'summary::before';
-  it(`parses out a pseudo-element from '${input14}'`, () => {
-    const selectors = parseSelectorsRich(input14);
-    selectors.should.deep.equal([tagSelector('summary'), pseudoElementSelector('::before')]);
-  });
-  const input15 = 'summary::-webkit-details-marker';
-  it(`parses out a vendor prefixed pseudo-element from '${input15}'`, () => {
-    const selectors = parseSelectorsRich(input15);
-    selectors.should.deep.equal([tagSelector('summary'), pseudoElementSelector('::-webkit-details-marker')]);
-  });
-  const input16 = 'input:-moz-focusring';
-  it(`parses out a vendor prefixed pseudo-class from '${input16}'`, () => {
-    const selectors = parseSelectorsRich(input16);
-    selectors.should.deep.equal([tagSelector('input'), pseudoSelector(':-moz-focusring')]);
-  });
-});

package/dist/rawHtml/parseHtml.sxyt.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=parseHtml.sxyt.d.ts.map

package/dist/rawHtml/parseHtml.sxyt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseHtml.sxyt.d.ts","sourceRoot":"","sources":["../../src/rawHtml/parseHtml.sxyt.ts"],"names":[],"mappings":""}

package/dist/rawHtml/parseHtml.sxyt.js

@@ -1,239 +0,0 @@
-import { describe } from 'sxy-test-runner';
-import { expect } from 'chai';
-import { parseHtml } from "./parseHtml.js";
-import { safeHtmlAllowList } from "./safeHtmlAllowList.js";
-import { decodeHtmlEntities } from "./decodeHtmlEntities.js";
-import { tokenizeHtml } from "./tokenizeHtml.js";
-import { renderingNodeToHtml } from "../render/renderingTreeToHtml.js";
-import { $props, $type } from "../contentNodeSymbols.js";
-// `found: true` short-circuits the <head> handling these tests do not need.
-// eslint-disable-next-line no-type-assertion/no-type-assertion
-const noHeadData = {
-  found: true
-};
-// Renders a parsed tree back to markup. The renderer takes a RenderingNode,
-// which for plain HTML content is structurally what parseHtml returns.
-const render = async content => renderingNodeToHtml(
-// eslint-disable-next-line no-type-assertion/no-type-assertion
-content, false, noHeadData, null);
-const roundTrip = html => render(parseHtml(html));
-describe('decodeHtmlEntities()', ({
-  it
-}) => {
-  it('decodes named, decimal and hex references', () => {
-    expect(decodeHtmlEntities('&pound;100 &amp; more')).to.equal('£100 & more');
-    expect(decodeHtmlEntities('&#65;&#66;')).to.equal('AB');
-    expect(decodeHtmlEntities('&#x41;&#X42;')).to.equal('AB');
-  });
-  it('leaves unknown and malformed references exactly as written', () => {
-    expect(decodeHtmlEntities('&notareal; &amp')).to.equal('&notareal; &amp');
-    expect(decodeHtmlEntities('a & b')).to.equal('a & b');
-  });
-  it('does not throw on out-of-range numeric references', () => {
-    expect(decodeHtmlEntities('&#xFFFFFFFF;')).to.equal('&#xFFFFFFFF;');
-    expect(decodeHtmlEntities('&#0;')).to.equal('&#0;');
-    expect(decodeHtmlEntities('&#xD800;')).to.equal('&#xD800;');
-  });
-});
-describe('tokenizeHtml()', ({
-  it
-}) => {
-  it('reads attributes in every quoting style', () => {
-    const [token] = tokenizeHtml('<a href="/x" title=\'y\' data-n=3 hidden>');
-    expect(token?.kind).to.equal('open');
-    expect(token?.kind === 'open' && token.attributes).to.deep.equal({
-      href: '/x',
-      title: 'y',
-      'data-n': '3',
-      hidden: true
-    });
-  });
-  it('drops comments and doctypes', () => {
-    expect(tokenizeHtml('<!doctype html><!-- hi --><b>x</b>').map(token => token.kind)).to.deep.equal(['open', 'text', 'close']);
-  });
-  it('treats a bare < as text', () => {
-    expect(tokenizeHtml('5 < 6 and 7 > 2')).to.deep.equal([{
-      kind: 'text',
-      text: '5 < 6 and 7 > 2'
-    }]);
-  });
-  it('takes script content as literal text, not markup', () => {
-    expect(tokenizeHtml('<script>if (a<b) x()</script>').map(token => token.kind)).to.deep.equal(['open', 'text', 'close']);
-  });
-  // scanning for the first > would cut this tag short and build a tree the
-  // browser disagrees with
-  it('does not end a tag at a > inside a quoted attribute value', () => {
-    const [token] = tokenizeHtml('<a title="a > b" href="/x">');
-    expect(token?.kind === 'open' && token.attributes).to.deep.equal({
-      title: 'a > b',
-      href: '/x'
-    });
-  });
-});
-describe('parseHtml()', ({
-  it
-}) => {
-  it('returns null for empty and non-string input', () => {
-    expect(parseHtml('')).to.equal(null);
-    // eslint-disable-next-line no-type-assertion/no-type-assertion
-    expect(parseHtml(undefined)).to.equal(null);
-  });
-  it('builds an element tree with decoded text', async () => {
-    const content = parseHtml('<p>Bonus &pound;100</p>');
-    // eslint-disable-next-line no-type-assertion/no-type-assertion
-    const node = content;
-    expect(node[$type]).to.equal('p');
-    expect(node[$props].children).to.equal('Bonus £100');
-  });
-  it('maps class to className and style to css, which the renderer expects', async () => {
-    expect(await roundTrip('<p class="a b" style="color: red">x</p>')).to.equal('<p class="a b" style="color: red">x</p>');
-  });
-  it('keeps sibling paragraphs as siblings rather than nesting them', async () => {
-    expect(await roundTrip('<p>one</p><p>two</p>')).to.equal('<p>one</p><p>two</p>');
-  });
-  // The rule that broke the dashboard: a browser closes an open <p> at the
-  // next block-level start tag, so the parser must too, or the tree and the
-  // DOM disagree and hydration walks off the end.
-  it('applies the implied end tag that closes a p at a block element', async () => {
-    expect(await roundTrip('<p>one<div>two</div>')).to.equal('<p>one</p><div>two</div>');
-  });
-  it('closes list items and table cells implicitly', async () => {
-    expect(await roundTrip('<ul><li>a<li>b</ul>')).to.equal('<ul><li>a</li><li>b</li></ul>');
-    expect(await roundTrip('<table><tbody><tr><td>a<td>b</tbody></table>')).to.equal('<table><tbody><tr><td>a</td><td>b</td></tr></tbody></table>');
-  });
-  // Parsers disagree over whether whitespace survives inside a table, so the
-  // markup carries none — the tree and the DOM then agree either way.
-  it('drops whitespace between table tags', async () => {
-    expect(await roundTrip('<table>\n<tbody>\n<tr><td>a</td></tr>\n</tbody>\n</table>')).to.equal('<table><tbody><tr><td>a</td></tr></tbody></table>');
-  });
-  it('foster-parents real text out to just before the table', async () => {
-    expect(await roundTrip('<table><tbody>stray<tr><td>a</td></tr></tbody></table>')).to.equal('stray<table><tbody><tr><td>a</td></tr></tbody></table>');
-  });
-  it('leaves stray text alone in lists and selects, which do not relocate it', async () => {
-    expect(await roundTrip('<ul>loose<li>a</li></ul>')).to.equal('<ul>loose<li>a</li></ul>');
-  });
-  it('handles void and self-closing elements', async () => {
-    expect(await roundTrip('<p>a<br>b<img src="/x" />c</p>')).to.equal('<p>a<br />b<img src="/x" />c</p>');
-  });
-});
-describe('parseHtml() resilience', ({
-  it
-}) => {
-  // "Safe" here means it always produces something renderable, whatever it
-  // is handed. None of these may throw.
-  const malformed = ['<p>unclosed', '</p>stray end tag', '<p><b>crossed</p></b>', '<<>><p>x</p>', '<p class="unterminated>x</p>', '<!-- never closed', '<p', '<>', '<p><p><p><p>deep', '&&&;&#;&#x;', '<div><span></div></span>', '<TABLE><TR><TD>caps</TD></TR></TABLE>'];
-  for (const html of malformed) {
-    it(`does not throw on ${JSON.stringify(html)}`, async () => {
-      const content = parseHtml(html);
-      const rendered = await render(content);
-      expect(rendered).to.be.a('string');
-    });
-  }
-  it('keeps the text of an unclosed element', async () => {
-    expect(await roundTrip('<p>unclosed')).to.equal('<p>unclosed</p>');
-  });
-  it('ignores a stray end tag but keeps its text', async () => {
-    expect(await roundTrip('</p>after')).to.equal('after');
-  });
-});
-describe('parseHtml() sanitizing', ({
-  it
-}) => {
-  it('drops script elements together with their contents', async () => {
-    expect(await roundTrip('<p>a</p><script>alert(1)</script><p>b</p>')).to.equal('<p>a</p><p>b</p>');
-  });
-  it('drops on* handler attributes', async () => {
-    expect(await roundTrip('<p onclick="alert(1)" onerror="x()" title="keep">a</p>')).to.equal('<p title="keep">a</p>');
-  });
-  it('drops javascript: urls, including obfuscated ones', async () => {
-    expect(await roundTrip('<a href="javascript:alert(1)">x</a>')).to.equal('<a>x</a>');
-    expect(await roundTrip('<a href="  JaVaScRiPt:alert(1)">x</a>')).to.equal('<a>x</a>');
-    // browsers ignore control characters inside the scheme, so this runs
-    expect(await roundTrip('<a href="java\tscript:alert(1)">x</a>')).to.equal('<a>x</a>');
-    expect(await roundTrip('<a href="vbscript:x">x</a>')).to.equal('<a>x</a>');
-    expect(await roundTrip('<a href="/safe">x</a>')).to.equal('<a href="/safe">x</a>');
-    expect(await roundTrip('<a href="https://x.test/">x</a>')).to.equal('<a href="https://x.test/">x</a>');
-  });
-  it('bars data: urls from navigation but allows them as image sources', async () => {
-    expect(await roundTrip('<a href="data:text/html,hello">x</a>')).to.equal('<a>x</a>');
-    expect(await roundTrip('<img src="data:image/png;base64,AAAA" />')).to.equal('<img src="data:image/png;base64,AAAA" />');
-  });
-  it('keeps handler attributes out even when sanitizing is off', async () => {
-    // Tungsten reads on* props as event listeners, so a string there is a
-    // hydration fault, not just a security question.
-    const content = parseHtml('<p onclick="alert(1)">a</p>', {
-      sanitize: false
-    });
-    expect(await render(content)).to.equal('<p>a</p>');
-  });
-  it('keeps scripts when sanitizing is turned off', async () => {
-    const content = parseHtml('<div><script>x()</script></div>', {
-      sanitize: false
-    });
-    expect(await render(content)).to.equal('<div><script>x()</script></div>');
-  });
-});
-describe('parseHtml() allow lists', ({
-  it
-}) => {
-  const withList = (html, allowList) => render(parseHtml(html, {
-    allowList
-  }));
-  const onlyEmphasis = {
-    tags: ['p', 'em'],
-    attributes: []
-  };
-  it('keeps listed tags and unwraps unlisted ones, preserving their text', async () => {
-    expect(await withList('<p>keep <em>this</em> and <b>that</b></p>', onlyEmphasis)).to.equal('<p>keep <em>this</em> and that</p>');
-  });
-  it('unwraps an unlisted element without losing its listed descendants', async () => {
-    expect(await withList('<div><p>inner</p></div>', onlyEmphasis)).to.equal('<p>inner</p>');
-  });
-  it('drops program-text elements entirely rather than unwrapping them', async () => {
-    // unwrapping <style> would put its CSS on the page as visible text
-    expect(await withList('<p>a</p><style>p { color: red }</style>', onlyEmphasis)).to.equal('<p>a</p>');
-  });
-  it('keeps only listed attributes', async () => {
-    const list = {
-      tags: ['p'],
-      attributes: ['title']
-    };
-    expect(await withList('<p title="t" id="i" data-x="1">a</p>', list)).to.equal('<p title="t">a</p>');
-  });
-  it('applies per-tag attributes only to their own tag', async () => {
-    const list = {
-      tags: ['a', 'p'],
-      attributes: [],
-      tagAttributes: {
-        a: ['href']
-      }
-    };
-    expect(await withList('<a href="/x">link</a><p href="/y">para</p>', list)).to.equal('<a href="/x">link</a><p>para</p>');
-  });
-});
-describe('safeHtmlAllowList', ({
-  it
-}) => {
-  const safely = html => render(parseHtml(html, {
-    allowList: safeHtmlAllowList
-  }));
-  it('keeps ordinary authored rich text intact', async () => {
-    const html = '<h2>Title</h2><p>Some <strong>bold</strong> and <em>italic</em>.</p>' + '<ul><li>one</li><li>two</li></ul>';
-    expect(await safely(html)).to.equal(html);
-  });
-  it('keeps tables with their layout attributes', async () => {
-    const html = '<table><tbody><tr><th align="left">H</th><td colspan="2">C</td></tr></tbody></table>';
-    expect(await safely(html)).to.equal(html);
-  });
-  it('keeps links and images with their own attributes', async () => {
-    expect(await safely('<a href="/x" target="_blank" rel="noopener">go</a>')).to.equal('<a href="/x" target="_blank" rel="noopener">go</a>');
-    expect(await safely('<img src="/a.png" alt="a" width="10" />')).to.equal('<img src="/a.png" alt="a" width="10" />');
-  });
-  it('strips style attributes, which can disguise the page without any script', async () => {
-    expect(await safely('<p style="position:fixed;top:0">a</p>')).to.equal('<p>a</p>');
-  });
-  it('removes embedding and form elements but keeps their text', async () => {
-    expect(await safely('<iframe src="//evil"></iframe><p>a</p>')).to.equal('<p>a</p>');
-    expect(await safely('<form><p>a</p></form>')).to.equal('<p>a</p>');
-  });
-});

package/dist/render/getFunctionBodyAsString.sxyt.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=getFunctionBodyAsString.sxyt.d.ts.map

package/dist/render/getFunctionBodyAsString.sxyt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getFunctionBodyAsString.sxyt.d.ts","sourceRoot":"","sources":["../../src/render/getFunctionBodyAsString.sxyt.ts"],"names":[],"mappings":""}

package/dist/render/getFunctionBodyAsString.sxyt.js

@@ -1,37 +0,0 @@
-import { describe } from 'sxy-test-runner';
-import { should as setupShould } from 'chai';
-const should = setupShould(); // eslint-disable-line @typescript-eslint/no-unused-vars
-import { getFunctionBodyAsString } from "./getFunctionBodyAsString.js";
-describe('getFunctionBodyAsString()', ({
-  it
-}) => {
-  it('should return the function body of a conventional function as a string', () => {
-    const func = function () {
-      return 'Hello World';
-    };
-    const body = getFunctionBodyAsString(func);
-    //console.log('body', body)
-    body.should.equal('return \'Hello World\';');
-  });
-  it('should handle multi line conventional functions', () => {
-    const func = function () {
-      return 'Hello World';
-    };
-    const body = getFunctionBodyAsString(func);
-    //console.log('body', body)
-    body.should.equal('return \'Hello World\';');
-  });
-  it('should return the function body of a braceless arrow function as a string', () => {
-    const func = () => 'Hello World';
-    const body = getFunctionBodyAsString(func);
-    //console.log('body', body)
-    body.should.equal('return \'Hello World\';');
-  });
-  it('should handle multi line braceless arrow functions', () => {
-    const func = () => 'Hello' + ' World';
-    const body = getFunctionBodyAsString(func);
-    //console.log('body', body)
-    body.should.equal('return \'Hello\' + \' World\';');
-    //body.should.equal('return \'Hello\'\n+ \' World\';')
-  });
-});

package/dist/render/processHead.sxyt.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=processHead.sxyt.d.ts.map

package/dist/render/processHead.sxyt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"processHead.sxyt.d.ts","sourceRoot":"","sources":["../../src/render/processHead.sxyt.ts"],"names":[],"mappings":""}