@immediately-run/sandpack-client 2.19.8

package/dist/types.d.ts

@@ -0,0 +1,348 @@
+import type { SandpackNodeMessage } from "./clients/node/types";
+import type { SandpackRuntimeMessage } from "./clients/runtime/types";
+import type { SandpackFS } from "./fs/SandpackFS";
+/**
+ * Host-pinned SDK artifact integrity (SDK_PACKAGING_SPEC §5.2), keyed
+ * module → concrete version → `{ relPath: 'sha384-<base64>' }`. The host (the
+ * TCB) supplies it; the runtime client forwards it verbatim into the
+ * register-frame handshake, and the bundler verifies fetched SDK bytes against
+ * it BEFORE evaluation, failing the boot closed on any mismatch. Absent ⇒
+ * verification is skipped (the pin is not wired) rather than self-attesting
+ * against the origin's own manifest.
+ */
+export type SdkIntegrity = Record<string, Record<string, Record<string, string>>>;
+export interface ClientOptions {
+    /**
+     * Paths to external resources
+     */
+    externalResources?: string[];
+    /**
+     * Location of the bundler.
+     */
+    bundlerURL?: string;
+    /**
+     * URL of the Babel transpiler worker script, served **same-origin with the
+     * parent page** (not the bundler origin). The runtime client spawns this
+     * worker itself and connects it to the sandboxed iframe over a `MessagePort`,
+     * so the iframe no longer needs to load a worker (and can drop
+     * `allow-same-origin`). Required for the runtime client to transpile.
+     */
+    babelWorkerURL?: string;
+    /**
+     * Level of logging to do in the bundler
+     */
+    logLevel?: SandpackLogLevel;
+    /**
+     * Relative path that the iframe loads (eg: /about)
+     */
+    startRoute?: string;
+    /**
+     * Width of iframe.
+     */
+    width?: string;
+    /**
+     * Height of iframe.
+     */
+    height?: string;
+    /**
+     * If we should skip the third step: evaluation.
+     */
+    skipEval?: boolean;
+    /**
+     * Boolean flags to trigger certain UI elements in the bundler
+     */
+    showOpenInCodeSandbox?: boolean;
+    showErrorScreen?: boolean;
+    showLoadingScreen?: boolean;
+    /**
+     * The bundler will clear the console if you set this to true, everytime the iframe refreshes / starts the first compile
+     */
+    clearConsoleOnFirstCompile?: boolean;
+    reactDevTools?: ReactDevToolsMode;
+    /**
+     * The custom private npm registry setting makes it possible
+     * to retrieve npm packages from your own npm registry.
+     */
+    customNpmRegistries?: NpmRegistry[];
+    /**
+     * CodeSandbox sandbox id: used internally by codesandbox
+     */
+    sandboxId?: string;
+    /**
+     * CodeSandbox team id: with this information, bundler can connect to CodeSandbox
+     * and unlock a few capabilities
+     */
+    teamId?: string;
+    /**
+     * Enable the service worker feature for sandpack-bundler
+     */
+    experimental_enableServiceWorker?: boolean;
+    experimental_stableServiceWorkerId?: string;
+    /**
+     * Host-pinned SDK artifact integrity hashes (SDK_PACKAGING_SPEC §5.2).
+     * Forwarded verbatim into the register-frame handshake; the bundler verifies
+     * fetched SDK bytes against it before evaluation. Absent ⇒ verification
+     * skipped.
+     */
+    sdkIntegrity?: SdkIntegrity;
+    /**
+     * The dirty set (PRETRANSPILED_ARTIFACTS_SPEC §5.2): repo-relative paths in the
+     * COW writable layer (edited in a previous session) plus the journal's deleted
+     * set. Forwarded verbatim into the register-frame handshake so the bundler
+     * never seeds a pre-transpiled artifact for a path whose `/app` content no
+     * longer matches the zip. Absent ⇒ nothing dirty.
+     */
+    dirtyPaths?: string[];
+    /**
+     * R3-49b ZenFS batch hydration: a bulk snapshot of the mounted tree (`/app`
+     * source + bundled `/node_modules` package msgpack) forwarded verbatim into the
+     * register-frame handshake. The bundler hydrates its read caches before the first
+     * compile so reads come from memory instead of one Port round-trip per file
+     * (`loadNodeModules` — ~99% of cold boot). Absent ⇒ reads cross the Port as before.
+     */
+    fsSnapshot?: FsSnapshot;
+    /**
+     * The chrome region this app instance occupies, e.g. `"panel.agent"` or
+     * `"stage.conversation"` (R3-114). Forwarded verbatim into the register-frame
+     * handshake so the bundler can surface it on the `__immediatelyRun__` runtime
+     * global for the SDK's `getRegion()`/`useRegion()`. Descriptive only — it grants
+     * and gates nothing. Absent ⇒ the app reads no region (`getRegion()` → null).
+     */
+    region?: string;
+}
+/** A batch-hydration snapshot entry list: each entry is a sandbox `/app`-rooted path
+ *  + its content (text for source, bytes for the bundled package msgpack). R3-49b. */
+export type FsSnapshot = Array<{
+    path: string;
+    content: string | Uint8Array;
+}>;
+export interface SandboxSetup {
+    /**
+     * The Sandpack filesystem used as the source of truth for file contents and
+     * UI metadata. Create one via {@link SandpackFS.fromFiles} or
+     * {@link SandpackFS.fromFileSystem}.
+     */
+    fs: SandpackFS;
+    dependencies?: Dependencies;
+    devDependencies?: Dependencies;
+    entry?: string;
+    /**
+     * What template we use, if not defined we infer the template from the dependencies or files.
+     *
+     */
+    template?: SandpackTemplate;
+    /**
+     * Only use unpkg for fetching the dependencies, no preprocessing. It's slower, but doesn't talk
+     * to AWS.
+     */
+    disableDependencyPreprocessing?: boolean;
+}
+export interface Module {
+    code: string;
+    path: string;
+}
+export type Modules = Record<string, {
+    code: string;
+    path: string;
+}>;
+export type Dependencies = Record<string, string>;
+export type ReactDevToolsMode = "latest" | "legacy";
+export interface ModuleSource {
+    fileName: string;
+    compiledCode: string;
+    sourceMap: unknown | undefined;
+}
+export declare enum SandpackLogLevel {
+    None = 0,
+    Error = 10,
+    Warning = 20,
+    Info = 30,
+    Debug = 40
+}
+export interface ErrorStackFrame {
+    columnNumber: number;
+    fileName: string;
+    functionName: string;
+    lineNumber: number;
+    _originalColumnNumber: number;
+    _originalFileName: string;
+    _originalFunctionName: string;
+    _originalLineNumber: number;
+    _originalScriptCode: Array<{
+        lineNumber: number;
+        content: string;
+        highlight: boolean;
+    }>;
+}
+export interface TranspiledModule {
+    module: Module;
+    query: string;
+    source: ModuleSource | undefined;
+    assets: Record<string, ModuleSource>;
+    isEntry: boolean;
+    isTestFile: boolean;
+    childModules: string[];
+    /**
+     * All extra modules emitted by the loader
+     */
+    emittedAssets: ModuleSource[];
+    initiators: string[];
+    dependencies: string[];
+    asyncDependencies: string[];
+    transpilationDependencies: string[];
+    transpilationInitiators: string[];
+}
+export interface BundlerState {
+    entry: string;
+    transpiledModules: Record<string, TranspiledModule>;
+}
+export type SandpackMessage = SandpackRuntimeMessage | SandpackNodeMessage;
+export type ListenerFunction = (msg: SandpackMessage) => void;
+export type UnsubscribeFunction = () => void;
+export type Listen = (listener: ListenerFunction, clientId?: string) => UnsubscribeFunction;
+export type Dispatch = (msg: SandpackMessage, clientId?: string) => void;
+export interface SandpackError {
+    message: string;
+    line?: number;
+    column?: number;
+    path?: string;
+    title?: string;
+}
+export interface SandpackErrorMessage {
+    title: string;
+    path: string;
+    message: string;
+    line: number;
+    column: number;
+    payload: {
+        frames?: ErrorStackFrame[];
+    };
+}
+export type ClientStatus = "initializing" | "installing-dependencies" | "transpiling" | "evaluating" | "running-tests" | "idle" | "done";
+export type SandpackMessageConsoleMethods = "log" | "debug" | "info" | "warn" | "error" | "table" | "clear" | "time" | "timeEnd" | "count" | "assert";
+export interface BaseSandpackMessage {
+    type: string;
+    $id?: number;
+    codesandbox?: boolean;
+    /**
+     * Transferable objects (e.g. a `MessagePort`) to hand to the iframe alongside
+     * this message. Stripped from the payload and passed as the `postMessage`
+     * transfer list by `IFrameProtocol.dispatch`. Used by `mount-add` to share a
+     * mount's filesystem port with the sandbox.
+     */
+    _transfer?: Transferable[];
+}
+export interface BaseProtocolMessage {
+    type: string;
+    msgId: string;
+}
+export interface ProtocolErrorMessage extends BaseProtocolMessage {
+    error: {
+        message: string;
+    };
+}
+export interface ProtocolResultMessage extends BaseProtocolMessage {
+    result: any;
+}
+export interface ProtocolRequestMessage extends BaseProtocolMessage {
+    method: string;
+    params: any[];
+}
+export interface NpmRegistry {
+    enabledScopes: string[];
+    limitToScopes: boolean;
+    registryUrl: string;
+    /**
+     * It must be `false` if you're providing a sef-host solution,
+     * otherwise, it'll try to proxy from CodeSandbox Proxy
+     */
+    proxyEnabled: boolean;
+    registryAuthToken?: string;
+}
+type TestStatus = "running" | "pass" | "fail";
+export type TestError = Error & {
+    matcherResult?: boolean;
+    mappedErrors?: Array<{
+        fileName: string;
+        _originalFunctionName: string;
+        _originalColumnNumber: number;
+        _originalLineNumber: number;
+        _originalScriptCode: Array<{
+            lineNumber: number;
+            content: string;
+            highlight: boolean;
+        }> | null;
+    }>;
+};
+export interface Test {
+    name: string;
+    blocks: string[];
+    status: TestStatus;
+    path: string;
+    errors: TestError[];
+    duration?: number | undefined;
+}
+export type SandboxTestMessage = RunAllTests | RunTests | ClearJestErrors | ({
+    type: "test";
+} & (InitializedTestsMessage | TestCountMessage | TotalTestStartMessage | TotalTestEndMessage | AddFileMessage | RemoveFileMessage | FileErrorMessage | DescribeStartMessage | DescribeEndMessage | AddTestMessage | TestStartMessage | TestEndMessage));
+interface InitializedTestsMessage {
+    event: "initialize_tests";
+}
+interface ClearJestErrors {
+    type: "action";
+    action: "clear-errors";
+    source: "jest";
+    path: string;
+}
+interface TestCountMessage {
+    event: "test_count";
+    count: number;
+}
+interface TotalTestStartMessage {
+    event: "total_test_start";
+}
+interface TotalTestEndMessage {
+    event: "total_test_end";
+}
+interface AddFileMessage {
+    event: "add_file";
+    path: string;
+}
+interface RemoveFileMessage {
+    event: "remove_file";
+    path: string;
+}
+interface FileErrorMessage {
+    event: "file_error";
+    path: string;
+    error: TestError;
+}
+interface DescribeStartMessage {
+    event: "describe_start";
+    blockName: string;
+}
+interface DescribeEndMessage {
+    event: "describe_end";
+}
+interface AddTestMessage {
+    event: "add_test";
+    testName: string;
+    path: string;
+}
+interface TestStartMessage {
+    event: "test_start";
+    test: Test;
+}
+interface TestEndMessage {
+    event: "test_end";
+    test: Test;
+}
+interface RunAllTests {
+    type: "run-all-tests";
+}
+interface RunTests {
+    type: "run-tests";
+    path: string;
+}
+export type SandpackTemplate = "angular-cli" | "create-react-app" | "create-react-app-typescript" | "svelte" | "parcel" | "vue-cli" | "static" | "solid" | "nextjs" | "node";
+export {};

package/dist/utils-BiVyytui.js

@@ -0,0 +1,262 @@
+'use strict';
+
+var outvariant = require('outvariant');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* globalThis Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+exports.__assign = function() {
+    exports.__assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return exports.__assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(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());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var createError = function (message) {
+    return "[sandpack-client]: ".concat(message);
+};
+function nullthrows(value, err) {
+    if (err === void 0) { err = "Value is nullish"; }
+    outvariant.invariant(value != null, createError(err));
+    return value;
+}
+var DEPENDENCY_ERROR_MESSAGE = "\"dependencies\" was not specified - provide either a package.json or a \"dependencies\" value";
+var ENTRY_ERROR_MESSAGE = "\"entry\" was not specified - provide either a package.json with the \"main\" field or an \"entry\" value";
+function createPackageJSON(dependencies, devDependencies, entry) {
+    if (dependencies === void 0) { dependencies = {}; }
+    if (devDependencies === void 0) { devDependencies = {}; }
+    if (entry === void 0) { entry = "/index.js"; }
+    return JSON.stringify({
+        name: "sandpack-project",
+        main: entry,
+        dependencies: dependencies,
+        devDependencies: devDependencies,
+    }, null, 2);
+}
+/**
+ * Ensures a `/package.json` exists inside a plain {@link SandpackFilesInput}
+ * map (pre-filesystem), merging any supplied dependency / entry overrides.
+ * Useful in pure planners like `getSandpackStateFromProps` so callers can decide
+ * what to seed the filesystem with before any I/O happens.
+ *
+ * (The former filesystem-mutating variant `addPackageJSONIfNeeded(fs, …)` was
+ * removed with BOOT_SCAFFOLDING_SPEC §3: the resolved package.json is delivered
+ * to the bundler out-of-band, so no synthesized copy is written into the CoW.)
+ */
+function addPackageJSONIfNeededToMap(files, dependencies, devDependencies, entry) {
+    var _a, _b;
+    var next = exports.__assign({}, files);
+    if (!next["/package.json"]) {
+        nullthrows(dependencies, DEPENDENCY_ERROR_MESSAGE);
+        nullthrows(entry, ENTRY_ERROR_MESSAGE);
+        next["/package.json"] = {
+            code: createPackageJSON(dependencies, devDependencies, entry),
+        };
+        return next;
+    }
+    var pkg = JSON.parse(next["/package.json"].code);
+    if (!dependencies && !pkg.dependencies) {
+        throw new Error(createError(ENTRY_ERROR_MESSAGE));
+    }
+    if (dependencies) {
+        pkg.dependencies = exports.__assign(exports.__assign({}, ((_a = pkg.dependencies) !== null && _a !== void 0 ? _a : {})), dependencies);
+    }
+    if (devDependencies) {
+        pkg.devDependencies = exports.__assign(exports.__assign({}, ((_b = pkg.devDependencies) !== null && _b !== void 0 ? _b : {})), devDependencies);
+    }
+    if (entry) {
+        pkg.main = entry;
+    }
+    next["/package.json"] = { code: JSON.stringify(pkg, null, 2) };
+    return next;
+}
+function extractErrorDetails(msg) {
+    var _a;
+    if (msg.title === "SyntaxError") {
+        var title = msg.title, path = msg.path, message = msg.message, line = msg.line, column = msg.column;
+        return { title: title, path: path, message: message, line: line, column: column };
+    }
+    var relevantStackFrame = getRelevantStackFrame((_a = msg.payload) === null || _a === void 0 ? void 0 : _a.frames);
+    if (!relevantStackFrame) {
+        return { message: msg.message };
+    }
+    var errorInCode = getErrorInOriginalCode(relevantStackFrame);
+    var errorLocation = getErrorLocation(relevantStackFrame);
+    var errorMessage = formatErrorMessage(relevantStackFrame._originalFileName, msg.message, errorLocation, errorInCode);
+    return {
+        message: errorMessage,
+        title: msg.title,
+        path: relevantStackFrame._originalFileName,
+        line: relevantStackFrame._originalLineNumber,
+        column: relevantStackFrame._originalColumnNumber,
+    };
+}
+function getRelevantStackFrame(frames) {
+    if (!frames) {
+        return;
+    }
+    return frames.find(function (frame) { return !!frame._originalFileName; });
+}
+function getErrorLocation(errorFrame) {
+    return errorFrame
+        ? " (".concat(errorFrame._originalLineNumber, ":").concat(errorFrame._originalColumnNumber, ")")
+        : "";
+}
+function getErrorInOriginalCode(errorFrame) {
+    var lastScriptLine = errorFrame._originalScriptCode[errorFrame._originalScriptCode.length - 1];
+    var numberOfLineNumberCharacters = lastScriptLine.lineNumber.toString().length;
+    var leadingCharacterOffset = 2;
+    var barSeparatorCharacterOffset = 3;
+    var extraLineLeadingSpaces = leadingCharacterOffset +
+        numberOfLineNumberCharacters +
+        barSeparatorCharacterOffset +
+        errorFrame._originalColumnNumber;
+    return errorFrame._originalScriptCode.reduce(function (result, scriptLine) {
+        var leadingChar = scriptLine.highlight ? ">" : " ";
+        var lineNumber = scriptLine.lineNumber.toString().length === numberOfLineNumberCharacters
+            ? "".concat(scriptLine.lineNumber)
+            : " ".concat(scriptLine.lineNumber);
+        var extraLine = scriptLine.highlight
+            ? "\n" + " ".repeat(extraLineLeadingSpaces) + "^"
+            : "";
+        return (result + // accumulator
+            "\n" +
+            leadingChar + // > or " "
+            " " +
+            lineNumber + // line number on equal number of characters
+            " | " +
+            scriptLine.content + // code
+            extraLine // line under the highlighed line to show the column index
+        );
+    }, "");
+}
+function formatErrorMessage(filePath, message, location, errorInCode) {
+    return "".concat(filePath, ": ").concat(message).concat(location, "\n").concat(errorInCode);
+}
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var normalizePath = function (path) {
+    if (typeof path === "string") {
+        return (path.startsWith("/") ? path : "/".concat(path));
+    }
+    if (Array.isArray(path)) {
+        return path.map(function (p) { return (p.startsWith("/") ? p : "/".concat(p)); });
+    }
+    if (typeof path === "object" && path !== null) {
+        return Object.entries(path).reduce(function (acc, _a) {
+            var key = _a[0], content = _a[1];
+            var fileName = key.startsWith("/") ? key : "/".concat(key);
+            acc[fileName] = content;
+            return acc;
+        }, {});
+    }
+    return null;
+};
+
+exports.__awaiter = __awaiter;
+exports.__extends = __extends;
+exports.__generator = __generator;
+exports.__rest = __rest;
+exports.__spreadArray = __spreadArray;
+exports.addPackageJSONIfNeededToMap = addPackageJSONIfNeededToMap;
+exports.createError = createError;
+exports.createPackageJSON = createPackageJSON;
+exports.extractErrorDetails = extractErrorDetails;
+exports.normalizePath = normalizePath;
+exports.nullthrows = nullthrows;