1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
import { LoaderKeys } from "../../api/schema";
import { sliceSourceCode } from "./builtin-parser";
// This is a list of extra syntax replacements to do. Kind of like macros
// These are only run on code itself, not string contents or comments.
export const replacements: ReplacementRule[] = [
{ from: /\bthrow new TypeError\b/g, to: "$throwTypeError" },
{ from: /\bthrow new RangeError\b/g, to: "$throwRangeError" },
{ from: /\bthrow new OutOfMemoryError\b/g, to: "$throwOutOfMemoryError" },
{ from: /\bnew TypeError\b/g, to: "$makeTypeError" },
{ from: /\bexport\s*default/g, to: "$exports =" },
];
// These rules are run on the entire file, including within strings.
export const globalReplacements: ReplacementRule[] = [
{
from: /\bnotImplementedIssue\(\s*([0-9]+)\s*,\s*((?:"[^"]*"|'[^']+'))\s*\)/g,
to: "new TypeError(`${$2} is not implemented yet. See https://github.com/oven-sh/bun/issues/$1`)",
},
{
from: /\bnotImplementedIssueFn\(\s*([0-9]+)\s*,\s*((?:"[^"]*"|'[^']+'))\s*\)/g,
to: "() => $throwTypeError(`${$2} is not implemented yet. See https://github.com/oven-sh/bun/issues/$1`)",
},
];
// This is a list of globals we should access using @ notation
// This prevents a global override attacks.
// Note that the public `Bun` global is immutable.
// undefined -> __intrinsic__undefined -> @undefined
export const globalsToPrefix = [
"AbortSignal",
"Array",
"ArrayBuffer",
"Buffer",
"Infinity",
"Loader",
"Promise",
"ReadableByteStreamController",
"ReadableStream",
"ReadableStreamBYOBReader",
"ReadableStreamBYOBRequest",
"ReadableStreamDefaultController",
"ReadableStreamDefaultReader",
"TransformStream",
"TransformStreamDefaultController",
"Uint8Array",
"String",
"Buffer",
"RegExp",
"WritableStream",
"WritableStreamDefaultController",
"WritableStreamDefaultWriter",
"isFinite",
"undefined",
];
// These enums map to $<enum>IdToLabel and $<enum>LabelToId
// Make sure to define in ./builtins.d.ts
export const enums = {
Loader: LoaderKeys,
ImportKind: [
"entry-point",
"import-statement",
"require-call",
"dynamic-import",
"require-resolve",
"import-rule",
"url-token",
"internal",
],
};
// These identifiers have typedef but not present at runtime (converted with replacements)
// If they are present in the bundle after runtime, we warn at the user.
// TODO: implement this check.
export const warnOnIdentifiersNotPresentAtRuntime = [
//
"OutOfMemoryError",
"notImplementedIssue",
"notImplementedIssueFn",
];
// These are passed to --define to the bundler
export const define: Record<string, string> = {
"process.env.NODE_ENV": "production",
"IS_BUN_DEVELOPMENT": "false",
$streamClosed: "1",
$streamClosing: "2",
$streamErrored: "3",
$streamReadable: "4",
$streamWaiting: "5",
$streamWritable: "6",
};
// ------------------------------ //
for (const name in enums) {
const value = enums[name];
if (typeof value !== "object") throw new Error("Invalid enum object " + name + " defined in " + import.meta.file);
if (typeof value === null) throw new Error("Invalid enum object " + name + " defined in " + import.meta.file);
const keys = Array.isArray(value) ? value : Object.keys(value).filter(k => !k.match(/^[0-9]+$/));
define[`$${name}IdToLabel`] = "[" + keys.map(k => `"${k}"`).join(", ") + "]";
define[`$${name}LabelToId`] = "{" + keys.map(k => `"${k}": ${keys.indexOf(k)}`).join(", ") + "}";
}
for (const name of globalsToPrefix) {
define[name] = "__intrinsic__" + name;
}
for (const key in define) {
if (key.startsWith("$")) {
define["__intrinsic__" + key.slice(1)] = define[key];
delete define[key];
}
}
export interface ReplacementRule {
from: RegExp;
to: string;
global?: boolean;
}
/** Applies source code replacements as defined in `replacements` */
export function applyReplacements(src: string, length: number) {
let slice = src.slice(0, length);
let rest = src.slice(length);
slice = slice.replace(/([^a-zA-Z0-9_\$])\$([a-zA-Z0-9_]+\b)/gm, `$1__intrinsic__$2`);
for (const replacement of replacements) {
slice = slice.replace(replacement.from, replacement.to.replaceAll("$", "__intrinsic__"));
}
let match;
if ((match = slice.match(/__intrinsic__(debug|assert)$/)) && rest.startsWith("(")) {
const name = match[1];
if (name === "debug") {
const innerSlice = sliceSourceCode(rest, true);
return [
slice.slice(0, match.index) + "(IS_BUN_DEVELOPMENT?$debug_log" + innerSlice.result + ":void 0)",
innerSlice.rest,
true,
];
} else if (name === "assert") {
const checkSlice = sliceSourceCode(rest, true, undefined, true);
let rest2 = checkSlice.rest;
let extraArgs = "";
if (checkSlice.result.at(-1) === ",") {
const sliced = sliceSourceCode("(" + rest2.slice(1), true, undefined, false);
extraArgs = ", " + sliced.result.slice(1, -1);
rest2 = sliced.rest;
}
return [
slice.slice(0, match.index) +
"(IS_BUN_DEVELOPMENT?$assert(" +
checkSlice.result.slice(1, -1) +
"," +
JSON.stringify(
checkSlice.result
.slice(1, -1)
.replace(/__intrinsic__/g, "$")
.trim(),
) +
extraArgs +
"):void 0)",
rest2,
true,
];
}
}
return [slice, rest, false];
}
/** Applies source code replacements as defined in `globalReplacements` */
export function applyGlobalReplacements(src: string) {
let result = src;
for (const replacement of globalReplacements) {
result = result.replace(replacement.from, replacement.to.replaceAll("$", "__intrinsic__"));
}
return result;
}
|
