@builder.io/mitosis 0.0.0-dev-20260605060721

package/dist/src/helpers/component-file-extensions.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileExtensionForTarget = exports.getComponentFileExtensionForTarget = exports.renameImport = exports.renameComponentImport = exports.renameComponentFile = exports.INPUT_EXTENSION_REGEX = exports.checkIsMitosisComponentFilePath = exports.checkIsLiteComponentFilePath = exports.checkIsSvelteComponentFilePath = exports.COMPONENT_IMPORT_EXTENSIONS = void 0;
+const output_1 = require("./output");
+const COMPONENT_EXTENSIONS = {
+    jsx: ['.lite.tsx', '.lite.jsx'],
+    svelte: ['.svelte'],
+};
+exports.COMPONENT_IMPORT_EXTENSIONS = [COMPONENT_EXTENSIONS.svelte, COMPONENT_EXTENSIONS.jsx]
+    .flat()
+    .concat(['.lite']);
+const checkIsSvelteComponentFilePath = (filePath) => COMPONENT_EXTENSIONS.svelte.some((x) => filePath.endsWith(x));
+exports.checkIsSvelteComponentFilePath = checkIsSvelteComponentFilePath;
+const checkIsLiteComponentFilePath = (filePath) => COMPONENT_EXTENSIONS.jsx.some((x) => filePath.endsWith(x));
+exports.checkIsLiteComponentFilePath = checkIsLiteComponentFilePath;
+const checkIsMitosisComponentFilePath = (filePath) => (0, exports.checkIsLiteComponentFilePath)(filePath) || (0, exports.checkIsSvelteComponentFilePath)(filePath);
+exports.checkIsMitosisComponentFilePath = checkIsMitosisComponentFilePath;
+/**
+ * Matches `.svelte`, `.lite.tsx`, `.lite.jsx` files (with optional `.jsx`/`.tsx` extension)
+ */
+exports.INPUT_EXTENSION_REGEX = /\.(svelte|(lite(\.tsx|\.jsx)?))/g;
+const getExplicitFileExtension = (path, explicitBuildFileExtensions) => {
+    if (explicitBuildFileExtensions) {
+        for (const [extension, regex] of Object.entries(explicitBuildFileExtensions)) {
+            const match = path.match(regex);
+            if (match) {
+                return extension;
+            }
+        }
+    }
+    return undefined;
+};
+const renameComponentFile = ({ path, target, options, }) => {
+    var _a;
+    const explicitExtension = getExplicitFileExtension(path, (_a = options.options[target]) === null || _a === void 0 ? void 0 : _a.explicitBuildFileExtensions);
+    const extension = explicitExtension !== null && explicitExtension !== void 0 ? explicitExtension : (0, exports.getComponentFileExtensionForTarget)({
+        type: 'filename',
+        target,
+        isTypescript: (0, output_1.checkShouldOutputTypeScript)({ options, target }),
+    });
+    return path.replace(exports.INPUT_EXTENSION_REGEX, extension);
+};
+exports.renameComponentFile = renameComponentFile;
+/**
+ * just like `INPUT_EXTENSION_REGEX`, but adds trailing quotes to the end of import paths.
+ */
+const INPUT_EXTENSION_IMPORT_REGEX = /\.(svelte|(lite(\.tsx|\.jsx)?))(?<quote>['"])/g;
+const renameComponentImport = ({ importPath, target, explicitImportFileExtension, }) => {
+    return importPath.replace(INPUT_EXTENSION_IMPORT_REGEX, `${(0, exports.getComponentFileExtensionForTarget)({
+        type: 'import',
+        target,
+        explicitImportFileExtension,
+    })}$4`);
+};
+exports.renameComponentImport = renameComponentImport;
+const renameImport = ({ importPath, target, explicitImportFileExtension, }) => {
+    return importPath.replace(/\.js(['"])/g, `${(0, exports.getFileExtensionForTarget)({
+        target,
+        explicitImportFileExtension,
+    })}$1`);
+};
+exports.renameImport = renameImport;
+/**
+ * Provides the correct file extension for a given component. This is used:
+ *  - in `core` to render import statements within other components.
+ *  - in `cli` to render filenames for generated components, and import statements within plain `.js`/`.ts` files.
+ */
+const getComponentFileExtensionForTarget = (args) => {
+    switch (args.target) {
+        case 'angular': {
+            switch (args.type) {
+                case 'import':
+                    return '.js';
+                case 'filename':
+                    return args.isTypescript ? '.ts' : '.js';
+            }
+        }
+        case 'alpine':
+        case 'html':
+            return '.html';
+        case 'svelte':
+            return '.svelte';
+        case 'swift':
+            return '.swift';
+        case 'vue':
+            return '.vue';
+        case 'webcomponent':
+            return '.ts';
+        case 'lit':
+            return '.ts';
+        case 'qwik': {
+            switch (args.type) {
+                case 'import':
+                    return '.jsx';
+                case 'filename':
+                    return args.isTypescript ? '.tsx' : '.jsx';
+            }
+        }
+        case 'solid':
+        case 'preact':
+        case 'react':
+        case 'reactNative':
+        case 'rsc':
+        case 'stencil':
+            switch (args.type) {
+                case 'import':
+                    // we can't have `.jsx`/`.tsx` extensions in the import paths, so we stick with implicit file extensions.
+                    return args.explicitImportFileExtension ? '.js' : '';
+                case 'filename':
+                    return args.isTypescript ? '.tsx' : '.jsx';
+            }
+        case 'marko':
+            return '.marko';
+        default:
+            return '.js';
+    }
+};
+exports.getComponentFileExtensionForTarget = getComponentFileExtensionForTarget;
+const getFileExtensionForTarget = ({ target, explicitImportFileExtension, }) => {
+    switch (target) {
+        case 'angular':
+        case 'alpine':
+        case 'html':
+        case 'svelte':
+        case 'swift':
+        case 'vue':
+        case 'webcomponent':
+        case 'lit':
+        case 'qwik':
+        case 'react':
+        case 'reactNative':
+        case 'rsc':
+        case 'solid':
+        case 'stencil':
+        case 'marko':
+        case 'preact':
+        default:
+            return explicitImportFileExtension ? '.js' : '';
+    }
+};
+exports.getFileExtensionForTarget = getFileExtensionForTarget;

package/dist/src/helpers/create-mitosis-component.d.ts

@@ -0,0 +1,7 @@
+import { MitosisComponent } from '../types/mitosis-component';
+import { Overwrite, Prettify } from './typescript';
+type PartialMitosisComponent = Prettify<Overwrite<Partial<MitosisComponent>, {
+    hooks: Partial<MitosisComponent['hooks']>;
+}>>;
+export declare const createMitosisComponent: (options?: PartialMitosisComponent) => MitosisComponent;
+export {};

package/dist/src/helpers/create-mitosis-component.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMitosisComponent = void 0;
+const createMitosisComponent = (options) => {
+    const { name, hooks, ...remainingOpts } = options || {};
+    const { onEvent = [], onMount = [], ...remainingHooks } = hooks || {};
+    return {
+        '@type': '@builder.io/mitosis/component',
+        imports: [],
+        exports: {},
+        inputs: [],
+        meta: {},
+        refs: {},
+        state: {},
+        children: [],
+        context: { get: {}, set: {} },
+        subComponents: [],
+        name: name || 'MyComponent',
+        hooks: {
+            onMount,
+            onEvent,
+            ...remainingHooks,
+        },
+        ...remainingOpts,
+    };
+};
+exports.createMitosisComponent = createMitosisComponent;

package/dist/src/helpers/create-mitosis-context.d.ts

@@ -0,0 +1,4 @@
+import { MitosisContext } from '../types/mitosis-context';
+export declare function createMitosisContext(options: Partial<MitosisContext> & {
+    name: string;
+}): MitosisContext;

package/dist/src/helpers/create-mitosis-context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMitosisContext = void 0;
+function createMitosisContext(options) {
+    return {
+        '@type': '@builder.io/mitosis/context',
+        value: {},
+        ...options,
+    };
+}
+exports.createMitosisContext = createMitosisContext;

package/dist/src/helpers/create-mitosis-node.d.ts

@@ -0,0 +1,2 @@
+import { MitosisNode } from '../types/mitosis-node';
+export declare const createMitosisNode: (options: Partial<MitosisNode>) => MitosisNode;

package/dist/src/helpers/create-mitosis-node.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMitosisNode = void 0;
+const createMitosisNode = (options) => ({
+    '@type': '@builder.io/mitosis/node',
+    name: 'div',
+    meta: {},
+    scope: {},
+    properties: {},
+    bindings: {},
+    children: [],
+    ...options,
+});
+exports.createMitosisNode = createMitosisNode;

package/dist/src/helpers/dash-case.d.ts

@@ -0,0 +1 @@
+export declare const dashCase: (string: string) => string;

package/dist/src/helpers/dash-case.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashCase = void 0;
+const lodash_1 = require("lodash");
+const dashCase = (string) => (0, lodash_1.kebabCase)(string);
+exports.dashCase = dashCase;

package/dist/src/helpers/dedent.d.ts

@@ -0,0 +1 @@
+export declare function dedent(strings: TemplateStringsArray, ...values: any[]): string;

package/dist/src/helpers/dedent.js

@@ -0,0 +1,83 @@
+"use strict";
+// Based on "dedent" package
+// Latest commit 2381e76 on Feb 15, 2017
+// Source: https://raw.githubusercontent.com/dmnd/dedent/master/dedent.js
+// License: MIT
+// Updates:
+// 1. Converted to TypeScript
+// 2. Preserve whitespace inside backtick string literals
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedent = void 0;
+function dedent(strings, ...values) {
+    const raw = typeof strings === 'string' ? [strings] : strings.raw;
+    // first, perform interpolation
+    let result = '';
+    for (let i = 0; i < raw.length; i++) {
+        result += raw[i]
+            // join lines when there is a suppressed newline
+            .replace(/\\\n[ \t]*/g, '')
+            // handle escaped backticks
+            .replace(/\\`/g, '`');
+        if (i < values.length) {
+            result += values[i];
+        }
+    }
+    // now strip indentation
+    const lines = split(result);
+    let mindent = null;
+    lines.forEach((l) => {
+        let m = l.match(/^(\s+)\S+/);
+        if (m) {
+            let indent = m[1].length;
+            if (!mindent) {
+                // this is the first indented line
+                mindent = indent;
+            }
+            else {
+                mindent = Math.min(mindent, indent);
+            }
+        }
+    });
+    if (mindent !== null) {
+        const m = mindent;
+        result = lines.map((l) => (l[0] === ' ' ? l.slice(m) : l)).join('\n');
+    }
+    // trim trailing whitespace on all lines
+    result = result
+        .split('\n')
+        .map((l) => l.trimEnd())
+        .join('\n');
+    return (result
+        // dedent eats leading and trailing whitespace too
+        .trim()
+        // handle escaped newlines at the end to ensure they don't get stripped too
+        .replace(/\\n/g, '\n'));
+}
+exports.dedent = dedent;
+/**
+ * Splits a string by newlines.
+ * Preserve whitespace inside backtick string literals.
+ * @param input The original input string.
+ * @returns The split string.
+ */
+function split(input) {
+    const result = [];
+    let prev = '';
+    let current = '';
+    let inBackticks = false;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        if (prev !== '\\' && char === '`') {
+            inBackticks = !inBackticks;
+        }
+        if (!inBackticks && char === '\n') {
+            result.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+        prev = char;
+    }
+    return result;
+}

package/dist/src/helpers/event-handlers.d.ts

@@ -0,0 +1,3 @@
+export declare const checkIsEvent: (code: string) => boolean;
+export declare const getEventNameWithoutOn: (code: string) => string;
+export declare const checkIsBindingNativeEvent: (code: string) => boolean;

package/dist/src/helpers/event-handlers.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIsBindingNativeEvent = exports.getEventNameWithoutOn = exports.checkIsEvent = void 0;
+const lodash_1 = require("lodash");
+const checkIsEvent = (code) => code.startsWith('on') && /[A-Z]/.test(code.charAt(2));
+exports.checkIsEvent = checkIsEvent;
+const getEventNameWithoutOn = (code) => (0, lodash_1.camelCase)(code.replace('on', ''));
+exports.getEventNameWithoutOn = getEventNameWithoutOn;
+const nativeEvents = [
+    'abort',
+    'animationcancel',
+    'animationend',
+    'animationiteration',
+    'animationstart',
+    'auxclick',
+    'beforeinput',
+    'beforetoggle',
+    'blur',
+    'cancel',
+    'canplay',
+    'canplaythrough',
+    'change',
+    'click',
+    'close',
+    'compositionend',
+    'compositionstart',
+    'compositionupdate',
+    'contextlost',
+    'contextmenu',
+    'contextrestored',
+    'copy',
+    'cuechange',
+    'cut',
+    'dblclick',
+    'drag',
+    'dragend',
+    'dragenter',
+    'dragleave',
+    'dragover',
+    'dragstart',
+    'drop',
+    'durationchange',
+    'emptied',
+    'ended',
+    'error',
+    'focus',
+    'focusin',
+    'focusout',
+    'formdata',
+    'gotpointercapture',
+    'input',
+    'invalid',
+    'keydown',
+    'keypress',
+    'keyup',
+    'load',
+    'loadeddata',
+    'loadedmetadata',
+    'loadstart',
+    'lostpointercapture',
+    'mousedown',
+    'mouseenter',
+    'mouseleave',
+    'mousemove',
+    'mouseout',
+    'mouseover',
+    'mouseup',
+    'paste',
+    'pause',
+    'play',
+    'playing',
+    'pointercancel',
+    'pointerdown',
+    'pointerenter',
+    'pointerleave',
+    'pointermove',
+    'pointerout',
+    'pointerover',
+    'pointerup',
+    'progress',
+    'ratechange',
+    'reset',
+    'resize',
+    'scroll',
+    'scrollend',
+    'securitypolicyviolation',
+    'seeked',
+    'seeking',
+    'select',
+    'selectionchange',
+    'selectstart',
+    'slotchange',
+    'stalled',
+    'submit',
+    'suspend',
+    'timeupdate',
+    'toggle',
+    'touchcancel',
+    'touchend',
+    'touchmove',
+    'touchstart',
+    'transitioncancel',
+    'transitionend',
+    'transitionrun',
+    'transitionstart',
+    'volumechange',
+    'waiting',
+    'webkitanimationend',
+    'webkitanimationiteration',
+    'webkitanimationstart',
+    'webkittransitionend',
+    'wheel',
+];
+const checkIsBindingNativeEvent = (code) => !!nativeEvents.find((nativeEvent) => nativeEvent === code.toLowerCase());
+exports.checkIsBindingNativeEvent = checkIsBindingNativeEvent;

package/dist/src/helpers/fast-clone.d.ts

@@ -0,0 +1 @@
+export declare const fastClone: <T extends object>(obj: T) => T;

package/dist/src/helpers/fast-clone.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastClone = void 0;
+const fastClone = (obj) => JSON.parse(JSON.stringify(obj));
+exports.fastClone = fastClone;

package/dist/src/helpers/filter-empty-text-nodes.d.ts

@@ -0,0 +1,3 @@
+import { MitosisNode } from '../types/mitosis-node';
+export declare const isEmptyTextNode: (node: MitosisNode) => boolean;
+export declare const filterEmptyTextNodes: (node: MitosisNode) => boolean;

package/dist/src/helpers/filter-empty-text-nodes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterEmptyTextNodes = exports.isEmptyTextNode = void 0;
+const isEmptyTextNode = (node) => {
+    return typeof node.properties._text === 'string' && node.properties._text.trim().length === 0;
+};
+exports.isEmptyTextNode = isEmptyTextNode;
+const filterEmptyTextNodes = (node) => !(0, exports.isEmptyTextNode)(node);
+exports.filterEmptyTextNodes = filterEmptyTextNodes;

package/dist/src/helpers/generic-format.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generic formatter for languages prettier doesn't support, like Swift
+ *
+ * Not super sophisticated, but much better than nothing
+ */
+export declare const format: (str: string, indentSpaces?: number) => string;

package/dist/src/helpers/generic-format.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = void 0;
+const preSpaceRegex = /^\s*/g;
+const DEFAULT_INDENT_SPACES = 2;
+/**
+ * Generic formatter for languages prettier doesn't support, like Swift
+ *
+ * Not super sophisticated, but much better than nothing
+ */
+const format = (str, indentSpaces = DEFAULT_INDENT_SPACES) => {
+    let currentIndent = 0;
+    const lines = str.split('\n');
+    lines.forEach((item, index) => {
+        item = item.trimEnd();
+        if (!item) {
+            lines[index] = '';
+            return;
+        }
+        lines[index] = item.replace(preSpaceRegex, ' '.repeat(currentIndent * indentSpaces));
+        const nextLine = lines[index + 1];
+        if (!nextLine) {
+            return;
+        }
+        if (nextLine.match(/^\s*[})][,;]?\s*$/)) {
+            currentIndent--;
+        }
+        else if (item.match(/([({]| in)$/)) {
+            currentIndent++;
+        }
+        currentIndent = Math.max(currentIndent, 0);
+    });
+    return lines.join('\n').replace(/\n{3,}/g, '\n\n');
+};
+exports.format = format;

package/dist/src/helpers/get-bindings.d.ts

@@ -0,0 +1,2 @@
+import { MitosisNode } from '../types/mitosis-node';
+export declare function getBindingsCode(children: MitosisNode[]): string[];

package/dist/src/helpers/get-bindings.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBindingsCode = void 0;
+function getBindingsCode(children) {
+    const bindings = [];
+    children.forEach((child) => {
+        Object.values(child.bindings || []).forEach((binding) => {
+            bindings.push(binding.code);
+        });
+        if (child.children) {
+            bindings.push(...getBindingsCode(child.children));
+        }
+    });
+    return bindings;
+}
+exports.getBindingsCode = getBindingsCode;

package/dist/src/helpers/get-child-components.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare const getChildComponents: (json: MitosisComponent) => string[];

package/dist/src/helpers/get-child-components.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChildComponents = void 0;
+const is_mitosis_node_1 = require("../helpers/is-mitosis-node");
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const getChildComponents = (json) => {
+    const nodes = [];
+    const childComponents = [json.name]; // a component can be recursively used in itself
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if ((0, is_mitosis_node_1.isMitosisNode)(item)) {
+            nodes.push(item.name);
+        }
+    });
+    for (const { imports } of json.imports) {
+        for (const key of Object.keys(imports)) {
+            if (nodes.includes(key)) {
+                childComponents.push(key);
+            }
+        }
+    }
+    return childComponents;
+};
+exports.getChildComponents = getChildComponents;

package/dist/src/helpers/get-components-used.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare function getComponentsUsed(json: MitosisComponent): Set<string>;

package/dist/src/helpers/get-components-used.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentsUsed = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const is_mitosis_node_1 = require("./is-mitosis-node");
+function getComponentsUsed(json) {
+    const components = new Set();
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if ((0, is_mitosis_node_1.isMitosisNode)(item)) {
+            components.add(item.name);
+        }
+    });
+    return components;
+}
+exports.getComponentsUsed = getComponentsUsed;

package/dist/src/helpers/get-components.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare function getComponents(json: MitosisComponent): Set<string>;

package/dist/src/helpers/get-components.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponents = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const is_mitosis_node_1 = require("./is-mitosis-node");
+const is_upper_case_1 = require("./is-upper-case");
+function getComponents(json) {
+    const components = new Set();
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if ((0, is_mitosis_node_1.isMitosisNode)(item)) {
+            if ((0, is_upper_case_1.isUpperCase)(item.name[0])) {
+                components.add(item.name);
+            }
+        }
+    });
+    return components;
+}
+exports.getComponents = getComponents;

package/dist/src/helpers/get-custom-imports.d.ts

@@ -0,0 +1,15 @@
+import { MitosisComponent } from '../types/mitosis-component';
+/**
+ * Return custom imports of basic values (aka things
+ * that are not ClassCase like components and types)
+ *
+ * For for code like:
+ *   import { foo, bar } from './constants'
+ *
+ * Will return:
+ *   ['foo', 'bar' ]
+ *
+ * This also filters for strings that appears to be actually used
+ * by the template
+ */
+export declare function getCustomImports(json: MitosisComponent): string[];

package/dist/src/helpers/get-custom-imports.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomImports = void 0;
+const is_upper_case_1 = require("./is-upper-case");
+/**
+ * Return custom imports of basic values (aka things
+ * that are not ClassCase like components and types)
+ *
+ * For for code like:
+ *   import { foo, bar } from './constants'
+ *
+ * Will return:
+ *   ['foo', 'bar' ]
+ *
+ * This also filters for strings that appears to be actually used
+ * by the template
+ */
+function getCustomImports(json) {
+    const blocksString = JSON.stringify(json.children);
+    const customImports = json.imports
+        .map((item) => {
+        return Object.keys(item.imports).filter((item) => item &&
+            // this ignores component imports, which are CamelCased.
+            (!(0, is_upper_case_1.isUpperCase)(item[0]) ||
+                // this includes constants which are typically CAPITALIZED.
+                item.toUpperCase() === item));
+    })
+        .flat()
+        // This is imperfect. Basically, if the string of this import name
+        // doesn't occur at all, it's definitely not used. If it does, it might.
+        // So this simple check helps us ~90% of the time not over-add imports
+        // to templates. Arguably "good enough" for now, as there is generally no
+        // consequence to over adding here, and it would be a lot more performance expensive
+        // during compilation to do a complete AST parse and look for real references
+        .filter((item) => blocksString.includes(item));
+    return customImports;
+}
+exports.getCustomImports = getCustomImports;

package/dist/src/helpers/get-function-string.d.ts

@@ -0,0 +1 @@
+export declare const getFunctionString: (code: string) => string;