@erxes/ui 4.0.0-v2.11 → 4.0.0-v2.13
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CATALOG.md +9 -2
- package/dist/components/color-picker.js +2 -2
- package/dist/components/combobox.js +4 -1
- package/dist/components/command-bar.js +3 -0
- package/dist/components/dialog.d.ts +5 -2
- package/dist/components/dialog.js +19 -10
- package/dist/components/field-control.d.ts +16 -0
- package/dist/components/field-control.js +19 -0
- package/dist/components/form-layout.d.ts +19 -0
- package/dist/components/form-layout.js +56 -0
- package/dist/components/form.d.ts +9 -2
- package/dist/components/form.js +17 -7
- package/dist/components/input.d.ts +1 -1
- package/dist/components/input.js +9 -4
- package/dist/components/multiselect.js +4 -1
- package/dist/components/on-demand.d.ts +9 -2
- package/dist/components/on-demand.js +15 -1
- package/dist/components/popover.js +17 -13
- package/dist/components/select.js +16 -11
- package/dist/components/sheet.d.ts +5 -2
- package/dist/components/sheet.js +18 -9
- package/dist/components/textarea.js +4 -1
- package/dist/hooks/use-focus-first-field.d.ts +8 -0
- package/dist/hooks/use-focus-first-field.js +15 -0
- package/dist/hooks/use-page-hotkey.d.ts +2 -0
- package/dist/hooks/use-page-hotkey.js +4 -2
- package/dist/index.d.ts +4 -2
- package/dist/index.js +4 -2
- package/dist/lib/render-in-dom.d.ts +6 -0
- package/dist/lib/render-in-dom.js +26 -0
- package/dist/modules/conditions/PathPicker.js +7 -2
- package/dist/modules/conditions/conditions.d.ts +2 -0
- package/dist/modules/filter/components/FilterBar.js +3 -0
- package/dist/modules/list/ListFilter.d.ts +11 -3
- package/dist/modules/list/ListFilter.js +8 -2
- package/dist/modules/list/ViewBar.d.ts +36 -4
- package/dist/modules/list/ViewBar.js +33 -9
- package/dist/modules/list/filter/ListFilterBar.js +11 -4
- package/dist/modules/list/filter/RuleChips.js +1 -5
- package/dist/modules/record-field/components/TextField.js +1 -4
- package/dist/modules/record-panel/PanelForm.d.ts +4 -2
- package/dist/modules/record-panel/PanelForm.js +73 -7
- package/dist/node_modules/.pnpm/vitest@5.1.0_@opentelemetry_api@1.10.0_@types_node@26.6.6_@vitest_browser-preview@5.1.0_d78d0f63d2a6b1c4a51a56547b330411/node_modules/vitest/dist/chunks/display.BlTmubjj.js +181 -0
- package/dist/node_modules/.pnpm/vitest@5.1.0_@opentelemetry_api@1.10.0_@types_node@26.6.6_@vitest_browser-preview@5.1.0_d78d0f63d2a6b1c4a51a56547b330411/node_modules/vitest/dist/chunks/index.D0heQG4v.js +987 -0
- package/dist/node_modules/.pnpm/vitest@5.1.0_@opentelemetry_api@1.10.0_@types_node@26.6.6_@vitest_browser-preview@5.1.0_d78d0f63d2a6b1c4a51a56547b330411/node_modules/vitest/dist/chunks/pathe.M-eThtNZ.zq3TM4NT.js +176 -0
- package/dist/node_modules/.pnpm/vitest@5.1.0_@opentelemetry_api@1.10.0_@types_node@26.6.6_@vitest_browser-preview@5.1.0_d78d0f63d2a6b1c4a51a56547b330411/node_modules/vitest/dist/chunks/run.CjdgFZiW.js +1509 -0
- package/dist/node_modules/.pnpm/vitest@5.1.0_@opentelemetry_api@1.10.0_@types_node@26.6.6_@vitest_browser-preview@5.1.0_d78d0f63d2a6b1c4a51a56547b330411/node_modules/vitest/dist/chunks/source-map.DakdQc29.js +687 -0
- package/dist/node_modules/.pnpm/vitest@5.1.0_@opentelemetry_api@1.10.0_@types_node@26.6.6_@vitest_browser-preview@5.1.0_d78d0f63d2a6b1c4a51a56547b330411/node_modules/vitest/dist/chunks/tinyrainbow.Do8I1XRG.js +85 -0
- package/dist/node_modules/.pnpm/vitest@5.1.0_@opentelemetry_api@1.10.0_@types_node@26.6.6_@vitest_browser-preview@5.1.0_d78d0f63d2a6b1c4a51a56547b330411/node_modules/vitest/dist/task-utils.js +6 -0
- package/exports.txt +7 -0
- package/package.json +4 -1
|
@@ -0,0 +1,687 @@
|
|
|
1
|
+
import { q as notNullish, r as resolve } from "./pathe.M-eThtNZ.zq3TM4NT.js";
|
|
2
|
+
// ../../node_modules/.pnpm/vitest@5.1.0_@opentelemetry+api@1.10.0_@types+node@26.6.6_@vitest+browser-preview@5.1.0_d78d0f63d2a6b1c4a51a56547b330411/node_modules/vitest/dist/chunks/source-map.DakdQc29.js
|
|
3
|
+
var build = {};
|
|
4
|
+
var hasRequiredBuild;
|
|
5
|
+
function requireBuild() {
|
|
6
|
+
if (hasRequiredBuild) return build;
|
|
7
|
+
hasRequiredBuild = 1;
|
|
8
|
+
Object.defineProperty(build, "__esModule", { value: true });
|
|
9
|
+
build.default = diffSequence;
|
|
10
|
+
/**
|
|
11
|
+
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
12
|
+
*
|
|
13
|
+
* This source code is licensed under the MIT license found in the
|
|
14
|
+
* LICENSE file in the root directory of this source tree.
|
|
15
|
+
*
|
|
16
|
+
*/
|
|
17
|
+
const pkg = "diff-sequences";
|
|
18
|
+
const NOT_YET_SET = 0;
|
|
19
|
+
const countCommonItemsF = (aIndex, aEnd, bIndex, bEnd, isCommon) => {
|
|
20
|
+
let nCommon = 0;
|
|
21
|
+
while (aIndex < aEnd && bIndex < bEnd && isCommon(aIndex, bIndex)) {
|
|
22
|
+
aIndex += 1;
|
|
23
|
+
bIndex += 1;
|
|
24
|
+
nCommon += 1;
|
|
25
|
+
}
|
|
26
|
+
return nCommon;
|
|
27
|
+
};
|
|
28
|
+
const countCommonItemsR = (aStart, aIndex, bStart, bIndex, isCommon) => {
|
|
29
|
+
let nCommon = 0;
|
|
30
|
+
while (aStart <= aIndex && bStart <= bIndex && isCommon(aIndex, bIndex)) {
|
|
31
|
+
aIndex -= 1;
|
|
32
|
+
bIndex -= 1;
|
|
33
|
+
nCommon += 1;
|
|
34
|
+
}
|
|
35
|
+
return nCommon;
|
|
36
|
+
};
|
|
37
|
+
const extendPathsF = (d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF) => {
|
|
38
|
+
let iF = 0;
|
|
39
|
+
let kF = -d;
|
|
40
|
+
let aFirst = aIndexesF[iF];
|
|
41
|
+
let aIndexPrev1 = aFirst;
|
|
42
|
+
aIndexesF[iF] += countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);
|
|
43
|
+
const nF = d < iMaxF ? d : iMaxF;
|
|
44
|
+
for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {
|
|
45
|
+
if (iF !== d && aIndexPrev1 < aIndexesF[iF]) aFirst = aIndexesF[iF];
|
|
46
|
+
else {
|
|
47
|
+
aFirst = aIndexPrev1 + 1;
|
|
48
|
+
if (aEnd <= aFirst) return iF - 1;
|
|
49
|
+
}
|
|
50
|
+
aIndexPrev1 = aIndexesF[iF];
|
|
51
|
+
aIndexesF[iF] = aFirst + countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);
|
|
52
|
+
}
|
|
53
|
+
return iMaxF;
|
|
54
|
+
};
|
|
55
|
+
const extendPathsR = (d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR) => {
|
|
56
|
+
let iR = 0;
|
|
57
|
+
let kR = d;
|
|
58
|
+
let aFirst = aIndexesR[iR];
|
|
59
|
+
let aIndexPrev1 = aFirst;
|
|
60
|
+
aIndexesR[iR] -= countCommonItemsR(aStart, aFirst - 1, bStart, bR + aFirst - kR - 1, isCommon);
|
|
61
|
+
const nR = d < iMaxR ? d : iMaxR;
|
|
62
|
+
for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {
|
|
63
|
+
if (iR !== d && aIndexesR[iR] < aIndexPrev1) aFirst = aIndexesR[iR];
|
|
64
|
+
else {
|
|
65
|
+
aFirst = aIndexPrev1 - 1;
|
|
66
|
+
if (aFirst < aStart) return iR - 1;
|
|
67
|
+
}
|
|
68
|
+
aIndexPrev1 = aIndexesR[iR];
|
|
69
|
+
aIndexesR[iR] = aFirst - countCommonItemsR(aStart, aFirst - 1, bStart, bR + aFirst - kR - 1, isCommon);
|
|
70
|
+
}
|
|
71
|
+
return iMaxR;
|
|
72
|
+
};
|
|
73
|
+
const extendOverlappablePathsF = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
|
|
74
|
+
const bF = bStart - aStart;
|
|
75
|
+
const aLength = aEnd - aStart;
|
|
76
|
+
const baDeltaLength = bEnd - bStart - aLength;
|
|
77
|
+
const kMinOverlapF = -baDeltaLength - (d - 1);
|
|
78
|
+
const kMaxOverlapF = -baDeltaLength + (d - 1);
|
|
79
|
+
let aIndexPrev1 = NOT_YET_SET;
|
|
80
|
+
const nF = d < iMaxF ? d : iMaxF;
|
|
81
|
+
for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {
|
|
82
|
+
const insert = iF === 0 || iF !== d && aIndexPrev1 < aIndexesF[iF];
|
|
83
|
+
const aLastPrev = insert ? aIndexesF[iF] : aIndexPrev1;
|
|
84
|
+
const aFirst = insert ? aLastPrev : aLastPrev + 1;
|
|
85
|
+
const bFirst = bF + aFirst - kF;
|
|
86
|
+
const nCommonF = countCommonItemsF(aFirst + 1, aEnd, bFirst + 1, bEnd, isCommon);
|
|
87
|
+
const aLast = aFirst + nCommonF;
|
|
88
|
+
aIndexPrev1 = aIndexesF[iF];
|
|
89
|
+
aIndexesF[iF] = aLast;
|
|
90
|
+
if (kMinOverlapF <= kF && kF <= kMaxOverlapF) {
|
|
91
|
+
const iR = (d - 1 - (kF + baDeltaLength)) / 2;
|
|
92
|
+
if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {
|
|
93
|
+
const bLastPrev = bF + aLastPrev - (insert ? kF + 1 : kF - 1);
|
|
94
|
+
const nCommonR = countCommonItemsR(aStart, aLastPrev, bStart, bLastPrev, isCommon);
|
|
95
|
+
const aIndexPrevFirst = aLastPrev - nCommonR;
|
|
96
|
+
const bIndexPrevFirst = bLastPrev - nCommonR;
|
|
97
|
+
const aEndPreceding = aIndexPrevFirst + 1;
|
|
98
|
+
const bEndPreceding = bIndexPrevFirst + 1;
|
|
99
|
+
division.nChangePreceding = d - 1;
|
|
100
|
+
if (d - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {
|
|
101
|
+
division.aEndPreceding = aStart;
|
|
102
|
+
division.bEndPreceding = bStart;
|
|
103
|
+
} else {
|
|
104
|
+
division.aEndPreceding = aEndPreceding;
|
|
105
|
+
division.bEndPreceding = bEndPreceding;
|
|
106
|
+
}
|
|
107
|
+
division.nCommonPreceding = nCommonR;
|
|
108
|
+
if (nCommonR !== 0) {
|
|
109
|
+
division.aCommonPreceding = aEndPreceding;
|
|
110
|
+
division.bCommonPreceding = bEndPreceding;
|
|
111
|
+
}
|
|
112
|
+
division.nCommonFollowing = nCommonF;
|
|
113
|
+
if (nCommonF !== 0) {
|
|
114
|
+
division.aCommonFollowing = aFirst + 1;
|
|
115
|
+
division.bCommonFollowing = bFirst + 1;
|
|
116
|
+
}
|
|
117
|
+
const aStartFollowing = aLast + 1;
|
|
118
|
+
const bStartFollowing = bFirst + nCommonF + 1;
|
|
119
|
+
division.nChangeFollowing = d - 1;
|
|
120
|
+
if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
|
|
121
|
+
division.aStartFollowing = aEnd;
|
|
122
|
+
division.bStartFollowing = bEnd;
|
|
123
|
+
} else {
|
|
124
|
+
division.aStartFollowing = aStartFollowing;
|
|
125
|
+
division.bStartFollowing = bStartFollowing;
|
|
126
|
+
}
|
|
127
|
+
return true;
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
return false;
|
|
132
|
+
};
|
|
133
|
+
const extendOverlappablePathsR = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
|
|
134
|
+
const bR = bEnd - aEnd;
|
|
135
|
+
const aLength = aEnd - aStart;
|
|
136
|
+
const baDeltaLength = bEnd - bStart - aLength;
|
|
137
|
+
const kMinOverlapR = baDeltaLength - d;
|
|
138
|
+
const kMaxOverlapR = baDeltaLength + d;
|
|
139
|
+
let aIndexPrev1 = NOT_YET_SET;
|
|
140
|
+
const nR = d < iMaxR ? d : iMaxR;
|
|
141
|
+
for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {
|
|
142
|
+
const insert = iR === 0 || iR !== d && aIndexesR[iR] < aIndexPrev1;
|
|
143
|
+
const aLastPrev = insert ? aIndexesR[iR] : aIndexPrev1;
|
|
144
|
+
const aFirst = insert ? aLastPrev : aLastPrev - 1;
|
|
145
|
+
const bFirst = bR + aFirst - kR;
|
|
146
|
+
const nCommonR = countCommonItemsR(aStart, aFirst - 1, bStart, bFirst - 1, isCommon);
|
|
147
|
+
const aLast = aFirst - nCommonR;
|
|
148
|
+
aIndexPrev1 = aIndexesR[iR];
|
|
149
|
+
aIndexesR[iR] = aLast;
|
|
150
|
+
if (kMinOverlapR <= kR && kR <= kMaxOverlapR) {
|
|
151
|
+
const iF = (d + (kR - baDeltaLength)) / 2;
|
|
152
|
+
if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {
|
|
153
|
+
const bLast = bFirst - nCommonR;
|
|
154
|
+
division.nChangePreceding = d;
|
|
155
|
+
if (d === aLast + bLast - aStart - bStart) {
|
|
156
|
+
division.aEndPreceding = aStart;
|
|
157
|
+
division.bEndPreceding = bStart;
|
|
158
|
+
} else {
|
|
159
|
+
division.aEndPreceding = aLast;
|
|
160
|
+
division.bEndPreceding = bLast;
|
|
161
|
+
}
|
|
162
|
+
division.nCommonPreceding = nCommonR;
|
|
163
|
+
if (nCommonR !== 0) {
|
|
164
|
+
division.aCommonPreceding = aLast;
|
|
165
|
+
division.bCommonPreceding = bLast;
|
|
166
|
+
}
|
|
167
|
+
division.nChangeFollowing = d - 1;
|
|
168
|
+
if (d === 1) {
|
|
169
|
+
division.nCommonFollowing = 0;
|
|
170
|
+
division.aStartFollowing = aEnd;
|
|
171
|
+
division.bStartFollowing = bEnd;
|
|
172
|
+
} else {
|
|
173
|
+
const bLastPrev = bR + aLastPrev - (insert ? kR - 1 : kR + 1);
|
|
174
|
+
const nCommonF = countCommonItemsF(aLastPrev, aEnd, bLastPrev, bEnd, isCommon);
|
|
175
|
+
division.nCommonFollowing = nCommonF;
|
|
176
|
+
if (nCommonF !== 0) {
|
|
177
|
+
division.aCommonFollowing = aLastPrev;
|
|
178
|
+
division.bCommonFollowing = bLastPrev;
|
|
179
|
+
}
|
|
180
|
+
const aStartFollowing = aLastPrev + nCommonF;
|
|
181
|
+
const bStartFollowing = bLastPrev + nCommonF;
|
|
182
|
+
if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
|
|
183
|
+
division.aStartFollowing = aEnd;
|
|
184
|
+
division.bStartFollowing = bEnd;
|
|
185
|
+
} else {
|
|
186
|
+
division.aStartFollowing = aStartFollowing;
|
|
187
|
+
division.bStartFollowing = bStartFollowing;
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
return true;
|
|
191
|
+
}
|
|
192
|
+
}
|
|
193
|
+
}
|
|
194
|
+
return false;
|
|
195
|
+
};
|
|
196
|
+
const divide = (nChange, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, aIndexesR, division) => {
|
|
197
|
+
const bF = bStart - aStart;
|
|
198
|
+
const bR = bEnd - aEnd;
|
|
199
|
+
const aLength = aEnd - aStart;
|
|
200
|
+
const bLength = bEnd - bStart;
|
|
201
|
+
const baDeltaLength = bLength - aLength;
|
|
202
|
+
let iMaxF = aLength;
|
|
203
|
+
let iMaxR = aLength;
|
|
204
|
+
aIndexesF[0] = aStart - 1;
|
|
205
|
+
aIndexesR[0] = aEnd;
|
|
206
|
+
if (baDeltaLength % 2 === 0) {
|
|
207
|
+
const dMin = (nChange || baDeltaLength) / 2;
|
|
208
|
+
const dMax = (aLength + bLength) / 2;
|
|
209
|
+
for (let d = 1; d <= dMax; d += 1) {
|
|
210
|
+
iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
|
|
211
|
+
if (d < dMin) iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
|
|
212
|
+
else if (extendOverlappablePathsR(d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division)) return;
|
|
213
|
+
}
|
|
214
|
+
} else {
|
|
215
|
+
const dMin = ((nChange || baDeltaLength) + 1) / 2;
|
|
216
|
+
const dMax = (aLength + bLength + 1) / 2;
|
|
217
|
+
let d = 1;
|
|
218
|
+
iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
|
|
219
|
+
for (d += 1; d <= dMax; d += 1) {
|
|
220
|
+
iMaxR = extendPathsR(d - 1, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
|
|
221
|
+
if (d < dMin) iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
|
|
222
|
+
else if (extendOverlappablePathsF(d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division)) return;
|
|
223
|
+
}
|
|
224
|
+
}
|
|
225
|
+
/* istanbul ignore next */
|
|
226
|
+
throw new Error(`${pkg}: no overlap aStart=${aStart} aEnd=${aEnd} bStart=${bStart} bEnd=${bEnd}`);
|
|
227
|
+
};
|
|
228
|
+
const findSubsequences = (nChange, aStart, aEnd, bStart, bEnd, transposed, callbacks, aIndexesF, aIndexesR, division) => {
|
|
229
|
+
if (bEnd - bStart < aEnd - aStart) {
|
|
230
|
+
transposed = !transposed;
|
|
231
|
+
if (transposed && callbacks.length === 1) {
|
|
232
|
+
const { foundSubsequence, isCommon } = callbacks[0];
|
|
233
|
+
callbacks[1] = {
|
|
234
|
+
foundSubsequence: (nCommon, bCommon, aCommon) => {
|
|
235
|
+
foundSubsequence(nCommon, aCommon, bCommon);
|
|
236
|
+
},
|
|
237
|
+
isCommon: (bIndex, aIndex) => isCommon(aIndex, bIndex)
|
|
238
|
+
};
|
|
239
|
+
}
|
|
240
|
+
const tStart = aStart;
|
|
241
|
+
const tEnd = aEnd;
|
|
242
|
+
aStart = bStart;
|
|
243
|
+
aEnd = bEnd;
|
|
244
|
+
bStart = tStart;
|
|
245
|
+
bEnd = tEnd;
|
|
246
|
+
}
|
|
247
|
+
const { foundSubsequence, isCommon } = callbacks[transposed ? 1 : 0];
|
|
248
|
+
divide(nChange, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, aIndexesR, division);
|
|
249
|
+
const { nChangePreceding, aEndPreceding, bEndPreceding, nCommonPreceding, aCommonPreceding, bCommonPreceding, nCommonFollowing, aCommonFollowing, bCommonFollowing, nChangeFollowing, aStartFollowing, bStartFollowing } = division;
|
|
250
|
+
if (aStart < aEndPreceding && bStart < bEndPreceding) findSubsequences(nChangePreceding, aStart, aEndPreceding, bStart, bEndPreceding, transposed, callbacks, aIndexesF, aIndexesR, division);
|
|
251
|
+
if (nCommonPreceding !== 0) foundSubsequence(nCommonPreceding, aCommonPreceding, bCommonPreceding);
|
|
252
|
+
if (nCommonFollowing !== 0) foundSubsequence(nCommonFollowing, aCommonFollowing, bCommonFollowing);
|
|
253
|
+
if (aStartFollowing < aEnd && bStartFollowing < bEnd) findSubsequences(nChangeFollowing, aStartFollowing, aEnd, bStartFollowing, bEnd, transposed, callbacks, aIndexesF, aIndexesR, division);
|
|
254
|
+
};
|
|
255
|
+
const validateLength = (name, arg) => {
|
|
256
|
+
if (typeof arg !== "number") throw new TypeError(`${pkg}: ${name} typeof ${typeof arg} is not a number`);
|
|
257
|
+
if (!Number.isSafeInteger(arg)) throw new RangeError(`${pkg}: ${name} value ${arg} is not a safe integer`);
|
|
258
|
+
if (arg < 0) throw new RangeError(`${pkg}: ${name} value ${arg} is a negative integer`);
|
|
259
|
+
};
|
|
260
|
+
const validateCallback = (name, arg) => {
|
|
261
|
+
const type = typeof arg;
|
|
262
|
+
if (type !== "function") throw new TypeError(`${pkg}: ${name} typeof ${type} is not a function`);
|
|
263
|
+
};
|
|
264
|
+
function diffSequence(aLength, bLength, isCommon, foundSubsequence) {
|
|
265
|
+
validateLength("aLength", aLength);
|
|
266
|
+
validateLength("bLength", bLength);
|
|
267
|
+
validateCallback("isCommon", isCommon);
|
|
268
|
+
validateCallback("foundSubsequence", foundSubsequence);
|
|
269
|
+
const nCommonF = countCommonItemsF(0, aLength, 0, bLength, isCommon);
|
|
270
|
+
if (nCommonF !== 0) foundSubsequence(nCommonF, 0, 0);
|
|
271
|
+
if (aLength !== nCommonF || bLength !== nCommonF) {
|
|
272
|
+
const aStart = nCommonF;
|
|
273
|
+
const bStart = nCommonF;
|
|
274
|
+
const nCommonR = countCommonItemsR(aStart, aLength - 1, bStart, bLength - 1, isCommon);
|
|
275
|
+
const aEnd = aLength - nCommonR;
|
|
276
|
+
const bEnd = bLength - nCommonR;
|
|
277
|
+
const nCommonFR = nCommonF + nCommonR;
|
|
278
|
+
if (aLength !== nCommonFR && bLength !== nCommonFR) findSubsequences(0, aStart, aEnd, bStart, bEnd, false, [{
|
|
279
|
+
foundSubsequence,
|
|
280
|
+
isCommon
|
|
281
|
+
}], [NOT_YET_SET], [NOT_YET_SET], {
|
|
282
|
+
aCommonFollowing: NOT_YET_SET,
|
|
283
|
+
aCommonPreceding: NOT_YET_SET,
|
|
284
|
+
aEndPreceding: NOT_YET_SET,
|
|
285
|
+
aStartFollowing: NOT_YET_SET,
|
|
286
|
+
bCommonFollowing: NOT_YET_SET,
|
|
287
|
+
bCommonPreceding: NOT_YET_SET,
|
|
288
|
+
bEndPreceding: NOT_YET_SET,
|
|
289
|
+
bStartFollowing: NOT_YET_SET,
|
|
290
|
+
nChangeFollowing: NOT_YET_SET,
|
|
291
|
+
nChangePreceding: NOT_YET_SET,
|
|
292
|
+
nCommonFollowing: NOT_YET_SET,
|
|
293
|
+
nCommonPreceding: NOT_YET_SET
|
|
294
|
+
});
|
|
295
|
+
if (nCommonR !== 0) foundSubsequence(nCommonR, aEnd, bEnd);
|
|
296
|
+
}
|
|
297
|
+
}
|
|
298
|
+
return build;
|
|
299
|
+
}
|
|
300
|
+
requireBuild();
|
|
301
|
+
const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
|
|
302
|
+
function getSafeTimers() {
|
|
303
|
+
const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
|
|
304
|
+
const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || {};
|
|
305
|
+
return {
|
|
306
|
+
nextTick: safeNextTick,
|
|
307
|
+
setTimeout: safeSetTimeout,
|
|
308
|
+
setInterval: safeSetInterval,
|
|
309
|
+
clearInterval: safeClearInterval,
|
|
310
|
+
clearTimeout: safeClearTimeout,
|
|
311
|
+
setImmediate: safeSetImmediate,
|
|
312
|
+
clearImmediate: safeClearImmediate,
|
|
313
|
+
queueMicrotask: safeQueueMicrotask
|
|
314
|
+
};
|
|
315
|
+
}
|
|
316
|
+
var comma = ",".charCodeAt(0);
|
|
317
|
+
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
318
|
+
var intToChar = /* @__PURE__ */ new Uint8Array(64);
|
|
319
|
+
var charToInt = /* @__PURE__ */ new Uint8Array(128);
|
|
320
|
+
for (let i = 0; i < chars.length; i++) {
|
|
321
|
+
const c = chars.charCodeAt(i);
|
|
322
|
+
intToChar[i] = c;
|
|
323
|
+
charToInt[c] = i;
|
|
324
|
+
}
|
|
325
|
+
function decodeInteger(reader) {
|
|
326
|
+
let value = 0;
|
|
327
|
+
let shift = 0;
|
|
328
|
+
let integer = 0;
|
|
329
|
+
do {
|
|
330
|
+
integer = charToInt[reader.next()];
|
|
331
|
+
value |= (integer & 31) << shift;
|
|
332
|
+
shift += 5;
|
|
333
|
+
} while (integer & 32);
|
|
334
|
+
return value;
|
|
335
|
+
}
|
|
336
|
+
function decodeSign(num) {
|
|
337
|
+
return num & 1 ? -2147483648 | -(num >>> 1) : num >>> 1;
|
|
338
|
+
}
|
|
339
|
+
function hasMoreVlq(reader, max) {
|
|
340
|
+
if (reader.pos >= max) return false;
|
|
341
|
+
return reader.peek() !== comma;
|
|
342
|
+
}
|
|
343
|
+
var StringReader = class {
|
|
344
|
+
constructor(buffer) {
|
|
345
|
+
this.pos = 0;
|
|
346
|
+
this.buffer = buffer;
|
|
347
|
+
}
|
|
348
|
+
next() {
|
|
349
|
+
return this.buffer.charCodeAt(this.pos++);
|
|
350
|
+
}
|
|
351
|
+
peek() {
|
|
352
|
+
return this.buffer.charCodeAt(this.pos);
|
|
353
|
+
}
|
|
354
|
+
indexOf(char) {
|
|
355
|
+
const { buffer, pos } = this;
|
|
356
|
+
const idx = buffer.indexOf(char, pos);
|
|
357
|
+
return idx === -1 ? buffer.length : idx;
|
|
358
|
+
}
|
|
359
|
+
};
|
|
360
|
+
function decode(mappings) {
|
|
361
|
+
const { length } = mappings;
|
|
362
|
+
const reader = new StringReader(mappings);
|
|
363
|
+
const decoded = [];
|
|
364
|
+
let genColumn = 0;
|
|
365
|
+
let sourcesIndex = 0;
|
|
366
|
+
let sourceLine = 0;
|
|
367
|
+
let sourceColumn = 0;
|
|
368
|
+
let namesIndex = 0;
|
|
369
|
+
do {
|
|
370
|
+
const semi = reader.indexOf(";");
|
|
371
|
+
const line = [];
|
|
372
|
+
let sorted = true;
|
|
373
|
+
let lastCol = 0;
|
|
374
|
+
genColumn = 0;
|
|
375
|
+
while (reader.pos < semi) {
|
|
376
|
+
let seg;
|
|
377
|
+
genColumn += decodeSign(decodeInteger(reader));
|
|
378
|
+
if (genColumn < lastCol) sorted = false;
|
|
379
|
+
lastCol = genColumn;
|
|
380
|
+
if (hasMoreVlq(reader, semi)) {
|
|
381
|
+
sourcesIndex += decodeSign(decodeInteger(reader));
|
|
382
|
+
sourceLine += decodeSign(decodeInteger(reader));
|
|
383
|
+
sourceColumn += decodeSign(decodeInteger(reader));
|
|
384
|
+
if (hasMoreVlq(reader, semi)) {
|
|
385
|
+
namesIndex += decodeSign(decodeInteger(reader));
|
|
386
|
+
seg = [
|
|
387
|
+
genColumn,
|
|
388
|
+
sourcesIndex,
|
|
389
|
+
sourceLine,
|
|
390
|
+
sourceColumn,
|
|
391
|
+
namesIndex
|
|
392
|
+
];
|
|
393
|
+
} else seg = [
|
|
394
|
+
genColumn,
|
|
395
|
+
sourcesIndex,
|
|
396
|
+
sourceLine,
|
|
397
|
+
sourceColumn
|
|
398
|
+
];
|
|
399
|
+
} else seg = [genColumn];
|
|
400
|
+
line.push(seg);
|
|
401
|
+
reader.pos++;
|
|
402
|
+
}
|
|
403
|
+
if (!sorted) sort(line);
|
|
404
|
+
decoded.push(line);
|
|
405
|
+
reader.pos = semi + 1;
|
|
406
|
+
} while (reader.pos <= length);
|
|
407
|
+
return decoded;
|
|
408
|
+
}
|
|
409
|
+
function sort(line) {
|
|
410
|
+
line.sort(sortComparator$1);
|
|
411
|
+
}
|
|
412
|
+
function sortComparator$1(a, b) {
|
|
413
|
+
return a[0] - b[0];
|
|
414
|
+
}
|
|
415
|
+
var COLUMN = 0;
|
|
416
|
+
var SOURCES_INDEX = 1;
|
|
417
|
+
var SOURCE_LINE = 2;
|
|
418
|
+
var SOURCE_COLUMN = 3;
|
|
419
|
+
var NAMES_INDEX = 4;
|
|
420
|
+
var found = false;
|
|
421
|
+
function binarySearch(haystack, needle, low, high) {
|
|
422
|
+
while (low <= high) {
|
|
423
|
+
const mid = low + (high - low >> 1);
|
|
424
|
+
const cmp = haystack[mid][COLUMN] - needle;
|
|
425
|
+
if (cmp === 0) {
|
|
426
|
+
found = true;
|
|
427
|
+
return mid;
|
|
428
|
+
}
|
|
429
|
+
if (cmp < 0) low = mid + 1;
|
|
430
|
+
else high = mid - 1;
|
|
431
|
+
}
|
|
432
|
+
found = false;
|
|
433
|
+
return low - 1;
|
|
434
|
+
}
|
|
435
|
+
function upperBound(haystack, needle, index) {
|
|
436
|
+
for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN] !== needle) break;
|
|
437
|
+
return index;
|
|
438
|
+
}
|
|
439
|
+
function lowerBound(haystack, needle, index) {
|
|
440
|
+
for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN] !== needle) break;
|
|
441
|
+
return index;
|
|
442
|
+
}
|
|
443
|
+
function memoizedBinarySearch(haystack, needle, state, key) {
|
|
444
|
+
const { lastKey, lastNeedle, lastIndex } = state;
|
|
445
|
+
let low = 0;
|
|
446
|
+
let high = haystack.length - 1;
|
|
447
|
+
if (key === lastKey) {
|
|
448
|
+
if (needle === lastNeedle) {
|
|
449
|
+
found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
|
|
450
|
+
return lastIndex;
|
|
451
|
+
}
|
|
452
|
+
if (needle >= lastNeedle) low = lastIndex === -1 ? 0 : lastIndex;
|
|
453
|
+
else high = lastIndex;
|
|
454
|
+
}
|
|
455
|
+
state.lastKey = key;
|
|
456
|
+
state.lastNeedle = needle;
|
|
457
|
+
return state.lastIndex = binarySearch(haystack, needle, low, high);
|
|
458
|
+
}
|
|
459
|
+
var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
|
|
460
|
+
var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
|
|
461
|
+
var LEAST_UPPER_BOUND = -1;
|
|
462
|
+
var GREATEST_LOWER_BOUND = 1;
|
|
463
|
+
function cast(map) {
|
|
464
|
+
return map;
|
|
465
|
+
}
|
|
466
|
+
function decodedMappings(map) {
|
|
467
|
+
var _a;
|
|
468
|
+
return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
|
|
469
|
+
}
|
|
470
|
+
function originalPositionFor(map, needle) {
|
|
471
|
+
let { line, column, bias } = needle;
|
|
472
|
+
line--;
|
|
473
|
+
if (line < 0) throw new Error(LINE_GTR_ZERO);
|
|
474
|
+
if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
|
|
475
|
+
const decoded = decodedMappings(map);
|
|
476
|
+
if (line >= decoded.length) return OMapping(null, null, null, null);
|
|
477
|
+
const segments = decoded[line];
|
|
478
|
+
const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
|
|
479
|
+
if (index === -1) return OMapping(null, null, null, null);
|
|
480
|
+
const segment = segments[index];
|
|
481
|
+
if (segment.length === 1) return OMapping(null, null, null, null);
|
|
482
|
+
const { names, resolvedSources } = map;
|
|
483
|
+
return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
|
|
484
|
+
}
|
|
485
|
+
function OMapping(source, line, column, name) {
|
|
486
|
+
return {
|
|
487
|
+
source,
|
|
488
|
+
line,
|
|
489
|
+
column,
|
|
490
|
+
name
|
|
491
|
+
};
|
|
492
|
+
}
|
|
493
|
+
function traceSegmentInternal(segments, memo, line, column, bias) {
|
|
494
|
+
let index = memoizedBinarySearch(segments, column, memo, line);
|
|
495
|
+
if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
|
|
496
|
+
else if (bias === LEAST_UPPER_BOUND) index++;
|
|
497
|
+
if (index === -1 || index === segments.length) return -1;
|
|
498
|
+
return index;
|
|
499
|
+
}
|
|
500
|
+
const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
|
|
501
|
+
const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
|
|
502
|
+
const stackIgnorePatterns = [
|
|
503
|
+
"node:internal",
|
|
504
|
+
/\/packages\/\w+\/dist\//,
|
|
505
|
+
/\/@vitest\/\w+\/dist\//,
|
|
506
|
+
"/vitest/dist/",
|
|
507
|
+
"/vitest/src/",
|
|
508
|
+
"/packages/expect/src/",
|
|
509
|
+
"/packages/snapshot/src/",
|
|
510
|
+
"/node_modules/chai/",
|
|
511
|
+
"/node_modules/tinyspy/",
|
|
512
|
+
"/vite/dist/node/module-runner",
|
|
513
|
+
"/rolldown-vite/dist/node/module-runner",
|
|
514
|
+
"/deps/chunk-",
|
|
515
|
+
"/deps/@vitest",
|
|
516
|
+
"/deps/loupe",
|
|
517
|
+
"/deps/chai",
|
|
518
|
+
"/browser-playwright/dist/locators.js",
|
|
519
|
+
"/browser-webdriverio/dist/locators.js",
|
|
520
|
+
"/browser-preview/dist/locators.js",
|
|
521
|
+
/node:\w+/,
|
|
522
|
+
/__vitest_test__/,
|
|
523
|
+
/__vitest_browser__/,
|
|
524
|
+
"/@id/__x00__vitest/browser",
|
|
525
|
+
/\/deps\/vitest_/,
|
|
526
|
+
"/deps/vitest.js"
|
|
527
|
+
];
|
|
528
|
+
const NOW_LENGTH = Date.now().toString().length;
|
|
529
|
+
const REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`);
|
|
530
|
+
function extractLocation(urlLike) {
|
|
531
|
+
if (!urlLike.includes(":")) return [urlLike];
|
|
532
|
+
const parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(urlLike.replace(/^\(|\)$/g, ""));
|
|
533
|
+
if (!parts) return [urlLike];
|
|
534
|
+
let url = parts[1];
|
|
535
|
+
if (url.startsWith("async ")) url = url.slice(6);
|
|
536
|
+
if (url.startsWith("http:") || url.startsWith("https:")) {
|
|
537
|
+
const urlObj = new URL(url);
|
|
538
|
+
urlObj.searchParams.delete("import");
|
|
539
|
+
urlObj.searchParams.delete("browserv");
|
|
540
|
+
url = tryDecode(urlObj.pathname, decodeURI) + urlObj.hash + urlObj.search;
|
|
541
|
+
}
|
|
542
|
+
if (url.startsWith("/@fs/")) {
|
|
543
|
+
const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
|
|
544
|
+
url = url.slice(isWindows ? 5 : 4);
|
|
545
|
+
}
|
|
546
|
+
if (url.includes("vitest=")) url = url.replace(REGEXP_VITEST, "").replace(/[?&]$/, "");
|
|
547
|
+
return [
|
|
548
|
+
url,
|
|
549
|
+
parts[2] || void 0,
|
|
550
|
+
parts[3] || void 0
|
|
551
|
+
];
|
|
552
|
+
}
|
|
553
|
+
function tryDecode(value, decode) {
|
|
554
|
+
try {
|
|
555
|
+
return decode(value);
|
|
556
|
+
} catch {
|
|
557
|
+
return value;
|
|
558
|
+
}
|
|
559
|
+
}
|
|
560
|
+
function parseSingleFFOrSafariStack(raw) {
|
|
561
|
+
let line = raw.trim();
|
|
562
|
+
if (SAFARI_NATIVE_CODE_REGEXP.test(line)) return null;
|
|
563
|
+
if (line.includes(" > eval")) line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
|
|
564
|
+
if (!line.includes("@")) return null;
|
|
565
|
+
let atIndex = -1;
|
|
566
|
+
let locationPart = "";
|
|
567
|
+
let functionName;
|
|
568
|
+
for (let i = 0; i < line.length; i++) if (line[i] === "@") {
|
|
569
|
+
const candidateLocation = line.slice(i + 1);
|
|
570
|
+
if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
|
|
571
|
+
atIndex = i;
|
|
572
|
+
locationPart = candidateLocation;
|
|
573
|
+
functionName = i > 0 ? line.slice(0, i) : void 0;
|
|
574
|
+
break;
|
|
575
|
+
}
|
|
576
|
+
}
|
|
577
|
+
if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) return null;
|
|
578
|
+
const [url, lineNumber, columnNumber] = extractLocation(locationPart);
|
|
579
|
+
if (!url || !lineNumber || !columnNumber) return null;
|
|
580
|
+
return {
|
|
581
|
+
file: url,
|
|
582
|
+
method: functionName || "",
|
|
583
|
+
line: Number.parseInt(lineNumber),
|
|
584
|
+
column: Number.parseInt(columnNumber)
|
|
585
|
+
};
|
|
586
|
+
}
|
|
587
|
+
function parseSingleV8Stack(raw) {
|
|
588
|
+
let line = raw.trim();
|
|
589
|
+
if (!CHROME_IE_STACK_REGEXP.test(line)) return null;
|
|
590
|
+
if (line.includes("(eval ")) line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
|
|
591
|
+
let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
|
|
592
|
+
const location = sanitizedLine.match(/ (\(.+\)$)/);
|
|
593
|
+
sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
|
|
594
|
+
const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
|
|
595
|
+
let method = location && sanitizedLine || "";
|
|
596
|
+
let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
|
|
597
|
+
if (!file || !lineNumber || !columnNumber) return null;
|
|
598
|
+
if (method.startsWith("async ")) method = method.slice(6);
|
|
599
|
+
if (file.startsWith("file://")) file = tryDecode(file.slice(7), decodeURIComponent);
|
|
600
|
+
file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
|
|
601
|
+
if (method) method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
|
|
602
|
+
return {
|
|
603
|
+
method,
|
|
604
|
+
file,
|
|
605
|
+
line: Number.parseInt(lineNumber),
|
|
606
|
+
column: Number.parseInt(columnNumber)
|
|
607
|
+
};
|
|
608
|
+
}
|
|
609
|
+
function parseStacktrace(stack, options = {}) {
|
|
610
|
+
const { ignoreStackEntries = stackIgnorePatterns } = options;
|
|
611
|
+
let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
|
|
612
|
+
const helperIndex = stacks.findLastIndex((s) => s.method.includes("__VITEST_HELPER__"));
|
|
613
|
+
if (helperIndex >= 0) stacks = stacks.slice(helperIndex + 1);
|
|
614
|
+
if (options.firstOnly) {
|
|
615
|
+
for (const stack of stacks) {
|
|
616
|
+
const mapped = mapStackFrame(stack, options, ignoreStackEntries);
|
|
617
|
+
if (mapped) return [mapped];
|
|
618
|
+
}
|
|
619
|
+
return [];
|
|
620
|
+
}
|
|
621
|
+
return stacks.map((stack) => mapStackFrame(stack, options, ignoreStackEntries)).filter((s) => s != null);
|
|
622
|
+
}
|
|
623
|
+
function mapStackFrame(stack, options, ignoreStackEntries) {
|
|
624
|
+
if (options.getUrlId) stack.file = options.getUrlId(stack.file);
|
|
625
|
+
const map = options.getSourceMap?.(stack.file);
|
|
626
|
+
if (!map || typeof map !== "object" || !map.version) return shouldFilter(ignoreStackEntries, stack.file) ? null : stack;
|
|
627
|
+
const traceMap = new DecodedMap(map, stack.file);
|
|
628
|
+
if (stack.line <= 0 || stack.column <= 0) return stack;
|
|
629
|
+
const position = getOriginalPosition(traceMap, {
|
|
630
|
+
line: stack.line,
|
|
631
|
+
column: stack.column - 1
|
|
632
|
+
});
|
|
633
|
+
if (!position) return stack;
|
|
634
|
+
const { line, column, source, name } = position;
|
|
635
|
+
let file = source || stack.file;
|
|
636
|
+
if (/\/\w:\//.test(file)) file = file.slice(1);
|
|
637
|
+
if (shouldFilter(ignoreStackEntries, file)) return null;
|
|
638
|
+
if (line != null && column != null) return {
|
|
639
|
+
line,
|
|
640
|
+
column: column + 1,
|
|
641
|
+
file,
|
|
642
|
+
method: name || stack.method
|
|
643
|
+
};
|
|
644
|
+
return stack;
|
|
645
|
+
}
|
|
646
|
+
function shouldFilter(ignoreStackEntries, file) {
|
|
647
|
+
return ignoreStackEntries.some((p) => file.match(p));
|
|
648
|
+
}
|
|
649
|
+
function parseFFOrSafariStackTrace(stack) {
|
|
650
|
+
return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
|
|
651
|
+
}
|
|
652
|
+
function parseV8Stacktrace(stack) {
|
|
653
|
+
return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
|
|
654
|
+
}
|
|
655
|
+
var DecodedMap = class {
|
|
656
|
+
map;
|
|
657
|
+
_encoded;
|
|
658
|
+
_decoded;
|
|
659
|
+
_decodedMemo;
|
|
660
|
+
url;
|
|
661
|
+
version;
|
|
662
|
+
names = [];
|
|
663
|
+
resolvedSources;
|
|
664
|
+
constructor(map, from) {
|
|
665
|
+
this.map = map;
|
|
666
|
+
const { mappings, names, sources } = map;
|
|
667
|
+
this.version = map.version;
|
|
668
|
+
this.names = names || [];
|
|
669
|
+
this._encoded = mappings || "";
|
|
670
|
+
this._decodedMemo = memoizedState();
|
|
671
|
+
this.url = from;
|
|
672
|
+
this.resolvedSources = (sources || []).map((s) => resolve(from, "..", s || ""));
|
|
673
|
+
}
|
|
674
|
+
};
|
|
675
|
+
function memoizedState() {
|
|
676
|
+
return {
|
|
677
|
+
lastKey: -1,
|
|
678
|
+
lastNeedle: -1,
|
|
679
|
+
lastIndex: -1
|
|
680
|
+
};
|
|
681
|
+
}
|
|
682
|
+
function getOriginalPosition(map, needle) {
|
|
683
|
+
const result = originalPositionFor(map, needle);
|
|
684
|
+
if (result.column == null) return null;
|
|
685
|
+
return result;
|
|
686
|
+
}
|
|
687
|
+
export { DecodedMap as D, getSafeTimers as a, getOriginalPosition as g, stackIgnorePatterns as k, originalPositionFor as o, parseStacktrace as p };
|