bestax-migrate 2.1.6 → 2.2.0

package/dist/sources/_shared/specials-utils.js

@@ -0,0 +1,124 @@
+/**
+ * Building blocks shared by every source's structural handlers: picking a
+ * target from an align-style prop, stripping Bulma modifier props off an
+ * element on its way to becoming plain HTML, merging a consumed `className`,
+ * and reading an icon-font class string.
+ *
+ * Source-agnostic. `makeStripModifierProps` is a factory precisely because
+ * the modifier vocabulary is the one thing here that differs per source.
+ */
+import { addTodo, findAttr, literalValueOf, removeAttr, } from './jsx-utils.js';
+/** Pick a target based on a literal align-style prop, removing the prop. */
+export function alignTarget(ctx, path, element, prop, targets, fallback) {
+    const attr = findAttr(element, prop);
+    if (!attr)
+        return { target: fallback };
+    const literal = literalValueOf(attr);
+    if (literal.kind === 'string' && targets[literal.value]) {
+        removeAttr(element, attr);
+        ctx.dirty = true;
+        return { target: targets[literal.value] };
+    }
+    if (literal.kind === 'string') {
+        removeAttr(element, attr);
+        ctx.dirty = true;
+        return { target: fallback };
+    }
+    addTodo(ctx, path, `prop:${prop}`, `\`${prop}\` has a dynamic value; pick between ${Object.values(targets).join(' / ')} by hand`);
+    removeAttr(element, attr);
+    ctx.dirty = true;
+    return { target: fallback };
+}
+/**
+ * Build the modifier-prop filter for one source: it needs that source's own
+ * universal-prop and breakpoint tables to know what counts as a modifier.
+ *
+ * The returned function filters Bulma modifier props out of an attribute list
+ * bound for a plain HTML element (they only exist on bestax components),
+ * leaving a TODO when any were dropped.
+ */
+export function makeStripModifierProps(universalProps, responsiveBreakpoints) {
+    return function stripModifierProps(ctx, path, attrs, where) {
+        const kept = [];
+        const dropped = [];
+        for (const attr of attrs) {
+            const name = attr?.name?.name;
+            if (name && (universalProps[name] || name in responsiveBreakpoints)) {
+                dropped.push(name);
+            }
+            else {
+                kept.push(attr);
+            }
+        }
+        if (dropped.length > 0) {
+            addTodo(ctx, path, 'plain-element', `${where} became a plain element; the Bulma helper prop(s) ${dropped
+                .map(d => `\`${d}\``)
+                .join(', ')} were dropped — restyle with classes`);
+        }
+        return kept;
+    };
+}
+/**
+ * Consume the element's `className` so a plain-element rewrite can merge it
+ * with its hard-coded Bulma class instead of dropping it. A dynamic value
+ * can't be merged safely — keep the base class and leave a TODO.
+ */
+export function mergeClassName(ctx, path, element, base, where) {
+    const attr = findAttr(element, 'className');
+    if (!attr)
+        return base;
+    const literal = literalValueOf(attr);
+    removeAttr(element, attr);
+    if (literal.kind === 'string') {
+        return base ? `${base} ${literal.value}` : literal.value;
+    }
+    addTodo(ctx, path, 'prop:className', base
+        ? `dynamic ${where} className; merge it with the \`${base}\` class by hand`
+        : `dynamic ${where} className; re-apply it to the emitted element by hand`);
+    return base;
+}
+/** Parse an icon-font <i className="..."> into bestax Icon name/library/variant. */
+export function parseIconClasses(className) {
+    const tokens = className.trim().split(/\s+/);
+    const faVariant = {
+        fas: 'solid',
+        far: 'regular',
+        fab: 'brands',
+        fal: 'light',
+        fad: 'duotone',
+        fat: 'thin',
+        // Font Awesome 6 spells the style out, and has been the default since
+        // 2022 — matching only the v5 short forms meant the common case fell
+        // through to the "migrate this icon by hand" TODO.
+        'fa-solid': 'solid',
+        'fa-regular': 'regular',
+        'fa-brands': 'brands',
+        'fa-light': 'light',
+        'fa-duotone': 'duotone',
+        'fa-thin': 'thin',
+    };
+    const faStyle = tokens.find(t => faVariant[t]);
+    // Every `fa-*` that is a MODIFIER rather than an icon name — including
+    // v6's spelled-out style and family words, which are `fa-` prefixed and
+    // would otherwise be read as the icon (`fa-solid fa-home` → name="solid").
+    // The old list
+    // covered only sizing and spin, so a class string that puts a modifier
+    // first — `fas fa-rotate-90 fa-home`, which Font Awesome's own docs show —
+    // yielded name="rotate-90". Ordering is not guaranteed, so the filter has
+    // to be exhaustive rather than positional.
+    const FA_MODIFIER = /^fa-(?:solid|regular|brands|light|duotone|thin|sharp|classic|2xs|xs|sm|lg|xl|2xl|\d{1,2}x|fw|ul|li|border|inverse|stack|stack-1x|stack-2x|pull-(?:left|right)|spin|spin-pulse|spin-reverse|pulse|beat|fade|beat-fade|bounce|flash|shake|swap-opacity|rotate-(?:90|180|270|by)|flip-(?:horizontal|vertical|both))$/;
+    const faName = tokens.find(t => /^fa-/.test(t) && !FA_MODIFIER.test(t));
+    if (faStyle && faName) {
+        return {
+            name: faName.replace(/^fa-/, ''),
+            library: 'fa',
+            variant: faVariant[faStyle],
+        };
+    }
+    if (tokens.includes('mdi')) {
+        const mdiName = tokens.find(t => /^mdi-/.test(t) && t !== 'mdi');
+        if (mdiName)
+            return { name: mdiName.replace(/^mdi-/, ''), library: 'mdi' };
+    }
+    return null;
+}

package/dist/sources/rbx/deps.d.ts

@@ -0,0 +1,18 @@
+/**
+ * package.json migration: swap rbx for @allxsmith/bestax-bulma and clear out
+ * the stylesheet dependencies rbx dragged in with it. Pure data-in/data-out —
+ * the CLI owns file IO, and no package manager is ever invoked (the report
+ * tells the user to install).
+ *
+ * This is the step with the biggest visible payoff for an rbx app. Unlike
+ * react-bulma-components, which peer-depends on Bulma and lets the app pick a
+ * version, rbx ships `bulma@0.7.5` as a *direct* dependency plus four Bulma
+ * extensions — so an rbx app cannot move to Bulma v1 at all while rbx is
+ * installed. Removing rbx is what frees that, and the report says so; its
+ * four Bulma extensions are reported for the user to remove, not deleted —
+ * see the note on that below.
+ * says so by name.
+ */
+import type { DependenciesUpdate } from '../../types.js';
+export declare const updateDependencies: DependenciesUpdate;
+//# sourceMappingURL=deps.d.ts.map

package/dist/sources/rbx/deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/deps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAgHzD,eAAO,MAAM,kBAAkB,EAAE,kBAqLhC,CAAC"}

package/dist/sources/rbx/deps.js

@@ -0,0 +1,287 @@
+/**
+ * package.json migration: swap rbx for @allxsmith/bestax-bulma and clear out
+ * the stylesheet dependencies rbx dragged in with it. Pure data-in/data-out —
+ * the CLI owns file IO, and no package manager is ever invoked (the report
+ * tells the user to install).
+ *
+ * This is the step with the biggest visible payoff for an rbx app. Unlike
+ * react-bulma-components, which peer-depends on Bulma and lets the app pick a
+ * version, rbx ships `bulma@0.7.5` as a *direct* dependency plus four Bulma
+ * extensions — so an rbx app cannot move to Bulma v1 at all while rbx is
+ * installed. Removing rbx is what frees that, and the report says so; its
+ * four Bulma extensions are reported for the user to remove, not deleted —
+ * see the note on that below.
+ * says so by name.
+ */
+const BESTAX_RANGE = '^5';
+const BULMA_RANGE = '^1.0.4';
+// Bulma v1's sass tree uses `color.channel(…)` — needs dart-sass ≥ 1.79.
+const SASS_RANGE = '^1.79.0';
+/**
+ * The Bulma extensions rbx depends on directly. Bulma v1 and bestax cover all
+ * four: badge and tooltip became bestax components, the page loader became
+ * `Loading`, and the divider became `Divider`.
+ */
+const RBX_STYLE_DEPS = [
+    'bulma-badge',
+    'bulma-divider',
+    'bulma-pageloader',
+    'bulma-tooltip',
+];
+const DEP_SECTIONS = ['dependencies', 'devDependencies'];
+/**
+ * True only when `range` PROVABLY admits no version >= 1.0.0.
+ *
+ * The first version matched a leading `0` and nothing else, so a range written
+ * as comparators (`>=0.7 <1`) was left on 0.x and then reported as already v1.
+ * This walks each `||` alternative and its comparators: a set is pre-v1 when
+ * some comparator caps it below 1.0.0 and none of them opens it at 1 or above.
+ *
+ * Conservative by design: an unrecognised shape returns false and the range is
+ * left alone (and reported as such). Bumping a range that might already admit
+ * v1 would be the best-guess rewrite this package refuses to make.
+ */
+function isPreV1(range) {
+    const alternatives = range.trim().split(/\s*\|\|\s*/);
+    return alternatives.length > 0 && alternatives.every(setIsPreV1);
+}
+function setIsPreV1(set) {
+    // npm accepts whitespace between an operator and its version
+    // (`>= 0.7.0 < 1.0.0`); splitting on whitespace first made the operator a
+    // token of its own, so the range parsed as unrecognised and was left alone.
+    const text = glueOperators(set);
+    if (text === '' || /^(\*|x|X|latest)$/.test(text))
+        return false;
+    const hyphen = text.match(/^(\S+)\s+-\s+(\S+)$/);
+    if (hyphen)
+        return majorOf(hyphen[2]) === 0;
+    let cappedBelowOne = false;
+    for (const token of text.split(/\s+/)) {
+        const match = token.match(/^(>=|<=|>|<|=)?\s*v?(.*)$/);
+        if (!match)
+            return false;
+        const [, op = '', version] = match;
+        const major = majorOf(version);
+        if (major === null)
+            return false;
+        switch (op) {
+            case '>':
+            case '>=':
+                if (major >= 1)
+                    return false;
+                break;
+            case '<':
+                // `<1`, `<1.0`, `<1.0.0` exclude every v1; `<0.9` does too.
+                if (major === 0 || (major === 1 && /^1(\.0)*$/.test(version))) {
+                    cappedBelowOne = true;
+                }
+                else {
+                    return false;
+                }
+                break;
+            case '<=':
+                if (major === 0)
+                    cappedBelowOne = true;
+                else
+                    return false;
+                break;
+            default:
+                // `0.9.4`, `=0.9.4`, `^0.9`, `~0.7.5`, `0.x`: caret and tilde never
+                // cross a major, so major 0 stays below 1.
+                if (major === 0)
+                    cappedBelowOne = true;
+                else
+                    return false;
+        }
+    }
+    return cappedBelowOne;
+}
+function glueOperators(set) {
+    return set.trim().replace(/(>=|<=|>|<|=)\s+/g, '$1');
+}
+/**
+ * True when every comparator in every alternative parses to a semver major,
+ * so the headline can tell "already v1" apart from "not a version range at
+ * all" (`latest`, a git URL) rather than calling both v1.
+ */
+function isRecognisedRange(range) {
+    return range
+        .trim()
+        .split(/\s*\|\|\s*/)
+        .every(alt => {
+        const text = glueOperators(alt);
+        if (/^(\*|x|X)$/.test(text))
+            return true;
+        const hyphen = text.match(/^(\S+)\s+-\s+(\S+)$/);
+        if (hyphen) {
+            return majorOf(hyphen[1]) !== null && majorOf(hyphen[2]) !== null;
+        }
+        return text
+            .split(/\s+/)
+            .every(tok => majorOf(tok.replace(/^(>=|<=|>|<|=)/, '')) !== null);
+    });
+}
+function majorOf(version) {
+    const m = version.replace(/^[~^=v]+/, '').match(/^(\d+)(?:\.|$)/);
+    return m ? Number(m[1]) : null;
+}
+export const updateDependencies = (filePath, pkg, collector, options) => {
+    const changes = [];
+    const next = pkg;
+    const section = (name) => (next[name] ?? undefined);
+    const note = (message) => {
+        changes.push(message);
+        collector?.add({ file: filePath, line: null, rule: 'deps', message });
+    };
+    // rbx goes away entirely.
+    const removed = [];
+    for (const name of DEP_SECTIONS) {
+        const deps = section(name);
+        if (deps && 'rbx' in deps) {
+            delete deps.rbx;
+            removed.push('rbx');
+            note(`removed rbx from ${name}`);
+        }
+    }
+    // The four Bulma extensions are REPORTED, not removed.
+    //
+    // rbx declares them as its own dependencies, so an app gets them
+    // transitively through the lockfile — they do not appear in the app's
+    // manifest unless the author put them there deliberately. A manifest entry
+    // is therefore a direct declaration, and an app may well be importing
+    // `bulma-tooltip`'s Sass on its own, outside anything rbx rendered.
+    // Deleting it because rbx happens to be present is precisely the
+    // best-guess rewrite this package refuses to make.
+    const extensions = [];
+    if (removed.includes('rbx')) {
+        for (const name of DEP_SECTIONS) {
+            const deps = section(name);
+            if (!deps)
+                continue;
+            for (const extension of RBX_STYLE_DEPS) {
+                if (extension in deps)
+                    extensions.push(extension);
+            }
+        }
+    }
+    if (extensions.length > 0) {
+        collector?.add({
+            file: filePath,
+            line: null,
+            rule: 'deps',
+            message: `${extensions.join(', ')} ${extensions.length === 1 ? 'is a Bulma extension' : 'are Bulma extensions'} rbx depended on, and bestax ships ${extensions.length === 1 ? 'its' : 'their'} equivalent${extensions.length === 1 ? '' : 's'} (Badge, Divider, Loading, Tooltip). Declared in this manifest, so removing ${extensions.length === 1 ? 'it' : 'them'} is your call — drop ${extensions.length === 1 ? 'it' : 'them'} unless your own Sass imports ${extensions.length === 1 ? 'it' : 'them'} directly`,
+        });
+    }
+    // @allxsmith/bestax-bulma comes in (runtime dependency).
+    const dependencies = (next.dependencies ??= {});
+    if (!dependencies['@allxsmith/bestax-bulma'] &&
+        !section('devDependencies')?.['@allxsmith/bestax-bulma']) {
+        dependencies['@allxsmith/bestax-bulma'] = BESTAX_RANGE;
+        note(`added @allxsmith/bestax-bulma ${BESTAX_RANGE} to dependencies`);
+    }
+    // Bulma: rbx pinned 0.7.5 as a direct dependency, so this almost always
+    // fires. Add it back only when sources still reference bulma/… directly —
+    // otherwise it arrives transitively via bestax-bulma.
+    let bulmaDeclared = false;
+    let declaredBulma = '';
+    let bulmaBumped = false;
+    let bulmaAdded = false;
+    for (const name of DEP_SECTIONS) {
+        const deps = section(name);
+        if (deps?.bulma) {
+            bulmaDeclared = true;
+            declaredBulma = deps.bulma;
+            if (isPreV1(deps.bulma)) {
+                deps.bulma = BULMA_RANGE;
+                bulmaBumped = true;
+                note(`bumped bulma to ${BULMA_RANGE} in ${name} (was pre-1.0)`);
+            }
+        }
+    }
+    if (!bulmaDeclared && options.bulmaReferenced) {
+        dependencies.bulma = BULMA_RANGE;
+        bulmaAdded = true;
+        note(`added bulma ${BULMA_RANGE} to dependencies (sources import bulma/… directly)`);
+    }
+    // The transform deliberately keeps a trimmed rbx import for components
+    // with no bestax equivalent (Tile, Generic, List, …) so a partially
+    // migrated app still runs. Removing the package from the manifest strands
+    // exactly those imports once the user runs the install the report asks for,
+    // so say so rather than letting them find out at build time.
+    if (removed.includes('rbx') && options.sourceStillImported) {
+        collector?.add({
+            file: filePath,
+            line: null,
+            rule: 'deps',
+            message: 'rbx was removed from package.json, but some files still import it for components with no bestax equivalent — resolve those `TODO(bestax-migrate)` imports before installing, or re-add rbx until you have',
+        });
+    }
+    // The headline result: rbx pinned Bulma 0.7.5 as a DIRECT dependency, so
+    // removing rbx is what frees the app to choose its own Bulma version.
+    //
+    // What it must NOT claim is a manifest change that did not happen. In the
+    // common rbx-app shape — `{ "dependencies": { "rbx": "^2.2.0" } }` with no
+    // direct `bulma/…` imports — bulma is neither bumped nor added, because it
+    // arrives transitively via bestax-bulma. Saying "bumped bulma" there
+    // described a pin the user would not find in their manifest.
+    if (removed.includes('rbx')) {
+        collector?.add({
+            file: filePath,
+            line: null,
+            rule: 'deps',
+            message: `removed rbx ${bulmaBumped
+                ? `and bumped bulma to ${BULMA_RANGE}`
+                : bulmaAdded
+                    ? `and added bulma ${BULMA_RANGE}`
+                    : bulmaDeclared
+                        ? isRecognisedRange(declaredBulma)
+                            ? 'and left your declared bulma range alone (already v1)'
+                            : `and left your declared bulma specifier alone (${JSON.stringify(declaredBulma)} is not a version range this tool can read; make sure it resolves to Bulma 1.x)`
+                        : '— bulma now arrives transitively via @allxsmith/bestax-bulma'} — rbx pinned Bulma 0.7.5 as a direct dependency, so the app can now choose its own Bulma version${extensions.length > 0 ? `; ${extensions.length} Bulma extension(s) are reported above for you to remove` : ''}`,
+        });
+    }
+    // bestax-bulma requires React 18/19; rbx peer-depends on ^16.8.6, and React
+    // 19 removed the `defaultProps` its forwardRefAs base is built on — so this
+    // is the other half of why an rbx app is stuck. Report only: a React major
+    // upgrade is the app's own migration step.
+    for (const name of DEP_SECTIONS) {
+        const range = section(name)?.react;
+        if (range && /^[~^]?(?:[0-9]|1[0-7])(?:[.x]|$)/.test(range.trim())) {
+            collector?.add({
+                file: filePath,
+                line: null,
+                rule: 'peer-deps',
+                message: `react ${range} predates bestax-bulma's peer range (^18 || ^19) — upgrade react and react-dom to 18 or 19 before installing`,
+            });
+        }
+    }
+    // Font Awesome older than 6 conflicts with bestax-bulma's optional peer
+    // range and makes `npm install` fail with ERESOLVE. Report only — icon
+    // names change across FA majors, so upgrading is the app's decision.
+    for (const name of DEP_SECTIONS) {
+        const range = section(name)?.['@fortawesome/fontawesome-free'];
+        if (range && /^[~^]?[0-5](?:[.x]|$)/.test(range.trim())) {
+            collector?.add({
+                file: filePath,
+                line: null,
+                rule: 'peer-deps',
+                message: `@fortawesome/fontawesome-free ${range} predates bestax-bulma's optional peer range (^6.7.2 || ^7.0.0) — upgrade it, or install with \`npm install --legacy-peer-deps\``,
+            });
+        }
+    }
+    // node-sass is dead; dart-sass replaces it in the same section. rbx's own
+    // customisation guide told people to install node-sass, so this is common.
+    for (const name of DEP_SECTIONS) {
+        const deps = section(name);
+        if (deps && 'node-sass' in deps) {
+            delete deps['node-sass'];
+            note(`removed node-sass from ${name}`);
+            const sassDeclared = DEP_SECTIONS.some(s => section(s)?.sass);
+            if (!sassDeclared) {
+                deps.sass = SASS_RANGE;
+                note(`added sass ${SASS_RANGE} to ${name} (replaces node-sass)`);
+            }
+        }
+    }
+    return changes.length > 0 ? next : null;
+};

package/dist/sources/rbx/index.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationSource } from '../../types.js';
+export declare const rbx: MigrationSource;
+//# sourceMappingURL=index.d.ts.map

package/dist/sources/rbx/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKtD,eAAO,MAAM,GAAG,EAAE,eAMjB,CAAC"}

package/dist/sources/rbx/index.js

@@ -0,0 +1,10 @@
+import transform from './transform.js';
+import { transformStyles } from './styles.js';
+import { updateDependencies } from './deps.js';
+export const rbx = {
+    name: 'rbx',
+    label: 'rbx (v2) → @allxsmith/bestax-bulma',
+    transform,
+    transformStyles,
+    updateDependencies,
+};

package/dist/sources/rbx/mapping.d.ts

@@ -0,0 +1,49 @@
+/**
+ * rbx (v2) → @allxsmith/bestax-bulma mapping tables.
+ *
+ * Data only — no AST work. `MAPPING` is the single source of truth for what
+ * the transform does with each rbx export; `RBX_EXPORTS` vendors rbx's public
+ * surface so `mapping-coverage.test.ts` can close it in both directions.
+ *
+ * rbx and bestax both target Bulma, and rbx's helper vocabulary lines up with
+ * `useBulmaClasses` far more closely than react-bulma-components' did — most
+ * of the value unions below are identical on both sides, so they pass through
+ * rather than being value-mapped. Where they diverge it is because Bulma v1
+ * itself changed (`is-marginless` became `m-0`), and those are recorded as
+ * explicit conversions rather than guesses.
+ */
+import type { ComponentMapping, PropAction } from '../../types.js';
+/**
+ * Helper props rbx mixes into every component via `HelpersProps`. Applied
+ * after each component's own prop map, to whatever attributes are left.
+ *
+ * `badge*`, `tooltip*` and `responsive` are deliberately absent: they are
+ * consumed structurally (see specials.ts / responsive.ts) before this pass
+ * runs, and letting them fall through here would be wrong — bestax has its
+ * own unrelated `responsive` prop (`'mobile' | 'narrow'`), so a pass-through
+ * would silently produce a type error rather than a TODO.
+ */
+export declare const UNIVERSAL_PROPS: Record<string, PropAction>;
+/** rbx badge helper props → bestax `<Badge>` props. */
+export declare const BADGE_PROPS: Record<string, string | null>;
+/** rbx tooltip helper props → bestax `<Tooltip>` props. */
+export declare const TOOLTIP_PROPS: Record<string, string | null>;
+/**
+ * rbx breakpoints → the suffix bestax uses on its viewport-aware helper props
+ * (`displayTablet`, `textSizeDesktop`, …). `null` means bestax has no
+ * equivalent viewport, so the value becomes a TODO rather than a guess.
+ */
+export declare const RESPONSIVE_BREAKPOINTS: Record<string, string | null>;
+export declare const MAPPING: Record<string, ComponentMapping>;
+/**
+ * rbx's public export surface, vendored from its five `index.ts` barrels at
+ * the pinned SHA. Values are the dot-notation sub-paths each export carries.
+ *
+ * `mapping-coverage.test.ts` walks this against `MAPPING` in both directions,
+ * so rbx coverage cannot silently regress and `MAPPING` cannot grow an entry
+ * for something rbx never exported.
+ */
+export declare const RBX_EXPORTS: Record<string, string[]>;
+/** Walk a dotted component path through `MAPPING`. */
+export declare function resolveMapping(path: string[]): ComponentMapping | undefined;
+//# sourceMappingURL=mapping.d.ts.map

package/dist/sources/rbx/mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAuCnE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAiCtD,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAOrD,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAQvD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAShE,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAosBpD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CA2FhD,CAAC;AAEF,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAM3E"}