@dcloudio/uni-app-uts 3.0.0-alpha-3071320230417001

package/dist/plugins/uvue/code/template/compiler/options.d.ts

@@ -0,0 +1,60 @@
+import { CompilerError } from '@vue/compiler-core';
+import { RawSourceMap } from 'source-map';
+import { DirectiveTransform, NodeTransform } from './transform';
+interface SharedTransformCodegenOptions {
+    targetLanguage: 'kotlin' | 'swift';
+    /**
+     * Transform expressions like {{ foo }} to `_ctx.foo`.
+     * @default false
+     */
+    prefixIdentifiers?: boolean;
+    /**
+     * Filename for source map generation.
+     * Also used for self-recursive reference in templates
+     * @default ''
+     */
+    filename?: string;
+}
+export interface CodegenOptions extends SharedTransformCodegenOptions {
+    /**
+     * function
+     * @default 'default'
+     */
+    mode?: 'default' | 'function';
+    /**
+     * Generate source map?
+     * @default false
+     */
+    sourceMap?: boolean;
+}
+export interface ErrorHandlingOptions {
+    onWarn?: (warning: CompilerError) => void;
+    onError?: (error: CompilerError) => void;
+}
+export interface TransformOptions extends SharedTransformCodegenOptions, ErrorHandlingOptions {
+    /**
+     * An array of node transforms to be applied to every AST node.
+     */
+    nodeTransforms?: NodeTransform[];
+    /**
+     * An object of { name: transform } to be applied to every directive attribute
+     * node found on element nodes.
+     */
+    directiveTransforms?: Record<string, DirectiveTransform | undefined>;
+    /**
+     * If the pairing runtime provides additional built-in elements, use this to
+     * mark them as built-in so the compiler will generate component vnodes
+     * for them.
+     */
+    isBuiltInComponent?: (tag: string) => symbol | void;
+    /**
+     * Used by some transforms that expects only native elements
+     */
+    isCustomElement?: (tag: string) => boolean | void;
+}
+export type CompilerOptions = TransformOptions & CodegenOptions;
+export interface CodegenResult {
+    code: string;
+    map?: RawSourceMap;
+}
+export {};

package/dist/plugins/uvue/code/template/compiler/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugins/uvue/code/template/compiler/transform.d.ts

@@ -0,0 +1,52 @@
+import { CacheExpression, ComponentNode, ConstantTypes, DirectiveNode, ElementNode, ExpressionNode, JSChildNode, ParentNode, PlainElementNode, Property, RootNode, TemplateChildNode, TemplateLiteral, TemplateNode } from '@vue/compiler-core';
+import { TransformOptions } from './options';
+export type NodeTransform = (node: RootNode | TemplateChildNode, context: TransformContext) => void | (() => void) | (() => void)[];
+export type DirectiveTransform = (dir: DirectiveNode, node: ElementNode, context: TransformContext, augmentor?: (ret: DirectiveTransformResult) => DirectiveTransformResult) => DirectiveTransformResult;
+export interface DirectiveTransformResult {
+    props: Property[];
+    needRuntime?: boolean | symbol;
+    ssrTagParts?: TemplateLiteral['elements'];
+}
+export type StructuralDirectiveTransform = (node: ElementNode, dir: DirectiveNode, context: TransformContext) => void | (() => void);
+export interface ImportItem {
+    exp: string | ExpressionNode;
+    path: string;
+}
+export interface TransformContext extends Required<Omit<TransformOptions, 'filename'>> {
+    selfName: string | null;
+    root: RootNode;
+    helpers: Map<symbol, number>;
+    components: Set<string>;
+    directives: Set<string>;
+    imports: ImportItem[];
+    temps: number;
+    cached: number;
+    identifiers: {
+        [name: string]: number | undefined;
+    };
+    scopes: {
+        vFor: number;
+        vSlot: number;
+        vPre: number;
+        vOnce: number;
+    };
+    parent: ParentNode | null;
+    childIndex: number;
+    currentNode: RootNode | TemplateChildNode | null;
+    inVOnce: boolean;
+    helper<T extends symbol>(name: T): T;
+    removeHelper<T extends symbol>(name: T): void;
+    helperString(name: symbol): string;
+    replaceNode(node: TemplateChildNode): void;
+    removeNode(node?: TemplateChildNode): void;
+    onNodeRemoved(): void;
+    addIdentifiers(exp: ExpressionNode | string): void;
+    removeIdentifiers(exp: ExpressionNode | string): void;
+    cache<T extends JSChildNode>(exp: T, isVNode?: boolean): CacheExpression | T;
+    constantCache: Map<TemplateChildNode, ConstantTypes>;
+}
+export declare function createTransformContext(root: RootNode, { targetLanguage, filename, prefixIdentifiers, nodeTransforms, directiveTransforms, isBuiltInComponent, isCustomElement, onError, onWarn, }: TransformOptions): TransformContext;
+export declare function transform(root: RootNode, options: TransformOptions): void;
+export declare function isSingleElementRoot(root: RootNode, child: TemplateChildNode): child is PlainElementNode | ComponentNode | TemplateNode;
+export declare function traverseChildren(parent: ParentNode, context: TransformContext): void;
+export declare function traverseNode(node: RootNode | TemplateChildNode, context: TransformContext): void;

package/dist/plugins/uvue/code/template/compiler/transform.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseNode = exports.traverseChildren = exports.isSingleElementRoot = exports.transform = exports.createTransformContext = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const shared_1 = require("@vue/shared");
+const errors_1 = require("./errors");
+function createTransformContext(root, { targetLanguage, filename = '', prefixIdentifiers = false, nodeTransforms = [], directiveTransforms = {}, isBuiltInComponent = shared_1.NOOP, isCustomElement = shared_1.NOOP, onError = errors_1.defaultOnError, onWarn = errors_1.defaultOnWarn, }) {
+    const nameMatch = filename.replace(/\?.*$/, '').match(/([^/\\]+)\.\w+$/);
+    const context = {
+        // options
+        targetLanguage,
+        selfName: nameMatch && (0, shared_1.capitalize)((0, shared_1.camelize)(nameMatch[1])),
+        prefixIdentifiers,
+        nodeTransforms,
+        directiveTransforms,
+        isBuiltInComponent,
+        isCustomElement,
+        onError,
+        onWarn,
+        // state
+        root,
+        helpers: new Map(),
+        components: new Set(),
+        directives: new Set(),
+        imports: [],
+        constantCache: new Map(),
+        temps: 0,
+        cached: 0,
+        identifiers: Object.create(null),
+        scopes: {
+            vFor: 0,
+            vSlot: 0,
+            vPre: 0,
+            vOnce: 0,
+        },
+        parent: null,
+        currentNode: root,
+        childIndex: 0,
+        inVOnce: false,
+        // methods
+        helper(name) {
+            const count = context.helpers.get(name) || 0;
+            context.helpers.set(name, count + 1);
+            return name;
+        },
+        removeHelper(name) {
+            const count = context.helpers.get(name);
+            if (count) {
+                const currentCount = count - 1;
+                if (!currentCount) {
+                    context.helpers.delete(name);
+                }
+                else {
+                    context.helpers.set(name, currentCount);
+                }
+            }
+        },
+        helperString(name) {
+            return `_${compiler_core_1.helperNameMap[context.helper(name)]}`;
+        },
+        replaceNode(node) {
+            if (!context.currentNode) {
+                throw new Error(`Node being replaced is already removed.`);
+            }
+            if (!context.parent) {
+                throw new Error(`Cannot replace root node.`);
+            }
+            context.parent.children[context.childIndex] = context.currentNode = node;
+        },
+        removeNode(node) {
+            if (!context.parent) {
+                throw new Error(`Cannot remove root node.`);
+            }
+            const list = context.parent.children;
+            const removalIndex = node
+                ? list.indexOf(node)
+                : context.currentNode
+                    ? context.childIndex
+                    : -1;
+            /* istanbul ignore if */
+            if (removalIndex < 0) {
+                throw new Error(`node being removed is not a child of current parent`);
+            }
+            if (!node || node === context.currentNode) {
+                // current node removed
+                context.currentNode = null;
+                context.onNodeRemoved();
+            }
+            else {
+                // sibling node removed
+                if (context.childIndex > removalIndex) {
+                    context.childIndex--;
+                    context.onNodeRemoved();
+                }
+            }
+            context.parent.children.splice(removalIndex, 1);
+        },
+        onNodeRemoved: () => { },
+        addIdentifiers(exp) {
+            // identifier tracking only happens in non-browser builds.
+            if ((0, shared_1.isString)(exp)) {
+                addId(exp);
+            }
+            else if (exp.identifiers) {
+                exp.identifiers.forEach(addId);
+            }
+            else if (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+                addId(exp.content);
+            }
+        },
+        removeIdentifiers(exp) {
+            if ((0, shared_1.isString)(exp)) {
+                removeId(exp);
+            }
+            else if (exp.identifiers) {
+                exp.identifiers.forEach(removeId);
+            }
+            else if (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+                removeId(exp.content);
+            }
+        },
+        cache(exp, isVNode = false) {
+            return (0, compiler_core_1.createCacheExpression)(context.cached++, exp, isVNode);
+        },
+    };
+    function addId(id) {
+        const { identifiers } = context;
+        if (identifiers[id] === undefined) {
+            identifiers[id] = 0;
+        }
+        identifiers[id]++;
+    }
+    function removeId(id) {
+        context.identifiers[id]--;
+    }
+    return context;
+}
+exports.createTransformContext = createTransformContext;
+function transform(root, options) {
+    const context = createTransformContext(root, options);
+    traverseNode(root, context);
+    createRootCodegen(root, context);
+}
+exports.transform = transform;
+function isSingleElementRoot(root, child) {
+    const { children } = root;
+    return (children.length === 1 &&
+        child.type === 1 /* NodeTypes.ELEMENT */ &&
+        !(0, compiler_core_1.isSlotOutlet)(child));
+}
+exports.isSingleElementRoot = isSingleElementRoot;
+function createRootCodegen(root, context) {
+    const { children } = root;
+    if (children.length === 1) {
+        const child = children[0];
+        // if the single child is an element, turn it into a block.
+        if (isSingleElementRoot(root, child) && child.codegenNode) {
+            // single element root is never hoisted so codegenNode will never be
+            // SimpleExpressionNode
+            const codegenNode = child.codegenNode;
+            if (codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) {
+                (0, compiler_core_1.makeBlock)(codegenNode, context);
+            }
+            root.codegenNode = codegenNode;
+        }
+        else {
+            // - single <slot/>, IfNode, ForNode: already blocks.
+            // - single text node: always patched.
+            // root codegen falls through via genNode()
+            root.codegenNode = child;
+        }
+    }
+    else if (children.length > 1) {
+        // root has multiple nodes - return a fragment block.
+        // let patchFlag = PatchFlags.STABLE_FRAGMENT
+        // let patchFlagText = PatchFlagNames[PatchFlags.STABLE_FRAGMENT]
+        // // check if the fragment actually contains a single valid child with
+        // // the rest being comments
+        // if (
+        //     children.filter(c => c.type !== NodeTypes.COMMENT).length === 1
+        // ) {
+        //     patchFlag |= PatchFlags.DEV_ROOT_FRAGMENT
+        //     patchFlagText += `, ${PatchFlagNames[PatchFlags.DEV_ROOT_FRAGMENT]}`
+        // }
+        // root.codegenNode = createVNodeCall(
+        //     context,
+        //     helper(FRAGMENT),
+        //     undefined,
+        //     root.children,
+        //     patchFlag + ` /* ${patchFlagText} */`,
+        //     undefined,
+        //     undefined,
+        //     true,
+        //     undefined,
+        //     false /* isComponent */
+        // )
+    }
+    else {
+        // no children = noop. codegen will return null.
+    }
+}
+function traverseChildren(parent, context) {
+    let i = 0;
+    const nodeRemoved = () => {
+        i--;
+    };
+    for (; i < parent.children.length; i++) {
+        const child = parent.children[i];
+        if ((0, shared_1.isString)(child))
+            continue;
+        context.parent = parent;
+        context.childIndex = i;
+        context.onNodeRemoved = nodeRemoved;
+        traverseNode(child, context);
+    }
+}
+exports.traverseChildren = traverseChildren;
+function traverseNode(node, context) {
+    context.currentNode = node;
+    // apply transform plugins
+    const { nodeTransforms } = context;
+    const exitFns = [];
+    for (let i = 0; i < nodeTransforms.length; i++) {
+        const onExit = nodeTransforms[i](node, context);
+        if (onExit) {
+            if ((0, shared_1.isArray)(onExit)) {
+                exitFns.push(...onExit);
+            }
+            else {
+                exitFns.push(onExit);
+            }
+        }
+        if (!context.currentNode) {
+            // node was removed
+            return;
+        }
+        else {
+            // node may have been replaced
+            node = context.currentNode;
+        }
+    }
+    switch (node.type) {
+        case 3 /* NodeTypes.COMMENT */:
+            break;
+        case 5 /* NodeTypes.INTERPOLATION */:
+            break;
+        // for container types, further traverse downwards
+        case 9 /* NodeTypes.IF */:
+            for (let i = 0; i < node.branches.length; i++) {
+                traverseNode(node.branches[i], context);
+            }
+            break;
+        case 10 /* NodeTypes.IF_BRANCH */:
+        case 11 /* NodeTypes.FOR */:
+        case 1 /* NodeTypes.ELEMENT */:
+        case 0 /* NodeTypes.ROOT */:
+            traverseChildren(node, context);
+            break;
+    }
+    // exit transforms
+    context.currentNode = node;
+    let i = exitFns.length;
+    while (i--) {
+        exitFns[i]();
+    }
+}
+exports.traverseNode = traverseNode;

package/dist/plugins/uvue/code/template/index.d.ts

@@ -0,0 +1,3 @@
+import { SFCTemplateBlock } from '@vue/compiler-sfc';
+import { CompilerOptions } from './compiler/options';
+export declare function genTemplate(template: SFCTemplateBlock | null, options: CompilerOptions): string;

package/dist/plugins/uvue/code/template/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genTemplate = void 0;
+const compiler_1 = require("./compiler");
+const utils_1 = require("./utils");
+function genTemplate(template, options) {
+    if (!template) {
+        return (0, utils_1.genRenderFunctionDecl)(options) + ` { return null }`;
+    }
+    return (0, compiler_1.compile)(template.content, options).code;
+}
+exports.genTemplate = genTemplate;

package/dist/plugins/uvue/code/template/utils.d.ts

@@ -0,0 +1,2 @@
+import { CompilerOptions } from './compiler/options';
+export declare function genRenderFunctionDecl({ targetLanguage, filename, }: CompilerOptions): string;

package/dist/plugins/uvue/code/template/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genRenderFunctionDecl = void 0;
+function genRenderFunctionDecl({ targetLanguage, filename, }) {
+    return `${targetLanguage === 'kotlin' ? '@Suppress("UNUSED_PARAMETER") ' : ''}function ${filename}Render(ctx: ${filename}): VNode | null`;
+}
+exports.genRenderFunctionDecl = genRenderFunctionDecl;

package/dist/plugins/uvue/descriptorCache.d.ts

@@ -0,0 +1,22 @@
+import type * as _compiler from '@vue/compiler-sfc';
+import type { CompilerError, SFCDescriptor } from '@vue/compiler-sfc';
+export interface ResolvedOptions {
+    compiler: typeof _compiler;
+    root: string;
+    sourceMap: boolean;
+}
+export interface SFCParseResult {
+    descriptor: SFCDescriptor;
+    errors: Array<CompilerError | SyntaxError>;
+}
+declare module '@vue/compiler-sfc' {
+    interface SFCDescriptor {
+        id: string;
+    }
+}
+export declare function createDescriptor(filename: string, source: string, { root, sourceMap, compiler }: ResolvedOptions): SFCParseResult;
+export declare function getPrevDescriptor(filename: string): SFCDescriptor | undefined;
+export declare function setPrevDescriptor(filename: string, entry: SFCDescriptor): void;
+export declare function getDescriptor(filename: string, options: ResolvedOptions, createIfNotFound?: boolean): SFCDescriptor | undefined;
+export declare function getSrcDescriptor(filename: string): SFCDescriptor;
+export declare function setSrcDescriptor(filename: string, entry: SFCDescriptor): void;

package/dist/plugins/uvue/descriptorCache.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSrcDescriptor = exports.getSrcDescriptor = exports.getDescriptor = exports.setPrevDescriptor = exports.getPrevDescriptor = exports.createDescriptor = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const cache = new Map();
+const prevCache = new Map();
+function createDescriptor(filename, source, { root, sourceMap, compiler }) {
+    const { descriptor, errors } = compiler.parse(source, {
+        filename,
+        sourceMap,
+    });
+    // ensure the path is normalized in a way that is consistent inside
+    // project (relative to root) and on different systems.
+    const normalizedPath = (0, uni_cli_shared_1.normalizePath)(path_1.default.normalize(path_1.default.relative(root, filename)));
+    descriptor.id = getHash(normalizedPath);
+    cache.set(filename, descriptor);
+    return { descriptor, errors };
+}
+exports.createDescriptor = createDescriptor;
+function getPrevDescriptor(filename) {
+    return prevCache.get(filename);
+}
+exports.getPrevDescriptor = getPrevDescriptor;
+function setPrevDescriptor(filename, entry) {
+    prevCache.set(filename, entry);
+}
+exports.setPrevDescriptor = setPrevDescriptor;
+function getDescriptor(filename, options, createIfNotFound = true) {
+    if (cache.has(filename)) {
+        return cache.get(filename);
+    }
+    if (createIfNotFound) {
+        const { descriptor, errors } = createDescriptor(filename, fs_1.default.readFileSync(filename, 'utf-8'), options);
+        if (errors.length) {
+            throw errors[0];
+        }
+        return descriptor;
+    }
+}
+exports.getDescriptor = getDescriptor;
+function getSrcDescriptor(filename) {
+    return cache.get(filename);
+}
+exports.getSrcDescriptor = getSrcDescriptor;
+function setSrcDescriptor(filename, entry) {
+    cache.set(filename, entry);
+}
+exports.setSrcDescriptor = setSrcDescriptor;
+function getHash(text) {
+    return (0, crypto_1.createHash)('sha256').update(text).digest('hex').substring(0, 8);
+}

package/dist/plugins/uvue/error.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerError } from '@vue/compiler-sfc';
+import type { RollupError } from 'rollup';
+export declare function createRollupError(id: string, error: CompilerError | SyntaxError): RollupError;

package/dist/plugins/uvue/error.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRollupError = void 0;
+function createRollupError(id, error) {
+    const { message, name, stack } = error;
+    const rollupError = {
+        id,
+        plugin: 'vue',
+        message,
+        name,
+        stack,
+    };
+    if ('code' in error && error.loc) {
+        rollupError.loc = {
+            file: id,
+            line: error.loc.start.line,
+            column: error.loc.start.column,
+        };
+    }
+    return rollupError;
+}
+exports.createRollupError = createRollupError;

package/dist/plugins/uvue/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function uniAppUVuePlugin(): Plugin;

package/dist/plugins/uvue/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniAppUVuePlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const descriptorCache_1 = require("./descriptorCache");
+const error_1 = require("./error");
+const utils_1 = require("../utils");
+const script_1 = require("./code/script");
+const template_1 = require("./code/template");
+const style_1 = require("./code/style");
+function resolveAppVue(inputDir) {
+    const appUVue = path_1.default.resolve(inputDir, 'app.uvue');
+    if (fs_extra_1.default.existsSync(appUVue)) {
+        return (0, uni_cli_shared_1.normalizePath)(appUVue);
+    }
+    return (0, uni_cli_shared_1.normalizePath)(path_1.default.resolve(inputDir, 'App.vue'));
+}
+function uniAppUVuePlugin() {
+    const options = {
+        root: process.env.UNI_INPUT_DIR,
+        sourceMap: false,
+        // eslint-disable-next-line no-restricted-globals
+        compiler: require('@vue/compiler-sfc'),
+    };
+    const appVue = resolveAppVue(process.env.UNI_INPUT_DIR);
+    function isAppVue(id) {
+        return (0, uni_cli_shared_1.normalizePath)(id) === appVue;
+    }
+    return {
+        name: 'uni:app-uvue',
+        apply: 'build',
+        transform(code, id) {
+            const { filename } = (0, uni_cli_shared_1.parseVueRequest)(id);
+            const isVue = filename.endsWith('.vue') || filename.endsWith('.uvue');
+            if (!isVue) {
+                return;
+            }
+            // prev descriptor is only set and used for hmr
+            const { descriptor, errors } = (0, descriptorCache_1.createDescriptor)(filename, code, options);
+            if (errors.length) {
+                errors.forEach((error) => this.error((0, error_1.createRollupError)(filename, error)));
+                return null;
+            }
+            const isApp = isAppVue(id);
+            const fileName = path_1.default.relative(process.env.UNI_INPUT_DIR, id);
+            const className = (0, utils_1.genClassName)(fileName);
+            // 生成 script 文件
+            this.emitFile({
+                type: 'asset',
+                fileName,
+                source: (0, script_1.genScript)(descriptor.script, { filename: className }) +
+                    '\n' +
+                    (0, style_1.genStyle)(descriptor.styles, { filename: className }) +
+                    '\n' +
+                    (!isApp
+                        ? (0, template_1.genTemplate)(descriptor.template, {
+                            targetLanguage: process.env.UNI_UVUE_TARGET_LANGUAGE,
+                            mode: 'function',
+                            filename: className,
+                        })
+                        : ''),
+            });
+            const content = descriptor.script?.content;
+            if (content) {
+                return (0, utils_1.parseImports)(content);
+            }
+            return {
+                code: 'export default {}',
+            };
+        },
+    };
+}
+exports.uniAppUVuePlugin = uniAppUVuePlugin;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dcloudio/uni-app-uts",
+  "version": "3.0.0-alpha-3071320230417001",
+  "description": "uni-app-uts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "bin",
+    "dist",
+    "lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcloudio/uni-app.git",
+    "directory": "packages/uni-app-uts"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@dcloudio/uni-cli-shared": "3.0.0-alpha-3071320230417001",
+    "@rollup/pluginutils": "^4.2.0",
+    "@vue/compiler-core": "3.2.47",
+    "@vue/compiler-sfc": "3.2.47",
+    "@vue/shared": "3.2.47",
+    "debug": "^4.3.3",
+    "es-module-lexer": "^1.2.1",
+    "fs-extra": "^10.0.0",
+    "source-map": "^0.6.1"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.7",
+    "@types/fs-extra": "^9.0.13"
+  }
+}