sval 0.6.3 → 0.6.5

package/dist/src/evaluate/declaration.d.ts

@@ -0,0 +1,27 @@
+import { VarKind } from '../scope/variable.ts';
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function FunctionDeclaration(node: acorn.FunctionDeclaration, scope: Scope): IterableIterator<any>;
+export interface VariableDeclarationOptions {
+    hoist?: boolean;
+    onlyBlock?: boolean;
+    feed?: any;
+}
+export declare function VariableDeclaration(node: acorn.VariableDeclaration, scope: Scope, options?: VariableDeclarationOptions): Generator<any, void, any>;
+export interface VariableDeclaratorOptions {
+    kind?: VarKind;
+}
+export declare function VariableDeclarator(node: acorn.VariableDeclarator, scope: Scope, options?: VariableDeclaratorOptions & VariableDeclarationOptions): Generator<any, void, any>;
+export declare function ClassDeclaration(node: acorn.ClassDeclaration, scope: Scope): IterableIterator<any>;
+export interface ClassOptions {
+    klass?: any;
+    superClass?: (...args: any[]) => void;
+}
+export declare function ClassBody(node: acorn.ClassBody, scope: Scope, options?: ClassOptions): Generator<any, void, any>;
+export declare function MethodDefinition(node: acorn.MethodDefinition, scope: Scope, options?: ClassOptions): Generator<any, void, any>;
+export declare function PropertyDefinition(node: acorn.PropertyDefinition, scope: Scope, options?: ClassOptions): Generator<any, void, any>;
+export declare function StaticBlock(node: acorn.StaticBlock, scope: Scope, options?: ClassOptions): Generator<any, any, any>;
+export declare function ImportDeclaration(node: acorn.ImportDeclaration, scope: Scope): Generator<never, void, unknown>;
+export declare function ExportDefaultDeclaration(node: acorn.ExportDefaultDeclaration, scope: Scope): Generator<any, void, any>;
+export declare function ExportNamedDeclaration(node: acorn.ExportNamedDeclaration, scope: Scope): Generator<any, void, any>;
+export declare function ExportAllDeclaration(node: acorn.ExportAllDeclaration, scope: Scope): Generator<never, void, unknown>;

package/dist/src/evaluate/expression.d.ts

@@ -0,0 +1,40 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function ThisExpression(node: acorn.ThisExpression, scope: Scope): Generator<never, any, unknown>;
+export declare function ArrayExpression(node: acorn.ArrayExpression, scope: Scope): Generator<any, any[], any>;
+export declare function ObjectExpression(node: acorn.ObjectExpression, scope: Scope): Generator<any, {
+    [key: string]: any;
+}, any>;
+export declare function FunctionExpression(node: acorn.FunctionExpression, scope: Scope): Generator<never, any, unknown>;
+export declare function UnaryExpression(node: acorn.UnaryExpression, scope: Scope): Generator<any, number | boolean | "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function", any>;
+export declare function UpdateExpression(node: acorn.UpdateExpression, scope: Scope): Generator<any, any, any>;
+export declare function BinaryExpression(node: acorn.BinaryExpression, scope: Scope): Generator<any, any, any>;
+export declare function AssignmentExpression(node: acorn.AssignmentExpression, scope: Scope): Generator<any, any, any>;
+export declare function LogicalExpression(node: acorn.LogicalExpression, scope: Scope): Generator<any, any, any>;
+export interface MemberExpressionOptions {
+    getObj?: boolean;
+    getVar?: boolean;
+}
+export declare function MemberExpression(node: acorn.MemberExpression, scope: Scope, options?: MemberExpressionOptions): Generator<any, any, any>;
+export declare function ConditionalExpression(node: acorn.ConditionalExpression, scope: Scope): Generator<any, any, any>;
+export declare function CallExpression(node: acorn.CallExpression, scope: Scope): Generator<any, any, any>;
+export declare function NewExpression(node: acorn.NewExpression, scope: Scope): Generator<any, any, any>;
+export declare function MetaProperty(node: acorn.MetaProperty, scope: Scope): Generator<never, any, unknown>;
+export declare function SequenceExpression(node: acorn.SequenceExpression, scope: Scope): Generator<any, any, any>;
+export declare function ArrowFunctionExpression(node: acorn.ArrowFunctionExpression, scope: Scope): Generator<never, any, unknown>;
+export declare function TemplateLiteral(node: acorn.TemplateLiteral, scope: Scope): Generator<any, string, any>;
+export declare function TaggedTemplateExpression(node: acorn.TaggedTemplateExpression, scope: Scope): Generator<any, any, any>;
+export declare function TemplateElement(node: acorn.TemplateElement, scope: Scope): Generator<never, string, unknown>;
+export declare function ClassExpression(node: acorn.ClassExpression, scope: Scope): Generator<any, () => Generator<any, any, any>, any>;
+export interface SuperOptions {
+    getProto?: boolean;
+}
+export declare function Super(node: acorn.Super, scope: Scope, options?: SuperOptions): Generator<never, any, unknown>;
+export interface SpreadOptions {
+    spreadProps?: boolean;
+}
+export declare function SpreadElement(node: acorn.SpreadElement, scope: Scope, options?: SpreadOptions): Generator<any, any, any>;
+export declare function ChainExpression(node: acorn.ChainExpression, scope: Scope): Generator<any, any, any>;
+export declare function ImportExpression(node: acorn.ImportExpression, scope: Scope): Generator<any, Promise<any>, any>;
+export declare function YieldExpression(node: acorn.YieldExpression, scope: Scope): any;
+export declare function AwaitExpression(node: acorn.AwaitExpression, scope: Scope): any;

package/dist/src/evaluate/helper.d.ts

@@ -0,0 +1,18 @@
+import { default as Scope } from '../scope/index.ts';
+import { PatternOptions } from './pattern.ts';
+import * as acorn from 'acorn';
+export interface hoistOptions {
+    onlyBlock?: boolean;
+}
+export declare function hoist(block: acorn.Program | acorn.BlockStatement | acorn.StaticBlock, scope: Scope, options?: hoistOptions): Generator<any, void, any>;
+export declare function pattern(node: acorn.Pattern, scope: Scope, options?: PatternOptions): IterableIterator<any>;
+export interface CtorOptions {
+    construct?: (object: any) => Generator | void;
+    superClass?: (...args: any[]) => any;
+}
+export declare function createFunc(node: acorn.FunctionDeclaration | acorn.FunctionExpression | acorn.ArrowFunctionExpression, scope: Scope, options?: CtorOptions): any;
+export declare function createClass(node: acorn.ClassDeclaration | acorn.ClassExpression, scope: Scope): Generator<any, () => Generator<any, any, any>, any>;
+export interface ForXHandlerOptions {
+    value: any;
+}
+export declare function ForXHandler(node: acorn.ForInStatement | acorn.ForOfStatement, scope: Scope, options: ForXHandlerOptions): Generator<any, any, any>;

package/dist/src/evaluate/identifier.d.ts

@@ -0,0 +1,7 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export interface IdentifierOptions {
+    getVar?: boolean;
+    throwErr?: boolean;
+}
+export declare function Identifier(node: acorn.Identifier, scope: Scope, options?: IdentifierOptions): Generator<never, any, unknown>;

package/dist/src/evaluate/index.d.ts

@@ -0,0 +1,3 @@
+import { Node } from 'acorn';
+import { default as Scope } from '../scope/index.ts';
+export default function evaluate(node: Node, scope: Scope): Generator<any, any, any>;

package/dist/src/evaluate/literal.d.ts

@@ -0,0 +1,3 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function Literal(node: acorn.Literal, scope: Scope): Generator<never, string | number | bigint | boolean | RegExp, unknown>;

package/dist/src/evaluate/pattern.d.ts

@@ -0,0 +1,13 @@
+import { VarKind } from '../scope/variable.ts';
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export interface PatternOptions {
+    kind?: VarKind;
+    hoist?: boolean;
+    onlyBlock?: boolean;
+    feed?: any;
+}
+export declare function ObjectPattern(node: acorn.ObjectPattern, scope: Scope, options?: PatternOptions): Generator<any, void, any>;
+export declare function ArrayPattern(node: acorn.ArrayPattern, scope: Scope, options?: PatternOptions): Generator<any, any[], any>;
+export declare function RestElement(node: acorn.RestElement, scope: Scope, options?: PatternOptions): Generator<any, void, any>;
+export declare function AssignmentPattern(node: acorn.AssignmentPattern, scope: Scope, options?: PatternOptions): Generator<any, void, any>;

package/dist/src/evaluate/program.d.ts

@@ -0,0 +1,3 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function Program(program: acorn.Program, scope: Scope): Generator<any, void, any>;

package/dist/src/evaluate/statement.d.ts

@@ -0,0 +1,35 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function ExpressionStatement(node: acorn.ExpressionStatement, scope: Scope): Generator<any, void, any>;
+export interface LabelOptions {
+    label?: string;
+}
+export interface BlockOptions {
+    invasived?: boolean;
+    hoisted?: boolean;
+}
+export declare function BlockStatement(block: acorn.BlockStatement | acorn.StaticBlock, scope: Scope, options?: BlockOptions & LabelOptions): Generator<any, any, any>;
+export declare function EmptyStatement(): IterableIterator<any>;
+export declare function DebuggerStatement(): IterableIterator<any>;
+export declare function ReturnStatement(node: acorn.ReturnStatement, scope: Scope): Generator<any, {
+    RES: any;
+}, any>;
+export declare function BreakStatement(node: acorn.BreakStatement): Generator<never, {
+    LABEL: string;
+}, unknown>;
+export declare function ContinueStatement(node: acorn.ContinueStatement): Generator<never, {
+    LABEL: string;
+}, unknown>;
+export declare function LabeledStatement(node: acorn.LabeledStatement, scope: Scope): Generator<any, any, any>;
+export declare function WithStatement(node: acorn.WithStatement, scope: Scope, options?: LabelOptions): Generator<any, any, any>;
+export declare function IfStatement(node: acorn.IfStatement, scope: Scope, options?: LabelOptions): Generator<any, any, any>;
+export declare function SwitchStatement(node: acorn.SwitchStatement, scope: Scope, options?: LabelOptions): Generator<any, any, any>;
+export declare function SwitchCase(node: acorn.SwitchCase, scope: Scope): Generator<any, any, any>;
+export declare function ThrowStatement(node: acorn.ThrowStatement, scope: Scope): Generator<any, void, any>;
+export declare function TryStatement(node: acorn.TryStatement, scope: Scope, options?: LabelOptions): Generator<any, any, any>;
+export declare function CatchClause(node: acorn.CatchClause, scope: Scope): Generator<any, any, any>;
+export declare function WhileStatement(node: acorn.WhileStatement, scope: Scope, options?: LabelOptions): Generator<any, any, any>;
+export declare function DoWhileStatement(node: acorn.DoWhileStatement, scope: Scope, options?: LabelOptions): Generator<any, any, any>;
+export declare function ForStatement(node: acorn.ForStatement, scope: Scope, options?: LabelOptions): Generator<any, any, any>;
+export declare function ForInStatement(node: acorn.ForInStatement, scope: Scope, options?: LabelOptions): Generator<any, any, any>;
+export declare function ForOfStatement(node: acorn.ForOfStatement, scope: Scope, options?: LabelOptions): any;

package/dist/src/evaluate_n/declaration.d.ts

@@ -0,0 +1,27 @@
+import { VarKind } from '../scope/variable.ts';
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function FunctionDeclaration(node: acorn.FunctionDeclaration, scope: Scope): any;
+export interface VariableDeclarationOptions {
+    hoist?: boolean;
+    onlyBlock?: boolean;
+    feed?: any;
+}
+export declare function VariableDeclaration(node: acorn.VariableDeclaration, scope: Scope, options?: VariableDeclarationOptions): void;
+export interface VariableDeclaratorOptions {
+    kind?: VarKind;
+}
+export declare function VariableDeclarator(node: acorn.VariableDeclarator, scope: Scope, options?: VariableDeclaratorOptions & VariableDeclarationOptions): void;
+export declare function ClassDeclaration(node: acorn.ClassDeclaration, scope: Scope): any;
+export interface ClassOptions {
+    klass?: any;
+    superClass?: (...args: any[]) => void;
+}
+export declare function ClassBody(node: acorn.ClassBody, scope: Scope, options?: ClassOptions): void;
+export declare function MethodDefinition(node: acorn.MethodDefinition, scope: Scope, options?: ClassOptions): void;
+export declare function PropertyDefinition(node: acorn.PropertyDefinition, scope: Scope, options?: ClassOptions): void;
+export declare function StaticBlock(node: acorn.StaticBlock, scope: Scope, options?: ClassOptions): any;
+export declare function ImportDeclaration(node: acorn.ImportDeclaration, scope: Scope): void;
+export declare function ExportDefaultDeclaration(node: acorn.ExportDefaultDeclaration, scope: Scope): void;
+export declare function ExportNamedDeclaration(node: acorn.ExportNamedDeclaration, scope: Scope): void;
+export declare function ExportAllDeclaration(node: acorn.ExportAllDeclaration, scope: Scope): void;

package/dist/src/evaluate_n/expression.d.ts

@@ -0,0 +1,38 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function ThisExpression(node: acorn.ThisExpression, scope: Scope): any;
+export declare function ArrayExpression(node: acorn.ArrayExpression, scope: Scope): any[];
+export declare function ObjectExpression(node: acorn.ObjectExpression, scope: Scope): {
+    [key: string]: any;
+};
+export declare function FunctionExpression(node: acorn.FunctionExpression, scope: Scope): any;
+export declare function UnaryExpression(node: acorn.UnaryExpression, scope: Scope): number | boolean | "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export declare function UpdateExpression(node: acorn.UpdateExpression, scope: Scope): any;
+export declare function BinaryExpression(node: acorn.BinaryExpression, scope: Scope): any;
+export declare function AssignmentExpression(node: acorn.AssignmentExpression, scope: Scope): any;
+export declare function LogicalExpression(node: acorn.LogicalExpression, scope: Scope): any;
+export interface MemberExpressionOptions {
+    getObj?: boolean;
+    getVar?: boolean;
+}
+export declare function MemberExpression(node: acorn.MemberExpression, scope: Scope, options?: MemberExpressionOptions): any;
+export declare function ConditionalExpression(node: acorn.ConditionalExpression, scope: Scope): any;
+export declare function CallExpression(node: acorn.CallExpression, scope: Scope): any;
+export declare function NewExpression(node: acorn.NewExpression, scope: Scope): any;
+export declare function MetaProperty(node: acorn.MetaProperty, scope: Scope): any;
+export declare function SequenceExpression(node: acorn.SequenceExpression, scope: Scope): any;
+export declare function ArrowFunctionExpression(node: acorn.ArrowFunctionExpression, scope: Scope): any;
+export declare function TemplateLiteral(node: acorn.TemplateLiteral, scope: Scope): string;
+export declare function TaggedTemplateExpression(node: acorn.TaggedTemplateExpression, scope: Scope): any;
+export declare function TemplateElement(node: acorn.TemplateElement, scope: Scope): string;
+export declare function ClassExpression(node: acorn.ClassExpression, scope: Scope): () => any;
+export interface SuperOptions {
+    getProto?: boolean;
+}
+export declare function Super(node: acorn.Super, scope: Scope, options?: SuperOptions): any;
+export interface SpreadOptions {
+    spreadProps?: boolean;
+}
+export declare function SpreadElement(node: acorn.SpreadElement, scope: Scope, options?: SpreadOptions): any;
+export declare function ChainExpression(node: acorn.ChainExpression, scope: Scope): any;
+export declare function ImportExpression(node: acorn.ImportExpression, scope: Scope): Promise<any>;

package/dist/src/evaluate_n/helper.d.ts

@@ -0,0 +1,18 @@
+import { default as Scope } from '../scope/index.ts';
+import { PatternOptions } from './pattern.ts';
+import * as acorn from 'acorn';
+export interface hoistOptions {
+    onlyBlock?: boolean;
+}
+export declare function hoist(block: acorn.Program | acorn.BlockStatement | acorn.StaticBlock, scope: Scope, options?: hoistOptions): void;
+export declare function pattern(node: acorn.Pattern, scope: Scope, options?: PatternOptions): any;
+export interface CtorOptions {
+    construct?: (object: any) => Generator | void;
+    superClass?: (...args: any[]) => any;
+}
+export declare function createFunc(node: acorn.FunctionDeclaration | acorn.FunctionExpression | acorn.ArrowFunctionExpression, scope: Scope, options?: CtorOptions): any;
+export declare function createClass(node: acorn.ClassDeclaration | acorn.ClassExpression, scope: Scope): () => any;
+export interface ForXHandlerOptions {
+    value: any;
+}
+export declare function ForXHandler(node: acorn.ForInStatement | acorn.ForOfStatement, scope: Scope, options: ForXHandlerOptions): any;

package/dist/src/evaluate_n/identifier.d.ts

@@ -0,0 +1,7 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export interface IdentifierOptions {
+    getVar?: boolean;
+    throwErr?: boolean;
+}
+export declare function Identifier(node: acorn.Identifier, scope: Scope, options?: IdentifierOptions): any;

package/dist/src/evaluate_n/index.d.ts

@@ -0,0 +1,3 @@
+import { Node } from 'acorn';
+import { default as Scope } from '../scope/index.ts';
+export default function evaluate(node: Node, scope: Scope): any;

package/dist/src/evaluate_n/literal.d.ts

@@ -0,0 +1,3 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function Literal(node: acorn.Literal, scope: Scope): string | number | bigint | boolean | RegExp;

package/dist/src/evaluate_n/pattern.d.ts

@@ -0,0 +1,13 @@
+import { VarKind } from '../scope/variable.ts';
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export interface PatternOptions {
+    kind?: VarKind;
+    hoist?: boolean;
+    onlyBlock?: boolean;
+    feed?: any;
+}
+export declare function ObjectPattern(node: acorn.ObjectPattern, scope: Scope, options?: PatternOptions): void;
+export declare function ArrayPattern(node: acorn.ArrayPattern, scope: Scope, options?: PatternOptions): any[];
+export declare function RestElement(node: acorn.RestElement, scope: Scope, options?: PatternOptions): void;
+export declare function AssignmentPattern(node: acorn.AssignmentPattern, scope: Scope, options?: PatternOptions): void;

package/dist/src/evaluate_n/program.d.ts

@@ -0,0 +1,3 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function Program(program: acorn.Program, scope: Scope): void;

package/dist/src/evaluate_n/statement.d.ts

@@ -0,0 +1,35 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function ExpressionStatement(node: acorn.ExpressionStatement, scope: Scope): void;
+export interface LabelOptions {
+    label?: string;
+}
+export interface BlockOptions {
+    invasived?: boolean;
+    hoisted?: boolean;
+}
+export declare function BlockStatement(block: acorn.BlockStatement | acorn.StaticBlock, scope: Scope, options?: BlockOptions & LabelOptions): any;
+export declare function EmptyStatement(): any;
+export declare function DebuggerStatement(): any;
+export declare function ReturnStatement(node: acorn.ReturnStatement, scope: Scope): {
+    RES: any;
+};
+export declare function BreakStatement(node: acorn.BreakStatement): {
+    LABEL: string;
+};
+export declare function ContinueStatement(node: acorn.ContinueStatement): {
+    LABEL: string;
+};
+export declare function LabeledStatement(node: acorn.LabeledStatement, scope: Scope): any;
+export declare function WithStatement(node: acorn.WithStatement, scope: Scope, options?: LabelOptions): any;
+export declare function IfStatement(node: acorn.IfStatement, scope: Scope, options?: LabelOptions): any;
+export declare function SwitchStatement(node: acorn.SwitchStatement, scope: Scope, options?: LabelOptions): any;
+export declare function SwitchCase(node: acorn.SwitchCase, scope: Scope): any;
+export declare function ThrowStatement(node: acorn.ThrowStatement, scope: Scope): void;
+export declare function TryStatement(node: acorn.TryStatement, scope: Scope, options?: LabelOptions): any;
+export declare function CatchClause(node: acorn.CatchClause, scope: Scope): any;
+export declare function WhileStatement(node: acorn.WhileStatement, scope: Scope, options?: LabelOptions): any;
+export declare function DoWhileStatement(node: acorn.DoWhileStatement, scope: Scope, options?: LabelOptions): any;
+export declare function ForStatement(node: acorn.ForStatement, scope: Scope, options?: LabelOptions): any;
+export declare function ForInStatement(node: acorn.ForInStatement, scope: Scope, options?: LabelOptions): any;
+export declare function ForOfStatement(node: acorn.ForOfStatement, scope: Scope, options?: LabelOptions): any;

package/{types → dist/src}/index.d.ts

@@ -1,17 +1,17 @@
-import { Options, Node } from 'acorn';
-export interface SvalOptions {
-    ecmaVer?: Options['ecmaVersion'];
-    sourceType?: Options['sourceType'];
-    sandBox?: boolean;
-}
-declare class Sval {
-    static version: string;
-    private options;
-    private scope;
-    exports: Record<string, any>;
-    constructor(options?: SvalOptions);
-    import(nameOrModules: string | Record<string, any>, mod?: any): void;
-    parse(code: string, parser?: (code: string, options: SvalOptions) => Node): Node;
-    run(code: string | Node): void;
-}
-export default Sval;
+import { Options, Node } from 'acorn';
+export interface SvalOptions {
+    ecmaVer?: Options['ecmaVersion'];
+    sourceType?: Options['sourceType'];
+    sandBox?: boolean;
+}
+declare class Sval {
+    static version: string;
+    private options;
+    private scope;
+    exports: Record<string, any>;
+    constructor(options?: SvalOptions);
+    import(nameOrModules: string | Record<string, any>, mod?: any): void;
+    parse(code: string, parser?: (code: string, options: SvalOptions) => Node): Node;
+    run(code: string | Node): void;
+}
+export default Sval;

package/dist/src/scope/index.d.ts

@@ -0,0 +1,15 @@
+import { Variable } from './variable.ts';
+export default class Scope {
+    private readonly parent;
+    private readonly isolated;
+    private readonly context;
+    private withContext;
+    constructor(parent?: Scope, isolated?: boolean);
+    global(): Scope;
+    find(name: string): Variable;
+    var(name: string, value?: any): void;
+    let(name: string, value: any): void;
+    const(name: string, value: any): void;
+    func(name: string, value: any): void;
+    with(value: any): void;
+}

package/dist/src/scope/variable.d.ts

@@ -0,0 +1,20 @@
+export type VarKind = 'var' | 'let' | 'const';
+export interface Variable {
+    get(): any;
+    set(value: any): boolean;
+}
+export declare class Var implements Variable {
+    readonly kind: VarKind;
+    private value;
+    constructor(kind: VarKind, value: any);
+    get(): any;
+    set(value: any): any;
+}
+export declare class Prop implements Variable {
+    private readonly object;
+    private readonly property;
+    constructor(object: any, property: string);
+    get(): any;
+    set(value: any): boolean;
+    del(): boolean;
+}

package/dist/src/share/async.d.ts

@@ -0,0 +1,7 @@
+export interface runAsyncOptions {
+    res?: any;
+    err?: any;
+    ret?: any;
+    fullRet?: boolean;
+}
+export declare function runAsync(iterator: IterableIterator<any>, options?: runAsyncOptions): Promise<any>;

package/dist/src/share/const.d.ts

@@ -0,0 +1,22 @@
+export declare const AWAIT: {
+    RES: any;
+};
+export declare const RETURN: {
+    RES: any;
+};
+export declare const CONTINUE: {
+    LABEL: string;
+};
+export declare const BREAK: {
+    LABEL: string;
+};
+export declare const SUPER: string;
+export declare const SUPERCALL: string;
+export declare const NOCTOR: string;
+export declare const CLSCTOR: string;
+export declare const NEWTARGET: string;
+export declare const PRIVATE: string;
+export declare const NOINIT: string;
+export declare const DEADZONE: string;
+export declare const IMPORT: string;
+export declare const EXPORTS: string;

package/dist/src/share/util.d.ts

@@ -0,0 +1,33 @@
+export declare const freeze: {
+    <T extends Function>(f: T): T;
+    <T extends {
+        [idx: string]: U | null | undefined | object;
+    }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+    <T>(o: T): Readonly<T>;
+};
+export declare const define: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+export declare const getDptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
+export declare function hasOwn(obj: any, key: string): boolean;
+export declare const getOwnNames: (o: any) => string[];
+export declare function setProto(obj: any, proto: any): void;
+export declare function getProto(obj: any): any;
+export declare function getGetter(obj: any, key: string): (() => any) | ((v: any) => void);
+export declare function getSetter(obj: any, key: string): (() => any) | ((v: any) => void);
+export declare const create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export declare function inherits(subClass: (...args: any[]) => any, superClass: (...args: any[]) => any): void;
+export declare function callSuper(target: any, superClass: (...args: any[]) => any, args?: any[]): any;
+export declare function _assign(target: any): any;
+export declare const assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare let globalObj: any;
+export declare const WINDOW: string;
+export declare function createSandBox(): any;
+export declare function createSymbol(key: string): string;
+export declare function getAsyncIterator(obj: any): any;