@fps-games/editor 0.1.8 → 0.2.0-beta.2

package/node_modules/semver/ranges/max-satisfying.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+
+const maxSatisfying = (versions, range, options) => {
+  let max = null
+  let maxSV = null
+  let rangeObj = null
+  try {
+    rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!max || maxSV.compare(v) === -1) {
+        // compare(max, v, true)
+        max = v
+        maxSV = new SemVer(max, options)
+      }
+    }
+  })
+  return max
+}
+module.exports = maxSatisfying

package/node_modules/semver/ranges/min-satisfying.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+const minSatisfying = (versions, range, options) => {
+  let min = null
+  let minSV = null
+  let rangeObj = null
+  try {
+    rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!min || minSV.compare(v) === 1) {
+        // compare(min, v, true)
+        min = v
+        minSV = new SemVer(min, options)
+      }
+    }
+  })
+  return min
+}
+module.exports = minSatisfying

package/node_modules/semver/ranges/min-version.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+const gt = require('../functions/gt')
+
+const minVersion = (range, loose) => {
+  range = new Range(range, loose)
+
+  let minver = new SemVer('0.0.0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = new SemVer('0.0.0-0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = null
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let setMin = null
+    comparators.forEach((comparator) => {
+      // Clone to avoid manipulating the comparator's semver object.
+      const compver = new SemVer(comparator.semver.version)
+      switch (comparator.operator) {
+        case '>':
+          if (compver.prerelease.length === 0) {
+            compver.patch++
+          } else {
+            compver.prerelease.push(0)
+          }
+          compver.raw = compver.format()
+          /* fallthrough */
+        case '':
+        case '>=':
+          if (!setMin || gt(compver, setMin)) {
+            setMin = compver
+          }
+          break
+        case '<':
+        case '<=':
+          /* Ignore maximum versions */
+          break
+        /* istanbul ignore next */
+        default:
+          throw new Error(`Unexpected operation: ${comparator.operator}`)
+      }
+    })
+    if (setMin && (!minver || gt(minver, setMin))) {
+      minver = setMin
+    }
+  }
+
+  if (minver && range.test(minver)) {
+    return minver
+  }
+
+  return null
+}
+module.exports = minVersion

package/node_modules/semver/ranges/outside.js

@@ -0,0 +1,82 @@
+'use strict'
+
+const SemVer = require('../classes/semver')
+const Comparator = require('../classes/comparator')
+const { ANY } = Comparator
+const Range = require('../classes/range')
+const satisfies = require('../functions/satisfies')
+const gt = require('../functions/gt')
+const lt = require('../functions/lt')
+const lte = require('../functions/lte')
+const gte = require('../functions/gte')
+
+const outside = (version, range, hilo, options) => {
+  version = new SemVer(version, options)
+  range = new Range(range, options)
+
+  let gtfn, ltefn, ltfn, comp, ecomp
+  switch (hilo) {
+    case '>':
+      gtfn = gt
+      ltefn = lte
+      ltfn = lt
+      comp = '>'
+      ecomp = '>='
+      break
+    case '<':
+      gtfn = lt
+      ltefn = gte
+      ltfn = gt
+      comp = '<'
+      ecomp = '<='
+      break
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"')
+  }
+
+  // If it satisfies the range it is not outside
+  if (satisfies(version, range, options)) {
+    return false
+  }
+
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
+
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let high = null
+    let low = null
+
+    comparators.forEach((comparator) => {
+      if (comparator.semver === ANY) {
+        comparator = new Comparator('>=0.0.0')
+      }
+      high = high || comparator
+      low = low || comparator
+      if (gtfn(comparator.semver, high.semver, options)) {
+        high = comparator
+      } else if (ltfn(comparator.semver, low.semver, options)) {
+        low = comparator
+      }
+    })
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) &&
+        ltefn(version, low.semver)) {
+      return false
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false
+    }
+  }
+  return true
+}
+
+module.exports = outside

package/node_modules/semver/ranges/simplify.js

@@ -0,0 +1,49 @@
+'use strict'
+
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+module.exports = (versions, range, options) => {
+  const set = []
+  let first = null
+  let prev = null
+  const v = versions.sort((a, b) => compare(a, b, options))
+  for (const version of v) {
+    const included = satisfies(version, range, options)
+    if (included) {
+      prev = version
+      if (!first) {
+        first = version
+      }
+    } else {
+      if (prev) {
+        set.push([first, prev])
+      }
+      prev = null
+      first = null
+    }
+  }
+  if (first) {
+    set.push([first, null])
+  }
+
+  const ranges = []
+  for (const [min, max] of set) {
+    if (min === max) {
+      ranges.push(min)
+    } else if (!max && min === v[0]) {
+      ranges.push('*')
+    } else if (!max) {
+      ranges.push(`>=${min}`)
+    } else if (min === v[0]) {
+      ranges.push(`<=${max}`)
+    } else {
+      ranges.push(`${min} - ${max}`)
+    }
+  }
+  const simplified = ranges.join(' || ')
+  const original = typeof range.raw === 'string' ? range.raw : String(range)
+  return simplified.length < original.length ? simplified : range
+}

package/node_modules/semver/ranges/subset.js

@@ -0,0 +1,249 @@
+'use strict'
+
+const Range = require('../classes/range.js')
+const Comparator = require('../classes/comparator.js')
+const { ANY } = Comparator
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+
+// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
+// - Every simple range `r1, r2, ...` is a null set, OR
+// - Every simple range `r1, r2, ...` which is not a null set is a subset of
+//   some `R1, R2, ...`
+//
+// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
+// - If c is only the ANY comparator
+//   - If C is only the ANY comparator, return true
+//   - Else if in prerelease mode, return false
+//   - else replace c with `[>=0.0.0]`
+// - If C is only the ANY comparator
+//   - if in prerelease mode, return true
+//   - else replace C with `[>=0.0.0]`
+// - Let EQ be the set of = comparators in c
+// - If EQ is more than one, return true (null set)
+// - Let GT be the highest > or >= comparator in c
+// - Let LT be the lowest < or <= comparator in c
+// - If GT and LT, and GT.semver > LT.semver, return true (null set)
+// - If any C is a = range, and GT or LT are set, return false
+// - If EQ
+//   - If GT, and EQ does not satisfy GT, return true (null set)
+//   - If LT, and EQ does not satisfy LT, return true (null set)
+//   - If EQ satisfies every C, return true
+//   - Else return false
+// - If GT
+//   - If GT.semver is lower than any > or >= comp in C, return false
+//   - If GT is >=, and GT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the GT.semver tuple, return false
+// - If LT
+//   - If LT.semver is greater than any < or <= comp in C, return false
+//   - If LT is <=, and LT.semver does not satisfy every C, return false
+//   - If LT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the LT.semver tuple, return false
+// - Else return true
+
+const subset = (sub, dom, options = {}) => {
+  if (sub === dom) {
+    return true
+  }
+
+  sub = new Range(sub, options)
+  dom = new Range(dom, options)
+  let sawNonNull = false
+
+  OUTER: for (const simpleSub of sub.set) {
+    for (const simpleDom of dom.set) {
+      const isSub = simpleSubset(simpleSub, simpleDom, options)
+      sawNonNull = sawNonNull || isSub !== null
+      if (isSub) {
+        continue OUTER
+      }
+    }
+    // the null set is a subset of everything, but null simple ranges in
+    // a complex range should be ignored.  so if we saw a non-null range,
+    // then we know this isn't a subset, but if EVERY simple range was null,
+    // then it is a subset.
+    if (sawNonNull) {
+      return false
+    }
+  }
+  return true
+}
+
+const minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]
+const minimumVersion = [new Comparator('>=0.0.0')]
+
+const simpleSubset = (sub, dom, options) => {
+  if (sub === dom) {
+    return true
+  }
+
+  if (sub.length === 1 && sub[0].semver === ANY) {
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      return true
+    } else if (options.includePrerelease) {
+      sub = minimumVersionWithPreRelease
+    } else {
+      sub = minimumVersion
+    }
+  }
+
+  if (dom.length === 1 && dom[0].semver === ANY) {
+    if (options.includePrerelease) {
+      return true
+    } else {
+      dom = minimumVersion
+    }
+  }
+
+  const eqSet = new Set()
+  let gt, lt
+  for (const c of sub) {
+    if (c.operator === '>' || c.operator === '>=') {
+      gt = higherGT(gt, c, options)
+    } else if (c.operator === '<' || c.operator === '<=') {
+      lt = lowerLT(lt, c, options)
+    } else {
+      eqSet.add(c.semver)
+    }
+  }
+
+  if (eqSet.size > 1) {
+    return null
+  }
+
+  let gtltComp
+  if (gt && lt) {
+    gtltComp = compare(gt.semver, lt.semver, options)
+    if (gtltComp > 0) {
+      return null
+    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
+      return null
+    }
+  }
+
+  // will iterate one or zero times
+  for (const eq of eqSet) {
+    if (gt && !satisfies(eq, String(gt), options)) {
+      return null
+    }
+
+    if (lt && !satisfies(eq, String(lt), options)) {
+      return null
+    }
+
+    for (const c of dom) {
+      if (!satisfies(eq, String(c), options)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  let higher, lower
+  let hasDomLT, hasDomGT
+  // if the subset has a prerelease, we need a comparator in the superset
+  // with the same tuple and a prerelease, or it's not a subset
+  let needDomLTPre = lt &&
+    !options.includePrerelease &&
+    lt.semver.prerelease.length ? lt.semver : false
+  let needDomGTPre = gt &&
+    !options.includePrerelease &&
+    gt.semver.prerelease.length ? gt.semver : false
+  // exception: <1.2.3-0 is the same as <1.2.3
+  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
+      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
+    needDomLTPre = false
+  }
+
+  for (const c of dom) {
+    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='
+    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='
+    if (gt) {
+      if (needDomGTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomGTPre.major &&
+            c.semver.minor === needDomGTPre.minor &&
+            c.semver.patch === needDomGTPre.patch) {
+          needDomGTPre = false
+        }
+      }
+      if (c.operator === '>' || c.operator === '>=') {
+        higher = higherGT(gt, c, options)
+        if (higher === c && higher !== gt) {
+          return false
+        }
+      } else if (gt.operator === '>=' && !c.test(gt.semver)) {
+        return false
+      }
+    }
+    if (lt) {
+      if (needDomLTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomLTPre.major &&
+            c.semver.minor === needDomLTPre.minor &&
+            c.semver.patch === needDomLTPre.patch) {
+          needDomLTPre = false
+        }
+      }
+      if (c.operator === '<' || c.operator === '<=') {
+        lower = lowerLT(lt, c, options)
+        if (lower === c && lower !== lt) {
+          return false
+        }
+      } else if (lt.operator === '<=' && !c.test(lt.semver)) {
+        return false
+      }
+    }
+    if (!c.operator && (lt || gt) && gtltComp !== 0) {
+      return false
+    }
+  }
+
+  // if there was a < or >, and nothing in the dom, then must be false
+  // UNLESS it was limited by another range in the other direction.
+  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
+  if (gt && hasDomLT && !lt && gtltComp !== 0) {
+    return false
+  }
+
+  if (lt && hasDomGT && !gt && gtltComp !== 0) {
+    return false
+  }
+
+  // we needed a prerelease range in a specific tuple, but didn't get one
+  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
+  // because it includes prereleases in the 1.2.3 tuple
+  if (needDomGTPre || needDomLTPre) {
+    return false
+  }
+
+  return true
+}
+
+// >=1.2.3 is lower than >1.2.3
+const higherGT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp > 0 ? a
+    : comp < 0 ? b
+    : b.operator === '>' && a.operator === '>=' ? b
+    : a
+}
+
+// <=1.2.3 is higher than <1.2.3
+const lowerLT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp < 0 ? a
+    : comp > 0 ? b
+    : b.operator === '<' && a.operator === '<=' ? b
+    : a
+}
+
+module.exports = subset

package/node_modules/semver/ranges/to-comparators.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const Range = require('../classes/range')
+
+// Mostly just for testing and legacy API reasons
+const toComparators = (range, options) =>
+  new Range(range, options).set
+    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))
+
+module.exports = toComparators

package/node_modules/semver/ranges/valid.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const Range = require('../classes/range')
+const validRange = (range, options) => {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range(range, options).range || '*'
+  } catch (er) {
+    return null
+  }
+}
+module.exports = validRange

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fps-games/editor",
-  "version": "0.1.8",
+  "version": "0.2.0-beta.2",
   "type": "module",
   "description": "Aggregate public entrypoint for fps-game-editor.",
   "repository": {
@@ -16,40 +16,85 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
+    },
+    "./vite/client": {
+      "types": "./dist/vite-client.d.ts"
+    },
     "./playable-sdk": {
       "types": "./dist/playable-sdk.d.ts",
       "import": "./dist/playable-sdk.js"
     },
+    "./playable-runtime": {
+      "types": "./dist/playable-runtime.d.ts",
+      "import": "./dist/playable-runtime.js"
+    },
+    "./playable-runtime/babylon": {
+      "types": "./dist/playable-runtime-babylon.d.ts",
+      "import": "./dist/playable-runtime-babylon.js"
+    },
     "./playable-sdk/vite": {
       "types": "./dist/playable-sdk-vite.d.ts",
       "import": "./dist/playable-sdk-vite.js"
+    },
+    "./playable-sdk/upgrade-doctor": {
+      "types": "./dist/playable-sdk-upgrade-doctor.d.ts",
+      "import": "./dist/playable-sdk-upgrade-doctor.js"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc -b",
+    "build": "tsc -b && node ../../scripts/copy-static-declarations.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "prepack": "node ../../scripts/prepare-single-package.mjs"
   },
   "dependencies": {
-    "@fps-games/babylon-renderer": "0.1.8",
-    "@fps-games/editor-babylon": "0.1.8",
-    "@fps-games/editor-browser": "0.1.8",
-    "@fps-games/editor-core": "0.1.8",
-    "@fps-games/editor-forge-play": "0.1.8",
-    "@fps-games/editor-playable-sdk": "0.1.8",
-    "@fps-games/editor-protocol": "0.1.8"
+    "@babel/parser": "^7.28.5",
+    "@fps-games/babylon-renderer": "0.2.0-beta.2",
+    "@fps-games/editor-babylon": "0.2.0-beta.2",
+    "@fps-games/editor-browser": "0.2.0-beta.2",
+    "@fps-games/editor-core": "0.2.0-beta.2",
+    "@fps-games/editor-forge-play": "0.2.0-beta.2",
+    "@fps-games/editor-playable-sdk": "0.2.0-beta.2",
+    "@fps-games/editor-tooling": "0.2.0-beta.2",
+    "@fps-games/playable-runtime": "0.2.0-beta.2",
+    "@fps-games/playable-rendering": "0.2.0-beta.2",
+    "@fps-games/plugin-api": "0.2.0-beta.2",
+    "@fps-games/plugin-assets": "0.2.0-beta.2",
+    "@fps-games/plugin-materials": "0.2.0-beta.2",
+    "@fps-games/plugin-markers": "0.2.0-beta.2",
+    "@fps-games/plugin-rendering": "0.2.0-beta.2",
+    "@fps-games/plugin-shadows": "0.2.0-beta.2",
+    "@fps-games/plugin-host": "0.2.0-beta.2",
+    "@fps-games/plugin-scene": "0.2.0-beta.2",
+    "@fps-games/editor-protocol": "0.2.0-beta.2",
+    "semver": "^7.8.5"
   },
   "bundleDependencies": [
+    "@babel/parser",
     "@fps-games/babylon-renderer",
     "@fps-games/editor-babylon",
     "@fps-games/editor-browser",
     "@fps-games/editor-core",
     "@fps-games/editor-forge-play",
     "@fps-games/editor-playable-sdk",
-    "@fps-games/editor-protocol"
+    "@fps-games/editor-tooling",
+    "@fps-games/playable-runtime",
+    "@fps-games/editor-protocol",
+    "@fps-games/playable-rendering",
+    "@fps-games/plugin-api",
+    "@fps-games/plugin-assets",
+    "@fps-games/plugin-materials",
+    "@fps-games/plugin-markers",
+    "@fps-games/plugin-rendering",
+    "@fps-games/plugin-shadows",
+    "@fps-games/plugin-host",
+    "@fps-games/plugin-scene",
+    "semver"
   ],
   "publishConfig": {
     "access": "public"

package/node_modules/@fps-games/babylon-renderer/dist/shadows/static-projected-shadow-system.d.ts

@@ -1,38 +0,0 @@
-import type { DirectionalLight } from '@babylonjs/core/Lights/directionalLight';
-import type { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
-import type { Scene } from '@babylonjs/core/scene';
-import { type ResolvedStaticProjectedShadowOptions, type StaticProjectedShadowArtifact, type StaticProjectedShadowArtifactDiagnostic, type StaticProjectedShadowOptions } from './types';
-/**
- * @deprecated Static projected shadows are artifact-only at runtime. Use
- * createStaticProjectedShadowArtifactSystem() for runtime/preview consumption
- * and StaticProjectedShadowBaker for editor/build-time baking.
- */
-export interface LegacyStaticProjectedShadowSystem {
-    initialize(): void;
-    addCaster(mesh: AbstractMesh): void;
-    removeCaster(mesh: AbstractMesh): void;
-    invalidateCaster(mesh: AbstractMesh): void;
-    enableCasterAutoDetection(patterns: string[]): void;
-    enableAutoDetectionForAll(): void;
-    refresh(): void;
-    setArtifact(artifact: StaticProjectedShadowArtifact | null | undefined): void;
-    setOptions(options: Partial<StaticProjectedShadowOptions> & {
-        artifact?: StaticProjectedShadowArtifact | null;
-    }): void;
-    getOptions(): ResolvedStaticProjectedShadowOptions;
-    getCasterInfo(mesh: AbstractMesh): null;
-    getCasterCount(): number;
-    getChunkCount(): number;
-    getDiagnostics(): StaticProjectedShadowArtifactDiagnostic;
-    dispose(): void;
-}
-/**
- * @deprecated Static projected shadows are artifact-only at runtime. This shim
- * is intentionally not exported from the package barrel; use
- * createStaticProjectedShadowArtifactSystem() instead.
- */
-export declare function createStaticProjectedShadowSystem(scene: Scene, _directionalLight: DirectionalLight, options?: Partial<StaticProjectedShadowOptions> & {
-    artifact?: StaticProjectedShadowArtifact | null;
-}): LegacyStaticProjectedShadowSystem;
-export declare function resolveStaticProjectedShadowOptions(options?: Partial<StaticProjectedShadowOptions>, fallback?: ResolvedStaticProjectedShadowOptions): ResolvedStaticProjectedShadowOptions;
-//# sourceMappingURL=static-projected-shadow-system.d.ts.map

package/node_modules/@fps-games/babylon-renderer/dist/shadows/static-projected-shadow-system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"static-projected-shadow-system.d.ts","sourceRoot":"","sources":["../../src/shadows/static-projected-shadow-system.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAEL,KAAK,oCAAoC,EACzC,KAAK,6BAA6B,EAClC,KAAK,uCAAuC,EAE5C,KAAK,4BAA4B,EAClC,MAAM,SAAS,CAAC;AAEjB;;;;GAIG;AACH,MAAM,WAAW,iCAAiC;IAChD,UAAU,IAAI,IAAI,CAAC;IACnB,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACpC,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACvC,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAC3C,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACpD,yBAAyB,IAAI,IAAI,CAAC;IAClC,OAAO,IAAI,IAAI,CAAC;IAChB,WAAW,CAAC,QAAQ,EAAE,6BAA6B,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC;IAC9E,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,4BAA4B,CAAC,GAAG;QAC1D,QAAQ,CAAC,EAAE,6BAA6B,GAAG,IAAI,CAAC;KACjD,GAAG,IAAI,CAAC;IACT,UAAU,IAAI,oCAAoC,CAAC;IACnD,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACxC,cAAc,IAAI,MAAM,CAAC;IACzB,aAAa,IAAI,MAAM,CAAC;IACxB,cAAc,IAAI,uCAAuC,CAAC;IAC1D,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,KAAK,EACZ,iBAAiB,EAAE,gBAAgB,EACnC,OAAO,GAAE,OAAO,CAAC,4BAA4B,CAAC,GAAG;IAC/C,QAAQ,CAAC,EAAE,6BAA6B,GAAG,IAAI,CAAC;CAC5C,GACL,iCAAiC,CAEnC;AA6GD,wBAAgB,mCAAmC,CACjD,OAAO,GAAE,OAAO,CAAC,4BAA4B,CAAM,EACnD,QAAQ,GAAE,oCAA8E,GACvF,oCAAoC,CA2CtC"}