tungsten 0.2.1 → 0.2.3

package/dist/babelPlugins/BabelTransformBindVar.js

@@ -0,0 +1,226 @@
+//import { T } from '@babel/core'
+import { TungstenError } from "../TungstenError.js";
+import { bindableHtmlElements } from "../components/bindable/bindableHtmlElements.js";
+import { throwError } from "../throwError.js";
+// BabelTransformBind
+// exports MakeBabelTransformBind (function)
+//
+// 
+const bindPropName = 'bind';
+function ExistingJsxAttributeValueIsExpressionContainer(v) {
+  return v.type === 'JSXExpressionContainer';
+}
+function ExpressionIsThisExpressionOrMemberExpression(expression) {
+  return expression.type === 'ThisExpression' || expression.type === 'MemberExpression';
+}
+function ExpressionIsIdentifier(expression) {
+  return expression.type === 'Identifier';
+}
+function NodeIsPrivateName(node) {
+  return node.type === 'PrivateName';
+}
+function AssertNodeIsJSXOpeningElement(node) {
+  if (node.type !== 'JSXOpeningElement') {
+    throw new TungstenError(`Node ${node} was not a JSXOpeningElement`);
+  }
+}
+function ExpressionOrJsxEmptyExpressionIsArrayExpression(ex) {
+  return ex.type === 'ArrayExpression';
+}
+function NameIsJSXIdentifier(name) {
+  return name.type === 'JSXIdentifier';
+}
+function AttributeIsJSXAttribute(att) {
+  return att.type === 'JSXAttribute';
+}
+function AttributeIsJSXSpreadAttribute(att) {
+  return att.type === 'JSXSpreadAttribute';
+}
+function AttributeValueIsJSXExpressionContainer(attributeValue) {
+  return !!attributeValue && attributeValue.type === 'JSXExpressionContainer';
+}
+// type BindVarTuple = [object, string]
+// function ArrayExpressionIsBindVarTuple(array: ArrayExpression): array is BindVarTupleExpression {
+// }
+function TupleElementIsIdentifierOrMemberExpressionOrCallExpression(element) {
+  return element != null && (element.type === 'Identifier' || element.type === 'MemberExpression' || element.type === 'CallExpression');
+}
+function TupleElementIsIdentifierOrStringLiteralOrTaggedTemplateExpressionOrCallExpression(element) {
+  return element != null && (element.type === 'Identifier' || element.type === 'StringLiteral' || element.type === 'TaggedTemplateExpression' || element.type === 'CallExpression');
+}
+export function MakeBabelTransformBindVar(/*opts: Opts*/
+) {
+  return function BabelTransformBindVar(babel) {
+    const make = babel.types;
+    return {
+      name: 'ast-transform',
+      // not required
+      visitor: {
+        JSXAttribute(path, state) {
+          // !!!! GUARD
+          if (path.node.name.name !== bindPropName) return;
+          const openingElement = path.parent;
+          AssertNodeIsJSXOpeningElement(openingElement);
+          // !!!! GUARD
+          const elementName = openingElement.name;
+          if (!NameIsJSXIdentifier(elementName) || !(elementName.name in bindableHtmlElements)) return;
+          if (!path.node.value) {
+            throw new TungstenError(`BabelTransformBind() error: bind prop is empty`);
+          }
+          const attributeValue = path.node.value;
+          if (!ExistingJsxAttributeValueIsExpressionContainer(attributeValue)) {
+            throw new TungstenError(`BabelTransformBind() error: bind prop should be an expression: {xxx}`);
+          }
+          // !!!!! bind var could be a literal tuple
+          // or instead an expression
+          const attributeValueExpression = attributeValue.expression;
+          if (!ExpressionOrJsxEmptyExpressionIsArrayExpression(attributeValueExpression)) {
+            throw new TungstenError(`BabelTransformBind() error: bind prop should be a tuple: [object, 'prop']`);
+          }
+          const bindVarTuple = attributeValueExpression;
+          if (bindVarTuple.elements.length !== 2) {
+            throw new TungstenError(`BabelTransformBind() error: bind prop should be a tuple: [object, 'prop']`);
+          }
+          const bindVarObjectExpression = bindVarTuple.elements[0];
+          const bindVarPropExpression = bindVarTuple.elements[1];
+          if (!TupleElementIsIdentifierOrMemberExpressionOrCallExpression(bindVarObjectExpression)) {
+            throwError('BabelTransformBindVar', 'The first element in the bind prop tuple must be a variable or function call');
+          }
+          if (!TupleElementIsIdentifierOrStringLiteralOrTaggedTemplateExpressionOrCallExpression(bindVarPropExpression)) {
+            throwError('BabelTransformBindVar', 'The second element in the bind prop tuple must be a string, variable, or function call');
+          }
+          //// determine whether the bind object is within component state
+          /*
+            //const originalVariable = attributeValueExpression
+                  
+          const variablePartsTemp: VariablePart[] = []
+          let remaining: (types.ThisExpression | types.MemberExpression) = bindVarObjectExpression
+              
+          while (remaining.type === 'MemberExpression') {
+              variablePartsTemp.push(remaining)
+              if ( ! ExpressionIsThisExpressionOrMemberExpression(remaining.object) ) {
+                  throw new TungstenError(
+                      `BabelTransformBind error: expected object in`
+                          + ` bind value to be ThisExpression or MemberExpression.`
+                          + ` Bind value must be a property on this, e.g. bind={this.foo}.`
+                          + ` Got ${remaining.object.type}: ${remaining.object}}`
+                  )
+              }
+              remaining = remaining.object
+          }
+              
+          variablePartsTemp.push(remaining)
+              
+          if (variablePartsTemp.length === 0) {
+              throw new Error(
+                  'Babel Plugin Transform Bind Error:'
+                          + ' bind={} did not find a valid variable to bind.'
+                          + ' A state variable such as foo should be passed for this.state.foo,'
+                          + ' or foo.bar for this.state.foo.bar.'
+                          + `\nfile: ${state.filename}`
+              )
+          }
+               variablePartsTemp.reverse()
+          const variableParts = variablePartsTemp as VariablePartsFinal
+               // only part 0 can be ThisExpression, anything after must be MemberExpression
+          const part2 = variableParts[1]
+          const property = part2.property
+               // check that the property is an identifier
+              // we might need to modify this to allow index access (state['foo'] instead of state.foo
+           if ( NodeIsPrivateName(property) ) {
+              throw new TungstenError(
+                  'Babel Plugin Transform Bind Error:'
+                      + ' Expected bind object property to be an Identifier'
+                      + ` Instead got ${property.type}`
+              )
+          }
+           if ( ! ExpressionIsIdentifier(property) ) {
+              throw new TungstenError(
+                  'Babel Plugin Transform Bind Error:'
+                      + ' Expected bind object property to be an Identifier'
+                      + ` Instead got ${property.type}`
+              )
+          }
+           let variable = make.memberExpression(
+              make.identifier('this'),
+                  // only part 0 can be ThisExpression, anything after must be MemberExpression
+              property
+          )
+                  
+          const stateBased = property.name === 'state'
+              
+              // just always use value as our framework doesn't understand defaultValue yet
+          path.node.name.name = 'value'
+           for (let i = 2; i < variableParts.length; i++) {
+                  // only part 0 can be other than MemberExpression
+              const varPart = variableParts[i] as types.MemberExpression
+              variable = make.memberExpression(
+                  variable,
+                  varPart.property,
+                  varPart.computed
+              )
+          }
+           */
+          let originalOnChange = null;
+          let filter = null;
+          for (const att of openingElement.attributes) {
+            if (AttributeIsJSXAttribute(att)) {
+              if (att.name.name === 'onChange') {
+                const attributeValue = att.value;
+                if (!AttributeValueIsJSXExpressionContainer(attributeValue)) {
+                  throw new TungstenError(`BabelTransformBind() error: expected onChange attribute value to be a JSX Expression: {xxx}`);
+                }
+                if (attributeValue.expression.type === 'JSXEmptyExpression') {
+                  throwError('BabelTransformBindVar', 'the onChange attribute contains an empty JSX expression');
+                }
+                originalOnChange = make.expressionStatement(make.callExpression(attributeValue.expression, [make.identifier('event'), make.identifier('value')]));
+              }
+              if (att.name.name === 'filter') {
+                const attributeValue = att.value;
+                if (!AttributeValueIsJSXExpressionContainer(attributeValue)) {
+                  throw new TungstenError(`BabelTransformBind() error: expected filter attribute value to be a JSX Expression: {xxx}`);
+                }
+                if (attributeValue.expression.type === 'JSXEmptyExpression') {
+                  throwError('BabelTransformBindVar', 'the filter attribute contains an empty JSX expression');
+                }
+                filter = make.variableDeclaration('const', [make.variableDeclarator(make.identifier('value'), make.callExpression(attributeValue.expression, [make.memberExpression(make.memberExpression(make.identifier('event'), make.identifier('target')), make.identifier('value')), make.identifier('event')]))]);
+              }
+            }
+          }
+          // remove the original onChange attribute(s)
+          openingElement.attributes = openingElement.attributes.filter(att => att.type !== 'JSXAttribute' || att.name.name !== 'onChange' && att.name.name !== 'filter');
+          let assignmentExpression;
+          //if (stateBased) {
+          assignmentExpression = make.expressionStatement(make.assignmentExpression('=', make.memberExpression(bindVarObjectExpression, bindVarPropExpression), make.identifier('value')));
+          // } else {
+          //     setFieldExpression = make.expressionStatement(
+          //         make.assignmentExpression(
+          //             '=',
+          //             variable,
+          //             make.identifier('value')
+          //         )
+          //     )
+          // }
+          const functionBodyExpressions = [];
+          const assignToValueVarExpression = make.variableDeclaration('const', [make.variableDeclarator(make.identifier('value'), make.memberExpression(make.memberExpression(make.identifier('event'), make.identifier('target')), make.identifier('value')))]);
+          if (filter) functionBodyExpressions.push(filter); // eslint-disable-line @typescript-eslint/strict-boolean-expressions
+          else functionBodyExpressions.push(assignToValueVarExpression);
+          // if (stateBased) {
+          //     if (stateSettingMode === 'assignment') {
+          //         functionBodyExpressions.push(stateAssignmentExpression)
+          //     } else {
+          //                 //// unused
+          //                 //// would only be useful for a back compat mode
+          //         functionBodyExpressions.push(setStateExpression)
+          //     }
+          // }
+          // else functionBodyExpressions.push(setFieldExpression)
+          functionBodyExpressions.push(assignmentExpression);
+          if (originalOnChange) functionBodyExpressions.push(originalOnChange); // eslint-disable-line @typescript-eslint/strict-boolean-expressions
+          const attr = make.jsxAttribute(make.jsxIdentifier('onKeyUp'), make.jsxExpressionContainer(make.arrowFunctionExpression([make.identifier('event')], make.blockStatement(functionBodyExpressions))));
+          openingElement.attributes.push(attr);
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformCjsToEsm.d.ts

@@ -0,0 +1,12 @@
+import type { BabelFile, NodePath, types } from '@babel/core';
+import type { BabelFake } from './BabelFakeType.js';
+export declare function MakeBabelTransformCjsToEsm(): (babel: BabelFake) => {
+    pre(state: BabelFile): void;
+    visitor: {
+        CallExpression(path: NodePath<types.CallExpression>): void;
+        Identifier(path: NodePath<types.Identifier>): void;
+        MemberExpression(path: NodePath<types.MemberExpression>): void;
+    };
+    post(state: BabelFile): void;
+};
+//# sourceMappingURL=BabelTransformCjsToEsm.d.ts.map

package/dist/babelPlugins/BabelTransformCjsToEsm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformCjsToEsm.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformCjsToEsm.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAqEnD,wBAAgB,0BAA0B,KACC,OAAO,SAAS;eAapC,SAAS;;6BAmBK,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC;yBAwBlC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC;+BAMpB,QAAQ,CAAC,KAAK,CAAC,gBAAgB,CAAC;;gBAU/C,SAAS;EAqGhC"}

package/dist/babelPlugins/BabelTransformCjsToEsm.js

@@ -0,0 +1,164 @@
+//// how do we know if an 
+import { readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { init as lexerInit, parse as lexerParse } from 'cjs-module-lexer';
+import { throwError } from "../throwError.js";
+lexerInit();
+const filenameAndDirnameCode = `import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+let __filename = fileURLToPath(import.meta.url);
+let __dirname = dirname(__filename);`;
+const createRequireCode = `import { createRequire } from 'module';
+const require = createRequire(import.meta.url)`;
+const exportsStartCode = `let exports = {};
+let module = { exports };`;
+const exportsEndCode = `export default module.exports;`;
+const exportNamesFromFileCache = {};
+function getExportNamesFromFile(file) {
+  const cache = exportNamesFromFileCache;
+  if (file in cache) {
+    return cache[file];
+  } else {
+    const code = readFileSync(file, 'utf8');
+    return cache[file] = getExportNamesFromCode(code, file);
+  }
+}
+function getExportNamesFromCode(code, filename) {
+  const combinedExports = {};
+  const {
+    exports,
+    reexports: reExports
+  } = lexerParse(code);
+  for (const reExport of reExports) {
+    const _require = createRequire(filename);
+    const target = _require.resolve(reExport);
+    const secondaryNames = getExportNamesFromFile(target);
+    if (secondaryNames === undefined) throwError('getExportNamesFromCode', 'secondaryNames is undefined');
+    for (const e of secondaryNames) {
+      combinedExports[e] = true;
+    }
+  }
+  for (const e of exports) {
+    combinedExports[e] = true;
+  }
+  return Object.keys(combinedExports);
+}
+export function MakeBabelTransformCjsToEsm(/*opts: Opts*/
+) {
+  return function BabelTransformCjsToEsm(babel) {
+    const t = babel.types;
+    const createRequire = babel.parse(createRequireCode).program.body;
+    const filenameAndDirname = babel.parse(filenameAndDirnameCode).program.body;
+    const exportsStart = babel.parse(exportsStartCode).program.body;
+    const exportsEnd = babel.parse(exportsEndCode).program.body;
+    //let identifiers
+    let imports;
+    let importNum;
+    let addFilenameAndDirname;
+    let addCreateRequire;
+    return {
+      pre(state) {
+        //identifiers = {}
+        imports = [];
+        importNum = 0;
+        addFilenameAndDirname = false;
+        addCreateRequire = false;
+        // wrap everything in a scoping code block to prevent naming conficts when exporting at the end
+        const body = state.ast.program.body;
+        state.ast.program.body = [t.blockStatement([...body])];
+        // // grab the whole file contents
+        // const body = state.ast.program.body
+        // // add a block statement containing a copy of this content at the start of the body
+        // state.path.unshiftContainer('body', t.blockStatement([...body]))
+        //  /// truncate the body to 1 item, removing the original content
+        // body.length = 1
+      },
+      visitor: {
+        CallExpression(path) {
+          const callee = path.node.callee;
+          if (callee.type === 'Identifier' && callee.name === 'require') {
+            imports.push(path.node.arguments);
+            //const newEx = t.awaitExpression(
+            //    t.callExpression(
+            //        t.import(),
+            //        path.node.arguments
+            //    )
+            //)
+            const newEx = t.memberExpression(t.identifier('__tungsten_cjs_to_esm_imports'), t.numericLiteral(importNum),
+            // pretty hard to read output code
+            true);
+            path.replaceWith(newEx);
+            importNum++;
+            // do we wanna cache???
+            //
+          }
+        },
+        Identifier(path) {
+          //identifiers[path.node.name] = true
+          if (path.node.name === '__filename' || path.node.name === '__dirname') {
+            addFilenameAndDirname = true;
+          }
+        },
+        MemberExpression(path) {
+          const node = path.node;
+          if (node.object.type === 'Identifier' && node.object.name === 'require' && node.property.type === 'Identifier' && node.property.name === 'resolve') {
+            addCreateRequire = true;
+          }
+        }
+      },
+      post(state) {
+        const importsStatement = t.variableDeclaration('const', [t.variableDeclarator(t.identifier('__tungsten_cjs_to_esm_imports'), t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('Promise'), t.identifier('all')), [t.arrayExpression(imports.map(imp => {
+          const sourceArgument = imp[0];
+          if (sourceArgument?.type !== 'StringLiteral') {
+            throwError('BabelTransformCjsToEsm', 'require() must have a string literal as its first argument');
+          }
+          const source = sourceArgument.value;
+          //// We don't wanna change imports, because we need to resolve and alter them
+          //// in the next step
+          // if ( // danger: death by regex
+          //     source.includes('/')
+          //     && ! /^@[^/]+\/[^/]+$/.test(source)
+          //     && ! /(.js|.cjs|.mjs|.json)$/.test(source)
+          // ) {
+          //     if (source.split('/').pop().includes('.')) {
+          //         console.log(`babel-plugin-sxy-transform-cjs-to-esm warning:`
+          //             + ` require location ${source} file contains a dot, but we did not`
+          //             + ` recognise the extension. Adding .js`)
+          //     }
+          //     source += '.js'
+          // }
+          return t.awaitExpression(t.callExpression(t.import(), [t.stringLiteral(source)]));
+        }))])))]);
+        state.path.unshiftContainer('body', importsStatement);
+        //for (const imp of imports) {
+        //  	const importDeclaration = t.importDeclaration(
+        //        [t.importDefaultSpecifier(
+        //            t.identifier(varNameForImport(imp[0].value))
+        //        )],
+        //        imp[0]
+        //    )
+        //   state.path.unshiftContainer('body', importDeclaration)
+        //}
+        // reverse the order, because we are unshifting 
+        if (addCreateRequire) {
+          state.path.unshiftContainer('body', createRequire);
+        }
+        if (addFilenameAndDirname) {
+          state.path.unshiftContainer('body', filenameAndDirname);
+        }
+        state.path.unshiftContainer('body', exportsStart);
+        const filename = state.opts.filename;
+        if (typeof filename !== 'string') {
+          throwError('BabelTransformCjsToEsm', 'Babel did not provide a filename');
+        }
+        const names = getExportNamesFromCode(state.code, filename);
+        for (const name of names) {
+          if (name === 'default') continue; /// cannot export named variables called default - this is reserved for the default export
+          const namedExport = t.exportNamedDeclaration(t.variableDeclaration('const', [t.variableDeclarator(t.identifier(name), t.memberExpression(t.memberExpression(t.identifier('module'), t.identifier('exports')), t.stringLiteral(name), true))]));
+          state.path.pushContainer('body', namedExport);
+        }
+        state.path.pushContainer('body', exportsEnd);
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformCjsToFunction.d.ts

@@ -0,0 +1,16 @@
+import type { Directive, Identifier } from '@babel/types';
+import type { BabelFile, NodePath } from '@babel/core';
+import type { BabelFake } from './BabelFakeType.js';
+type Opts = {
+    dependencies: string[];
+};
+export declare function MakeBabelTransformCjsToFunction(opts: Opts): (babel: BabelFake) => {
+    pre(state: BabelFile): void;
+    visitor: {
+        Identifier(path: NodePath<Identifier>): void;
+        Directive(path: NodePath<Directive>): void;
+    };
+    post(state: BabelFile): void;
+};
+export {};
+//# sourceMappingURL=BabelTransformCjsToFunction.d.ts.map

package/dist/babelPlugins/BabelTransformCjsToFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformCjsToFunction.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformCjsToFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAanD,KAAK,IAAI,GAAG;IACR,YAAY,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,IAAI,IACV,OAAO,SAAS;eASzC,SAAS;;yBAkBC,QAAQ,CAAC,UAAU,CAAC;wBAMrB,QAAQ,CAAC,SAAS,CAAC;;gBAM3B,SAAS;EA4BhC"}

package/dist/babelPlugins/BabelTransformCjsToFunction.js

@@ -0,0 +1,54 @@
+//// let or const??
+const filenameAndDirnameCode = `import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+let __filename = fileURLToPath(import.meta.url);
+let __dirname = dirname(__filename);`;
+const createRequireCode = `import { createRequire } from 'module';
+const require = createRequire(import.meta.url)`;
+export function MakeBabelTransformCjsToFunction(opts) {
+  return function BabelTransformCjsToFunction(babel) {
+    const t = babel.types;
+    const createRequire = babel.parse(createRequireCode).program.body;
+    const filenameAndDirname = babel.parse(filenameAndDirnameCode).program.body;
+    let identifiers;
+    let addFilenameAndDirname;
+    let addCreateRequire;
+    return {
+      pre(state) {
+        identifiers = {};
+        addFilenameAndDirname = false;
+        addCreateRequire = false;
+        // wrap everything in a function and export it as default
+        const body = state.ast.program.body;
+        const func = t.exportDefaultDeclaration(t.functionDeclaration(t.identifier('commonJsModule'), [t.identifier('module'), t.identifier('exports'), t.identifier('require')], t.blockStatement([...body])));
+        state.ast.program.body = [func];
+      },
+      visitor: {
+        Identifier(path) {
+          identifiers[path.node.name] = true;
+          if (path.node.name === '__filename' || path.node.name === '__dirname') {
+            addFilenameAndDirname = true;
+          }
+        },
+        Directive(path) {
+          if (path.node.value.value === 'use strict') {
+            path.remove();
+          }
+        }
+      },
+      post(state) {
+        // reverse the order, because we are unshifting 
+        if (addCreateRequire) {
+          state.path.unshiftContainer('body', createRequire);
+        }
+        if (addFilenameAndDirname) {
+          state.path.unshiftContainer('body', filenameAndDirname);
+        }
+        //if (state.opts.filename.endsWith('highlight.js')) {
+        //console.log(chalk.purple`deps for ${state.opts.filename}`, opts.dependencies)    
+        //}
+        state.path.unshiftContainer('body', t.exportNamedDeclaration(t.variableDeclaration('const', [t.variableDeclarator(t.identifier('deps'), t.arrayExpression(opts.dependencies.map(d => t.stringLiteral(d))))])));
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformCjsToFunction2.d.ts

@@ -0,0 +1,17 @@
+import { BabelFile, NodePath } from '@babel/core';
+import { CallExpression, Directive, Identifier } from '@babel/types';
+import { Babel } from './BabelTypes.js';
+type Opts = {
+    dependencies: string[];
+};
+export declare function MakeBabelTransformCjsToFunction(opts: Opts): (babel: Babel) => {
+    pre(state: BabelFile): void;
+    visitor: {
+        CallExpression(path: NodePath<CallExpression>): void;
+        Identifier(path: NodePath<Identifier>): void;
+        Directive(path: NodePath<Directive>): void;
+    };
+    post(state: BabelFile): void;
+};
+export {};
+//# sourceMappingURL=BabelTransformCjsToFunction2.d.ts.map

package/dist/babelPlugins/BabelTransformCjsToFunction2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformCjsToFunction2.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformCjsToFunction2.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACpE,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AA6DvC,KAAK,IAAI,GAAG;IACR,YAAY,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,IAAI,IACV,OAAO,KAAK;eAarC,SAAS;;6BAqCK,QAAQ,CAAC,cAAc,CAAC;yBAsC5B,QAAQ,CAAC,UAAU,CAAC;wBAerB,QAAQ,CAAC,SAAS,CAAC;;gBAM3B,SAAS;EAuIhC"}