bestax-migrate 2.2.1 → 2.3.0

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

@@ -1 +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"}
+{"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,CAssBpD,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"}

package/dist/sources/rbx/mapping.js

@@ -126,7 +126,7 @@ export const MAPPING = {
     },
     forwardRefAs: {
         status: 'todo',
-        todo: '`forwardRefAs` is rbx-internal and has no counterpart. Only the bestax form controls and a few components (Dialog, Sidebar, Toast, Carousel) forward refs; most, Button and Box included, are plain function components that do not — put the ref on a wrapping element you control',
+        todo: '`forwardRefAs` is rbx-internal and has no counterpart. bestax forwards a ref from the form controls and from `Button`, `LinkButton`, `Modal`, `Dropdown`, `Navbar` (plus `Navbar.Burger` and `Navbar.Link`), `Dialog`, `Sidebar`, `Toast` and `Carousel` — pass `ref` directly on those. Mind the `Navbar.Dropdown` collision: your rbx `Navbar.Dropdown` is the menu and becomes `Navbar.DropdownMenu`, which forwards no ref, while bestax `Navbar.Dropdown` — the container your `<Navbar.Item dropdown>` becomes — does. The rest, `Box` included, are plain function components that forward no ref; put the ref on a wrapping element you control',
     },
     // ---- elements -----------------------------------------------------------
     Block: { status: 'mapped', target: 'Block' },
@@ -136,6 +136,7 @@ export const MAPPING = {
         target: 'Button',
         props: {
             as: AS_OK,
+            innerRef: { rename: 'ref' },
             color: {},
             size: {},
             outlined: { booleanToProp: { name: 'isOutlined' } },
@@ -497,9 +498,7 @@ export const MAPPING = {
             managed: {
                 todo: 'bestax `Dropdown` is uncontrolled by default; use `active` + `onActiveChange` for controlled behaviour',
             },
-            innerRef: {
-                todo: 'this bestax component is a plain function component and forwards no ref; drop `innerRef`, or put the ref on a wrapping element you control',
-            },
+            innerRef: { rename: 'ref' },
         },
         subs: {
             Container: { status: 'mapped', special: 'dropdown-container' },
@@ -606,25 +605,25 @@ export const MAPPING = {
         props: {
             active: {},
             onClose: {},
-            closeOnEsc: {
-                todo: 'bestax `Modal` implements no Escape handling at all; add your own keydown listener, or drop the prop if the behaviour is not needed',
-            },
+            closeOnEsc: { rename: 'closeOnEscape' },
             closeOnBlur: {
-                todo: "bestax `Modal` has no built-in background-click close; wire it through `Modal.Background`'s onClick and `onClose`",
+                todo: 'bestax `Modal` closes on background click in its legacy form, where it renders its own background wired to `onClose`; a `Modal.Content` or `Modal.Card` child selects the compound form, which renders only the children you wrote — there, add a `<Modal.Background>` whose `onClick` calls your close handler, or drop the prop if you passed false',
             },
             document: {
-                todo: 'bestax `Modal` renders inline where you place it rather than portalling into a document at all; drop this prop, and see the advisory the codemod adds on every Modal',
+                todo: 'bestax `Modal` portals via `portal`, but that takes `true`, a selector or an element — not a `Document`. Pass an element from the document you targeted, or drop the prop if you were passing the default document',
             },
             containerClassName: { rename: 'className' },
-            innerRef: {
-                todo: 'this bestax component is a plain function component and forwards no ref; drop `innerRef`, or put the ref on a wrapping element you control',
-            },
+            innerRef: { rename: 'ref' },
         },
         subs: {
             Background: { status: 'mapped', target: 'Modal.Background' },
             Close: { status: 'mapped', target: 'Modal.Close' },
             Content: { status: 'mapped', target: 'Modal.Content' },
-            Container: { status: 'mapped', special: 'modal-container' },
+            Container: {
+                status: 'mapped',
+                special: 'modal-container',
+                props: { innerRef: { rename: 'ref' } },
+            },
             Card: {
                 status: 'mapped',
                 target: 'Modal.Card',
@@ -641,7 +640,7 @@ export const MAPPING = {
             },
             Portal: {
                 status: 'todo',
-                todo: '`Modal.Portal` is rbx-internal; bestax `<Modal>` renders inline and does not portal at all — wrap it in `createPortal` yourself if you relied on that (see the advisory the codemod adds on every Modal)',
+                todo: '`Modal.Portal` is rbx-internal; set `portal` on the `<Modal>` instead — it takes `true`, a selector or an element',
             },
         },
     },
@@ -659,13 +658,15 @@ export const MAPPING = {
                 todo: 'bestax `Navbar` is uncontrolled; drop `managed`',
             },
             document: { todo: 'bestax `Navbar` has no `document` prop; drop it' },
-            innerRef: {
-                todo: 'this bestax component is a plain function component and forwards no ref; drop `innerRef`, or put the ref on a wrapping element you control',
-            },
+            innerRef: { rename: 'ref' },
         },
         subs: {
             Brand: { status: 'mapped', target: 'Navbar.Brand' },
-            Burger: { status: 'mapped', target: 'Navbar.Burger' },
+            Burger: {
+                status: 'mapped',
+                target: 'Navbar.Burger',
+                props: { innerRef: { rename: 'ref' } },
+            },
             Divider: { status: 'mapped', target: 'Navbar.Divider' },
             Menu: { status: 'mapped', target: 'Navbar.Menu' },
             Link: {
@@ -673,6 +674,7 @@ export const MAPPING = {
                 target: 'Navbar.Link',
                 props: {
                     as: AS_OK,
+                    innerRef: { rename: 'ref' },
                     arrowless: {},
                     onClick: {},
                 },

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

@@ -1 +1 @@
-{"version":3,"file":"responsive.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/responsive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAML,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AAIjC,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,cAAc,CAAC;AAEnE,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAG3D,CAAC;AAwVF,8DAA8D;AAC9D,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,EACZ,IAAI,EAAE,cAAc,GACnB,IAAI,CAKN"}
+{"version":3,"file":"responsive.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/responsive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAUL,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AAIjC,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,cAAc,CAAC;AAEnE,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAG3D,CAAC;AA0TF,8DAA8D;AAC9D,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,EACZ,IAAI,EAAE,cAAc,GACnB,IAAI,CAKN"}

package/dist/sources/rbx/responsive.js

@@ -21,42 +21,12 @@
  * here — only the shape changes.
  */
 import { RESPONSIVE_BREAKPOINTS } from './mapping.js';
-import { addAttr, addTodo, attributesOf, makeAttr, removeAttr, } from '../_shared/jsx-utils.js';
+import { addAttr, addTodo, attributesOf, attrValue, literalOf, makeAttr, objectExpressionOf, propKey, removeAttr, } from '../_shared/jsx-utils.js';
 /** Which specials opt their element into the extra breakpoint shapes. */
 export const RESPONSIVE_KINDS = {
     column: 'column',
     'column-group': 'column-group',
 };
-function literalOf(node) {
-    if (!node)
-        return undefined;
-    if (node.type === 'StringLiteral')
-        return node.value;
-    if (node.type === 'NumericLiteral')
-        return node.value;
-    if (node.type === 'BooleanLiteral')
-        return node.value;
-    return undefined;
-}
-/**
- * Reuse a value node as a JSX attribute value: a string literal can sit bare
- * (`size="one-third"`), anything else needs an expression container.
- */
-function attrValue(j, node) {
-    return node?.type === 'StringLiteral'
-        ? j.stringLiteral(node.value)
-        : j.jsxExpressionContainer(node);
-}
-function propKey(prop) {
-    const key = prop.key?.name ?? prop.key?.value;
-    return typeof key === 'string' ? key : undefined;
-}
-function objectExpressionOf(value) {
-    return value?.type === 'JSXExpressionContainer' &&
-        value.expression?.type === 'ObjectExpression'
-        ? value.expression
-        : null;
-}
 /**
  * One `{ value, only }` cell of the universal `responsive` prop. Returns the
  * inner `value` node, or undefined when the cell isn't the expected shape.

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

@@ -1 +1 @@
-{"version":3,"file":"specials.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/specials.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAO3C,OAAO,EAYL,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,aAAa,EAAE,CAAC;AAy8B9B,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,GACX,aAAa,CAIf"}
+{"version":3,"file":"specials.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/specials.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAO3C,OAAO,EAYL,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAUL,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,aAAa,EAAE,CAAC;AAs2B9B,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,GACX,aAAa,CAIf"}

package/dist/sources/rbx/specials.js

@@ -15,26 +15,9 @@
  */
 import { BADGE_PROPS, RESPONSIVE_BREAKPOINTS, TOOLTIP_PROPS, UNIVERSAL_PROPS, } from './mapping.js';
 import { addAttr, addTodo, buildJsxName, attributesOf, findAttr, jsxNameParts, literalValueOf, makeAttr, plainElement, removeAttr, resolveBooleanish, } from '../_shared/jsx-utils.js';
-import { alignTarget, makeStripModifierProps, mergeClassName, parseIconClasses, } from '../_shared/specials-utils.js';
+import { alignTarget, applyIconProps, makeStripModifierProps, makeStructuralHelpers, mergeClassName, modifierClass, parseIconClasses, restrictAsToTargets, } from '../_shared/specials-utils.js';
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const stripModifierProps = makeStripModifierProps(UNIVERSAL_PROPS, RESPONSIVE_BREAKPOINTS);
-/**
- * Turn a literal modifier prop into an `is-*` class fragment for an element
- * on its way to becoming plain HTML. Returns the class (or undefined) and
- * always removes the attribute.
- */
-function modifierClass(ctx, path, element, prop, base, where) {
-    const attr = findAttr(element, prop);
-    if (!attr)
-        return base;
-    const literal = literalValueOf(attr);
-    removeAttr(element, attr);
-    if (literal.kind === 'string' || literal.kind === 'number') {
-        return `${base} is-${literal.value}`;
-    }
-    addTodo(ctx, path, `prop:${prop}`, `dynamic ${where} \`${prop}\`; add the matching is-* class by hand`);
-    return base;
-}
 /**
  * Also strips the universal `responsive` object: responsive.ts would have
  * consumed it, but a `replaced: true` special skips that pass too, and it is
@@ -68,66 +51,11 @@ function stripHelperComponentProps(ctx, path, attrs, where) {
     return kept;
 }
 /**
- * rbx puts `as` on every component, but a handler that chooses its target from
- * a prop value can land on a bestax component that has no `as` — Media.Item
- * resolves to Left/Content/Right where only Left declares one, Level.Item to
- * Left/Right/Item where only Item does, Navbar.Item to Item/Dropdown where
- * only Item does. Opting into `as` in the mapping table cannot express that,
- * so the target has to be checked after it is picked.
- */
-function restrictAsToTargets(ctx, path, element, target, allowed) {
-    const asAttr = findAttr(element, 'as');
-    if (!asAttr || (target && allowed.includes(target)))
-        return;
-    removeAttr(element, asAttr);
-    addTodo(ctx, path, 'prop:as', `bestax's \`${target}\` has no \`as\` prop (of the targets this can resolve to, only ${allowed
-        .map(a => `\`${a}\``)
-        .join(' / ')} does); render the tag directly or restructure`);
-    ctx.dirty = true;
-}
-/** Replace the element with a plain HTML tag carrying `className`. */
-function replaceWithPlain(ctx, path, element, tag, className, where) {
-    const merged = mergeClassName(ctx, path, element, className, where);
-    const rest = stripHelperComponentProps(ctx, path, stripModifierProps(ctx, path, attributesOf(element), where), where);
-    path.replace(plainElement(ctx.j, tag, merged, rest, element.children ?? []));
-    ctx.dirty = true;
-    return { replaced: true };
-}
-/**
- * rbx wraps several components in a `*.Container` that owns the modifiers,
- * where bestax's component renders that wrapper itself. Move the container's
- * (already-converted) attributes onto its single child and replace the
- * container with it — otherwise both would rename to the same bestax
- * component and nest, which is invalid.
- *
- * Returns null when the element isn't the single-JSX-child shape, so the
- * caller can fall back to keeping the container.
+ * rbx's plain-element rewrites strip both the universal helper props and the
+ * badge/tooltip/responsive props (which would otherwise ride onto the HTML
+ * tag as unknown DOM attributes — see stripHelperComponentProps).
  */
-function collapseOntoChild(ctx, path, element, where, expected) {
-    const children = (element.children ?? []).filter((c) => !(c.type === 'JSXText' && c.value.trim() === ''));
-    if (children.length !== 1 || children[0].type !== 'JSXElement')
-        return null;
-    const child = children[0];
-    // The child must be the component this container exists to wrap. rbx lets
-    // both of these containers hold something else — an `<iframe>` for a ratio
-    // box, a native `<select>` — and folding onto that put Bulma modifier props
-    // on an intrinsic element and dropped the wrapper the markup needs.
-    const childPath = ctx.resolve?.(child.openingElement?.name);
-    if (!childPath || childPath.join('.') !== expected)
-        return null;
-    for (const attr of [...attributesOf(element)]) {
-        const name = attr.name.name;
-        if (findAttr(child, name)) {
-            addTodo(ctx, path, `prop:${name}`, `\`${where}\` folded into its child, but both set \`${name}\`; the child's value was kept — reconcile by hand`);
-            continue;
-        }
-        removeAttr(element, attr);
-        addAttr(child, attr);
-    }
-    path.replace(child);
-    ctx.dirty = true;
-    return { replaced: true };
-}
+const { replaceWithPlain, collapseOntoChild } = makeStructuralHelpers((ctx, path, attrs, where) => stripHelperComponentProps(ctx, path, stripModifierProps(ctx, path, attrs, where), where));
 const SPECIALS = {
     /**
      * rbx's `Heading` is Bulma's `.heading` label (small caps), not a title —
@@ -171,6 +99,11 @@ const SPECIALS = {
             else if (resolved === 'falsy') {
                 removeAttr(element, spacedAttr);
             }
+            else if (findAttr(element, 'isSpaced')) {
+                // `isSpaced` is already set (rbx passes unknown props through), so
+                // renaming onto it would emit the attribute twice.
+                addTodo(ctx, path, 'prop:spaced', 'dynamic `spaced` alongside an `isSpaced` already on this element; bestax has one prop for both — reconcile by hand');
+            }
             else {
                 // Dynamic: keep the expression, just rename the prop.
                 spacedAttr.name = ctx.j.jsxIdentifier('isSpaced');
@@ -195,20 +128,10 @@ const SPECIALS = {
             const literal = classAttr ? literalValueOf(classAttr) : undefined;
             if (literal?.kind === 'string') {
                 const parsed = parseIconClasses(literal.value);
-                if (parsed) {
-                    addAttr(element, makeAttr(ctx.j, 'name', parsed.name));
-                    if (parsed.library) {
-                        addAttr(element, makeAttr(ctx.j, 'library', parsed.library));
-                    }
-                    if (parsed.variant) {
-                        addAttr(element, makeAttr(ctx.j, 'variant', parsed.variant));
-                    }
-                    element.children = [];
-                    if (element.openingElement) {
-                        element.openingElement.selfClosing = true;
-                        element.closingElement = null;
-                    }
-                    ctx.dirty = true;
+                // An app's own class on the <i> has no home on bestax's glyph, so
+                // the child is kept (and flagged below) rather than losing it.
+                if (parsed && parsed.leftovers.length === 0) {
+                    applyIconProps(ctx, path, element, parsed);
                     return {};
                 }
             }
@@ -538,15 +461,14 @@ const SPECIALS = {
         return { ...result, handledProps: ['align', 'as'] };
     },
     /**
-     * The markup maps cleanly, but three rbx behaviours do not exist in bestax
-     * and none of them fail loudly: rbx portals the modal into `document.body`,
-     * closes it on Escape by default, and clips document scroll while it is
-     * open. bestax renders inline and implements none of the three. An
-     * unmodified `<Modal>` therefore migrates to something that looks right and
-     * behaves differently, so every conversion is flagged.
+     * rbx's Modal portals into `document.body`, closes on Escape and clips
+     * document scroll, all by default. bestax matches two of those since #633 —
+     * `closeOnEscape` and `lockScroll` both default to `true` — but still
+     * renders inline unless `portal` is set. That last difference does not fail
+     * loudly, so every conversion is still flagged, now about the portal alone.
      */
     modal(ctx, path, _element) {
-        addTodo(ctx, path, 'component:Modal', 'bestax `Modal` renders inline rather than portalling into document.body, and implements neither Escape-to-close nor scroll locking — rbx did all three by default. Re-add whichever your UI relied on');
+        addTodo(ctx, path, 'component:Modal', 'bestax `Modal` closes on Escape and locks body scroll by default, matching rbx, but it renders inline: set `portal` if you relied on rbx portalling into document.body');
         return {};
     },
     /** rbx Modal.Container is the modal itself in bestax. */
@@ -588,6 +510,21 @@ const SPECIALS = {
             addTodo(ctx, path, `prop:${prop}`, `bestax \`Navbar.Item\` has no \`${prop}\` prop; restructure or add a class by hand`);
             ctx.dirty = true;
         }
+        // bestax's `Navbar.Dropdown` forwards a ref, but it is the one such target
+        // the `innerRef: { rename: 'ref' }` entries in mapping.ts cannot reach:
+        // that table is keyed on the rbx name (`Navbar.Item`), and only this
+        // handler knows which of the two targets was picked. A plain
+        // `Navbar.Item` is still a function component, so the rename is
+        // conditional — there, `innerRef` is left alone.
+        const renamedInnerRef = [];
+        if (target === 'Navbar.Dropdown') {
+            const innerRefAttr = findAttr(element, 'innerRef');
+            if (innerRefAttr) {
+                innerRefAttr.name = ctx.j.jsxIdentifier('ref');
+                renamedInnerRef.push('innerRef');
+                ctx.dirty = true;
+            }
+        }
         restrictAsToTargets(ctx, path, element, target ?? 'Navbar.Item', [
             'Navbar.Item',
         ]);
@@ -601,6 +538,7 @@ const SPECIALS = {
                 'expanded',
                 'hoverable',
                 'managed',
+                ...renamedInnerRef,
             ],
         };
     },

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

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA0DvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CAu/BpB"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA2DvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CAmoCpB"}