{"version":3,"names":["buildLoopBody","path","declar","newBody","block","bodyPath","get","body","node","t","isBlockStatement","Object","keys","getBindingIdentifiers","some","id","scope","hasOwnBinding","blockStatement","toBlock","unshift","declare","api","options","assertVersion","assumeArray","allowArrayLike","loose","Error","test","version","iterableIsArray","assumption","arrayLikeIsIterable","skipIteratorClosing","name","visitor","ForOfStatement","left","right","await","isAwait","i","generateUidIdentifier","array","maybeGenerateMemoised","inits","variableDeclarator","numericLiteral","push","item","memberExpression","cloneNode","assignment","isVariableDeclaration","declarations","init","expressionStatement","assignmentExpression","replaceWith","forStatement","variableDeclaration","binaryExpression","identifier","updateExpression","buildForOfArray","template","buildForOfNoIteratorClosing","statements","buildForOf","builder","build","helper","getContainer","nodes","_ForOfStatementArray","generateUidIdentifierBasedOnNode","iterationKey","loop","BODY","KEY","NAME","ARR","inherits","iterationValue","state","isArrayExpression","isGenericType","isArrayTypeAnnotation","getTypeAnnotation","availableHelper","transformWithoutHelper","parent","stepKey","generateUid","stepValue","kind","CREATE_ITERATOR_HELPER","addHelper","ITERATOR_HELPER","ARRAY_LIKE_IS_ITERABLE","booleanLiteral","STEP_KEY","OBJECT","container","isLabeledStatement","labeledStatement","label","parentPath","replaceWithMultiple","skip"],"sources":["../src/index.ts"],"sourcesContent":["import { declare } from \"@babel/helper-plugin-utils\";\nimport { template, types as t } from \"@babel/core\";\nimport type { NodePath } from \"@babel/traverse\";\n\nimport transformWithoutHelper from \"./no-helper-implementation\";\n\nexport interface Options {\n  allowArrayLike?: boolean;\n  assumeArray?: boolean;\n  loose?: boolean;\n}\n\nfunction buildLoopBody(\n  path: NodePath<t.ForXStatement>,\n  declar: t.Statement,\n  newBody?: t.Statement | t.Expression,\n) {\n  let block;\n  const bodyPath = path.get(\"body\");\n  const body = newBody ?? bodyPath.node;\n  if (\n    t.isBlockStatement(body) &&\n    Object.keys(path.getBindingIdentifiers()).some(id =>\n      bodyPath.scope.hasOwnBinding(id),\n    )\n  ) {\n    block = t.blockStatement([declar, body]);\n  } else {\n    block = t.toBlock(body);\n    block.body.unshift(declar);\n  }\n  return block;\n}\n\nexport default declare((api, options: Options) => {\n  api.assertVersion(7);\n\n  {\n    const { assumeArray, allowArrayLike, loose } = options;\n\n    if (loose === true && assumeArray === true) {\n      throw new Error(\n        `The loose and assumeArray options cannot be used together in @babel/plugin-transform-for-of`,\n      );\n    }\n\n    if (assumeArray === true && allowArrayLike === true) {\n      throw new Error(\n        `The assumeArray and allowArrayLike options cannot be used together in @babel/plugin-transform-for-of`,\n      );\n    }\n\n    // TODO: Remove in Babel 8\n    if (allowArrayLike && /^7\\.\\d\\./.test(api.version)) {\n      throw new Error(\n        `The allowArrayLike is only supported when using @babel/core@^7.10.0`,\n      );\n    }\n  }\n\n  const iterableIsArray =\n    options.assumeArray ??\n    // Loose mode is not compatible with 'assumeArray', so we shouldn't read\n    // 'iterableIsArray' if 'loose' is true.\n    (!options.loose && api.assumption(\"iterableIsArray\"));\n\n  const arrayLikeIsIterable =\n    options.allowArrayLike ?? api.assumption(\"arrayLikeIsIterable\");\n\n  const skipIteratorClosing =\n    api.assumption(\"skipForOfIteratorClosing\") ?? options.loose;\n\n  if (iterableIsArray && arrayLikeIsIterable) {\n    throw new Error(\n      `The \"iterableIsArray\" and \"arrayLikeIsIterable\" assumptions are not compatible.`,\n    );\n  }\n\n  if (iterableIsArray) {\n    return {\n      name: \"transform-for-of\",\n\n      visitor: {\n        ForOfStatement(path) {\n          const { scope } = path;\n          const { left, right, await: isAwait } = path.node;\n          if (isAwait) {\n            return;\n          }\n          const i = scope.generateUidIdentifier(\"i\");\n          let array: t.Identifier | t.ThisExpression =\n            scope.maybeGenerateMemoised(right, true);\n\n          const inits = [t.variableDeclarator(i, t.numericLiteral(0))];\n          if (array) {\n            inits.push(t.variableDeclarator(array, right));\n          } else {\n            array = right as t.Identifier | t.ThisExpression;\n          }\n\n          const item = t.memberExpression(\n            t.cloneNode(array),\n            t.cloneNode(i),\n            true,\n          );\n          let assignment;\n          if (t.isVariableDeclaration(left)) {\n            assignment = left;\n            assignment.declarations[0].init = item;\n          } else {\n            assignment = t.expressionStatement(\n              t.assignmentExpression(\"=\", left, item),\n            );\n          }\n\n          path.replaceWith(\n            t.forStatement(\n              t.variableDeclaration(\"let\", inits),\n              t.binaryExpression(\n                \"<\",\n                t.cloneNode(i),\n                t.memberExpression(t.cloneNode(array), t.identifier(\"length\")),\n              ),\n              t.updateExpression(\"++\", t.cloneNode(i)),\n              buildLoopBody(path, assignment),\n            ),\n          );\n        },\n      },\n    };\n  }\n\n  const buildForOfArray = template`\n    for (var KEY = 0, NAME = ARR; KEY < NAME.length; KEY++) BODY;\n  `;\n\n  const buildForOfNoIteratorClosing = template.statements`\n    for (var ITERATOR_HELPER = CREATE_ITERATOR_HELPER(OBJECT, ARRAY_LIKE_IS_ITERABLE), STEP_KEY;\n        !(STEP_KEY = ITERATOR_HELPER()).done;) BODY;\n  `;\n\n  const buildForOf = template.statements`\n    var ITERATOR_HELPER = CREATE_ITERATOR_HELPER(OBJECT, ARRAY_LIKE_IS_ITERABLE), STEP_KEY;\n    try {\n      for (ITERATOR_HELPER.s(); !(STEP_KEY = ITERATOR_HELPER.n()).done;) BODY;\n    } catch (err) {\n      ITERATOR_HELPER.e(err);\n    } finally {\n      ITERATOR_HELPER.f();\n    }\n  `;\n\n  const builder = skipIteratorClosing\n    ? {\n        build: buildForOfNoIteratorClosing,\n        helper: \"createForOfIteratorHelperLoose\",\n        getContainer: (nodes: t.Statement[]): [t.ForStatement] =>\n          nodes as [t.ForStatement],\n      }\n    : {\n        build: buildForOf,\n        helper: \"createForOfIteratorHelper\",\n        getContainer: (nodes: t.Statement[]): [t.ForStatement] =>\n          (nodes[1] as t.TryStatement).block.body as [t.ForStatement],\n      };\n\n  function _ForOfStatementArray(path: NodePath<t.ForOfStatement>) {\n    const { node, scope } = path;\n\n    const right = scope.generateUidIdentifierBasedOnNode(node.right, \"arr\");\n    const iterationKey = scope.generateUidIdentifier(\"i\");\n\n    const loop = buildForOfArray({\n      BODY: node.body,\n      KEY: iterationKey,\n      NAME: right,\n      ARR: node.right,\n    }) as t.For;\n\n    t.inherits(loop, node);\n\n    const iterationValue = t.memberExpression(\n      t.cloneNode(right),\n      t.cloneNode(iterationKey),\n      true,\n    );\n\n    let declar;\n    const left = node.left;\n    if (t.isVariableDeclaration(left)) {\n      left.declarations[0].init = iterationValue;\n      declar = left;\n    } else {\n      declar = t.expressionStatement(\n        t.assignmentExpression(\"=\", left, iterationValue),\n      );\n    }\n\n    loop.body = buildLoopBody(path, declar, loop.body);\n\n    return loop;\n  }\n\n  return {\n    name: \"transform-for-of\",\n    visitor: {\n      ForOfStatement(path, state) {\n        const right = path.get(\"right\");\n        if (\n          right.isArrayExpression() ||\n          (process.env.BABEL_8_BREAKING\n            ? right.isGenericType(\"Array\")\n            : right.isGenericType(\"Array\") ||\n              t.isArrayTypeAnnotation(right.getTypeAnnotation()))\n        ) {\n          path.replaceWith(_ForOfStatementArray(path));\n          return;\n        }\n\n        if (!state.availableHelper(builder.helper)) {\n          // Babel <7.9.0 doesn't support this helper\n          transformWithoutHelper(skipIteratorClosing, path, state);\n          return;\n        }\n\n        const { node, parent, scope } = path;\n        const left = node.left;\n        let declar;\n\n        const stepKey = scope.generateUid(\"step\");\n        const stepValue = t.memberExpression(\n          t.identifier(stepKey),\n          t.identifier(\"value\"),\n        );\n\n        if (t.isVariableDeclaration(left)) {\n          // for (let i of test)\n          declar = t.variableDeclaration(left.kind, [\n            t.variableDeclarator(left.declarations[0].id, stepValue),\n          ]);\n        } else {\n          // for (i of test), for ({ i } of test)\n          declar = t.expressionStatement(\n            t.assignmentExpression(\"=\", left, stepValue),\n          );\n        }\n\n        const nodes = builder.build({\n          CREATE_ITERATOR_HELPER: state.addHelper(builder.helper),\n          ITERATOR_HELPER: scope.generateUidIdentifier(\"iterator\"),\n          ARRAY_LIKE_IS_ITERABLE: arrayLikeIsIterable\n            ? t.booleanLiteral(true)\n            : null,\n          STEP_KEY: t.identifier(stepKey),\n          OBJECT: node.right,\n          BODY: buildLoopBody(path, declar),\n        });\n        const container = builder.getContainer(nodes);\n\n        t.inherits(container[0], node);\n        t.inherits(container[0].body, node.body);\n\n        if (t.isLabeledStatement(parent)) {\n          // @ts-expect-error replacing node types\n          container[0] = t.labeledStatement(parent.label, container[0]);\n\n          path.parentPath.replaceWithMultiple(nodes);\n\n          // The parent has been replaced, prevent Babel from traversing a detached path\n          path.skip();\n        } else {\n          path.replaceWithMultiple(nodes);\n        }\n      },\n    },\n  };\n});\n"],"mappings":";;;;;;AAAA;AACA;AAGA;AAQA,SAASA,aAAa,CACpBC,IAA+B,EAC/BC,MAAmB,EACnBC,OAAoC,EACpC;EACA,IAAIC,KAAK;EACT,MAAMC,QAAQ,GAAGJ,IAAI,CAACK,GAAG,CAAC,MAAM,CAAC;EACjC,MAAMC,IAAI,GAAGJ,OAAO,WAAPA,OAAO,GAAIE,QAAQ,CAACG,IAAI;EACrC,IACEC,WAAC,CAACC,gBAAgB,CAACH,IAAI,CAAC,IACxBI,MAAM,CAACC,IAAI,CAACX,IAAI,CAACY,qBAAqB,EAAE,CAAC,CAACC,IAAI,CAACC,EAAE,IAC/CV,QAAQ,CAACW,KAAK,CAACC,aAAa,CAACF,EAAE,CAAC,CACjC,EACD;IACAX,KAAK,GAAGK,WAAC,CAACS,cAAc,CAAC,CAAChB,MAAM,EAAEK,IAAI,CAAC,CAAC;EAC1C,CAAC,MAAM;IACLH,KAAK,GAAGK,WAAC,CAACU,OAAO,CAACZ,IAAI,CAAC;IACvBH,KAAK,CAACG,IAAI,CAACa,OAAO,CAAClB,MAAM,CAAC;EAC5B;EACA,OAAOE,KAAK;AACd;AAAC,eAEc,IAAAiB,0BAAO,EAAC,CAACC,GAAG,EAAEC,OAAgB,KAAK;EAAA;EAChDD,GAAG,CAACE,aAAa,CAAC,CAAC,CAAC;EAEpB;IACE,MAAM;MAAEC,WAAW;MAAEC,cAAc;MAAEC;IAAM,CAAC,GAAGJ,OAAO;IAEtD,IAAII,KAAK,KAAK,IAAI,IAAIF,WAAW,KAAK,IAAI,EAAE;MAC1C,MAAM,IAAIG,KAAK,CACZ,6FAA4F,CAC9F;IACH;IAEA,IAAIH,WAAW,KAAK,IAAI,IAAIC,cAAc,KAAK,IAAI,EAAE;MACnD,MAAM,IAAIE,KAAK,CACZ,sGAAqG,CACvG;IACH;IAGA,IAAIF,cAAc,IAAI,UAAU,CAACG,IAAI,CAACP,GAAG,CAACQ,OAAO,CAAC,EAAE;MAClD,MAAM,IAAIF,KAAK,CACZ,qEAAoE,CACtE;IACH;EACF;EAEA,MAAMG,eAAe,2BACnBR,OAAO,CAACE,WAAW,mCAGlB,CAACF,OAAO,CAACI,KAAK,IAAIL,GAAG,CAACU,UAAU,CAAC,iBAAiB,CAAE;EAEvD,MAAMC,mBAAmB,4BACvBV,OAAO,CAACG,cAAc,oCAAIJ,GAAG,CAACU,UAAU,CAAC,qBAAqB,CAAC;EAEjE,MAAME,mBAAmB,sBACvBZ,GAAG,CAACU,UAAU,CAAC,0BAA0B,CAAC,8BAAIT,OAAO,CAACI,KAAK;EAE7D,IAAII,eAAe,IAAIE,mBAAmB,EAAE;IAC1C,MAAM,IAAIL,KAAK,CACZ,iFAAgF,CAClF;EACH;EAEA,IAAIG,eAAe,EAAE;IACnB,OAAO;MACLI,IAAI,EAAE,kBAAkB;MAExBC,OAAO,EAAE;QACPC,cAAc,CAACpC,IAAI,EAAE;UACnB,MAAM;YAAEe;UAAM,CAAC,GAAGf,IAAI;UACtB,MAAM;YAAEqC,IAAI;YAAEC,KAAK;YAAEC,KAAK,EAAEC;UAAQ,CAAC,GAAGxC,IAAI,CAACO,IAAI;UACjD,IAAIiC,OAAO,EAAE;YACX;UACF;UACA,MAAMC,CAAC,GAAG1B,KAAK,CAAC2B,qBAAqB,CAAC,GAAG,CAAC;UAC1C,IAAIC,KAAsC,GACxC5B,KAAK,CAAC6B,qBAAqB,CAACN,KAAK,EAAE,IAAI,CAAC;UAE1C,MAAMO,KAAK,GAAG,CAACrC,WAAC,CAACsC,kBAAkB,CAACL,CAAC,EAAEjC,WAAC,CAACuC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;UAC5D,IAAIJ,KAAK,EAAE;YACTE,KAAK,CAACG,IAAI,CAACxC,WAAC,CAACsC,kBAAkB,CAACH,KAAK,EAAEL,KAAK,CAAC,CAAC;UAChD,CAAC,MAAM;YACLK,KAAK,GAAGL,KAAwC;UAClD;UAEA,MAAMW,IAAI,GAAGzC,WAAC,CAAC0C,gBAAgB,CAC7B1C,WAAC,CAAC2C,SAAS,CAACR,KAAK,CAAC,EAClBnC,WAAC,CAAC2C,SAAS,CAACV,CAAC,CAAC,EACd,IAAI,CACL;UACD,IAAIW,UAAU;UACd,IAAI5C,WAAC,CAAC6C,qBAAqB,CAAChB,IAAI,CAAC,EAAE;YACjCe,UAAU,GAAGf,IAAI;YACjBe,UAAU,CAACE,YAAY,CAAC,CAAC,CAAC,CAACC,IAAI,GAAGN,IAAI;UACxC,CAAC,MAAM;YACLG,UAAU,GAAG5C,WAAC,CAACgD,mBAAmB,CAChChD,WAAC,CAACiD,oBAAoB,CAAC,GAAG,EAAEpB,IAAI,EAAEY,IAAI,CAAC,CACxC;UACH;UAEAjD,IAAI,CAAC0D,WAAW,CACdlD,WAAC,CAACmD,YAAY,CACZnD,WAAC,CAACoD,mBAAmB,CAAC,KAAK,EAAEf,KAAK,CAAC,EACnCrC,WAAC,CAACqD,gBAAgB,CAChB,GAAG,EACHrD,WAAC,CAAC2C,SAAS,CAACV,CAAC,CAAC,EACdjC,WAAC,CAAC0C,gBAAgB,CAAC1C,WAAC,CAAC2C,SAAS,CAACR,KAAK,CAAC,EAAEnC,WAAC,CAACsD,UAAU,CAAC,QAAQ,CAAC,CAAC,CAC/D,EACDtD,WAAC,CAACuD,gBAAgB,CAAC,IAAI,EAAEvD,WAAC,CAAC2C,SAAS,CAACV,CAAC,CAAC,CAAC,EACxC1C,aAAa,CAACC,IAAI,EAAEoD,UAAU,CAAC,CAChC,CACF;QACH;MACF;IACF,CAAC;EACH;EAEA,MAAMY,eAAe,GAAG,IAAAC,cAAQ,CAAC;AACnC;AACA,GAAG;EAED,MAAMC,2BAA2B,GAAGD,cAAQ,CAACE,UAAW;AAC1D;AACA;AACA,GAAG;EAED,MAAMC,UAAU,GAAGH,cAAQ,CAACE,UAAW;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;EAED,MAAME,OAAO,GAAGpC,mBAAmB,GAC/B;IACEqC,KAAK,EAAEJ,2BAA2B;IAClCK,MAAM,EAAE,gCAAgC;IACxCC,YAAY,EAAGC,KAAoB,IACjCA;EACJ,CAAC,GACD;IACEH,KAAK,EAAEF,UAAU;IACjBG,MAAM,EAAE,2BAA2B;IACnCC,YAAY,EAAGC,KAAoB,IAChCA,KAAK,CAAC,CAAC,CAAC,CAAoBtE,KAAK,CAACG;EACvC,CAAC;EAEL,SAASoE,oBAAoB,CAAC1E,IAAgC,EAAE;IAC9D,MAAM;MAAEO,IAAI;MAAEQ;IAAM,CAAC,GAAGf,IAAI;IAE5B,MAAMsC,KAAK,GAAGvB,KAAK,CAAC4D,gCAAgC,CAACpE,IAAI,CAAC+B,KAAK,EAAE,KAAK,CAAC;IACvE,MAAMsC,YAAY,GAAG7D,KAAK,CAAC2B,qBAAqB,CAAC,GAAG,CAAC;IAErD,MAAMmC,IAAI,GAAGb,eAAe,CAAC;MAC3Bc,IAAI,EAAEvE,IAAI,CAACD,IAAI;MACfyE,GAAG,EAAEH,YAAY;MACjBI,IAAI,EAAE1C,KAAK;MACX2C,GAAG,EAAE1E,IAAI,CAAC+B;IACZ,CAAC,CAAU;IAEX9B,WAAC,CAAC0E,QAAQ,CAACL,IAAI,EAAEtE,IAAI,CAAC;IAEtB,MAAM4E,cAAc,GAAG3E,WAAC,CAAC0C,gBAAgB,CACvC1C,WAAC,CAAC2C,SAAS,CAACb,KAAK,CAAC,EAClB9B,WAAC,CAAC2C,SAAS,CAACyB,YAAY,CAAC,EACzB,IAAI,CACL;IAED,IAAI3E,MAAM;IACV,MAAMoC,IAAI,GAAG9B,IAAI,CAAC8B,IAAI;IACtB,IAAI7B,WAAC,CAAC6C,qBAAqB,CAAChB,IAAI,CAAC,EAAE;MACjCA,IAAI,CAACiB,YAAY,CAAC,CAAC,CAAC,CAACC,IAAI,GAAG4B,cAAc;MAC1ClF,MAAM,GAAGoC,IAAI;IACf,CAAC,MAAM;MACLpC,MAAM,GAAGO,WAAC,CAACgD,mBAAmB,CAC5BhD,WAAC,CAACiD,oBAAoB,CAAC,GAAG,EAAEpB,IAAI,EAAE8C,cAAc,CAAC,CAClD;IACH;IAEAN,IAAI,CAACvE,IAAI,GAAGP,aAAa,CAACC,IAAI,EAAEC,MAAM,EAAE4E,IAAI,CAACvE,IAAI,CAAC;IAElD,OAAOuE,IAAI;EACb;EAEA,OAAO;IACL3C,IAAI,EAAE,kBAAkB;IACxBC,OAAO,EAAE;MACPC,cAAc,CAACpC,IAAI,EAAEoF,KAAK,EAAE;QAC1B,MAAM9C,KAAK,GAAGtC,IAAI,CAACK,GAAG,CAAC,OAAO,CAAC;QAC/B,IACEiC,KAAK,CAAC+C,iBAAiB,EAAE,IAGrB/C,KAAK,CAACgD,aAAa,CAAC,OAAO,CAAC,IAC5B9E,WAAC,CAAC+E,qBAAqB,CAACjD,KAAK,CAACkD,iBAAiB,EAAE,CAAE,EACvD;UACAxF,IAAI,CAAC0D,WAAW,CAACgB,oBAAoB,CAAC1E,IAAI,CAAC,CAAC;UAC5C;QACF;QAEA,IAAI,CAACoF,KAAK,CAACK,eAAe,CAACpB,OAAO,CAACE,MAAM,CAAC,EAAE;UAE1C,IAAAmB,+BAAsB,EAACzD,mBAAmB,EAAEjC,IAAI,EAAEoF,KAAK,CAAC;UACxD;QACF;QAEA,MAAM;UAAE7E,IAAI;UAAEoF,MAAM;UAAE5E;QAAM,CAAC,GAAGf,IAAI;QACpC,MAAMqC,IAAI,GAAG9B,IAAI,CAAC8B,IAAI;QACtB,IAAIpC,MAAM;QAEV,MAAM2F,OAAO,GAAG7E,KAAK,CAAC8E,WAAW,CAAC,MAAM,CAAC;QACzC,MAAMC,SAAS,GAAGtF,WAAC,CAAC0C,gBAAgB,CAClC1C,WAAC,CAACsD,UAAU,CAAC8B,OAAO,CAAC,EACrBpF,WAAC,CAACsD,UAAU,CAAC,OAAO,CAAC,CACtB;QAED,IAAItD,WAAC,CAAC6C,qBAAqB,CAAChB,IAAI,CAAC,EAAE;UAEjCpC,MAAM,GAAGO,WAAC,CAACoD,mBAAmB,CAACvB,IAAI,CAAC0D,IAAI,EAAE,CACxCvF,WAAC,CAACsC,kBAAkB,CAACT,IAAI,CAACiB,YAAY,CAAC,CAAC,CAAC,CAACxC,EAAE,EAAEgF,SAAS,CAAC,CACzD,CAAC;QACJ,CAAC,MAAM;UAEL7F,MAAM,GAAGO,WAAC,CAACgD,mBAAmB,CAC5BhD,WAAC,CAACiD,oBAAoB,CAAC,GAAG,EAAEpB,IAAI,EAAEyD,SAAS,CAAC,CAC7C;QACH;QAEA,MAAMrB,KAAK,GAAGJ,OAAO,CAACC,KAAK,CAAC;UAC1B0B,sBAAsB,EAAEZ,KAAK,CAACa,SAAS,CAAC5B,OAAO,CAACE,MAAM,CAAC;UACvD2B,eAAe,EAAEnF,KAAK,CAAC2B,qBAAqB,CAAC,UAAU,CAAC;UACxDyD,sBAAsB,EAAEnE,mBAAmB,GACvCxB,WAAC,CAAC4F,cAAc,CAAC,IAAI,CAAC,GACtB,IAAI;UACRC,QAAQ,EAAE7F,WAAC,CAACsD,UAAU,CAAC8B,OAAO,CAAC;UAC/BU,MAAM,EAAE/F,IAAI,CAAC+B,KAAK;UAClBwC,IAAI,EAAE/E,aAAa,CAACC,IAAI,EAAEC,MAAM;QAClC,CAAC,CAAC;QACF,MAAMsG,SAAS,GAAGlC,OAAO,CAACG,YAAY,CAACC,KAAK,CAAC;QAE7CjE,WAAC,CAAC0E,QAAQ,CAACqB,SAAS,CAAC,CAAC,CAAC,EAAEhG,IAAI,CAAC;QAC9BC,WAAC,CAAC0E,QAAQ,CAACqB,SAAS,CAAC,CAAC,CAAC,CAACjG,IAAI,EAAEC,IAAI,CAACD,IAAI,CAAC;QAExC,IAAIE,WAAC,CAACgG,kBAAkB,CAACb,MAAM,CAAC,EAAE;UAEhCY,SAAS,CAAC,CAAC,CAAC,GAAG/F,WAAC,CAACiG,gBAAgB,CAACd,MAAM,CAACe,KAAK,EAAEH,SAAS,CAAC,CAAC,CAAC,CAAC;UAE7DvG,IAAI,CAAC2G,UAAU,CAACC,mBAAmB,CAACnC,KAAK,CAAC;UAG1CzE,IAAI,CAAC6G,IAAI,EAAE;QACb,CAAC,MAAM;UACL7G,IAAI,CAAC4G,mBAAmB,CAACnC,KAAK,CAAC;QACjC;MACF;IACF;EACF,CAAC;AACH,CAAC,CAAC;AAAA"}