bun-workspaces 1.0.1-alpha → 1.0.2

package/src/internal/core/language/string/utf/eastAsianWidth.mjs

@@ -0,0 +1,326 @@
+// CONCATENATED MODULE: ./src/internal/core/language/string/utf/eastAsianWidth.ts
+/** A port of the package eastasianwidth */ const eaw = {
+  /**
+   * F: Full width
+   * H: Half width
+   * W: Wide
+   * Na: Narrow
+   * A: Ambiguous
+   * N: Neutral
+   */ eastAsianWidth: (character) => {
+    let x = character.charCodeAt(0);
+    let y = character.length === 2 ? character.charCodeAt(1) : 0;
+    let codePoint = x;
+    if (0xd800 <= x && x <= 0xdbff && 0xdc00 <= y && y <= 0xdfff) {
+      x &= 0x3ff;
+      y &= 0x3ff;
+      codePoint = (x << 10) | y;
+      codePoint += 0x10000;
+    }
+    if (
+      0x3000 === codePoint ||
+      (0xff01 <= codePoint && codePoint <= 0xff60) ||
+      (0xffe0 <= codePoint && codePoint <= 0xffe6)
+    ) {
+      return "F";
+    }
+    if (
+      0x20a9 === codePoint ||
+      (0xff61 <= codePoint && codePoint <= 0xffbe) ||
+      (0xffc2 <= codePoint && codePoint <= 0xffc7) ||
+      (0xffca <= codePoint && codePoint <= 0xffcf) ||
+      (0xffd2 <= codePoint && codePoint <= 0xffd7) ||
+      (0xffda <= codePoint && codePoint <= 0xffdc) ||
+      (0xffe8 <= codePoint && codePoint <= 0xffee)
+    ) {
+      return "H";
+    }
+    if (
+      (0x1100 <= codePoint && codePoint <= 0x115f) ||
+      (0x11a3 <= codePoint && codePoint <= 0x11a7) ||
+      (0x11fa <= codePoint && codePoint <= 0x11ff) ||
+      (0x2329 <= codePoint && codePoint <= 0x232a) ||
+      (0x2e80 <= codePoint && codePoint <= 0x2e99) ||
+      (0x2e9b <= codePoint && codePoint <= 0x2ef3) ||
+      (0x2f00 <= codePoint && codePoint <= 0x2fd5) ||
+      (0x2ff0 <= codePoint && codePoint <= 0x2ffb) ||
+      (0x3001 <= codePoint && codePoint <= 0x303e) ||
+      (0x3041 <= codePoint && codePoint <= 0x3096) ||
+      (0x3099 <= codePoint && codePoint <= 0x30ff) ||
+      (0x3105 <= codePoint && codePoint <= 0x312d) ||
+      (0x3131 <= codePoint && codePoint <= 0x318e) ||
+      (0x3190 <= codePoint && codePoint <= 0x31ba) ||
+      (0x31c0 <= codePoint && codePoint <= 0x31e3) ||
+      (0x31f0 <= codePoint && codePoint <= 0x321e) ||
+      (0x3220 <= codePoint && codePoint <= 0x3247) ||
+      (0x3250 <= codePoint && codePoint <= 0x32fe) ||
+      (0x3300 <= codePoint && codePoint <= 0x4dbf) ||
+      (0x4e00 <= codePoint && codePoint <= 0xa48c) ||
+      (0xa490 <= codePoint && codePoint <= 0xa4c6) ||
+      (0xa960 <= codePoint && codePoint <= 0xa97c) ||
+      (0xac00 <= codePoint && codePoint <= 0xd7a3) ||
+      (0xd7b0 <= codePoint && codePoint <= 0xd7c6) ||
+      (0xd7cb <= codePoint && codePoint <= 0xd7fb) ||
+      (0xf900 <= codePoint && codePoint <= 0xfaff) ||
+      (0xfe10 <= codePoint && codePoint <= 0xfe19) ||
+      (0xfe30 <= codePoint && codePoint <= 0xfe52) ||
+      (0xfe54 <= codePoint && codePoint <= 0xfe66) ||
+      (0xfe68 <= codePoint && codePoint <= 0xfe6b) ||
+      (0x1b000 <= codePoint && codePoint <= 0x1b001) ||
+      (0x1f200 <= codePoint && codePoint <= 0x1f202) ||
+      (0x1f210 <= codePoint && codePoint <= 0x1f23a) ||
+      (0x1f240 <= codePoint && codePoint <= 0x1f248) ||
+      (0x1f250 <= codePoint && codePoint <= 0x1f251) ||
+      (0x20000 <= codePoint && codePoint <= 0x2f73f) ||
+      (0x2b740 <= codePoint && codePoint <= 0x2fffd) ||
+      (0x30000 <= codePoint && codePoint <= 0x3fffd)
+    ) {
+      return "W";
+    }
+    if (
+      (0x0020 <= codePoint && codePoint <= 0x007e) ||
+      (0x00a2 <= codePoint && codePoint <= 0x00a3) ||
+      (0x00a5 <= codePoint && codePoint <= 0x00a6) ||
+      0x00ac === codePoint ||
+      0x00af === codePoint ||
+      (0x27e6 <= codePoint && codePoint <= 0x27ed) ||
+      (0x2985 <= codePoint && codePoint <= 0x2986)
+    ) {
+      return "Na";
+    }
+    if (
+      0x00a1 === codePoint ||
+      0x00a4 === codePoint ||
+      (0x00a7 <= codePoint && codePoint <= 0x00a8) ||
+      0x00aa === codePoint ||
+      (0x00ad <= codePoint && codePoint <= 0x00ae) ||
+      (0x00b0 <= codePoint && codePoint <= 0x00b4) ||
+      (0x00b6 <= codePoint && codePoint <= 0x00ba) ||
+      (0x00bc <= codePoint && codePoint <= 0x00bf) ||
+      0x00c6 === codePoint ||
+      0x00d0 === codePoint ||
+      (0x00d7 <= codePoint && codePoint <= 0x00d8) ||
+      (0x00de <= codePoint && codePoint <= 0x00e1) ||
+      0x00e6 === codePoint ||
+      (0x00e8 <= codePoint && codePoint <= 0x00ea) ||
+      (0x00ec <= codePoint && codePoint <= 0x00ed) ||
+      0x00f0 === codePoint ||
+      (0x00f2 <= codePoint && codePoint <= 0x00f3) ||
+      (0x00f7 <= codePoint && codePoint <= 0x00fa) ||
+      0x00fc === codePoint ||
+      0x00fe === codePoint ||
+      0x0101 === codePoint ||
+      0x0111 === codePoint ||
+      0x0113 === codePoint ||
+      0x011b === codePoint ||
+      (0x0126 <= codePoint && codePoint <= 0x0127) ||
+      0x012b === codePoint ||
+      (0x0131 <= codePoint && codePoint <= 0x0133) ||
+      0x0138 === codePoint ||
+      (0x013f <= codePoint && codePoint <= 0x0142) ||
+      0x0144 === codePoint ||
+      (0x0148 <= codePoint && codePoint <= 0x014b) ||
+      0x014d === codePoint ||
+      (0x0152 <= codePoint && codePoint <= 0x0153) ||
+      (0x0166 <= codePoint && codePoint <= 0x0167) ||
+      0x016b === codePoint ||
+      0x01ce === codePoint ||
+      0x01d0 === codePoint ||
+      0x01d2 === codePoint ||
+      0x01d4 === codePoint ||
+      0x01d6 === codePoint ||
+      0x01d8 === codePoint ||
+      0x01da === codePoint ||
+      0x01dc === codePoint ||
+      0x0251 === codePoint ||
+      0x0261 === codePoint ||
+      0x02c4 === codePoint ||
+      0x02c7 === codePoint ||
+      (0x02c9 <= codePoint && codePoint <= 0x02cb) ||
+      0x02cd === codePoint ||
+      0x02d0 === codePoint ||
+      (0x02d8 <= codePoint && codePoint <= 0x02db) ||
+      0x02dd === codePoint ||
+      0x02df === codePoint ||
+      (0x0300 <= codePoint && codePoint <= 0x036f) ||
+      (0x0391 <= codePoint && codePoint <= 0x03a1) ||
+      (0x03a3 <= codePoint && codePoint <= 0x03a9) ||
+      (0x03b1 <= codePoint && codePoint <= 0x03c1) ||
+      (0x03c3 <= codePoint && codePoint <= 0x03c9) ||
+      0x0401 === codePoint ||
+      (0x0410 <= codePoint && codePoint <= 0x044f) ||
+      0x0451 === codePoint ||
+      0x2010 === codePoint ||
+      (0x2013 <= codePoint && codePoint <= 0x2016) ||
+      (0x2018 <= codePoint && codePoint <= 0x2019) ||
+      (0x201c <= codePoint && codePoint <= 0x201d) ||
+      (0x2020 <= codePoint && codePoint <= 0x2022) ||
+      (0x2024 <= codePoint && codePoint <= 0x2027) ||
+      0x2030 === codePoint ||
+      (0x2032 <= codePoint && codePoint <= 0x2033) ||
+      0x2035 === codePoint ||
+      0x203b === codePoint ||
+      0x203e === codePoint ||
+      0x2074 === codePoint ||
+      0x207f === codePoint ||
+      (0x2081 <= codePoint && codePoint <= 0x2084) ||
+      0x20ac === codePoint ||
+      0x2103 === codePoint ||
+      0x2105 === codePoint ||
+      0x2109 === codePoint ||
+      0x2113 === codePoint ||
+      0x2116 === codePoint ||
+      (0x2121 <= codePoint && codePoint <= 0x2122) ||
+      0x2126 === codePoint ||
+      0x212b === codePoint ||
+      (0x2153 <= codePoint && codePoint <= 0x2154) ||
+      (0x215b <= codePoint && codePoint <= 0x215e) ||
+      (0x2160 <= codePoint && codePoint <= 0x216b) ||
+      (0x2170 <= codePoint && codePoint <= 0x2179) ||
+      0x2189 === codePoint ||
+      (0x2190 <= codePoint && codePoint <= 0x2199) ||
+      (0x21b8 <= codePoint && codePoint <= 0x21b9) ||
+      0x21d2 === codePoint ||
+      0x21d4 === codePoint ||
+      0x21e7 === codePoint ||
+      0x2200 === codePoint ||
+      (0x2202 <= codePoint && codePoint <= 0x2203) ||
+      (0x2207 <= codePoint && codePoint <= 0x2208) ||
+      0x220b === codePoint ||
+      0x220f === codePoint ||
+      0x2211 === codePoint ||
+      0x2215 === codePoint ||
+      0x221a === codePoint ||
+      (0x221d <= codePoint && codePoint <= 0x2220) ||
+      0x2223 === codePoint ||
+      0x2225 === codePoint ||
+      (0x2227 <= codePoint && codePoint <= 0x222c) ||
+      0x222e === codePoint ||
+      (0x2234 <= codePoint && codePoint <= 0x2237) ||
+      (0x223c <= codePoint && codePoint <= 0x223d) ||
+      0x2248 === codePoint ||
+      0x224c === codePoint ||
+      0x2252 === codePoint ||
+      (0x2260 <= codePoint && codePoint <= 0x2261) ||
+      (0x2264 <= codePoint && codePoint <= 0x2267) ||
+      (0x226a <= codePoint && codePoint <= 0x226b) ||
+      (0x226e <= codePoint && codePoint <= 0x226f) ||
+      (0x2282 <= codePoint && codePoint <= 0x2283) ||
+      (0x2286 <= codePoint && codePoint <= 0x2287) ||
+      0x2295 === codePoint ||
+      0x2299 === codePoint ||
+      0x22a5 === codePoint ||
+      0x22bf === codePoint ||
+      0x2312 === codePoint ||
+      (0x2460 <= codePoint && codePoint <= 0x24e9) ||
+      (0x24eb <= codePoint && codePoint <= 0x254b) ||
+      (0x2550 <= codePoint && codePoint <= 0x2573) ||
+      (0x2580 <= codePoint && codePoint <= 0x258f) ||
+      (0x2592 <= codePoint && codePoint <= 0x2595) ||
+      (0x25a0 <= codePoint && codePoint <= 0x25a1) ||
+      (0x25a3 <= codePoint && codePoint <= 0x25a9) ||
+      (0x25b2 <= codePoint && codePoint <= 0x25b3) ||
+      (0x25b6 <= codePoint && codePoint <= 0x25b7) ||
+      (0x25bc <= codePoint && codePoint <= 0x25bd) ||
+      (0x25c0 <= codePoint && codePoint <= 0x25c1) ||
+      (0x25c6 <= codePoint && codePoint <= 0x25c8) ||
+      0x25cb === codePoint ||
+      (0x25ce <= codePoint && codePoint <= 0x25d1) ||
+      (0x25e2 <= codePoint && codePoint <= 0x25e5) ||
+      0x25ef === codePoint ||
+      (0x2605 <= codePoint && codePoint <= 0x2606) ||
+      0x2609 === codePoint ||
+      (0x260e <= codePoint && codePoint <= 0x260f) ||
+      (0x2614 <= codePoint && codePoint <= 0x2615) ||
+      0x261c === codePoint ||
+      0x261e === codePoint ||
+      0x2640 === codePoint ||
+      0x2642 === codePoint ||
+      (0x2660 <= codePoint && codePoint <= 0x2661) ||
+      (0x2663 <= codePoint && codePoint <= 0x2665) ||
+      (0x2667 <= codePoint && codePoint <= 0x266a) ||
+      (0x266c <= codePoint && codePoint <= 0x266d) ||
+      0x266f === codePoint ||
+      (0x269e <= codePoint && codePoint <= 0x269f) ||
+      (0x26be <= codePoint && codePoint <= 0x26bf) ||
+      (0x26c4 <= codePoint && codePoint <= 0x26cd) ||
+      (0x26cf <= codePoint && codePoint <= 0x26e1) ||
+      0x26e3 === codePoint ||
+      (0x26e8 <= codePoint && codePoint <= 0x26ff) ||
+      0x273d === codePoint ||
+      0x2757 === codePoint ||
+      (0x2776 <= codePoint && codePoint <= 0x277f) ||
+      (0x2b55 <= codePoint && codePoint <= 0x2b59) ||
+      (0x3248 <= codePoint && codePoint <= 0x324f) ||
+      (0xe000 <= codePoint && codePoint <= 0xf8ff) ||
+      (0xfe00 <= codePoint && codePoint <= 0xfe0f) ||
+      0xfffd === codePoint ||
+      (0x1f100 <= codePoint && codePoint <= 0x1f10a) ||
+      (0x1f110 <= codePoint && codePoint <= 0x1f12d) ||
+      (0x1f130 <= codePoint && codePoint <= 0x1f169) ||
+      (0x1f170 <= codePoint && codePoint <= 0x1f19a) ||
+      (0xe0100 <= codePoint && codePoint <= 0xe01ef) ||
+      (0xf0000 <= codePoint && codePoint <= 0xffffd) ||
+      (0x100000 <= codePoint && codePoint <= 0x10fffd)
+    ) {
+      return "A";
+    }
+    // 🚨 Not in original eastasianwidth package: fallback to detect emojis not accounted for
+    if (/\p{Emoji_Presentation}/u.test(character)) {
+      return "W";
+    }
+    return "N";
+  },
+  characterLength: (character) => {
+    const code = eaw.eastAsianWidth(character);
+    if (code === "F" || code === "W") {
+      // 🚨 Changed from original eastasianwidth package to not treat A as 2,
+      // thanks to Western terminal locales generally rendering chars like this as width 1
+      // and developers generally using Western locales for ecosystems like Bun etc.
+      return 2;
+    } else {
+      return 1;
+    }
+  },
+  // Split a string considering surrogate-pairs.
+  stringToArray: (s) => {
+    return s.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^\uD800-\uDFFF]/g) || [];
+  },
+  length: (string) => {
+    const characters = eaw.stringToArray(string);
+    let len = 0;
+    for (let i = 0; i < characters.length; i++) {
+      len = len + eaw.characterLength(characters[i]);
+    }
+    return len;
+  },
+  slice: (text, start, end) => {
+    const textLen = eaw.length(text);
+    start = start === undefined || start === null ? 0 : start;
+    end = end === undefined || start === null ? 1 : end;
+    if (start < 0) {
+      start = textLen + start;
+    }
+    if (end < 0) {
+      end = textLen + end;
+    }
+    let result = "";
+    let eawLen = 0;
+    const chars = eaw.stringToArray(text);
+    for (let i = 0; i < chars.length; i++) {
+      const char = chars[i];
+      const charLen = eaw.length(char);
+      if (eawLen >= start - (charLen === 2 ? 1 : 0)) {
+        if (eawLen + charLen <= end) {
+          result += char;
+        } else {
+          break;
+        }
+      }
+      eawLen += charLen;
+    }
+    return result;
+  },
+};
+
+export { eaw };

package/src/internal/core/language/string/utf/visibleLength.d.ts

@@ -0,0 +1,5 @@
+export declare const calculateVisibleLength: (str: string) => number;
+export declare const truncateTerminalString: (
+  str: string,
+  maxVisible: number,
+) => string;

package/src/internal/core/language/string/utf/visibleLength.mjs

@@ -0,0 +1,29 @@
+import { eaw } from "./eastAsianWidth.mjs"; // CONCATENATED MODULE: external "./eastAsianWidth.mjs"
+// CONCATENATED MODULE: ./src/internal/core/language/string/utf/visibleLength.ts
+
+const getVisibleSliceIndex = (str, maxVisible) => {
+  let i = 0;
+  let visibleCount = 0;
+  while (i < str.length && visibleCount < maxVisible) {
+    if (str[i] === "\x1b" && str[i + 1] === "[") {
+      i += 2;
+      while (i < str.length && /[0-9;?]/.test(str[i])) i++;
+      if (i < str.length) i++;
+    } else {
+      const codePoint = str.codePointAt(i);
+      const char = String.fromCodePoint(codePoint);
+      const charWidth = eaw.characterLength(char);
+      if (visibleCount + charWidth > maxVisible) break;
+      visibleCount += charWidth;
+      i += char.length;
+    }
+  }
+  return i;
+};
+const calculateVisibleLength = (str) => {
+  return eaw.length(Bun.stripANSI(str));
+};
+const truncateTerminalString = (str, maxVisible) =>
+  str.slice(0, getVisibleSliceIndex(str, maxVisible));
+
+export { calculateVisibleLength, truncateTerminalString };

package/src/internal/core/language/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./typeof";
+export type * from "./types";

package/src/internal/core/language/types/index.mjs

@@ -0,0 +1 @@
+export * from "./typeof.mjs"; // CONCATENATED MODULE: ./src/internal/core/language/types/index.ts

package/src/internal/core/language/types/typeof.d.ts

@@ -0,0 +1,102 @@
+import { type OptionalArray } from "../array/optionalArray";
+import { type AnyFunction } from "./types";
+export declare const InvalidJSTypeError: typeof import("../..").BunWorkspacesError;
+export declare const InvalidJSNumberError: typeof import("../..").BunWorkspacesError;
+export declare const VALIDATE_NUMBER_ERRORS: import("../..").DefinedErrors<
+  "NoNaN" | "NoNonFinite" | "NoInfinity" | "NoNegInfinity"
+>;
+export declare const VALIDATE_TYPEOF_ERRORS: import("../..").DefinedErrors<
+  "NoNull" | "InvalidType"
+>;
+interface JSTypeofToTypeMap {
+  string: string;
+  number: number;
+  boolean: boolean;
+  undefined: undefined;
+  bigint: bigint;
+  function: (...args: unknown[]) => unknown;
+  object: null | object;
+  symbol: symbol;
+}
+export type JSDataTypeofName = keyof JSTypeofToTypeMap;
+export type TypeToJSTypeofName<T> = {
+  [K in keyof JSTypeofToTypeMap]: T extends AnyFunction
+    ? "function"
+    : T extends JSTypeofToTypeMap[K]
+      ? K
+      : never;
+}[keyof JSTypeofToTypeMap];
+export type JSTypeofNameToType<Name extends JSDataTypeofName> =
+  JSTypeofToTypeMap[Name];
+export type TypeToJSTypeof<T> = JSTypeofNameToType<TypeToJSTypeofName<T>>;
+export declare const isTypeof: <T, D extends JSDataTypeofName>(
+  value: T,
+  ...types: D[]
+) => value is Extract<T, JSTypeofNameToType<D>>;
+export declare const isPlainObject: (value: unknown) => value is object;
+export type ValidateNumberRules = {
+  noNaN?: boolean;
+  noNonFinite?: boolean;
+  noInfinity?: boolean;
+  noNegInfinity?: boolean;
+};
+export type ValidateJSTypeOptions = {
+  value: unknown;
+  typeofName: OptionalArray<JSDataTypeofName>;
+  /** For use in error message */
+  valueLabel?: string;
+  numberRules?: ValidateNumberRules;
+  optional?: boolean;
+};
+export type ValidateJSTypesTypeEntry = Omit<
+  ValidateJSTypeOptions,
+  "valueLabel"
+> & {
+  array?: false;
+};
+export type ValidateJSTypesArrayEntry = Omit<
+  ValidateJSArrayOptions,
+  "valueLabel"
+> & {
+  array: true;
+};
+export type ValidateJSTypesConfigEntry =
+  | ValidateJSTypesTypeEntry
+  | ValidateJSTypesArrayEntry;
+export type ValidateJSTypesConfig = {
+  [valueLabel: string]: ValidateJSTypesConfigEntry;
+};
+export declare const validateNumber: (
+  value: number,
+  rules: ValidateNumberRules,
+  valueLabel?: string,
+) => InstanceType<typeof InvalidJSNumberError> | null;
+export declare const validateJSType: ({
+  value,
+  typeofName,
+  numberRules,
+  valueLabel,
+  optional,
+}: ValidateJSTypeOptions) => InstanceType<typeof InvalidJSTypeError> | null;
+export type ValidateJSArrayOptions = {
+  value: unknown;
+  /** For use in error messages */
+  valueLabel?: string;
+  optional?: boolean;
+  /** Options to validate each item in the array */
+  itemOptions?: Omit<ValidateJSTypeOptions, "value" | "valueLabel">;
+};
+export declare const validateJSArray: ({
+  value,
+  valueLabel,
+  optional,
+  itemOptions,
+}: ValidateJSArrayOptions) => InstanceType<typeof InvalidJSTypeError> | null;
+export type ValidateJSTypesOptions = {
+  throw?: boolean;
+};
+export declare const validateJSTypes: (
+  config: ValidateJSTypesConfig,
+  options?: ValidateJSTypesOptions,
+) => InstanceType<typeof InvalidJSTypeError> | null;
+export {};

package/src/internal/core/language/types/typeof.mjs

@@ -0,0 +1,123 @@
+import { defineErrors } from "../../error/index.mjs";
+import { resolveOptionalArray } from "../array/optionalArray.mjs"; // CONCATENATED MODULE: external "../../error/index.mjs"
+// CONCATENATED MODULE: external "../array/optionalArray.mjs"
+// CONCATENATED MODULE: ./src/internal/core/language/types/typeof.ts
+
+const InvalidJSTypeError = defineErrors("InvalidJSType").InvalidJSType;
+const InvalidJSNumberError = defineErrors("InvalidJSNumber").InvalidJSNumber;
+const VALIDATE_NUMBER_ERRORS = defineErrors(
+  InvalidJSNumberError,
+  "NoNaN",
+  "NoNonFinite",
+  "NoInfinity",
+  "NoNegInfinity",
+);
+const VALIDATE_TYPEOF_ERRORS = defineErrors(
+  InvalidJSTypeError,
+  "NoNull",
+  "InvalidType",
+);
+const isTypeof = (value, ...types) => types.includes(typeof value);
+const isPlainObject = (value) =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+const validateNumber = (value, rules, valueLabel = "Number") => {
+  if (Number.isNaN(value) && rules?.noNaN) {
+    return new InvalidJSNumberError(
+      `Invalid number: ${valueLabel} cannot be NaN`,
+    );
+  } else if (!Number.isFinite(value) && rules?.noNonFinite) {
+    return new InvalidJSNumberError(
+      `Invalid number: ${valueLabel} cannot be non-finite`,
+    );
+  } else if (value === Infinity && rules?.noInfinity) {
+    return new InvalidJSNumberError(
+      `Invalid number: ${valueLabel} cannot be Infinity`,
+    );
+  } else if (value === -Infinity && rules?.noNegInfinity) {
+    return new InvalidJSNumberError(
+      `Invalid number: ${valueLabel} cannot be -Infinity`,
+    );
+  }
+  return null;
+};
+const validateJSType = ({
+  value,
+  typeofName,
+  numberRules,
+  valueLabel,
+  optional,
+}) => {
+  if (optional && (value === null || value === undefined)) return null;
+  const typeofNames = resolveOptionalArray(typeofName);
+  const isValid = isTypeof(value, ...typeofNames);
+  if (isValid && typeof value === "number" && numberRules) {
+    return validateNumber(value, numberRules, valueLabel);
+  } else if (isValid && typeof value === "object" && value === null) {
+    return new InvalidJSTypeError(
+      `Type error: ${valueLabel ?? "Value"} cannot be null`,
+    );
+  } else if (!isValid) {
+    return new InvalidJSTypeError(
+      `Type error: ${valueLabel ?? "Value"} expects type ${typeofNames.join(" | ")}, received ${value === null ? "null" : typeof value}`,
+    );
+  }
+  return null;
+};
+const validateJSArray = ({ value, valueLabel, optional, itemOptions }) => {
+  if (optional && (value === null || value === undefined)) return null;
+  if (!Array.isArray(value)) {
+    return new InvalidJSTypeError(
+      `Type error: ${valueLabel ?? "Value"} expects an array, received ${value === null ? "null" : typeof value}`,
+    );
+  }
+  if (itemOptions) {
+    for (let i = 0; i < value.length; i++) {
+      const itemError = validateJSType({
+        ...itemOptions,
+        value: value[i],
+        valueLabel: `${valueLabel ?? "Value"}[${i}]`,
+      });
+      if (itemError) return itemError;
+    }
+  }
+  return null;
+};
+const validateJSTypes = (config, options) => {
+  const errors = [];
+  for (const [valueLabel, entry] of Object.entries(config)) {
+    const error = entry.array
+      ? validateJSArray({
+          ...entry,
+          valueLabel,
+        })
+      : validateJSType({
+          ...entry,
+          valueLabel,
+        });
+    if (error) {
+      errors.push(error.message);
+    }
+  }
+  if (errors.length === 0) return null;
+  const result =
+    errors.length === 1
+      ? new InvalidJSTypeError(errors[0])
+      : new InvalidJSTypeError(
+          `Type errors:\n${errors.map((e) => ` - ${e}`).join("\n")}`,
+        );
+  if (options?.throw) throw result;
+  return result;
+};
+
+export {
+  InvalidJSNumberError,
+  InvalidJSTypeError,
+  VALIDATE_NUMBER_ERRORS,
+  VALIDATE_TYPEOF_ERRORS,
+  isPlainObject,
+  isTypeof,
+  validateJSArray,
+  validateJSType,
+  validateJSTypes,
+  validateNumber,
+};

package/src/internal/core/language/types/types.d.ts

@@ -0,0 +1,14 @@
+/** Does not change an object type, but remaps it for cleaner Intellisense only */
+export type Simplify<T extends object> = {
+  [K in keyof T]: T[K];
+};
+/** A normal `AsyncIterable` that is only intended for `for await` style iteration */
+export type SimpleAsyncIterable<T> = AsyncIterable<T, void, undefined>;
+export type AnyFunction<Args extends unknown[] = any[], Return = any> = (
+  ...args: Args
+) => Return;
+export type RequiredDeep<T> = T extends object
+  ? Required<{
+      [K in keyof T]: RequiredDeep<T[K]>;
+    }>
+  : T;

package/src/internal/core/language/types/types.mjs

@@ -0,0 +1,2 @@
+// CONCATENATED MODULE: ./src/internal/core/language/types/types.ts
+/** Does not change an object type, but remaps it for cleaner Intellisense only */

package/src/internal/core/runtime/env.d.ts

@@ -0,0 +1,6 @@
+export type RuntimeMode = "development" | "production" | "test";
+export declare const RUNTIME_MODE: RuntimeMode;
+export declare const IS_INTERNAL_TEST: boolean;
+export declare const IS_TEST: boolean;
+export declare const IS_PRODUCTION: boolean;
+export declare const IS_DEVELOPMENT: boolean;

package/src/internal/core/runtime/env.mjs

@@ -0,0 +1,36 @@
+// CONCATENATED MODULE: ./src/internal/core/runtime/env.ts
+/* eslint-disable no-console */ const _process =
+  typeof process === "undefined"
+    ? {
+        env: {},
+      }
+    : process;
+const RUNTIME_MODE_VALUES = ["development", "production", "test"];
+const _RUNTIME_MODE =
+  _process.env._BW_RUNTIME_MODE ||
+  (process.env.NODE_ENV?.match(/test(ing | s)?/)
+    ? "test"
+    : process.env.NODE_ENV === "development"
+      ? "development"
+      : "production");
+const RUNTIME_MODE = RUNTIME_MODE_VALUES.includes(_RUNTIME_MODE)
+  ? _RUNTIME_MODE
+  : "production";
+if (RUNTIME_MODE !== _RUNTIME_MODE) {
+  // eslint-disable-next-line no-console
+  console.error(
+    `Env var _BW_RUNTIME_MODE has an invalid value: "${_RUNTIME_MODE}". Defaulting to "${RUNTIME_MODE}". Accepted values: ${RUNTIME_MODE_VALUES.join(", ")}.`,
+  );
+}
+const IS_INTERNAL_TEST = process.env._BW_IS_INTERNAL_TEST === "true";
+const IS_TEST = RUNTIME_MODE === "test";
+const IS_PRODUCTION = RUNTIME_MODE === "production";
+const IS_DEVELOPMENT = RUNTIME_MODE === "development";
+
+export {
+  IS_DEVELOPMENT,
+  IS_INTERNAL_TEST,
+  IS_PRODUCTION,
+  IS_TEST,
+  RUNTIME_MODE,
+};

package/src/internal/core/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./env";
+export * from "./os";
+export * from "./onExit";
+export * from "./tempFile";
+export * from "./terminal";

package/src/internal/core/runtime/index.mjs

@@ -0,0 +1,5 @@
+export * from "./env.mjs";
+export * from "./os.mjs";
+export * from "./onExit.mjs";
+export * from "./tempFile.mjs";
+export * from "./terminal.mjs"; // CONCATENATED MODULE: ./src/internal/core/runtime/index.ts

package/src/internal/core/runtime/onExit.d.ts

@@ -0,0 +1,4 @@
+type ExitCodeOrSignal = NodeJS.Signals | number;
+type ExitHandler = (exit?: ExitCodeOrSignal) => unknown;
+export declare const runOnExit: <F extends ExitHandler>(fn: F) => void;
+export {};