@htmlplus/element 2.12.0 → 2.13.0

package/client/utils/updateAttribute.d.ts

@@ -1,2 +0,0 @@
-import { HTMLPlusElement } from '../../types/index.js';
-export declare const updateAttribute: (target: HTMLElement | HTMLPlusElement, key: string, value: any) => void;

package/client/utils/updateAttribute.js

@@ -1,10 +0,0 @@
-import { kebabCase } from 'change-case';
-import { host } from './host.js';
-export const updateAttribute = (target, key, value) => {
-    const element = host(target);
-    const name = kebabCase(key);
-    if ([undefined, null, false].includes(value)) {
-        return element.removeAttribute(name);
-    }
-    element.setAttribute(name, value === true ? '' : value);
-};

package/constants/index.d.ts

@@ -1,48 +0,0 @@
-export declare const PACKAGE_NAME = "@htmlplus/element";
-export declare const MAPPER: unique symbol;
-export declare const API_CONNECTED: unique symbol;
-export declare const API_HOST: unique symbol;
-export declare const API_INSTANCE: unique symbol;
-export declare const API_REQUEST: unique symbol;
-export declare const API_RENDER_COMPLETED: unique symbol;
-export declare const API_STACKS: unique symbol;
-export declare const API_STYLE: unique symbol;
-export declare const COMMENT_AUTO_ADDED = " THIS IS AUTO-ADDED, DO NOT EDIT MANUALY";
-export declare const DECORATOR_CSS_VARIABLE = "@Property()";
-export declare const DECORATOR_ELEMENT = "Element";
-export declare const DECORATOR_EVENT = "Event";
-export declare const DECORATOR_PROPERTY = "Property";
-export declare const DECORATOR_PROPERTY_TYPE = "type";
-export declare const DECORATOR_STATE = "State";
-export declare const DECORATOR_METHOD = "Method";
-export declare const ELEMENT_HOST_NAME = "host";
-export declare const LIFECYCLE_ADOPTED = "adoptedCallback";
-export declare const LIFECYCLE_CONNECTED = "connectedCallback";
-export declare const LIFECYCLE_CONSTRUCTED = "constructedCallback";
-export declare const LIFECYCLE_DISCONNECTED = "disconnectedCallback";
-export declare const LIFECYCLE_LOADED = "loadedCallback";
-export declare const LIFECYCLE_UPDATE = "updateCallback";
-export declare const LIFECYCLE_UPDATED = "updatedCallback";
-export declare const METHOD_RENDER = "render";
-export declare const STATIC_STYLE = "style";
-export declare const STATIC_TAG = "tag";
-export declare const STYLE_IMPORTED = "STYLE_IMPORTED";
-export declare const TYPE_ARRAY: number;
-export declare const TYPE_BOOLEAN: number;
-export declare const TYPE_DATE: number;
-export declare const TYPE_ENUM: number;
-export declare const TYPE_FUNCTION: number;
-export declare const TYPE_NULL: number;
-export declare const TYPE_NUMBER: number;
-export declare const TYPE_OBJECT: number;
-export declare const TYPE_STRING: number;
-export declare const TYPE_UNDEFINED: number;
-export declare const UTILS_ATTRIBUTES_IMPORTED = "attributes";
-export declare const UTILS_ATTRIBUTES_LOCAL = "UTILS_ATTRIBUTES";
-export declare const UTILS_HOST_IMPORTED = "host";
-export declare const UTILS_HOST_LOCAL = "UTILS_HOST";
-export declare const UTILS_HTML_IMPORTED = "html";
-export declare const UTILS_HTML_LOCAL = "UTILS_HTML";
-export declare const UTILS_STYLES_IMPORTED = "styles";
-export declare const UTILS_STYLES_LOCAL = "UTILS_STYLES";
-export declare const UTILS_PATH = "@htmlplus/element/client/utils/index.js";

package/constants/index.js

@@ -1,60 +0,0 @@
-export const PACKAGE_NAME = '@htmlplus/element';
-// TODO
-export const MAPPER = Symbol();
-// APIs
-export const API_CONNECTED = Symbol();
-export const API_HOST = Symbol();
-export const API_INSTANCE = Symbol();
-export const API_REQUEST = Symbol();
-export const API_RENDER_COMPLETED = Symbol();
-export const API_STACKS = Symbol();
-export const API_STYLE = Symbol();
-// comments
-export const COMMENT_AUTO_ADDED = ' THIS IS AUTO-ADDED, DO NOT EDIT MANUALY';
-// CSS decorators
-export const DECORATOR_CSS_VARIABLE = '@Property()';
-// decorators
-export const DECORATOR_ELEMENT = 'Element';
-export const DECORATOR_EVENT = 'Event';
-export const DECORATOR_PROPERTY = 'Property';
-export const DECORATOR_PROPERTY_TYPE = 'type';
-export const DECORATOR_STATE = 'State';
-export const DECORATOR_METHOD = 'Method';
-// element
-export const ELEMENT_HOST_NAME = 'host';
-// lifecycle
-export const LIFECYCLE_ADOPTED = 'adoptedCallback';
-export const LIFECYCLE_CONNECTED = 'connectedCallback';
-export const LIFECYCLE_CONSTRUCTED = 'constructedCallback';
-export const LIFECYCLE_DISCONNECTED = 'disconnectedCallback';
-export const LIFECYCLE_LOADED = 'loadedCallback';
-export const LIFECYCLE_UPDATE = 'updateCallback';
-export const LIFECYCLE_UPDATED = 'updatedCallback';
-// methods
-export const METHOD_RENDER = 'render';
-// statics
-export const STATIC_STYLE = 'style';
-export const STATIC_TAG = 'tag';
-// style
-export const STYLE_IMPORTED = 'STYLE_IMPORTED';
-// types
-export const TYPE_ARRAY = 2 ** 0;
-export const TYPE_BOOLEAN = 2 ** 1;
-export const TYPE_DATE = 2 ** 2;
-export const TYPE_ENUM = 2 ** 3;
-export const TYPE_FUNCTION = 2 ** 4;
-export const TYPE_NULL = 2 ** 5;
-export const TYPE_NUMBER = 2 ** 6;
-export const TYPE_OBJECT = 2 ** 7;
-export const TYPE_STRING = 2 ** 8;
-export const TYPE_UNDEFINED = 2 ** 9;
-// utils
-export const UTILS_ATTRIBUTES_IMPORTED = 'attributes';
-export const UTILS_ATTRIBUTES_LOCAL = 'UTILS_ATTRIBUTES';
-export const UTILS_HOST_IMPORTED = 'host';
-export const UTILS_HOST_LOCAL = 'UTILS_HOST';
-export const UTILS_HTML_IMPORTED = 'html';
-export const UTILS_HTML_LOCAL = 'UTILS_HTML';
-export const UTILS_STYLES_IMPORTED = 'styles';
-export const UTILS_STYLES_LOCAL = 'UTILS_STYLES';
-export const UTILS_PATH = '@htmlplus/element/client/utils/index.js';

package/transformer/index.d.ts

@@ -1,3 +0,0 @@
-export * from './transformer.js';
-export * from './transformer.types.js';
-export * from './plugins/index.js';

package/transformer/index.js

@@ -1,3 +0,0 @@
-export * from './transformer.js';
-export * from './transformer.types.js';
-export * from './plugins/index.js';

package/transformer/plugins/assets.d.ts

@@ -1,7 +0,0 @@
-import { TransformerPlugin, TransformerPluginContext } from '../transformer.types.js';
-export declare const ASSETS_OPTIONS: Partial<AssetsOptions>;
-export interface AssetsOptions {
-    destination?: (context: TransformerPluginContext) => string;
-    source?: (context: TransformerPluginContext) => string;
-}
-export declare const assets: (options?: AssetsOptions) => TransformerPlugin;

package/transformer/plugins/assets.js

@@ -1,26 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-export const ASSETS_OPTIONS = {
-    destination(context) {
-        return path.join('dist', 'assets', context.fileName);
-    },
-    source(context) {
-        return path.join(context.directoryPath, 'assets');
-    }
-};
-export const assets = (options) => {
-    const name = 'assets';
-    options = Object.assign({}, ASSETS_OPTIONS, options);
-    const finish = (global) => {
-        for (const context of global.contexts) {
-            context.assetsDestination = options.destination(context);
-            context.assetsSource = options.source(context);
-            if (!context.assetsSource)
-                continue;
-            if (!fs.existsSync(context.assetsSource))
-                continue;
-            fs.copySync(context.assetsSource, context.assetsDestination);
-        }
-    };
-    return { name, finish };
-};

package/transformer/plugins/copy.d.ts

@@ -1,9 +0,0 @@
-import { TransformerPlugin } from '../transformer.types.js';
-export declare const COPY_OPTIONS: Partial<CopyOptions>;
-export interface CopyOptions {
-    at?: 'start' | 'run' | 'finish';
-    destination: string;
-    source: string;
-    transformer?: (content: string) => string;
-}
-export declare const copy: (options: CopyOptions) => TransformerPlugin;

package/transformer/plugins/copy.js

@@ -1,29 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-export const COPY_OPTIONS = {
-    at: 'start'
-};
-export const copy = (options) => {
-    const name = 'copy';
-    options = Object.assign({}, COPY_OPTIONS, options);
-    const copy = (caller) => {
-        if (options.at != caller)
-            return;
-        let content;
-        content = fs.readFileSync(options.source, 'utf8');
-        if (options.transformer)
-            content = options.transformer(content);
-        fs.ensureDirSync(path.dirname(options.destination));
-        fs.writeFileSync(options.destination, content, 'utf8');
-    };
-    const start = () => {
-        copy('start');
-    };
-    const run = () => {
-        copy('run');
-    };
-    const finish = () => {
-        copy('finish');
-    };
-    return { name, start, run, finish };
-};

package/transformer/plugins/customElement.d.ts

@@ -1,7 +0,0 @@
-import { TransformerPlugin } from '../transformer.types.js';
-export declare const CUSTOM_ELEMENT_OPTIONS: Partial<CustomElementOptions>;
-export interface CustomElementOptions {
-    prefix?: string;
-    typings?: boolean;
-}
-export declare const customElement: (options?: CustomElementOptions) => TransformerPlugin;

package/transformer/plugins/customElement.js

@@ -1,392 +0,0 @@
-import template from '@babel/template';
-import t from '@babel/types';
-import { camelCase, kebabCase, pascalCase } from 'change-case';
-import * as CONSTANTS from '../../constants/index.js';
-import { addDependency, extractAttribute, getType, print, visitor } from '../utils/index.js';
-export const CUSTOM_ELEMENT_OPTIONS = {
-    prefix: undefined,
-    typings: true
-};
-// TODO: support {variable && jsxElement}
-export const customElement = (options) => {
-    const name = 'customElement';
-    options = Object.assign({}, CUSTOM_ELEMENT_OPTIONS, options);
-    const run = (context) => {
-        const ast = t.cloneNode(context.fileAST, true);
-        context.elementTagName = `${options.prefix || ''}${context.elementKey}`;
-        context.elementInterfaceName = `HTML${pascalCase(context.elementTagName)}Element`;
-        // attach tag name
-        visitor(ast, {
-            ClassDeclaration(path) {
-                const { body, id } = path.node;
-                if (id.name != context.className)
-                    return;
-                const node = t.classProperty(t.identifier(CONSTANTS.STATIC_TAG), t.stringLiteral(context.elementTagName), undefined, undefined, undefined, true);
-                t.addComment(node, 'leading', CONSTANTS.COMMENT_AUTO_ADDED, true);
-                body.body.unshift(node);
-            }
-        });
-        // attach style mapper for 'style' attribute
-        visitor(ast, {
-            JSXAttribute(path) {
-                const { name, value } = path.node;
-                if (name.name != 'style')
-                    return;
-                if (!value)
-                    return;
-                if (value.type != 'JSXExpressionContainer')
-                    return;
-                const { local } = addDependency(path, CONSTANTS.UTILS_PATH, CONSTANTS.UTILS_STYLES_LOCAL, CONSTANTS.UTILS_STYLES_IMPORTED);
-                // TODO: remove 'local!'
-                path.replaceWith(t.jsxAttribute(t.jsxIdentifier('style'), t.jsxExpressionContainer(t.callExpression(t.identifier(local), [value.expression]))));
-                path.skip();
-            }
-        });
-        // replace 'className' attribute with 'class'
-        visitor(ast, {
-            JSXAttribute(path) {
-                const { name, value } = path.node;
-                if (name.name != 'className')
-                    return;
-                const hasClass = path.parentPath.node.attributes.some((attribute) => {
-                    return attribute.name?.name == 'class';
-                });
-                if (hasClass)
-                    return path.remove();
-                path.replaceWith(t.jsxAttribute(t.jsxIdentifier('class'), value));
-            }
-        });
-        // TODO
-        visitor(ast, {
-            JSXAttribute(path) {
-                const { name, value } = path.node;
-                if (name.name == 'value') {
-                    name.name = '.' + name.name;
-                    return;
-                }
-                const key = ['tabIndex', 'viewBox'];
-                if (!key.includes(name.name))
-                    return;
-                path.replaceWith(t.jsxAttribute(t.jsxIdentifier(name.name.toLowerCase()), value));
-            }
-        });
-        // TODO
-        // convert 'jsx' to 'uhtml' syntax
-        visitor(ast, {
-            enter(path) {
-                const { type } = path.node;
-                if (!['JSXElement', 'JSXFragment'].includes(type))
-                    return;
-                const TODO = (node, attributes) => {
-                    const { local } = addDependency(path, CONSTANTS.UTILS_PATH, CONSTANTS.UTILS_ATTRIBUTES_LOCAL, CONSTANTS.UTILS_ATTRIBUTES_IMPORTED);
-                    return t.callExpression(t.identifier(local), [
-                        node,
-                        t.arrayExpression(attributes.map((attribute) => {
-                            switch (attribute.type) {
-                                case 'JSXSpreadAttribute':
-                                    return attribute.argument;
-                                default:
-                                    return t.objectExpression([
-                                        t.objectProperty(t.stringLiteral(attribute.name.name), attribute.value?.type == 'JSXExpressionContainer'
-                                            ? attribute.value.expression
-                                            : attribute.value || t.booleanLiteral(true))
-                                    ]);
-                            }
-                        }))
-                    ]);
-                };
-                const render = (node) => {
-                    switch (node.type) {
-                        case 'JSXElement':
-                            const attributes = node.openingElement.attributes;
-                            const isHost = node.openingElement.name.name == CONSTANTS.ELEMENT_HOST_NAME;
-                            // TODO
-                            if (isHost) {
-                                const children = node.children.map(render).flat();
-                                if (!attributes.length)
-                                    return children;
-                                return [TODO(t.thisExpression(), attributes), ...children];
-                            }
-                            const name = node.openingElement.name.name;
-                            const children = node.children.map(render).flat();
-                            const parts = [];
-                            parts.push('<', name);
-                            const hasSpreadAttribute = attributes.some((attribute) => {
-                                return attribute.type == 'JSXSpreadAttribute';
-                            });
-                            if (hasSpreadAttribute) {
-                                parts.push(' ', TODO(t.identifier('TODO'), attributes));
-                            }
-                            else {
-                                for (const attribute of attributes) {
-                                    switch (attribute.type) {
-                                        case 'JSXAttribute':
-                                            if (attribute.name.name == 'dangerouslySetInnerHTML') {
-                                                try {
-                                                    parts.push(' ', '.innerHTML');
-                                                    parts.push('=');
-                                                    parts.push(attribute.value.expression.properties.at(0).value);
-                                                }
-                                                catch { }
-                                                continue;
-                                            }
-                                            parts.push(' ', attribute.name.name);
-                                            if (!attribute.value)
-                                                continue;
-                                            parts.push('=');
-                                            switch (attribute.value.type) {
-                                                case 'JSXExpressionContainer':
-                                                    parts.push(attribute.value.expression);
-                                                    break;
-                                                default:
-                                                    parts.push(attribute.value.extra.raw);
-                                                    break;
-                                            }
-                                            break;
-                                        default:
-                                            parts.push(' ', attribute);
-                                            break;
-                                    }
-                                }
-                            }
-                            parts.push(node.closingElement ? '>' : ' />');
-                            parts.push(...children);
-                            if (node.closingElement) {
-                                parts.push('<', '/', name, '>');
-                            }
-                            return parts;
-                        case 'JSXFragment':
-                            return node.children.map(render).flat();
-                        case 'JSXText':
-                            return [node.extra.raw];
-                        case 'JSXExpressionContainer':
-                            if (node.expression.type == 'JSXEmptyExpression')
-                                return [];
-                            return [node.expression];
-                    }
-                };
-                const transform = (parts) => {
-                    const quasis = [];
-                    const expressions = [];
-                    let i = 0;
-                    while (i < parts.length + 1) {
-                        let quasi = '';
-                        while (typeof parts[i] == 'string') {
-                            quasi += parts[i].replace(/[\\`]/g, (s) => `\\${s}`);
-                            i += 1;
-                        }
-                        quasis.push(t.templateElement({ raw: quasi }));
-                        if (parts[i] != null)
-                            expressions.push(parts[i]);
-                        i += 1;
-                    }
-                    const templateLiteral = t.templateLiteral(quasis, expressions);
-                    // TODO
-                    // if (!expressions.length) return template;
-                    const { local } = addDependency(path, CONSTANTS.UTILS_PATH, CONSTANTS.UTILS_HTML_LOCAL, CONSTANTS.UTILS_HTML_IMPORTED, true);
-                    return t.taggedTemplateExpression(t.identifier(local), templateLiteral);
-                };
-                path.replaceWith(transform(render(path.node)));
-            }
-        });
-        // add type to properties
-        visitor(ast, {
-            Decorator(path) {
-                const { expression } = path.node;
-                if (expression.callee?.name != CONSTANTS.DECORATOR_PROPERTY)
-                    return;
-                if (!expression.arguments.length) {
-                    expression.arguments.push(t.objectExpression([]));
-                }
-                const [argument] = expression.arguments;
-                const filtered = argument.properties.filter((property) => {
-                    return property.key.name != CONSTANTS.DECORATOR_PROPERTY_TYPE;
-                });
-                if (argument.properties.length != filtered.length)
-                    return;
-                argument.properties = filtered;
-                let type = 0;
-                const extract = (input) => {
-                    switch (input?.type) {
-                        case 'BooleanLiteral':
-                            type |= CONSTANTS.TYPE_BOOLEAN;
-                            break;
-                        case 'NumericLiteral':
-                            type |= CONSTANTS.TYPE_NUMBER;
-                            break;
-                        case 'StringLiteral':
-                            type |= CONSTANTS.TYPE_ENUM;
-                            break;
-                        case 'TSArrayType':
-                            type |= CONSTANTS.TYPE_ARRAY;
-                            break;
-                        case 'TSBooleanKeyword':
-                            type |= CONSTANTS.TYPE_BOOLEAN;
-                            break;
-                        case 'TSLiteralType':
-                            extract(input.literal);
-                            break;
-                        case 'TSNullKeyword':
-                            type |= CONSTANTS.TYPE_NULL;
-                            break;
-                        case 'TSNumberKeyword':
-                            type |= CONSTANTS.TYPE_NUMBER;
-                            break;
-                        case 'TSObjectKeyword':
-                            type |= CONSTANTS.TYPE_OBJECT;
-                            break;
-                        case 'TSStringKeyword':
-                            type |= CONSTANTS.TYPE_STRING;
-                            break;
-                        case 'TSTupleType':
-                            type |= CONSTANTS.TYPE_ARRAY;
-                            break;
-                        case 'TSTypeLiteral':
-                            type |= CONSTANTS.TYPE_OBJECT;
-                            break;
-                        case 'TSTypeReference':
-                            if (!input.typeName)
-                                break;
-                            switch (input.typeName.name) {
-                                case 'Array':
-                                    type |= CONSTANTS.TYPE_ARRAY;
-                                    break;
-                                case 'Boolean':
-                                    type |= CONSTANTS.TYPE_BOOLEAN;
-                                    break;
-                                case 'bool':
-                                    type |= CONSTANTS.TYPE_BOOLEAN;
-                                    break;
-                                case 'Date':
-                                    type |= CONSTANTS.TYPE_DATE;
-                                    break;
-                                case 'Number':
-                                    type |= CONSTANTS.TYPE_NUMBER;
-                                    break;
-                                case 'Object':
-                                    type |= CONSTANTS.TYPE_OBJECT;
-                                    break;
-                            }
-                            break;
-                        case 'TSUnionType':
-                            input.types.forEach(extract);
-                            break;
-                    }
-                    // TODO
-                    if (input?.type == 'TSParenthesizedType' &&
-                        input?.typeAnnotation?.type == 'TSIntersectionType') {
-                        let types = input.types || input.typeAnnotation.types;
-                        if (types.length != 2)
-                            return;
-                        types = types.filter((type) => type.type != 'TSTypeLiteral');
-                        if (types.length != 1)
-                            return;
-                        extract(types[0]);
-                    }
-                };
-                extract(getType(context.directoryPath, ast, path.parentPath.node.typeAnnotation?.typeAnnotation));
-                argument.properties.push(t.objectProperty(t.identifier(CONSTANTS.DECORATOR_PROPERTY_TYPE), t.numericLiteral(type)));
-            }
-        });
-        // attach typings
-        if (options.typings) {
-            visitor(ast, {
-                Program(path) {
-                    const attributes = context
-                        .classProperties.filter((property) => !t.isClassMethod(property))
-                        .map((property) => {
-                        const key = extractAttribute(property) || kebabCase(property.key['name']);
-                        const typeAnnotation = property.typeAnnotation;
-                        return Object.assign(t.tSPropertySignature(t.stringLiteral(kebabCase(key)), typeAnnotation), {
-                            optional: property.optional,
-                            leadingComments: t.cloneNode(property, true).leadingComments
-                        });
-                    });
-                    const events = context.classEvents.map((event) => {
-                        const key = event.key;
-                        const typeAnnotation = event.typeAnnotation;
-                        return Object.assign(t.tSPropertySignature(t.identifier(camelCase('on-' + key.name)), t.tsTypeAnnotation(t.tsFunctionType(undefined, [
-                            Object.assign({}, t.identifier('event'), {
-                                typeAnnotation: t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CustomEvent'), typeAnnotation?.['typeAnnotation']?.typeParameters))
-                            })
-                        ], t.tsTypeAnnotation(t.tsVoidKeyword())))), {
-                            optional: true,
-                            leadingComments: t.cloneNode(event, true).leadingComments
-                        });
-                    });
-                    const methods = context.classMethods.map((method) => {
-                        return Object.assign(t.tsMethodSignature(method.key, undefined, method.params, // TODO
-                        method.returnType // TODO
-                        ), {
-                            leadingComments: t.cloneNode(method, true).leadingComments
-                        });
-                    });
-                    const properties = context.classProperties.map((property) => {
-                        const key = property.key;
-                        // TODO
-                        const readonly = property.readonly || !!property['returnType'];
-                        // TODO
-                        const typeAnnotation = (property.typeAnnotation ||
-                            property['returnType']);
-                        return Object.assign(t.tsPropertySignature(t.identifier(key.name), typeAnnotation), {
-                            readonly,
-                            optional: property.optional,
-                            leadingComments: t.cloneNode(property, true).leadingComments
-                        });
-                    });
-                    // prettier-ignore
-                    const ast = template.default.ast(`
-              // THE FOLLOWING TYPES HAVE BEEN ADDED AUTOMATICALLY
-
-              export interface ${context.className}Attributes {
-                ${attributes.map(print).join('')}
-              }
-
-              export interface ${context.className}Events {
-                ${events.map(print).join('')}
-              }
-
-              export interface ${context.className}Methods {
-                ${methods.map(print).join('')}
-              }
-
-              export interface ${context.className}Properties {
-                ${properties.map(print).join('')}
-              }
-
-              export interface ${context.className}JSX extends ${context.className}Events, ${context.className}Properties { }
-    
-              declare global {
-                interface ${context.elementInterfaceName} extends HTMLElement, ${context.className}Methods, ${context.className}Properties { }
-
-                var ${context.elementInterfaceName}: {
-                  prototype: ${context.elementInterfaceName};
-                  new (): ${context.elementInterfaceName};
-                };
-
-                interface HTMLElementTagNameMap {
-                  "${context.elementTagName}": ${context.elementInterfaceName};
-                }
-                
-                namespace JSX {
-                  interface IntrinsicElements {
-                    "${context.elementTagName}": ${context.className}Events & ${context.className}Attributes & {
-                      [key: string]: any;
-                    };
-                  }
-                }
-              }
-
-              export type ${context.className}Element = globalThis.${context.elementInterfaceName}
-            `, {
-                        plugins: ['typescript'],
-                        preserveComments: true
-                    });
-                    path.node.body.push(...ast);
-                }
-            });
-        }
-        context.script = print(ast);
-    };
-    return { name, run };
-};

package/transformer/plugins/document.d.ts

@@ -1,7 +0,0 @@
-import { TransformerPlugin, TransformerPluginContext } from '../transformer.types.js';
-export declare const DOCUMENT_OPTIONS: Partial<DocumentOptions>;
-export interface DocumentOptions {
-    destination: string;
-    transformer?: (context: TransformerPluginContext, element: any) => any;
-}
-export declare const document: (options?: DocumentOptions) => TransformerPlugin;