tungsten 0.2.1 → 0.2.3

package/dist/build/sassImportParser.js

@@ -0,0 +1,296 @@
+/* eslint-disable no-inner-declarations */
+import { throwError } from "../throwError.js";
+function debug(...texts) {
+  //console.log(...texts)
+}
+export function sassImportParser(code) {
+  try {
+    let mode = 'search';
+    let commentMode = 'none';
+    const imports = [];
+    let indentationChar = null;
+    let indentation = {
+      space: 0,
+      tab: 0
+    };
+    let statement = 'none';
+    let firstLevelIndentation = null;
+    //let secondLevelIndentation: ValidIndentation | null = null
+    let atRule = '';
+    let openQuote = null;
+    let atUseImportTarget = '';
+    let atUseImportTargetStart = -1;
+    function finishAtRule(char) {
+      switch (atRule) {
+        case '':
+          throw new Error('Expected identifier after @');
+        case 'use':
+        case 'import':
+          if (char === `'` || char === `"`) {
+            openQuote = char;
+            mode = 'at-use-import-target';
+          } else {
+            mode = 'at-use-import';
+          }
+          break;
+      }
+      atRule = '';
+    }
+    function errOnMixedSpacesAndTabs(i) {
+      if (i.space > 0 && i.tab > 0) throw new Error('Error, found mixed spaces and tabs');
+      return true;
+    }
+    function IndentationIsValidIndentationOrThrow(i) {
+      errOnMixedSpacesAndTabs(i);
+      return true;
+    }
+    function hasIndentation(i) {
+      return i.tab > 0 || i.space > 0;
+    }
+    function getIndentationChar(i) {
+      if (i.space > 0) {
+        return 'space';
+      } else if (i.tab > 0) {
+        return 'tab';
+      } else {
+        return null;
+      }
+    }
+    function handleFirstLevelIndentation(i) {
+      if (IndentationIsValidIndentationOrThrow(i)) {
+        if (hasIndentation(i)) {
+          if (indentationChar === null) {
+            indentationChar = getIndentationChar(i);
+          } else {
+            if (getIndentationChar(i) !== indentationChar) {
+              throw new Error('Found mixed spaces and tabs');
+            }
+          }
+        }
+        firstLevelIndentation = i;
+      }
+    }
+    function compareIndentation(i, j) {
+      if (IndentationIsValidIndentationOrThrow(i) && IndentationIsValidIndentationOrThrow(j)) {
+        if (indentationChar === null) {
+          const iic = getIndentationChar(i);
+          const jic = getIndentationChar(j);
+          if (iic !== null) {
+            indentationChar = iic;
+            if (jic !== null && jic !== iic) throw new Error('Found mixed spaces and tabs');
+          } else {
+            if (jic !== null) indentationChar = jic;else {
+              return 0;
+            }
+          }
+        }
+        if (i[indentationChar] > j[indentationChar]) return 1;else if (i[indentationChar] < j[indentationChar]) return -1;else return 0;
+      }
+      throw new Error('never');
+    }
+    const lines = code.split('\n');
+    let lineIndex = -1;
+    let totalCharIndex = -2;
+    for (const line of lines) {
+      lineIndex++;
+      totalCharIndex++;
+      debug('line', lineIndex, line);
+      let charIndex = -1;
+      for (const char of line) {
+        charIndex++;
+        totalCharIndex++;
+        debug(mode, charIndex, totalCharIndex, char);
+        switch (commentMode) {
+          case 'none':
+            {
+              if (char === '/') {
+                if (line[charIndex + 1] === '/') {
+                  commentMode = 'line-comment';
+                  continue;
+                } else if (line[charIndex + 1] === '*') {
+                  commentMode = 'block-comment';
+                  continue;
+                }
+                //commentMode = 'slash'
+              }
+              break;
+            }
+          // case 'slash': {
+          //     if (char === '/') {
+          //         commentMode = 'line-comment'
+          //     } else if (char === '*') {
+          //         commentMode = 'block-comment'
+          //     }
+          //     break
+          // }
+          case 'line-comment':
+            {
+              // skip?
+              continue;
+            }
+          case 'block-comment':
+            {
+              // skip?
+              if (char === '*' && line[charIndex + 1] === '/') {
+                commentMode = 'block-comment-ending';
+              }
+              continue;
+            }
+          case 'block-comment-ending':
+            {
+              commentMode = 'none';
+              continue;
+            }
+          default:
+            {
+              throw new Error(`unknown commentMode ${commentMode}`);
+            }
+        }
+        switch (mode) {
+          // eslint-disable-line no-type-assertion/no-type-assertion -- TS incorrectly reduces type of mode
+          case 'search':
+            {
+              if (char === ' ') {
+                indentation.space++;
+              } else if (char === '\t') {
+                indentation.tab++;
+              } else if (char === '@') {
+                handleFirstLevelIndentation(indentation);
+                statement = 'at-rule';
+                mode = 'at-rule';
+              } else if (/\S/.test(char)) {
+                if (statement === 'selector') {
+                  if (IndentationIsValidIndentationOrThrow(indentation)) {
+                    if (firstLevelIndentation === null) throw new Error('internal error: firstLevelIndentation was null when comparing indentation');
+                    const result = compareIndentation(indentation, firstLevelIndentation);
+                    if (result === 1) {
+                      mode = 'style-rules';
+                      //secondLevelIndentation = indentation
+                      break;
+                    }
+                  }
+                }
+                handleFirstLevelIndentation(indentation);
+                statement = 'selector';
+                mode = 'selector';
+              }
+              break;
+            }
+          case 'at-rule':
+            {
+              if (/[a-zA-Z0-9-_]/.test(char)) {
+                atRule += char;
+              } else if (char === ' ' || char === '\t' || char === `'` || char === `"`) {
+                finishAtRule(char);
+              }
+              break;
+            }
+          case 'at-use-import':
+            {
+              if (char === ' ' || char === '\t') {
+                // ignore whitespace
+              } else if (char === `'`) {
+                openQuote = char;
+                mode = 'at-use-import-target';
+              } else if (char === `"`) {
+                openQuote = char;
+                mode = 'at-use-import-target';
+              }
+              break;
+            }
+          case 'at-use-import-target':
+            {
+              if (char === openQuote) {
+                debug(`Found import target '${atUseImportTarget}' at position ${atUseImportTargetStart}`);
+                imports.push({
+                  target: atUseImportTarget,
+                  start: atUseImportTargetStart
+                });
+                openQuote = null;
+                atUseImportTarget = '';
+                atUseImportTargetStart = -1;
+                mode = 'post-at-rule';
+              } else {
+                if (atUseImportTarget === '') {
+                  atUseImportTargetStart = totalCharIndex;
+                }
+                atUseImportTarget += char;
+              }
+              break;
+            }
+          case 'post-at-rule':
+            {
+              break;
+            }
+          case 'selector':
+            {
+              // don't care, line end will end this mode
+              break;
+            }
+          case 'style-rules':
+            {
+              // don't care what is in here until we break out
+              break;
+            }
+          default:
+            {
+              throw new Error(`unknown mode ${mode}`);
+            }
+        }
+      }
+      switch (commentMode) {
+        case 'line-comment':
+          {
+            commentMode = 'none';
+            break;
+          }
+      }
+      // end of line
+      switch (mode) {
+        // eslint-disable-line no-type-assertion/no-type-assertion -- TS incorrectly reduces type of mode
+        case 'at-rule':
+          {
+            finishAtRule();
+            mode = 'search';
+            break;
+          }
+        case 'at-use-import':
+          {
+            atRule = '';
+            mode = 'search';
+            throw new Error('Incomplete @import statement');
+          }
+        case 'at-use-import-target':
+          {
+            openQuote = null;
+            atUseImportTarget = '';
+            atUseImportTargetStart = -1;
+            mode = 'search';
+            break;
+          }
+        case 'post-at-rule':
+        case 'post-at-use-import':
+          {
+            mode = 'search';
+            break;
+          }
+        case 'selector':
+          {
+            if (IndentationIsValidIndentationOrThrow(indentation)) {
+              firstLevelIndentation = indentation;
+            }
+            mode = 'search';
+            break;
+          }
+      }
+      indentation = {
+        space: 0,
+        tab: 0
+      };
+    }
+    return imports;
+  } catch (e) {
+    console.log(e); //throw e
+    throwError('sassImportParser', 'threw an error');
+  }
+}

package/dist/build/sassImportParser.sxyt.d.ts

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

package/dist/build/sassImportParser.sxyt.d.ts.map

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

package/dist/build/sassImportParser.sxyt.js

@@ -0,0 +1,110 @@
+import { describe } from 'sxy-test-runner';
+import { sassImportParser } from "./sassImportParser.js";
+describe('sassImportParser()', ({
+  it
+}) => {
+  const input = `@import 'foo'`;
+  it(`parses out an import '${input}'`, () => {
+    const imports = sassImportParser(input);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+  const input2 = `@import 'foo'
+@import 'bar'`;
+  it(`parses out 2 imports from '${input2}'`, () => {
+    const imports = sassImportParser(input2);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input3 = `    
+    @import 'foo'
+
+    @import 'bar'
+    
+`;
+  it(`parses out 2 imports with spaces from '${input3}'`, () => {
+    const imports = sassImportParser(input3);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input4 = `    
+    @import 'foo'
+    @import 'bar'
+    p::after
+        content: "@import 'baz'"
+`;
+  it(`ignores extra imports within style values '${input4}'`, () => {
+    const imports = sassImportParser(input4);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input5 = `    
+    @import 'foo'
+    @import 'bar'
+    // @import 'ignoreme'
+    /* @use 'ignoremetoo' */
+    /*
+    @use 'ignoremealso'
+    */
+    @use 'baz'
+`;
+  it(`ignores imports within comments in '${input5}'`, () => {
+    const imports = sassImportParser(input5);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar', 'baz']);
+  });
+  const input6 = `    
+    @import /* comment */ 'foo'
+    @import /* comment */'bar'
+`;
+  it(`tolerates comments within @import and @use statements in '${input6}'`, () => {
+    const imports = sassImportParser(input6);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input7 = `    
+    @import'foo'
+    @import/* comment */'bar'
+`;
+  it(`does not require a space between @import / @use and the target using '${input7}'`, () => {
+    const imports = sassImportParser(input7);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input8 = `@import 'foo'`;
+  it(`returns a correct index for the start position when extracting from '${input8}'`, () => {
+    const imports = sassImportParser(input8);
+    Array.from(imports).should.deep.equal([{
+      target: 'foo',
+      start: 9
+    }]);
+  });
+  const input9 = `
+
+    @import 'bar'`;
+  it(`returns a correct index for the start position when extracting from '${input9}'`, () => {
+    const imports = sassImportParser(input9);
+    Array.from(imports).should.deep.equal([{
+      target: 'bar',
+      start: 15
+    }]);
+  });
+  const input10 = `@use 'foo' as bar`;
+  it(`handles aliasing in @use statements in '${input10}'`, () => {
+    const imports = sassImportParser(input10);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+  const input11 = `@use './foo' as bar`;
+  it(`extract relative targets from '${input11}'`, () => {
+    const imports = sassImportParser(input11);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['./foo']);
+  });
+  const input12 = `@use "foo" as bar`;
+  it(`handles double quotes in '${input12}'`, () => {
+    const imports = sassImportParser(input12);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+});

package/dist/build/scssImportParserChatgpt.d.ts

@@ -0,0 +1,6 @@
+export type ImportTarget = {
+    target: string;
+    start: number;
+};
+export declare function scssImportParserChatgpt(content: string): ImportTarget[];
+//# sourceMappingURL=scssImportParserChatgpt.d.ts.map

package/dist/build/scssImportParserChatgpt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scssImportParserChatgpt.d.ts","sourceRoot":"","sources":["../../src/build/scssImportParserChatgpt.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5D,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CA6DvE"}

package/dist/build/scssImportParserChatgpt.js

@@ -0,0 +1,61 @@
+// Code by ChatGPT-3.5
+export function scssImportParserChatgpt(content) {
+  const importStatements = [];
+  let currentToken = '';
+  let currentStatementType = '';
+  let isInString = false;
+  let isEscaped = false;
+  let importStart = -1;
+  let isInsideBlockComment = false;
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+    if (char === '"' || char === '\'') {
+      if (!isInString) {
+        isInString = true;
+        importStart = i + 1; // Set importStart to the character after the opening quote
+      } else if (!isEscaped) {
+        isInString = false;
+      }
+    }
+    if (char === '\\' && isInString) {
+      isEscaped = true;
+    } else {
+      isEscaped = false;
+    }
+    if (char === '/' && content[i + 1] === '*' && !isInString) {
+      // Skip block comments
+      isInsideBlockComment = true;
+      i++; // Skip the opening comment character
+    } else if (char === '*' && content[i + 1] === '/' && isInsideBlockComment) {
+      isInsideBlockComment = false;
+      i++; // Skip the closing comment character
+    } else if (!isInsideBlockComment) {
+      if (char === ';' && !isInString) {
+        if (currentToken.trim() !== '') {
+          const targets = currentToken.trim().replace(/['"]/g, '').split(/\s+/);
+          if (currentStatementType === '@import' || currentStatementType === '@use') {
+            importStatements.push({
+              target: targets[0],
+              start: importStart
+            });
+          }
+        }
+        currentToken = '';
+        currentStatementType = '';
+      } else if (char === '@' && !isInString) {
+        currentStatementType = '';
+        currentToken = '';
+        if (content.slice(i, i + 7) === '@import') {
+          currentStatementType = '@import';
+          i += 6;
+        } else if (content.slice(i, i + 4) === '@use') {
+          currentStatementType = '@use';
+          i += 3;
+        }
+      } else {
+        currentToken += char;
+      }
+    }
+  }
+  return importStatements;
+}

package/dist/build/scssImportParserChatgpt.sxyt.d.ts

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

package/dist/build/scssImportParserChatgpt.sxyt.d.ts.map

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

package/dist/build/scssImportParserChatgpt.sxyt.js

@@ -0,0 +1,120 @@
+import { describe } from 'sxy-test-runner';
+import { scssImportParserChatgpt } from "./scssImportParserChatgpt.js";
+describe('sassImportParser()', ({
+  it
+}) => {
+  const input = `@import 'foo';`;
+  it(`parses out an import '${input}'`, () => {
+    const imports = scssImportParserChatgpt(input);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+  const input2 = `@import 'foo';
+@import 'bar';`;
+  it(`parses out 2 imports from '${input2}'`, () => {
+    const imports = scssImportParserChatgpt(input2);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input3 = `    
+    @import 'foo';
+
+    @import 'bar';
+    
+`;
+  it(`parses out 2 imports with spaces from '${input3}'`, () => {
+    const imports = scssImportParserChatgpt(input3);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input4 = `    
+    @import 'foo';
+    @import 'bar';
+    p::after {
+        content: "@import 'baz'";
+    }
+`;
+  it(`ignores extra imports within style values '${input4}'`, () => {
+    const imports = scssImportParserChatgpt(input4);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input5b = `    
+    @import 'foo';
+    @import 'bar';
+    /* @use 'ignoremetoo'; */
+    @use 'baz';
+`;
+  it(`ignores imports within comments in '${input5b}'`, () => {
+    const imports = scssImportParserChatgpt(input5b);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar', 'baz']);
+  });
+  const input5c = `    
+    @import 'foo';
+    @import 'bar';
+    /*
+    @use 'ignoremealso';
+    */
+    @use 'baz';
+`;
+  it(`ignores imports within comments in '${input5c}'`, () => {
+    const imports = scssImportParserChatgpt(input5c);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar', 'baz']);
+  });
+  const input6 = `    
+    @import /* comment */ 'foo';
+    @import /* comment */'bar';
+`;
+  it(`tolerates comments within @import and @use statements in '${input6}'`, () => {
+    const imports = scssImportParserChatgpt(input6);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input7 = `    
+    @import'foo';
+    @import/* comment */'bar';
+`;
+  it(`does not require a space between @import / @use and the target using '${input7}'`, () => {
+    const imports = scssImportParserChatgpt(input7);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo', 'bar']);
+  });
+  const input8 = `@import 'foo';`;
+  it(`returns a correct index for the start position when extracting from '${input8}'`, () => {
+    const imports = scssImportParserChatgpt(input8);
+    Array.from(imports).should.deep.equal([{
+      target: 'foo',
+      start: 9
+    }]);
+  });
+  const input9 = `
+
+    @import 'bar';`;
+  it(`returns a correct index for the start position when extracting from '${input9}'`, () => {
+    const imports = scssImportParserChatgpt(input9);
+    Array.from(imports).should.deep.equal([{
+      target: 'bar',
+      start: 15
+    }]);
+  });
+  const input10 = `@use 'foo' as bar;`;
+  it(`handles aliasing in @use statements in '${input10}'`, () => {
+    const imports = scssImportParserChatgpt(input10);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+  const input11 = `@use './foo' as bar;`;
+  it(`extract relative targets from '${input11}'`, () => {
+    const imports = scssImportParserChatgpt(input11);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['./foo']);
+  });
+  const input12 = `@use "foo" as bar;`;
+  it(`handles double quotes in '${input12}'`, () => {
+    const imports = scssImportParserChatgpt(input12);
+    const targets = Array.from(imports).map(x => x.target);
+    targets.should.deep.equal(['foo']);
+  });
+});

package/dist/calculateImportedStaticFileLocations.d.ts

@@ -0,0 +1,10 @@
+import { TungstenError as TungstenError } from './TungstenError.js';
+export declare class TungstenFileNotInBaseError extends TungstenError {
+    name: string;
+}
+export declare function calculateImportedStaticFileLocations(projectDir: string, base: string, importer: string, imported: string): {
+    source: string;
+    target: string;
+    targetRel: string;
+};
+//# sourceMappingURL=calculateImportedStaticFileLocations.d.ts.map

package/dist/calculateImportedStaticFileLocations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateImportedStaticFileLocations.d.ts","sourceRoot":"","sources":["../src/calculateImportedStaticFileLocations.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAInE,qBAAa,0BAA2B,SAAQ,aAAa;IACzD,IAAI,SAA+B;CACtC;AAED,wBAAgB,oCAAoC,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;EAmCxH"}

package/dist/calculateImportedStaticFileLocations.js

@@ -0,0 +1,37 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/////////////////////////////////////////////////
+//// UNUSED
+/////////////////////////////////////////////////
+import { dirname, join } from 'path';
+import { TungstenError } from "./TungstenError.js";
+import { devBuildOuterFolder, packageNameCapitalized, staticFolder } from "./settings.js";
+export class TungstenFileNotInBaseError extends TungstenError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'TungstenFileNotInBaseError');
+  }
+}
+export function calculateImportedStaticFileLocations(projectDir, base, importer, imported) {
+  //return {}
+  if (!importer.startsWith(base)) {
+    throw new TungstenError(`${packageNameCapitalized}, calculatedImportedStaticFileTargetLocation() Error:` + ` The importing file does not appear to be inside the base folder` + `\nFile being processed: ${importer}` + `\nBase folder: ${base}`);
+  }
+  const relFile = importer.slice(base.length + 1);
+  //console.log('rel file', relFile)
+  const relDir = dirname(relFile);
+  //console.log('rel dir', relDir)
+  const source = join(base, relDir, imported);
+  //console.log('staticFolder', staticFolder)
+  //console.log('relDir', relDir)
+  //console.log('imported', imported)
+  const targetRel = join(staticFolder, relDir, imported);
+  //console.log('target rel file', targetRel)
+  const target = join(projectDir, devBuildOuterFolder, targetRel);
+  return {
+    source,
+    target,
+    targetRel
+  };
+}

package/dist/calledFrom.d.ts

@@ -0,0 +1,7 @@
+type Opts = {
+    excludeFunctions?: string[];
+    skip?: number;
+};
+export declare function calledFrom(_opts?: Opts): string;
+export {};
+//# sourceMappingURL=calledFrom.d.ts.map

package/dist/calledFrom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calledFrom.d.ts","sourceRoot":"","sources":["../src/calledFrom.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG;IACR,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAMD,wBAAgB,UAAU,CAAC,KAAK,GAAE,IAAS,UAwB1C"}