tungsten 0.1.7 → 0.1.25

package/dist/postcssPlugins/parseSelectorsRich.js

@@ -0,0 +1,276 @@
+import { throwError } from "../throwError.js";
+// | 'attribute-name-search' | 'attribute-name' | 'attribute-equals-search' | 'attribute-equals'
+// | 'attribute-value-search' | 'attribute-value' | 'attribute-end-search'
+export function parseSelectorsRich(selectorGroup) {
+  let mode = 'search';
+  let selectorObject = {
+    type: 'none',
+    content: '',
+    valid: false
+  };
+  const selectorObjects = [];
+  let pseudoOpenBrackets = 0;
+  let pos = 0;
+  while (pos < selectorGroup.length) {
+    const char = selectorGroup[pos];
+    switch (mode) {
+      case 'search':
+        {
+          if (selectorObject.type !== 'none' && selectorObject.content !== '') {
+            selectorObjects.push(selectorObject);
+            selectorObject = {
+              type: 'none',
+              content: '',
+              valid: false
+            };
+          }
+          if (/\s/.test(char)) {
+            // any whitespace
+            mode = 'whitespace';
+            selectorObject = {
+              type: 'whitespace',
+              content: ' ',
+              valid: true
+            };
+            pos++;
+          } else if (/[a-zA-Z]/.test(char)) {
+            mode = 'tag';
+            selectorObject = {
+              type: 'tag',
+              content: char,
+              valid: true
+            };
+            pos++;
+          } else if (/#/.test(char)) {
+            mode = 'id';
+            selectorObject = {
+              type: 'id',
+              content: char,
+              valid: false
+            };
+            pos++;
+          } else if (/[.]/.test(char)) {
+            mode = 'class';
+            selectorObject = {
+              type: 'class',
+              content: char,
+              valid: false
+            };
+            pos++;
+          } else if (/:/.test(char)) {
+            mode = 'pseudo';
+            selectorObject = {
+              type: 'none',
+              // will be pseudo-class or pseudo-element, we will set this later
+              content: char,
+              valid: false
+            };
+            pos++;
+          } else if (/\[/.test(char)) {
+            mode = 'attribute';
+            selectorObject = {
+              type: 'attribute',
+              content: char,
+              valid: false
+            };
+            pos++;
+          } else if (['+', '>'].includes(char)) {
+            // we don't include "," here, because the previous parser                                 
+            // separates comma separated selectors already
+            // save this grammar as a selectorObject, but leave it in search mode
+            // search mode will save this SO on the next iteration, and continue searching
+            // will need to change this if we find longer grammars
+            selectorObject = {
+              type: 'grammar',
+              content: char,
+              valid: true
+            };
+            pos++;
+          } else {
+            // some chars here might be errors
+            throwError('parseSelectorsRich', `Unexpected character when parsing stylesheet: ${char}`);
+            //pos++
+          }
+          break;
+        }
+      case 'whitespace':
+        {
+          if (/\s/.test(char)) {
+            pos++;
+          } else {
+            mode = 'search';
+          }
+          break;
+        }
+      case 'tag':
+        {
+          if (/[a-zA-Z0-9-]/.test(char)) {
+            selectorObject.content += char;
+            pos++;
+          } else {
+            // some chars here should be errors
+            mode = 'search';
+          }
+          break;
+        }
+      case 'id':
+        {
+          if (selectorObject.content.length === 1) {
+            // first char after #
+            if (/[a-zA-Z]/.test(char)) {
+              selectorObject.content += char;
+              selectorObject.valid = true;
+              pos++;
+            } else {
+              // some chars here should be errors
+              mode = 'search';
+            }
+          } else {
+            if (/[a-zA-Z0-9-_:]/.test(char)) {
+              selectorObject.content += char;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          }
+          break;
+        }
+      case 'class':
+        {
+          if (selectorObject.content.length === 1) {
+            // first char after #
+            if (/[a-zA-Z-_]/.test(char)) {
+              selectorObject.content += char;
+              selectorObject.valid = true;
+              pos++;
+            } else {
+              // some chars here should be errors
+              mode = 'search';
+            }
+          } else {
+            if (/[a-zA-Z0-9-_]/.test(char)) {
+              selectorObject.content += char;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          }
+          break;
+        }
+      // TODO -- handle pseudo with brackets
+      case 'pseudo':
+        {
+          if (/[a-zA-Z]/.test(char)) {
+            //console.log('its a pseudo class')
+            selectorObject.type = 'pseudo-class';
+            selectorObject.content += char;
+            //console.log(selectorObject.kind, selectorObject.content)
+            selectorObject.valid = true;
+            mode = 'pseudo-class';
+            pos++;
+          } else if (char === ':') {
+            selectorObject.type === 'pseudo-element';
+            selectorObject.content += char;
+            mode = 'pseudo-element';
+            pos++;
+          } else {
+            mode = 'search';
+          }
+          break;
+        }
+      case 'pseudo-class':
+        {
+          if (pseudoOpenBrackets === 0) {
+            // before any bracket, will never be 0 after opening
+            // because it will cycle mode on closing bracket
+            if (/[a-zA-Z0-9-_]/.test(char)) {
+              // not based on any spec, could not find one
+              selectorObject.content += char;
+              pos++;
+            } else if (char === '(') {
+              selectorObject.content += char;
+              pseudoOpenBrackets++;
+              pos++;
+            } else {
+              mode = 'search';
+            }
+          } else {
+            // after opening bracket
+            switch (char) {
+              case '(':
+                {
+                  selectorObject.content += char;
+                  pseudoOpenBrackets++;
+                  pos++;
+                  break;
+                }
+              case ')':
+                {
+                  selectorObject.content += char;
+                  pseudoOpenBrackets--;
+                  if (pseudoOpenBrackets === 0) {
+                    selectorObject.valid = true;
+                    mode = 'search';
+                  }
+                  pos++;
+                  break;
+                }
+              default:
+                {
+                  selectorObject.content += char;
+                  pos++;
+                }
+            }
+          }
+          break;
+        }
+      case 'pseudo-element':
+        {
+          if (selectorObject.content.length === 2) {
+            // first char after ::
+            if (/[a-zA-Z0-9]/.test(char)) {
+              // not based on any spec, could not find one
+              selectorObject.content += char;
+              selectorObject.valid = true;
+              pos++;
+            } else {
+              // invalid, continue
+              mode = 'search';
+            }
+          } else {
+            if (/[a-zA-Z0-9-_]/.test(char)) {
+              // not based on any spec, could not find one
+              selectorObject.content += char;
+              pos++;
+            } else {
+              // invalid, continue
+              mode = 'search';
+            }
+          }
+          break;
+        }
+      // TODO
+      case 'attribute':
+        {
+          if (char === ']') {
+            selectorObject.content += char;
+            selectorObject.valid = true;
+            mode = 'search';
+            pos++;
+          } else {
+            selectorObject.content += char;
+            pos++;
+          }
+          break;
+        }
+      default:
+        {
+          throwError('parseSelectors', 'invalid mode');
+        }
+    }
+  }
+  //console.log('end sel', JSON.stringify(selectorObject))
+  if (selectorObject.type !== 'none') selectorObjects.push(selectorObject);
+  //console.log(`parsed selectors [${selectorGroup}]:`, selectorObjects)
+  return selectorObjects;
+}

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

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

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

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

package/dist/postcssPlugins/parseSelectorsRich.sxyt.js

@@ -0,0 +1,130 @@
+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 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)')]);
+  });
+});

package/dist/promise.d.ts

@@ -0,0 +1,2 @@
+export declare function promise<T>(func: (resolve: (reason?: any) => void, reject: (reason?: any) => void) => T): Promise<T>;
+//# sourceMappingURL=promise.d.ts.map

package/dist/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../src/promise.ts"],"names":[],"mappings":"AACA,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAKnH"}

package/dist/promise.js

@@ -0,0 +1,6 @@
+export function promise(func) {
+  return new Promise((resolve, reject) => {
+    // func can be async 
+    func(resolve, reject);
+  });
+}

package/dist/reRouting/addRequireResolveHooks.d.ts

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

package/dist/reRouting/addRequireResolveHooks.d.ts.map

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

package/dist/reRouting/addRequireResolveHooks.js

@@ -0,0 +1,26 @@
+// 
+// // this is still used ????
+export {};
+// import requireResolveHookModule from 'require-resolve-hook'
+// // @ts-ignore
+// const requireResolveHook = requireResolveHookModule.default
+// import { TungstenError } from '../TungstenError.js'
+// import { getFrameworkDir } from '../getFrameworkDir.js'
+// import { cliWarn } from '../cliOutput.js'
+// let added = false
+// export function addRequireResolveHooks() {
+//     if (added) return
+//     added = true
+//     requireResolveHook('react', (id, parent, isMain) => {
+//         const newLocation = getFrameworkDir() + '/dist/syncServer/index.cjs'
+//         return newLocation
+//     })
+//     requireResolveHook(/^react\//, (id, parent, isMain) => {
+//         cliWarn('A React submodule was required')
+//         cliWarn('require resolve hook id', id)
+//         cliWarn('require resolve hook parent', parent)
+//         cliWarn('require resolve hook isMain', isMain)
+//         throw new TungstenError(`requireResolveHook.js react sub hook error: a react submodule was required - we don't know how to handle this yet`)
+//         //if (id === 'react') return getFrameworkDir() + '/dist/index.js'
+//     })
+// }

package/dist/reRouting/importLoader.d.ts

@@ -0,0 +1,7 @@
+type Resolve = (specifier: string, context: Context, nextResolve?: Resolve) => unknown;
+type Context = {
+    parentURL: string;
+};
+export declare function resolve(specifier: string, context: Context, nextResolve: Resolve): Promise<unknown>;
+export {};
+//# sourceMappingURL=importLoader.d.ts.map

package/dist/reRouting/importLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importLoader.d.ts","sourceRoot":"","sources":["../../src/reRouting/importLoader.ts"],"names":[],"mappings":"AAIA,KAAK,OAAO,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;AAEtF,KAAK,OAAO,GAAG;IACX,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,wBAAsB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,oBAYtF"}

package/dist/reRouting/importLoader.js

@@ -0,0 +1,27 @@
+// node --experimental-loader sxy-loader-react-to-sxy blah.js
+export async function resolve(specifier, context, nextResolve) {
+  //const { parentURL = null } = context
+  if (specifier === './module.js') specifier = './module2.js';
+  return nextResolve(specifier, context);
+  // Defer to the next hook in the chain, which would be the
+  // Node.js default resolve if this is the last user-specified loader.
+}
+// export async function load(url, context, nextLoad) {
+//     const { format } = context
+//     if (Math.random() > 0.5) { // Some condition
+//       /*
+//         For some or all URLs, do some custom logic for retrieving the source.
+//         Always return an object of the form {
+//           format: <string>,
+//           source: <string|buffer>,
+//         }.
+//       */
+//         return {
+//             format,
+//             shortCircuit: true,
+//             source: '...',
+//         }
+//     }
+//     // Defer to the next hook in the chain.
+//     return nextLoad(url)
+// }

package/dist/ref.d.ts

@@ -0,0 +1,2 @@
+export declare function ref(v: any): any;
+//# sourceMappingURL=ref.d.ts.map

package/dist/ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../src/ref.ts"],"names":[],"mappings":"AAEA,wBAAgB,GAAG,CAAC,CAAC,EAAE,GAAG,OAEzB"}

package/dist/ref.js

@@ -0,0 +1,4 @@
+// just used as a marker to help babel not transform passed args when wrapped with this func
+export function ref(v) {
+  return v;
+}

package/dist/regexEscape.d.ts

@@ -0,0 +1,2 @@
+export declare function regexEscape(r: string): string;
+//# sourceMappingURL=regexEscape.d.ts.map

package/dist/regexEscape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexEscape.d.ts","sourceRoot":"","sources":["../src/regexEscape.ts"],"names":[],"mappings":"AAGA,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,UAEpC"}

package/dist/regexEscape.js

@@ -0,0 +1,4 @@
+// probably an incomplete function, good enough for task so far
+export function regexEscape(r) {
+  return r.replaceAll('.', '\\.');
+}

package/dist/render/HeadData.d.ts

@@ -0,0 +1,15 @@
+import { TungstenEnvOrUndefined } from 'tungsten/env/types.js';
+import type { Instance } from '../Instance/Instance.js';
+import type { ImportAliases } from '../build/ImportAliases.js';
+export type SiteBasePath = '' | `/${string}`;
+export type HeadData = {
+    found: boolean;
+    instance: Instance;
+    clientImportAliases: ImportAliases;
+    importAliases: ImportAliases;
+    compilationLocation: string;
+    dev: boolean;
+    tungstenPublicEnv: TungstenEnvOrUndefined;
+    siteBasePath: SiteBasePath;
+};
+//# sourceMappingURL=HeadData.d.ts.map

package/dist/render/HeadData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeadData.d.ts","sourceRoot":"","sources":["../../src/render/HeadData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE9D,MAAM,MAAM,YAAY,GAAG,EAAE,GAAG,IAAI,MAAM,EAAE,CAAA;AAE5C,MAAM,MAAM,QAAQ,GAAG;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,mBAAmB,EAAE,aAAa,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,YAAY,EAAE,YAAY,CAAA;CAC7B,CAAA"}

package/dist/render/HeadData.js

@@ -0,0 +1 @@
+export {};

package/dist/render/SxyFrameworkModule.d.ts

@@ -0,0 +1,5 @@
+export type SxyFrameworkModule = {
+    abs: string;
+    rel: string;
+};
+//# sourceMappingURL=SxyFrameworkModule.d.ts.map

package/dist/render/SxyFrameworkModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SxyFrameworkModule.d.ts","sourceRoot":"","sources":["../../src/render/SxyFrameworkModule.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,kBAAkB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACf,CAAA"}

package/dist/render/SxyFrameworkModule.js

@@ -0,0 +1 @@
+export {};

package/dist/render/SxyFrameworkModules.d.ts

@@ -0,0 +1,3 @@
+import type { SxyFrameworkModule } from './SxyFrameworkModule.js';
+export type SxyFrameworkModules = SxyFrameworkModule[];
+//# sourceMappingURL=SxyFrameworkModules.d.ts.map

package/dist/render/SxyFrameworkModules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SxyFrameworkModules.d.ts","sourceRoot":"","sources":["../../src/render/SxyFrameworkModules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,EAAE,CAAA"}

package/dist/render/SxyFrameworkModules.js

@@ -0,0 +1 @@
+export {};

package/dist/render/addImportMap.d.ts

@@ -0,0 +1,4 @@
+import type { ContentNodeElementWithChildrenArray } from '../ContentNode.js';
+import type { ImportAliases } from '../build/ImportAliases.js';
+export declare function addImportMap(head: ContentNodeElementWithChildrenArray, importAliases: ImportAliases, clientImportAliases: ImportAliases): void;
+//# sourceMappingURL=addImportMap.d.ts.map

package/dist/render/addImportMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addImportMap.d.ts","sourceRoot":"","sources":["../../src/render/addImportMap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,mBAAmB,CAAA;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAQ9D,wBAAgB,YAAY,CAAC,IAAI,EAAE,mCAAmC,EAAE,aAAa,EAAE,aAAa,EAChG,mBAAmB,EAAE,aAAa,QAgCrC"}

package/dist/render/addImportMap.js

@@ -0,0 +1,28 @@
+/* eslint-disable indent */
+//import { packageName, frameworkDistFolder } from '../settings.js'
+import { isDev } from "../isDev.js";
+import { $props, $type } from "../contentNodeSymbols.js";
+//import { clientModulesAliases } from '../build/clientModuleAliases.js'
+//const nodeModulesLength = `node_modules/`.length
+export function addImportMap(head, importAliases, clientImportAliases) {
+  //console.log('generated import aliases to show', clientImportAliases)
+  //console.log('client import aliases',  clientImportAliases)
+  //console.log('import aliases',  importAliases)
+  head[$props].children.unshift({
+    [$type]: 'script',
+    [$props]: {
+      type: 'importmap',
+      //noEscape: true,
+      children: [`{
+    "imports": {
+        ${
+      // [`"tungsten": "/.packages/${packageName}/${frameworkDistFolder}/index.js"`]
+      //     .concat(Object.entries(clientImportAliases).map( ([source, dest]) => 
+      //         `"${source}": "${dest}"`    
+      //     ))
+      Object.entries(clientImportAliases).map(([source, dest]) => `"${source}": "${dest}"`).concat(Object.entries(importAliases).map(([source, dest]) => `"${source}": "${dest}"`)).join(isDev ? ',\n        ' : ',')}
+    }
+}`]
+    }
+  });
+}

package/dist/render/classComponentNodeToRenderingTree.d.ts

@@ -0,0 +1,6 @@
+import type { RenderingNodeComponent } from '../RenderingNode.js';
+import type { Instance } from '../Instance/Instance.js';
+import type { ContentNodeClassComponent } from '../ContentNode.js';
+import type { AnyComponent } from '../AnyComponent.js';
+export declare function classComponentNodeToRenderingTree(node: ContentNodeClassComponent, parentComponent: AnyComponent | null, instance: Instance, noEscape: boolean): Promise<RenderingNodeComponent>;
+//# sourceMappingURL=classComponentNodeToRenderingTree.d.ts.map

package/dist/render/classComponentNodeToRenderingTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classComponentNodeToRenderingTree.d.ts","sourceRoot":"","sources":["../../src/render/classComponentNodeToRenderingTree.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAOtD,wBAAsB,iCAAiC,CACnD,IAAI,EAAE,yBAAyB,EAC/B,eAAe,EAAE,YAAY,GAAG,IAAI,EACpC,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,OAAO,GACjB,OAAO,CAAC,sBAAsB,CAAC,CAiBlC"}

package/dist/render/classComponentNodeToRenderingTree.js

@@ -0,0 +1,16 @@
+import { contentTreeToRenderingTree } from "./contentTreeToRenderingTree.js";
+import { debug } from "./debug.js";
+import { makeRenderingNodeClassComponentFromContentNodeClassComponent } from "../RenderingNode.js";
+import { instantiateClassComponent } from "./instantiateClassComponent.js";
+export async function classComponentNodeToRenderingTree(node, parentComponent, instance, noEscape) {
+  const component = await instantiateClassComponent(node, parentComponent, instance);
+  //const component = instantiateComponent(node, parentComponent, instance)
+  debug('component', component);
+  if (component.content) debug('element content func string', component.content.toString());
+  const childrenContent = await component.__styledContent();
+  //if (node[$type] === Stylesheet) console.log('childrenContent for ', node[$type].name, childrenContent)
+  debug('classComponentToTree tree', childrenContent);
+  const renderingContent = await contentTreeToRenderingTree(childrenContent, parentComponent, instance, noEscape);
+  //if (node[$type] === Stylesheet) console.log('content for ', node[$type].name, renderingContent)
+  return makeRenderingNodeClassComponentFromContentNodeClassComponent(node, component, renderingContent);
+}

package/dist/render/componentNodeToRenderingToTree.d.ts

@@ -0,0 +1,6 @@
+import type { Instance } from '../Instance/Instance.js';
+import type { RenderingNodeComponent } from '../RenderingNode.js';
+import { type ContentNodeComponent } from '../ContentNode.js';
+import { AnyComponent } from '../AnyComponent.js';
+export declare function componentNodeToRenderingToTree(componentNode: ContentNodeComponent, parentComponent: AnyComponent | null, instance: Instance, noEscape: boolean): Promise<RenderingNodeComponent>;
+//# sourceMappingURL=componentNodeToRenderingToTree.d.ts.map