@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/@vitest/spy/index.js

@@ -0,0 +1,433 @@
+function isMockFunction(fn) {
+  return typeof fn === "function" && "_isMockFunction" in fn && fn._isMockFunction === true;
+}
+const MOCK_RESTORE = new Set();
+// Jest keeps the state in a separate WeakMap which is good for memory,
+// but it makes the state slower to access and return different values
+// if you stored it before calling `mockClear` where it will be recreated
+const REGISTERED_MOCKS = new Set();
+const MOCK_CONFIGS = new WeakMap();
+function createMockInstance(options = {}) {
+  var _ref;
+  const { originalImplementation, restore, mockImplementation, resetToMockImplementation, resetToMockName } = options;
+  if (restore) {
+    MOCK_RESTORE.add(restore);
+  }
+  const config = getDefaultConfig(originalImplementation);
+  const state = getDefaultState();
+  const mock = createMock({
+    config,
+    state,
+    ...options
+  });
+  const mockLength = ((_ref = mockImplementation || originalImplementation) === null || _ref === void 0 ? void 0 : _ref.length) ?? 0;
+  Object.defineProperty(mock, "length", {
+    writable: true,
+    enumerable: false,
+    value: mockLength,
+    configurable: true
+  });
+  // inherit the default name so it appears in snapshots and logs
+  // this is used by `vi.spyOn()` for better debugging.
+  // when `vi.fn()` is called, we just use the default string
+  if (resetToMockName) {
+    config.mockName = mock.name || "vi.fn()";
+  }
+  MOCK_CONFIGS.set(mock, config);
+  REGISTERED_MOCKS.add(mock);
+  mock._isMockFunction = true;
+  mock.getMockImplementation = () => {
+    // Jest only returns `config.mockImplementation` here,
+    // but we think it makes sense to return what the next function will be called
+    return config.onceMockImplementations[0] || config.mockImplementation;
+  };
+  Object.defineProperty(mock, "mock", {
+    configurable: false,
+    enumerable: true,
+    writable: false,
+    value: state
+  });
+  mock.mockImplementation = function mockImplementation(implementation) {
+    config.mockImplementation = implementation;
+    return mock;
+  };
+  mock.mockImplementationOnce = function mockImplementationOnce(implementation) {
+    config.onceMockImplementations.push(implementation);
+    return mock;
+  };
+  mock.withImplementation = function withImplementation(implementation, callback) {
+    const previousImplementation = config.mockImplementation;
+    const previousOnceImplementations = config.onceMockImplementations;
+    const reset = () => {
+      config.mockImplementation = previousImplementation;
+      config.onceMockImplementations = previousOnceImplementations;
+    };
+    config.mockImplementation = implementation;
+    config.onceMockImplementations = [];
+    const returnValue = callback();
+    if (typeof returnValue === "object" && typeof (returnValue === null || returnValue === void 0 ? void 0 : returnValue.then) === "function") {
+      return returnValue.then(() => {
+        reset();
+        return mock;
+      });
+    } else {
+      reset();
+    }
+    return mock;
+  };
+  mock.mockReturnThis = function mockReturnThis() {
+    return mock.mockImplementation(function() {
+      return this;
+    });
+  };
+  mock.mockReturnValue = function mockReturnValue(value) {
+    return mock.mockImplementation(() => value);
+  };
+  mock.mockReturnValueOnce = function mockReturnValueOnce(value) {
+    return mock.mockImplementationOnce(() => value);
+  };
+  mock.mockResolvedValue = function mockResolvedValue(value) {
+    return mock.mockImplementation(() => Promise.resolve(value));
+  };
+  mock.mockResolvedValueOnce = function mockResolvedValueOnce(value) {
+    return mock.mockImplementationOnce(() => Promise.resolve(value));
+  };
+  mock.mockRejectedValue = function mockRejectedValue(value) {
+    return mock.mockImplementation(() => Promise.reject(value));
+  };
+  mock.mockRejectedValueOnce = function mockRejectedValueOnce(value) {
+    return mock.mockImplementationOnce(() => Promise.reject(value));
+  };
+  mock.mockClear = function mockClear() {
+    state.calls = [];
+    state.contexts = [];
+    state.instances = [];
+    state.invocationCallOrder = [];
+    state.results = [];
+    state.settledResults = [];
+    return mock;
+  };
+  mock.mockReset = function mockReset() {
+    mock.mockClear();
+    config.mockImplementation = resetToMockImplementation ? mockImplementation : undefined;
+    config.mockName = resetToMockName ? mock.name || "vi.fn()" : "vi.fn()";
+    config.onceMockImplementations = [];
+    return mock;
+  };
+  mock.mockRestore = function mockRestore() {
+    mock.mockReset();
+    return restore === null || restore === void 0 ? void 0 : restore();
+  };
+  mock.mockName = function mockName(name) {
+    if (typeof name === "string") {
+      config.mockName = name;
+    }
+    return mock;
+  };
+  mock.getMockName = function getMockName() {
+    return config.mockName || "vi.fn()";
+  };
+  if (Symbol.dispose) {
+    mock[Symbol.dispose] = () => mock.mockRestore();
+  }
+  if (mockImplementation) {
+    mock.mockImplementation(mockImplementation);
+  }
+  return mock;
+}
+function fn(originalImplementation) {
+  // if the function is already a mock, just return the same function,
+  // simillarly to how vi.spyOn() works
+  if (originalImplementation != null && isMockFunction(originalImplementation)) {
+    return originalImplementation;
+  }
+  return createMockInstance({
+    mockImplementation: originalImplementation,
+    resetToMockImplementation: true
+  });
+}
+function spyOn(object, key, accessor) {
+  assert(object != null, "The vi.spyOn() function could not find an object to spy upon. The first argument must be defined.");
+  assert(typeof object === "object" || typeof object === "function", "Vitest cannot spy on a primitive value.");
+  const [originalDescriptorObject, originalDescriptor] = getDescriptor(object, key) || [];
+  assert(originalDescriptor || key in object, `The property "${String(key)}" is not defined on the ${typeof object}.`);
+  let accessType = accessor || "value";
+  let ssr = false;
+  // vite ssr support - actual function is stored inside a getter
+  if (accessType === "value" && originalDescriptor && originalDescriptor.value == null && originalDescriptor.get) {
+    accessType = "get";
+    ssr = true;
+  }
+  let original;
+  if (originalDescriptor) {
+    original = originalDescriptor[accessType];
+  } else if (accessType !== "value") {
+    original = () => object[key];
+  } else {
+    original = object[key];
+  }
+  const originalImplementation = ssr && original ? original() : original;
+  const originalType = typeof originalImplementation;
+  assert(
+    // allow only functions
+    originalType === "function" || accessType !== "value" && original == null,
+    `vi.spyOn() can only spy on a function. Received ${originalType}.`
+  );
+  if (isMockFunction(originalImplementation)) {
+    return originalImplementation;
+  }
+  const reassign = (cb) => {
+    const { value, ...desc } = originalDescriptor || {
+      configurable: true,
+      writable: true
+    };
+    if (accessType !== "value") {
+      delete desc.writable;
+    }
+    desc[accessType] = cb;
+    Object.defineProperty(object, key, desc);
+  };
+  const restore = () => {
+    // if method is defined on the prototype, we can just remove it from
+    // the current object instead of redefining a copy of it
+    if (originalDescriptorObject !== object) {
+      Reflect.deleteProperty(object, key);
+    } else if (originalDescriptor && !original) {
+      Object.defineProperty(object, key, originalDescriptor);
+    } else {
+      reassign(original);
+    }
+  };
+  const mock = createMockInstance({
+    restore,
+    originalImplementation,
+    resetToMockName: true
+  });
+  try {
+    reassign(ssr ? () => mock : mock);
+  } catch (error) {
+    if (error instanceof TypeError && Symbol.toStringTag && object[Symbol.toStringTag] === "Module" && (error.message.includes("Cannot redefine property") || error.message.includes("Cannot replace module namespace") || error.message.includes("can't redefine non-configurable property"))) {
+      throw new TypeError(`Cannot spy on export "${String(key)}". Module namespace is not configurable in ESM. See: https://vitest.dev/guide/browser/#limitations`, { cause: error });
+    }
+    throw error;
+  }
+  return mock;
+}
+function getDescriptor(obj, method) {
+  const objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
+  if (objDescriptor) {
+    return [obj, objDescriptor];
+  }
+  let currentProto = Object.getPrototypeOf(obj);
+  while (currentProto !== null) {
+    const descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
+    if (descriptor) {
+      return [currentProto, descriptor];
+    }
+    currentProto = Object.getPrototypeOf(currentProto);
+  }
+}
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+let invocationCallCounter = 1;
+function createMock({ state, config, name: mockName, prototypeState, prototypeConfig, keepMembersImplementation, mockImplementation, prototypeMembers = [] }) {
+  const original = config.mockOriginal;
+  const pseudoOriginal = mockImplementation;
+  const name = mockName || (original === null || original === void 0 ? void 0 : original.name) || "Mock";
+  const namedObject = { [name]: (function(...args) {
+    registerCalls(args, state, prototypeState);
+    registerInvocationOrder(invocationCallCounter++, state, prototypeState);
+    const result = {
+      type: "incomplete",
+      value: undefined
+    };
+    const settledResult = {
+      type: "incomplete",
+      value: undefined
+    };
+    registerResult(result, state, prototypeState);
+    registerSettledResult(settledResult, state, prototypeState);
+    const context = new.target ? undefined : this;
+    const [instanceIndex, instancePrototypeIndex] = registerInstance(context, state, prototypeState);
+    const [contextIndex, contextPrototypeIndex] = registerContext(context, state, prototypeState);
+    const implementation = config.onceMockImplementations.shift() || config.mockImplementation || (prototypeConfig === null || prototypeConfig === void 0 ? void 0 : prototypeConfig.onceMockImplementations.shift()) || (prototypeConfig === null || prototypeConfig === void 0 ? void 0 : prototypeConfig.mockImplementation) || original || function() {};
+    let returnValue;
+    let thrownValue;
+    let didThrow = false;
+    try {
+      if (new.target) {
+        returnValue = Reflect.construct(implementation, args, new.target);
+        // jest calls this before the implementation, but we have to resolve this _after_
+        // because we cannot do it before the `Reflect.construct` called the custom implementation.
+        // fortunetly, the constructor is always an empty functon because `prototypeMethods`
+        // are only used by the automocker, so this doesn't matter
+        for (const prop of prototypeMembers) {
+          const prototypeMock = returnValue[prop];
+          // the method was overidden because of inheritence, ignore it
+          // eslint-disable-next-line ts/no-use-before-define
+          if (prototypeMock !== mock.prototype[prop]) {
+            continue;
+          }
+          const isMock = isMockFunction(prototypeMock);
+          const prototypeState = isMock ? prototypeMock.mock : undefined;
+          const prototypeConfig = isMock ? MOCK_CONFIGS.get(prototypeMock) : undefined;
+          returnValue[prop] = createMockInstance({
+            originalImplementation: keepMembersImplementation ? prototypeConfig === null || prototypeConfig === void 0 ? void 0 : prototypeConfig.mockOriginal : undefined,
+            prototypeState,
+            prototypeConfig,
+            keepMembersImplementation
+          });
+        }
+      } else {
+        returnValue = implementation.apply(this, args);
+      }
+    } catch (error) {
+      thrownValue = error;
+      didThrow = true;
+      if (error instanceof TypeError && error.message.includes("is not a constructor")) {
+        console.warn(`[vitest] The ${namedObject[name].getMockName()} mock did not use 'function' or 'class' in its implementation, see https://vitest.dev/api/vi#vi-spyon for examples.`);
+      }
+      throw error;
+    } finally {
+      if (didThrow) {
+        result.type = "throw";
+        result.value = thrownValue;
+        settledResult.type = "rejected";
+        settledResult.value = thrownValue;
+      } else {
+        result.type = "return";
+        result.value = returnValue;
+        if (new.target) {
+          state.contexts[contextIndex - 1] = returnValue;
+          state.instances[instanceIndex - 1] = returnValue;
+          if (contextPrototypeIndex != null && prototypeState) {
+            prototypeState.contexts[contextPrototypeIndex - 1] = returnValue;
+          }
+          if (instancePrototypeIndex != null && prototypeState) {
+            prototypeState.instances[instancePrototypeIndex - 1] = returnValue;
+          }
+        }
+        if (returnValue instanceof Promise) {
+          returnValue.then((settledValue) => {
+            settledResult.type = "fulfilled";
+            settledResult.value = settledValue;
+          }, (rejectedValue) => {
+            settledResult.type = "rejected";
+            settledResult.value = rejectedValue;
+          });
+        } else {
+          settledResult.type = "fulfilled";
+          settledResult.value = returnValue;
+        }
+      }
+    }
+    return returnValue;
+  }) };
+  const mock = namedObject[name];
+  const copyPropertiesFrom = original || pseudoOriginal;
+  if (copyPropertiesFrom) {
+    copyOriginalStaticProperties(mock, copyPropertiesFrom);
+  }
+  return mock;
+}
+function registerCalls(args, state, prototypeState) {
+  state.calls.push(args);
+  prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.calls.push(args);
+}
+function registerInvocationOrder(order, state, prototypeState) {
+  state.invocationCallOrder.push(order);
+  prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.invocationCallOrder.push(order);
+}
+function registerResult(result, state, prototypeState) {
+  state.results.push(result);
+  prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.results.push(result);
+}
+function registerSettledResult(result, state, prototypeState) {
+  state.settledResults.push(result);
+  prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.settledResults.push(result);
+}
+function registerInstance(instance, state, prototypeState) {
+  const instanceIndex = state.instances.push(instance);
+  const instancePrototypeIndex = prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.instances.push(instance);
+  return [instanceIndex, instancePrototypeIndex];
+}
+function registerContext(context, state, prototypeState) {
+  const contextIndex = state.contexts.push(context);
+  const contextPrototypeIndex = prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.contexts.push(context);
+  return [contextIndex, contextPrototypeIndex];
+}
+function copyOriginalStaticProperties(mock, original) {
+  const { properties, descriptors } = getAllProperties(original);
+  for (const key of properties) {
+    const descriptor = descriptors[key];
+    const mockDescriptor = getDescriptor(mock, key);
+    if (mockDescriptor) {
+      continue;
+    }
+    Object.defineProperty(mock, key, descriptor);
+  }
+}
+const ignoreProperties = new Set([
+  "length",
+  "name",
+  "prototype",
+  Symbol.for("nodejs.util.promisify.custom")
+]);
+function getAllProperties(original) {
+  const properties = new Set();
+  const descriptors = {};
+  while (original && original !== Object.prototype && original !== Function.prototype) {
+    const ownProperties = [...Object.getOwnPropertyNames(original), ...Object.getOwnPropertySymbols(original)];
+    for (const prop of ownProperties) {
+      if (descriptors[prop] || ignoreProperties.has(prop)) {
+        continue;
+      }
+      properties.add(prop);
+      descriptors[prop] = Object.getOwnPropertyDescriptor(original, prop);
+    }
+    original = Object.getPrototypeOf(original);
+  }
+  return {
+    properties,
+    descriptors
+  };
+}
+function getDefaultConfig(original) {
+  return {
+    mockImplementation: undefined,
+    mockOriginal: original,
+    mockName: "vi.fn()",
+    onceMockImplementations: []
+  };
+}
+function getDefaultState() {
+  const state = {
+    calls: [],
+    contexts: [],
+    instances: [],
+    invocationCallOrder: [],
+    settledResults: [],
+    results: [],
+    get lastCall() {
+      return state.calls.at(-1);
+    }
+  };
+  return state;
+}
+function restoreAllMocks() {
+  for (const restore of MOCK_RESTORE) {
+    restore();
+  }
+  MOCK_RESTORE.clear();
+}
+function clearAllMocks() {
+  REGISTERED_MOCKS.forEach((mock) => mock.mockClear());
+}
+function resetAllMocks() {
+  REGISTERED_MOCKS.forEach((mock) => mock.mockReset());
+}
+
+export { clearAllMocks, createMockInstance, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn };

package/dist/@vitest/utils/chunk-_commonjsHelpers.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+export { getDefaultExportFromCjs as g };

package/dist/@vitest/utils/chunk-pathe.M-eThtNZ.js

@@ -0,0 +1,156 @@
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path[path.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
+      } else {
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path += seg;
+    }
+  }
+  return normalize(path);
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+
+export { dirname as d, join as j, resolve as r };

package/dist/@vitest/utils/constants.d.ts

@@ -0,0 +1,21 @@
+declare const KNOWN_ASSET_TYPES: string[];
+declare const KNOWN_ASSET_RE: RegExp;
+declare const CSS_LANGS_RE: RegExp;
+/**
+* Prefix for resolved Ids that are not valid browser import specifiers
+*/
+declare const VALID_ID_PREFIX = "/@id/";
+/**
+* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+* module ID with `\0`, a convention from the rollup ecosystem.
+* This prevents other plugins from trying to process the id (like node resolution),
+* and core features like sourcemaps can use this info to differentiate between
+* virtual modules and regular files.
+* `\0` is not a permitted char in import URLs so we have to replace them during
+* import analysis. The id will be decoded back before entering the plugins pipeline.
+* These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+* modules in the browser end up encoded as `/@id/__x00__{id}`
+*/
+declare const NULL_BYTE_PLACEHOLDER = "__x00__";
+
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES, NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX };

package/dist/@vitest/utils/constants.js

@@ -0,0 +1,49 @@
+// TODO: this is all copy pasted from Vite - can they expose a module that exports only constants?
+const KNOWN_ASSET_TYPES = [
+  "apng",
+  "bmp",
+  "png",
+  "jpe?g",
+  "jfif",
+  "pjpeg",
+  "pjp",
+  "gif",
+  "svg",
+  "ico",
+  "webp",
+  "avif",
+  "mp4",
+  "webm",
+  "ogg",
+  "mp3",
+  "wav",
+  "flac",
+  "aac",
+  "woff2?",
+  "eot",
+  "ttf",
+  "otf",
+  "webmanifest",
+  "pdf",
+  "txt"
+];
+const KNOWN_ASSET_RE = new RegExp(`\\.(${KNOWN_ASSET_TYPES.join("|")})$`);
+const CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+/**
+* Prefix for resolved Ids that are not valid browser import specifiers
+*/
+const VALID_ID_PREFIX = `/@id/`;
+/**
+* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+* module ID with `\0`, a convention from the rollup ecosystem.
+* This prevents other plugins from trying to process the id (like node resolution),
+* and core features like sourcemaps can use this info to differentiate between
+* virtual modules and regular files.
+* `\0` is not a permitted char in import URLs so we have to replace them during
+* import analysis. The id will be decoded back before entering the plugins pipeline.
+* These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+* modules in the browser end up encoded as `/@id/__x00__{id}`
+*/
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES, NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX };