@scelar/nodepod 1.0.1 → 1.0.2

package/dist/polyfills/path.d.ts

@@ -0,0 +1,95 @@
+export declare const sep = "/";
+export declare const delimiter = ":";
+export declare function normalize(inputPath: string): string;
+export declare function join(...fragments: string[]): string;
+export declare function resolve(...segments: string[]): string;
+export declare function isAbsolute(targetPath: string): boolean;
+export declare function dirname(targetPath: string): string;
+export declare function basename(targetPath: string, suffix?: string): string;
+export declare function extname(targetPath: string): string;
+export declare function relative(fromPath: string, toPath: string): string;
+export declare function parse(targetPath: string): {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+};
+export declare function format(components: {
+    root?: string;
+    dir?: string;
+    base?: string;
+    ext?: string;
+    name?: string;
+}): string;
+export declare const posix: {
+    sep: string;
+    delimiter: string;
+    normalize: typeof normalize;
+    join: typeof join;
+    resolve: typeof resolve;
+    isAbsolute: typeof isAbsolute;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+};
+export declare const win32: {
+    sep: string;
+    delimiter: string;
+    normalize: typeof normalize;
+    join: typeof join;
+    resolve: typeof resolve;
+    isAbsolute: typeof isAbsolute;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+};
+declare const _default: {
+    sep: string;
+    delimiter: string;
+    normalize: typeof normalize;
+    join: typeof join;
+    resolve: typeof resolve;
+    isAbsolute: typeof isAbsolute;
+    dirname: typeof dirname;
+    basename: typeof basename;
+    extname: typeof extname;
+    relative: typeof relative;
+    parse: typeof parse;
+    format: typeof format;
+    posix: {
+        sep: string;
+        delimiter: string;
+        normalize: typeof normalize;
+        join: typeof join;
+        resolve: typeof resolve;
+        isAbsolute: typeof isAbsolute;
+        dirname: typeof dirname;
+        basename: typeof basename;
+        extname: typeof extname;
+        relative: typeof relative;
+        parse: typeof parse;
+        format: typeof format;
+    };
+    win32: {
+        sep: string;
+        delimiter: string;
+        normalize: typeof normalize;
+        join: typeof join;
+        resolve: typeof resolve;
+        isAbsolute: typeof isAbsolute;
+        dirname: typeof dirname;
+        basename: typeof basename;
+        extname: typeof extname;
+        relative: typeof relative;
+        parse: typeof parse;
+        format: typeof format;
+    };
+};
+export default _default;

package/dist/polyfills/perf_hooks.d.ts

@@ -0,0 +1,48 @@
+export declare const performance: Performance;
+export interface TimingEntryList {
+    getEntries(): PerformanceEntry[];
+    getEntriesByName(name: string, kind?: string): PerformanceEntry[];
+    getEntriesByType(kind: string): PerformanceEntry[];
+}
+export interface PerformanceObserver {
+    observe(cfg: {
+        entryTypes?: string[];
+        type?: string;
+    }): void;
+    disconnect(): void;
+    takeRecords(): PerformanceEntry[];
+}
+export declare const PerformanceObserver: {
+    new (fn: (list: TimingEntryList) => void): PerformanceObserver;
+    prototype: any;
+    supportedEntryTypes: string[];
+};
+export interface TimingHistogram {
+    min: number;
+    max: number;
+    mean: number;
+    stddev: number;
+    percentiles: Map<number, number>;
+    exceeds: number;
+    reset(): void;
+    percentile(p: number): number;
+}
+export declare const TimingHistogram: {
+    new (): TimingHistogram;
+    prototype: any;
+};
+export declare function createHistogram(): TimingHistogram;
+export declare function monitorEventLoopDelay(_opts?: {
+    resolution?: number;
+}): TimingHistogram;
+declare const _default: {
+    performance: Performance;
+    PerformanceObserver: {
+        new (fn: (list: TimingEntryList) => void): PerformanceObserver;
+        prototype: any;
+        supportedEntryTypes: string[];
+    };
+    createHistogram: typeof createHistogram;
+    monitorEventLoopDelay: typeof monitorEventLoopDelay;
+};
+export default _default;

package/dist/polyfills/process.d.ts

@@ -0,0 +1,190 @@
+import { EventHandler } from "./events";
+export interface ProcessEnvVars {
+    [key: string]: string | undefined;
+}
+interface OutputStreamBridge {
+    isTTY: boolean;
+    columns: number;
+    rows: number;
+    write: (data: string | Buffer, encoding?: string, cb?: () => void) => boolean;
+    end?: (data?: string, cb?: () => void) => void;
+    on: (evt: string, fn: EventHandler) => OutputStreamBridge;
+    once: (evt: string, fn: EventHandler) => OutputStreamBridge;
+    off: (evt: string, fn: EventHandler) => OutputStreamBridge;
+    emit: (evt: string, ...args: unknown[]) => boolean;
+    addListener: (evt: string, fn: EventHandler) => OutputStreamBridge;
+    removeListener: (evt: string, fn: EventHandler) => OutputStreamBridge;
+    removeAllListeners: (evt?: string) => OutputStreamBridge;
+    setMaxListeners: (n: number) => OutputStreamBridge;
+    getMaxListeners: () => number;
+    listenerCount: (evt: string) => number;
+    listeners: (evt: string) => EventHandler[];
+    rawListeners: (evt: string) => EventHandler[];
+    prependListener: (evt: string, fn: EventHandler) => OutputStreamBridge;
+    prependOnceListener: (evt: string, fn: EventHandler) => OutputStreamBridge;
+    eventNames: () => string[];
+    pause?: () => OutputStreamBridge;
+    resume?: () => OutputStreamBridge;
+    setEncoding?: (enc: string) => OutputStreamBridge;
+    clearLine?: (dir: number, cb?: () => void) => boolean;
+    cursorTo?: (x: number, y?: number, cb?: () => void) => boolean;
+    moveCursor?: (dx: number, dy: number, cb?: () => void) => boolean;
+    getWindowSize?: () => [number, number];
+    getColorDepth?: (env?: Record<string, string>) => number;
+    hasColors?: (countOrEnv?: number | Record<string, string>, env?: Record<string, string>) => boolean;
+}
+interface InputStreamBridge extends OutputStreamBridge {
+    read?: (size?: number) => string | Buffer | null;
+    setRawMode?: (flag: boolean) => InputStreamBridge;
+    isRaw?: boolean;
+    destroy?: () => InputStreamBridge;
+    pipe?: (dest: any) => any;
+    unpipe?: () => InputStreamBridge;
+    unshift?: (...args: unknown[]) => void;
+    wrap?: (stream: any) => InputStreamBridge;
+    readable?: boolean;
+    writable?: boolean;
+    destroyed?: boolean;
+    [Symbol.asyncIterator]?: () => AsyncIterator<any>;
+}
+export interface ProcessObject {
+    env: ProcessEnvVars;
+    cwd: () => string;
+    chdir: (dir: string) => void;
+    _chdirHook?: (dir: string) => void;
+    platform: string;
+    version: string;
+    versions: {
+        node: string;
+        v8: string;
+        uv: string;
+        modules: string;
+        openssl: string;
+        napi: string;
+        webcontainer: string;
+    };
+    argv: string[];
+    argv0: string;
+    execPath: string;
+    execArgv: string[];
+    pid: number;
+    ppid: number;
+    exit: (code?: number) => never;
+    nextTick: (fn: (...args: unknown[]) => void, ...args: unknown[]) => void;
+    stdout: OutputStreamBridge;
+    stderr: OutputStreamBridge;
+    stdin: InputStreamBridge;
+    arch: string;
+    title: string;
+    hrtime: {
+        (prev?: [number, number]): [number, number];
+        bigint: () => bigint;
+    };
+    memoryUsage: () => {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        arrayBuffers: number;
+    };
+    uptime: () => number;
+    cpuUsage: () => {
+        user: number;
+        system: number;
+    };
+    resourceUsage: () => {
+        userCPUTime: number;
+        systemCPUTime: number;
+        maxRSS: number;
+        sharedMemorySize: number;
+        unsharedDataSize: number;
+        unsharedStackSize: number;
+        minorPageFault: number;
+        majorPageFault: number;
+        swappedOut: number;
+        fsRead: number;
+        fsWrite: number;
+        ipcSent: number;
+        ipcReceived: number;
+        signalsCount: number;
+        voluntaryContextSwitches: number;
+        involuntaryContextSwitches: number;
+    };
+    abort: () => never;
+    kill: (pid: number, signal?: string | number) => boolean;
+    umask: (mask?: number) => number;
+    config: {
+        variables: Record<string, unknown>;
+        target_defaults: Record<string, unknown>;
+    };
+    release: {
+        name: string;
+        sourceUrl: string;
+        headersUrl: string;
+    };
+    features: {
+        inspector: boolean;
+        debug: boolean;
+        uv: boolean;
+        ipv6: boolean;
+        tls_alpn: boolean;
+        tls_sni: boolean;
+        tls_ocsp: boolean;
+        tls: boolean;
+    };
+    debugPort: number;
+    allowedNodeEnvironmentFlags: Set<string>;
+    on: (evt: string, fn: EventHandler) => ProcessObject;
+    once: (evt: string, fn: EventHandler) => ProcessObject;
+    off: (evt: string, fn: EventHandler) => ProcessObject;
+    emit: (evt: string, ...args: unknown[]) => boolean;
+    addListener: (evt: string, fn: EventHandler) => ProcessObject;
+    removeListener: (evt: string, fn: EventHandler) => ProcessObject;
+    removeAllListeners: (evt?: string) => ProcessObject;
+    listeners: (evt: string) => EventHandler[];
+    listenerCount: (evt: string) => number;
+    prependListener: (evt: string, fn: EventHandler) => ProcessObject;
+    prependOnceListener: (evt: string, fn: EventHandler) => ProcessObject;
+    eventNames: () => string[];
+    setMaxListeners: (n: number) => ProcessObject;
+    getMaxListeners: () => number;
+    send?: (msg: unknown, cb?: (err: Error | null) => void) => boolean;
+    disconnect?: () => void;
+    connected?: boolean;
+    _debugCwdCalls?: number;
+    mainModule?: unknown;
+    channel?: unknown;
+    noDeprecation?: boolean;
+    throwDeprecation?: boolean;
+    traceDeprecation?: boolean;
+    traceProcessWarnings?: boolean;
+    report?: Record<string, unknown>;
+    binding?: (name: string) => Record<string, unknown>;
+    _linkedBinding?: (name: string) => Record<string, unknown>;
+    dlopen?: (module: unknown, filename: string, flags?: number) => void;
+    reallyExit?: (code?: number) => void;
+    _getActiveRequests?: () => unknown[];
+    _getActiveHandles?: () => unknown[];
+    emitWarning?: (warning: string | Error, typeOrOptions?: string | {
+        type?: string;
+        code?: string;
+        detail?: string;
+    }, code?: string) => void;
+    hasUncaughtExceptionCaptureCallback?: () => boolean;
+    setUncaughtExceptionCaptureCallback?: (fn: ((err: Error) => void) | null) => void;
+    sourceMapsEnabled?: boolean;
+    setSourceMapsEnabled?: (val: boolean) => void;
+    constrainedMemory?: () => number;
+    availableMemory?: () => number;
+}
+export declare function buildProcessEnv(config?: {
+    cwd?: string;
+    env?: ProcessEnvVars;
+    onExit?: (code: number) => void;
+    onStdout?: (text: string) => void;
+    onStderr?: (text: string) => void;
+    pid?: number;
+    ppid?: number;
+}): ProcessObject;
+export declare const process: ProcessObject;
+export default process;

package/dist/polyfills/punycode.d.ts

@@ -0,0 +1,21 @@
+export declare function decode(input: string): string;
+export declare function encode(input: string): string;
+export declare function toUnicode(domain: string): string;
+export declare function toASCII(domain: string): string;
+export declare const ucs2: {
+    decode: (str: string) => number[];
+    encode: (codePoints: number[]) => string;
+};
+export declare const version = "2.3.1";
+declare const _default: {
+    decode: typeof decode;
+    encode: typeof encode;
+    toUnicode: typeof toUnicode;
+    toASCII: typeof toASCII;
+    ucs2: {
+        decode: (str: string) => number[];
+        encode: (codePoints: number[]) => string;
+    };
+    version: string;
+};
+export default _default;

package/dist/polyfills/querystring.d.ts

@@ -0,0 +1,18 @@
+export type ParsedQuery = Record<string, string | string[]>;
+export declare function parse(input: string, pairSep?: string, kvSep?: string, options?: {
+    maxKeys?: number;
+}): ParsedQuery;
+export declare function stringify(obj: Record<string, string | string[] | number | boolean | undefined>, pairSep?: string, kvSep?: string): string;
+export declare function escape(text: string): string;
+export declare function unescape(text: string): string;
+export declare const encode: typeof stringify;
+export declare const decode: typeof parse;
+declare const _default: {
+    parse: typeof parse;
+    stringify: typeof stringify;
+    escape: typeof escape;
+    unescape: typeof unescape;
+    encode: typeof stringify;
+    decode: typeof parse;
+};
+export default _default;

package/dist/polyfills/quic.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from "./events";
+export interface QuicEndpoint extends EventEmitter {
+    close(): void;
+    destroy(_err?: Error): void;
+    readonly address: {
+        address: string;
+        family: string;
+        port: number;
+    };
+}
+interface QuicEndpointConstructor {
+    new (_opts?: object): QuicEndpoint;
+    (this: any, _opts?: object): void;
+    prototype: any;
+}
+export declare const QuicEndpoint: QuicEndpointConstructor;
+export interface QuicSession extends EventEmitter {
+    close(): void;
+    destroy(_err?: Error): void;
+    readonly destroyed: boolean;
+}
+interface QuicSessionConstructor {
+    new (): QuicSession;
+    (this: any): void;
+    prototype: any;
+}
+export declare const QuicSession: QuicSessionConstructor;
+export interface QuicStream extends EventEmitter {
+    readonly id: number;
+}
+interface QuicStreamConstructor {
+    new (): QuicStream;
+    (this: any): void;
+    prototype: any;
+}
+export declare const QuicStream: QuicStreamConstructor;
+declare const _default: {
+    QuicEndpoint: QuicEndpointConstructor;
+    QuicSession: QuicSessionConstructor;
+    QuicStream: QuicStreamConstructor;
+};
+export default _default;

package/dist/polyfills/readdirp.d.ts

@@ -0,0 +1,48 @@
+import type { MemoryVolume, FileStat } from "../memory-volume";
+export declare function setVolume(vol: MemoryVolume): void;
+export interface ScanOptions {
+    root?: string;
+    fileFilter?: string | string[] | ((entry: ScanEntry) => boolean);
+    directoryFilter?: string | string[] | ((entry: ScanEntry) => boolean);
+    depth?: number;
+    type?: "files" | "directories" | "files_directories" | "all";
+    lstat?: boolean;
+    alwaysStat?: boolean;
+}
+export interface ScanEntry {
+    path: string;
+    fullPath: string;
+    basename: string;
+    stats?: FileStat;
+    dirent?: {
+        isFile(): boolean;
+        isDirectory(): boolean;
+        name: string;
+    };
+}
+interface DirectoryScanner {
+    cfg: ScanOptions;
+    rootDir: string;
+    results: ScanEntry[];
+    scanned: boolean;
+    handlerMap: Map<string, Array<(...args: unknown[]) => void>>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<ScanEntry>;
+    toArray(): Promise<ScanEntry[]>;
+    on(event: string, handler: (...args: unknown[]) => void): this;
+    once(event: string, handler: (...args: unknown[]) => void): this;
+    off(event: string, handler: (...args: unknown[]) => void): this;
+    fireEvent(event: string, ...args: unknown[]): void;
+    runScan(): void;
+    crawl(dir: string, level: number, relative: string): void;
+    applyFilter(entry: ScanEntry, filter?: string | string[] | ((e: ScanEntry) => boolean)): boolean;
+    globMatch(filename: string, pattern: string): boolean;
+}
+interface DirectoryScannerConstructor {
+    new (root: string, cfg?: ScanOptions): DirectoryScanner;
+    (this: any, root: string, cfg?: ScanOptions): void;
+    prototype: any;
+}
+declare const DirectoryScanner: DirectoryScannerConstructor;
+export default function readdirp(root: string, options?: ScanOptions): DirectoryScanner;
+export declare function readdirpPromise(root: string, options?: ScanOptions): Promise<ScanEntry[]>;
+export { readdirp, DirectoryScanner };

package/dist/polyfills/readline.d.ts

@@ -0,0 +1,87 @@
+import { EventEmitter } from "./events";
+export declare function getActiveInterfaceCount(): number;
+export declare function setActiveInterfaceCount(n: number): void;
+export declare function resetActiveInterfaceCount(): void;
+export interface InterfaceConfig {
+    input?: unknown;
+    output?: unknown;
+    terminal?: boolean;
+    prompt?: string;
+    historySize?: number;
+    completer?: (line: string) => [string[], string] | void;
+    crlfDelay?: number;
+    escapeCodeTimeout?: number;
+    tabSize?: number;
+}
+export declare function emitKeypressEvents(stream: unknown, _iface?: Interface): void;
+export interface Interface extends EventEmitter {
+    _promptStr: string;
+    _input: unknown;
+    _output: unknown;
+    _closed: boolean;
+    _lineBuffer: string;
+    _pendingQuestions: Array<{
+        query: string;
+        handler: (answer: string) => void;
+    }>;
+    terminal: boolean;
+    line: string;
+    cursor: number;
+    _refreshLine(): void;
+    _onKeypress(char: string | undefined, key: any): void;
+    _onData(text: string): void;
+    prompt(preserveCursor?: boolean): void;
+    setPrompt(text: string): void;
+    getPrompt(): string;
+    question(query: string, optsOrHandler?: unknown, handler?: (answer: string) => void): void;
+    pause(): this;
+    resume(): this;
+    close(): void;
+    write(data: string | null, _key?: {
+        ctrl?: boolean;
+        name?: string;
+        meta?: boolean;
+        shift?: boolean;
+        sequence?: string;
+    }): void;
+    getCursorPos(): {
+        rows: number;
+        cols: number;
+    };
+    [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>;
+}
+interface InterfaceConstructor {
+    new (cfg?: InterfaceConfig): Interface;
+    (this: any, cfg?: InterfaceConfig): void;
+    prototype: any;
+}
+export declare const Interface: InterfaceConstructor;
+export declare function createInterface(cfgOrInput?: InterfaceConfig | unknown, output?: unknown): Interface;
+export declare function clearLine(stream: unknown, dir: number, done?: () => void): boolean;
+export declare function clearScreenDown(stream: unknown, done?: () => void): boolean;
+export declare function cursorTo(stream: unknown, x: number, yOrDone?: number | (() => void), done?: () => void): boolean;
+export declare function moveCursor(stream: unknown, dx: number, dy: number, done?: () => void): boolean;
+export declare const promises: {
+    createInterface(cfg?: InterfaceConfig): {
+        question(query: string): Promise<string>;
+        close(): void;
+        [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>;
+    };
+};
+declare const _default: {
+    Interface: InterfaceConstructor;
+    createInterface: typeof createInterface;
+    clearLine: typeof clearLine;
+    clearScreenDown: typeof clearScreenDown;
+    cursorTo: typeof cursorTo;
+    moveCursor: typeof moveCursor;
+    emitKeypressEvents: typeof emitKeypressEvents;
+    promises: {
+        createInterface(cfg?: InterfaceConfig): {
+            question(query: string): Promise<string>;
+            close(): void;
+            [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>;
+        };
+    };
+};
+export default _default;

package/dist/polyfills/repl.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from "./events";
+export declare const REPL_MODE_SLOPPY: unique symbol;
+export declare const REPL_MODE_STRICT: unique symbol;
+export interface Recoverable extends SyntaxError {
+    err: Error;
+}
+interface RecoverableConstructor {
+    new (err: Error): Recoverable;
+    (this: any, err: Error): void;
+    prototype: any;
+}
+export declare const Recoverable: RecoverableConstructor;
+export interface REPLServer extends EventEmitter {
+    context: Record<string, unknown>;
+    terminal: boolean;
+    _prompt: string;
+    _commands: Map<string, {
+        help: string;
+        action: Function;
+    }>;
+    setPrompt(prompt: string): void;
+    getPrompt(): string;
+    displayPrompt(_preserveCursor?: boolean): void;
+    defineCommand(keyword: string, cmd: {
+        help?: string;
+        action: Function;
+    } | Function): void;
+    close(): void;
+    setupHistory(_historyPath: string, cb: (err: Error | null, repl: REPLServer) => void): void;
+}
+interface REPLServerConstructor {
+    new (options?: string | Record<string, unknown>): REPLServer;
+    (this: any, options?: string | Record<string, unknown>): void;
+    prototype: any;
+}
+export declare const REPLServer: REPLServerConstructor;
+export declare function start(options?: string | Record<string, unknown>): REPLServer;
+declare const _default: {
+    start: typeof start;
+    REPLServer: REPLServerConstructor;
+    Recoverable: RecoverableConstructor;
+    REPL_MODE_SLOPPY: symbol;
+    REPL_MODE_STRICT: symbol;
+};
+export default _default;

package/dist/polyfills/rollup.d.ts

@@ -0,0 +1,37 @@
+declare function ensureRollup(): Promise<unknown>;
+export declare const VERSION: string;
+export declare function rollup(inputOptions: unknown): Promise<unknown>;
+export declare function watch(watchOptions: unknown): Promise<unknown>;
+export declare function defineConfig<T>(config: T): T;
+export declare function parseAst(source: string, opts?: {
+    allowReturnOutsideFunction?: boolean;
+    jsx?: boolean;
+}): unknown;
+export declare function parseAstAsync(source: string, opts?: {
+    allowReturnOutsideFunction?: boolean;
+    jsx?: boolean;
+    signal?: AbortSignal;
+}): Promise<unknown>;
+export declare function getPackageBase(): string;
+export { ensureRollup as loadRollup };
+export interface Plugin {
+    name: string;
+    [key: string]: unknown;
+}
+export interface PluginContext {
+    meta: {
+        rollupVersion: string;
+    };
+    parse: (code: string) => unknown;
+    [key: string]: unknown;
+}
+declare const _default: {
+    VERSION: string;
+    rollup: typeof rollup;
+    watch: typeof watch;
+    defineConfig: typeof defineConfig;
+    parseAst: typeof parseAst;
+    parseAstAsync: typeof parseAstAsync;
+    loadRollup: typeof ensureRollup;
+};
+export default _default;

package/dist/polyfills/sea.d.ts

@@ -0,0 +1,11 @@
+export declare function isSea(): boolean;
+export declare function getAsset(_key: string): never;
+export declare function getAssetAsBlob(_key: string): never;
+export declare function getRawAsset(_key: string): never;
+declare const _default: {
+    isSea: typeof isSea;
+    getAsset: typeof getAsset;
+    getAssetAsBlob: typeof getAssetAsBlob;
+    getRawAsset: typeof getRawAsset;
+};
+export default _default;

package/dist/polyfills/sqlite.d.ts

@@ -0,0 +1,30 @@
+export interface StatementSync {
+    run(..._params: unknown[]): object;
+    get(..._params: unknown[]): unknown;
+    all(..._params: unknown[]): unknown[];
+    expandedSQL(): string;
+    sourceSQL(): string;
+}
+interface StatementSyncConstructor {
+    new (): StatementSync;
+    (this: any): void;
+    prototype: any;
+}
+export declare const StatementSync: StatementSyncConstructor;
+export interface DatabaseSync {
+    close(): void;
+    exec(_sql: string): void;
+    prepare(_sql: string): StatementSync;
+    open(): void;
+}
+interface DatabaseSyncConstructor {
+    new (_location: string, _options?: object): DatabaseSync;
+    (this: any, _location: string, _options?: object): void;
+    prototype: any;
+}
+export declare const DatabaseSync: DatabaseSyncConstructor;
+declare const _default: {
+    DatabaseSync: DatabaseSyncConstructor;
+    StatementSync: StatementSyncConstructor;
+};
+export default _default;