tungsten 0.3.2 → 0.3.4

package/dist/hydrate/reconcileHydratedAttributes.sxyt.js

@@ -1,190 +0,0 @@
-import { describe } from 'sxy-test-runner';
-import { expect } from 'chai';
-import { Window } from 'happy-dom';
-import { reconcileHydratedAttributes } from "./reconcileHydratedAttributes.js";
-import { $props, $type } from "../contentNodeSymbols.js";
-const window = new Window();
-const node = (type, props) => ({
-  [$type]: type,
-  [$props]: props
-});
-/** Builds an element from markup the server could have produced. */
-const element = html => {
-  const host = window.document.createElement('div');
-  host.innerHTML = html;
-  // eslint-disable-next-line no-type-assertion/no-type-assertion
-  return host.firstElementChild;
-};
-const attributesOf = domNode => Object.fromEntries([...domNode.attributes].map(attribute => [attribute.name, attribute.value]));
-/** Reconciles and returns what changed. */
-const reconcile = (type, props, html) => {
-  const domNode = element(html);
-  const mismatches = [];
-  reconcileHydratedAttributes(node(type, props), domNode, mismatch => mismatches.push(mismatch));
-  return {
-    domNode,
-    mismatches,
-    attributes: attributesOf(domNode)
-  };
-};
-describe('reconcileHydratedAttributes()', ({
-  it
-}) => {
-  it('patches an attribute whose rendered value differs from the markup', () => {
-    const {
-      attributes,
-      mismatches
-    } = reconcile('div', {
-      style: {
-        backgroundColor: '#123456'
-      }
-    }, '<div style="background-color: #bae3ff;"></div>');
-    expect(attributes.style).to.equal('background-color: #123456;');
-    expect(mismatches.map(mismatch => mismatch.name)).to.deep.equal(['style']);
-  });
-  it('leaves a matching attribute untouched and reports nothing', () => {
-    const {
-      attributes,
-      mismatches
-    } = reconcile('input', {
-      name: 'ref',
-      title: 'Reference'
-    }, '<input name="ref" title="Reference">');
-    expect(attributes).to.deep.equal({
-      name: 'ref',
-      title: 'Reference'
-    });
-    expect(mismatches).to.deep.equal([]);
-  });
-  it('adds an attribute the markup is missing', () => {
-    const {
-      attributes
-    } = reconcile('a', {
-      href: '/x',
-      title: 't'
-    }, '<a href="/x"></a>');
-    expect(attributes).to.deep.equal({
-      href: '/x',
-      title: 't'
-    });
-  });
-  it('removes an attribute the render no longer produces', () => {
-    const {
-      attributes,
-      mismatches
-    } = reconcile('a', {
-      href: '/x'
-    }, '<a href="/x" title="gone"></a>');
-    expect(attributes).to.deep.equal({
-      href: '/x'
-    });
-    expect(mismatches.map(mismatch => mismatch.name)).to.deep.equal(['title']);
-  });
-  it('treats a true boolean as a present, empty attribute', () => {
-    expect(reconcile('button', {
-      disabled: true
-    }, '<button></button>').attributes).to.deep.equal({
-      disabled: ''
-    });
-  });
-  it('removes an attribute whose rendered value is false, null or undefined', () => {
-    expect(reconcile('button', {
-      disabled: false
-    }, '<button disabled></button>').attributes).to.deep.equal({});
-    expect(reconcile('a', {
-      href: null
-    }, '<a href="/x"></a>').attributes).to.deep.equal({});
-    expect(reconcile('a', {
-      href: undefined
-    }, '<a href="/x"></a>').attributes).to.deep.equal({});
-  });
-  // The comparison has to apply the same transformation the server used, or
-  // every element looks mismatched and the whole document gets rewritten.
-  it('applies the server prop transform, so className compares against class', () => {
-    const {
-      attributes,
-      mismatches
-    } = reconcile('div', {
-      className: 'frame Qtc_frame'
-    }, '<div class="frame Qtc_frame"></div>');
-    expect(attributes).to.deep.equal({
-      class: 'frame Qtc_frame'
-    });
-    expect(mismatches).to.deep.equal([]);
-  });
-  it('ignores event handlers rather than writing them as attributes', () => {
-    const {
-      attributes,
-      mismatches
-    } = reconcile('input', {
-      name: 'a',
-      onInput: () => undefined,
-      onClick: () => undefined
-    }, '<input name="a">');
-    expect(attributes).to.deep.equal({
-      name: 'a'
-    });
-    expect(mismatches).to.deep.equal([]);
-  });
-  it('ignores props that are instructions to Tungsten', () => {
-    const {
-      attributes,
-      mismatches
-    } = reconcile('div', {
-      __opaque: true,
-      dangerouslySetInnerHTML: {
-        __html: '<b>x</b>'
-      },
-      id: 'd'
-    }, '<div id="d"></div>');
-    expect(attributes).to.deep.equal({
-      id: 'd'
-    });
-    expect(mismatches).to.deep.equal([]);
-  });
-  // children is rendered content, not an attribute - the server renderer and the client
-  // update path both strip it before comparing/writing attributes, and hydration has to
-  // match or it writes the stringified child list (e.g. "[object Object],[object Object]")
-  // onto every element in the page as a literal "children" attribute.
-  it('does not write children as an attribute', () => {
-    const {
-      attributes,
-      mismatches
-    } = reconcile('div', {
-      id: 'd',
-      children: ['a', 'b']
-    }, '<div id="d"></div>');
-    expect(attributes).to.deep.equal({
-      id: 'd'
-    });
-    expect(mismatches).to.deep.equal([]);
-  });
-  it('reports what changed, for a dev-mode warning', () => {
-    const {
-      mismatches
-    } = reconcile('a', {
-      href: '/new'
-    }, '<a href="/old" title="stale"></a>');
-    expect(mismatches).to.deep.include({
-      name: 'href',
-      expected: '/new',
-      actual: '/old'
-    });
-    expect(mismatches).to.deep.include({
-      name: 'title',
-      expected: null,
-      actual: 'stale'
-    });
-  });
-  it('clears the checked property when removing a checked attribute', () => {
-    const domNode = element('<input type="checkbox" checked>');
-    // eslint-disable-next-line no-type-assertion/no-type-assertion
-    const checkbox = domNode;
-    expect(checkbox.checked).to.equal(true);
-    reconcileHydratedAttributes(node('input', {
-      type: 'checkbox'
-    }), domNode);
-    expect(checkbox.checked).to.equal(false);
-    expect(domNode.hasAttribute('checked')).to.equal(false);
-  });
-});

package/dist/importDevModuleWithRetry.sxyt.d.ts

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

package/dist/importDevModuleWithRetry.sxyt.d.ts.map

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

package/dist/importDevModuleWithRetry.sxyt.js

@@ -1,104 +0,0 @@
-import { expect } from 'chai';
-import { describe } from 'sxy-test-runner';
-import { mkdtemp, rm, writeFile } from 'fs/promises';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { importDevModuleWithRetry, isTransientDevModuleError } from "./importDevModuleWithRetry.js";
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-async function makeFixture() {
-  const dir = await mkdtemp(join(tmpdir(), 'tungsten-import-dev-module-retry-'));
-  const depPath = join(dir, 'dep.mjs');
-  const entryPath = join(dir, 'entry.mjs');
-  // dep.mjs never changes - it's the entry file itself that's momentarily
-  // stale on disk, exactly like Home.js briefly still reading its
-  // pre-rename import statement while Button.js has already been rewritten
-  await writeFile(depPath, `export const NewName = 2\n`);
-  await writeFile(entryPath, `export { OldName as NewName } from './dep.mjs'\n`);
-  return {
-    dir,
-    depPath,
-    entryPath
-  };
-}
-describe('importDevModuleWithRetry()', ({
-  it
-}) => {
-  it(`rides out a transient module-shape mismatch, succeeding once the entry file itself catches up`, async () => {
-    const {
-      dir,
-      entryPath
-    } = await makeFixture();
-    try {
-      // simulate the entry file's own recompile (e.g. babel finishing
-      // its pass over Home.tsx) landing a little after this request
-      // started - the exact race this helper exists for
-      void delay(150).then(() => writeFile(entryPath, `export { NewName } from './dep.mjs'\n`));
-      const module = await importDevModuleWithRetry(`file://${entryPath}`, 10, 50);
-      expect(module.NewName).to.equal(2);
-    } finally {
-      await rm(dir, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-  it(`gives up and throws the real error once attempts are exhausted`, async () => {
-    const {
-      dir,
-      entryPath
-    } = await makeFixture();
-    try {
-      let threw = false;
-      try {
-        await importDevModuleWithRetry(`file://${entryPath}`, 3, 20);
-      } catch (e) {
-        threw = true;
-        expect(String(e)).to.contain('does not provide an export');
-      }
-      expect(threw).to.equal(true);
-    } finally {
-      await rm(dir, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-  it(`does not retry a genuine, unrelated error - so real bugs still surface immediately`, async () => {
-    const dir = await mkdtemp(join(tmpdir(), 'tungsten-import-dev-module-retry-real-error-'));
-    try {
-      const brokenPath = join(dir, 'broken.mjs');
-      await writeFile(brokenPath, `this is not valid javascript {{{\n`);
-      const start = Date.now();
-      let threw = false;
-      try {
-        await importDevModuleWithRetry(`file://${brokenPath}`, 10, 200);
-      } catch {
-        threw = true;
-      }
-      expect(threw).to.equal(true);
-      // a real syntax error must not be retried - if it were, this would
-      // take multiple * 200ms delays instead of failing on the first attempt
-      expect(Date.now() - start).to.be.lessThan(200);
-    } finally {
-      await rm(dir, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-});
-describe('isTransientDevModuleError()', ({
-  it
-}) => {
-  it(`recognizes a bare "X is not defined" ReferenceError - the within-file version of the same race, seen live when a file's JSX still referenced a just-renamed import mid-multi-step-edit`, () => {
-    expect(isTransientDevModuleError(new ReferenceError('Button is not defined'))).to.equal(true);
-  });
-  it('does not match a differently-shaped ReferenceError, to stay a narrow signal', () => {
-    expect(isTransientDevModuleError(new ReferenceError('Cannot access X before initialization'))).to.equal(false);
-  });
-  it('does not match an unrelated TypeError', () => {
-    expect(isTransientDevModuleError(new TypeError(`Cannot read properties of undefined (reading 'foo')`))).to.equal(false);
-  });
-});

package/dist/innerHtmlFromProps.sxyt.d.ts

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

package/dist/innerHtmlFromProps.sxyt.d.ts.map

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

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":""}