@elench/testkit 0.1.64 → 0.1.66

package/node_modules/@swc/core/postinstall.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A postinstall script runs after `@swc/core` is installed.
+ *
+ * It checks if corresponding optional dependencies for native binary is installed and can be loaded properly.
+ * If it fails, it'll internally try to install `@swc/wasm` as fallback.
+ */
+const fs_1 = require("fs");
+const assert = __importStar(require("assert"));
+const path = __importStar(require("path"));
+const child_process = __importStar(require("child_process"));
+const fs = __importStar(require("fs"));
+function removeRecursive(dir) {
+    for (const entry of fs.readdirSync(dir)) {
+        const entryPath = path.join(dir, entry);
+        let stats;
+        try {
+            stats = fs.lstatSync(entryPath);
+        }
+        catch (_a) {
+            continue; // Guard against https://github.com/nodejs/node/issues/4760
+        }
+        if (stats.isDirectory())
+            removeRecursive(entryPath);
+        else
+            fs.unlinkSync(entryPath);
+    }
+    fs.rmdirSync(dir);
+}
+/**
+ * Trying to validate @swc/core's native binary installation, then installs if it is not supported.
+ */
+const validateBinary = () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const { name } = require(path.resolve(process.env.INIT_CWD, "package.json"));
+        if (name === "@swc/core" || name === "@swc/workspace") {
+            return;
+        }
+    }
+    catch (_) {
+        return;
+    }
+    // TODO: We do not take care of the case if user try to install with `--no-optional`.
+    // For now, it is considered as deliberate decision.
+    let binding;
+    try {
+        binding = require("./binding.js");
+        // Check if binding binary actually works.
+        // For the latest version, checks target triple. If it's old version doesn't have target triple, use parseSync instead.
+        const triple = binding.getTargetTriple
+            ? binding.getTargetTriple()
+            : binding.parseSync("console.log()", Buffer.from(JSON.stringify({ syntax: "ecmascript" })));
+        assert.ok(triple, "Failed to read target triple from native binary.");
+    }
+    catch (error) {
+        // if error is unsupported architecture, ignore to display.
+        if (!((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("Unsupported architecture"))) {
+            console.warn(error);
+        }
+        console.warn(`@swc/core was not able to resolve native bindings installation. It'll try to use @swc/wasm as fallback instead.`);
+    }
+    if (!!binding) {
+        return;
+    }
+    // User choose to override the binary installation. Skip remanining validation.
+    if (!!process.env["SWC_BINARY_PATH"]) {
+        console.warn(`@swc/core could not resolve native bindings installation, but found manual override config SWC_BINARY_PATH specified. Skipping remaning validation.`);
+        return;
+    }
+    // Check if top-level package.json installs @swc/wasm separately already
+    let wasmBinding;
+    try {
+        wasmBinding = require.resolve(`@swc/wasm`);
+    }
+    catch (_) { }
+    if (!!wasmBinding && (0, fs_1.existsSync)(wasmBinding)) {
+        return;
+    }
+    const env = Object.assign(Object.assign({}, process.env), { npm_config_global: undefined });
+    const { version } = require(path.join(path.dirname(require.resolve("@swc/core")), "package.json"));
+    // We want to place @swc/wasm next to the @swc/core as if normal installation was done,
+    // but can't directly set cwd to INIT_CWD as npm seems to acquire lock to the working dir.
+    // Instead, create a temporary inner and move it out.
+    const coreDir = path.dirname(require.resolve("@swc/core"));
+    const installDir = path.join(coreDir, "npm-install");
+    try {
+        fs.mkdirSync(installDir);
+        fs.writeFileSync(path.join(installDir, "package.json"), "{}");
+        // Instead of carrying over own dependencies to download & resolve package which increases installation sizes of `@swc/core`,
+        // assume & relies on system's npm installation.
+        child_process.execSync(`npm install --no-save --loglevel=error --prefer-offline --no-audit --progress=false @swc/wasm@${version}`, { cwd: installDir, stdio: "pipe", env });
+        const installedBinPath = path.join(installDir, "node_modules", `@swc/wasm`);
+        // INIT_CWD is injected via npm. If it doesn't exists, can't proceed.
+        fs.renameSync(installedBinPath, path.resolve(process.env.INIT_CWD, "node_modules", `@swc/wasm`));
+    }
+    catch (error) {
+        console.error(error);
+        console.error(`Failed to install fallback @swc/wasm@${version}. @swc/core will not properly.
+Please install @swc/wasm manually, or retry whole installation.
+If there are unexpected errors, please report at https://github.com/swc-project/swc/issues`);
+    }
+    finally {
+        try {
+            removeRecursive(installDir);
+        }
+        catch (_) {
+            // Gracefully ignore any failures. This'll make few leftover files but it shouldn't block installation.
+        }
+    }
+});
+validateBinary().catch((error) => {
+    // for now just throw the error as-is.
+    throw error;
+});

package/node_modules/@swc/core/spack.d.ts

@@ -0,0 +1,51 @@
+import { Options } from "@swc/types";
+export type BundleInput = BundleOptions | BundleOptions[];
+export declare const isLocalFile: RegExp;
+export declare function compileBundleOptions(config: BundleInput | string | undefined): Promise<BundleInput>;
+/**
+ * Usage: In `spack.config.js` / `spack.config.ts`, you can utilize type annotations (to get autocompletions) like
+ *
+ * ```ts
+ * import { config } from '@swc/core/spack';
+ *
+ * export default config({
+ *      name: 'web',
+ * });
+ * ```
+ *
+ *
+ *
+ */
+export declare function config(c: BundleInput): BundleInput;
+export interface BundleOptions extends SpackConfig {
+    workingDir?: string;
+}
+/**
+ * `spack.config,js`
+ */
+export interface SpackConfig {
+    /**
+     * @default process.env.NODE_ENV
+     */
+    mode?: Mode;
+    target?: Target;
+    entry: EntryConfig;
+    output: OutputConfig;
+    module: ModuleConfig;
+    options?: Options;
+    /**
+     * Modules to exclude from bundle.
+     */
+    externalModules?: string[];
+}
+export interface OutputConfig {
+    name: string;
+    path: string;
+}
+export interface ModuleConfig {
+}
+export type Mode = "production" | "development" | "none";
+export type Target = "browser" | "node";
+export type EntryConfig = string | string[] | {
+    [name: string]: string;
+};

package/node_modules/@swc/core/spack.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.compileBundleOptions = exports.isLocalFile = void 0;
+const path = __importStar(require("path"));
+exports.isLocalFile = /^\.{0,2}\//; // starts with '/' './' '../'
+function compileBundleOptions(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const f = config === undefined ? "." : config;
+        try {
+            const filepath = typeof f === "string" ? f : "spack.config.js";
+            const fileModule = exports.isLocalFile.test(filepath)
+                ? path.resolve(filepath)
+                : filepath;
+            let configFromFile = require(fileModule);
+            if (configFromFile.default) {
+                configFromFile = configFromFile.default;
+            }
+            if (Array.isArray(configFromFile)) {
+                if (Array.isArray(f)) {
+                    return [...configFromFile, ...f];
+                }
+                if (typeof f !== "string") {
+                    configFromFile.push(f);
+                }
+                return configFromFile;
+            }
+            return Object.assign(Object.assign({}, configFromFile), (typeof config === "string" ? {} : config));
+        }
+        catch (e) {
+            if (typeof f === "string") {
+                throw new Error(`Error occurred while loading config file at ${config}: ${e}`);
+            }
+            return f;
+        }
+    });
+}
+exports.compileBundleOptions = compileBundleOptions;
+/**
+ * Usage: In `spack.config.js` / `spack.config.ts`, you can utilize type annotations (to get autocompletions) like
+ *
+ * ```ts
+ * import { config } from '@swc/core/spack';
+ *
+ * export default config({
+ *      name: 'web',
+ * });
+ * ```
+ *
+ *
+ *
+ */
+function config(c) {
+    return c;
+}
+exports.config = config;

package/node_modules/@swc/core/util.d.ts

@@ -0,0 +1 @@
+export declare function wrapNativeSuper(Class: any): never;

package/node_modules/@swc/core/util.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapNativeSuper = void 0;
+//@ts-ignore
+function wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    //@ts-ignore
+    exports.wrapNativeSuper = wrapNativeSuper = function wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class))
+            return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class))
+                return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            //@ts-ignore
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true,
+            },
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return wrapNativeSuper(Class);
+}
+exports.wrapNativeSuper = wrapNativeSuper;
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct)
+        return false;
+    //@ts-ignore
+    if (Reflect.construct.sham)
+        return false;
+    if (typeof Proxy === "function")
+        return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function () { }));
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+//@ts-ignore
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        //@ts-ignore
+        _construct = Reflect.construct;
+    }
+    else {
+        //@ts-ignore
+        _construct = function _construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            //@ts-ignore
+            var Constructor = Function.bind.apply(Parent, a);
+            //@ts-ignore
+            var instance = new Constructor();
+            if (Class)
+                _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    //@ts-ignore
+    return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+//@ts-ignore
+function _setPrototypeOf(o, p) {
+    //@ts-ignore
+    _setPrototypeOf =
+        Object.setPrototypeOf ||
+            //@ts-ignore
+            function _setPrototypeOf(o, p) {
+                o.__proto__ = p;
+                return o;
+            };
+    return _setPrototypeOf(o, p);
+}
+//@ts-ignore
+function _getPrototypeOf(o) {
+    //@ts-ignore
+    _getPrototypeOf = Object.setPrototypeOf
+        ? Object.getPrototypeOf
+        : function _getPrototypeOf(
+        //@ts-ignore
+        o) {
+            return o.__proto__ || Object.getPrototypeOf(o);
+        };
+    return _getPrototypeOf(o);
+}
+module.exports = {
+    wrapNativeSuper,
+};

package/node_modules/@swc/core-linux-x64-gnu/README.md

@@ -0,0 +1,3 @@
+# `@swc/core-linux-x64-gnu`
+
+This is the **x86_64-unknown-linux-gnu** binary for `@swc/core`

package/node_modules/@swc/core-linux-x64-gnu/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@swc/core-linux-x64-gnu",
+  "version": "1.15.32",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "main": "swc.linux-x64-gnu.node",
+  "files": [
+    "swc.linux-x64-gnu.node",
+    "swc"
+  ],
+  "libc": [
+    "glibc"
+  ],
+  "description": "Super-fast alternative for babel",
+  "keywords": [
+    "swc",
+    "swcpack",
+    "babel",
+    "typescript",
+    "rust",
+    "webpack",
+    "tsc"
+  ],
+  "author": "강동윤 <kdy1997.dev@gmail.com>",
+  "homepage": "https://swc.rs",
+  "license": "Apache-2.0 AND MIT",
+  "engines": {
+    "node": ">=10"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/swc-project/swc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/swc-project/swc/issues"
+  }
+}

package/node_modules/@swc/counter/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @swc/counter
+
+## 0.1.3
+
+### Patch Changes
+
+-   a87f28d: Refactoring for @swc/counter

package/node_modules/@swc/counter/README.md

@@ -0,0 +1,7 @@
+# @swc/couter
+
+Download counter for swc packages.
+
+This package does not contain any code. It is used solely to track number of downloads of npm packages like `@swc/core` and `@next/swc`. If you are building a huge project using SWC, please consider depending on this package. It will not add any code to your bundle, but it will help us determine the number of users of SWC.
+
+Counting is done by npm, just like other packages.

package/node_modules/@swc/counter/index.js

@@ -0,0 +1 @@
+console.log("download-counter/index.js");

package/node_modules/@swc/counter/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@swc/counter",
+  "packageManager": "pnpm@8.6.7",
+  "main": "index.js",
+  "version": "0.1.3",
+  "description": "Downloade counter for the swc project",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/swc-project/pkgs.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "keywords": [
+    "swc",
+    "download",
+    "counter"
+  ],
+  "author": "강동윤 <kdy1997.dev@gmail.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/swc-project/swc/issues"
+  },
+  "homepage": "https://swc.rs"
+}