@vinena/knobs 0.5.3 → 0.6.0
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/CHANGELOG.md +27 -0
- package/README.md +7 -6
- package/dist/context-amfyasb5.js +23 -0
- package/dist/context-svtr7vwt.js +22 -0
- package/dist/early.global.js +5 -5
- package/dist/edit/css.d.ts +59 -0
- package/dist/edit/html.d.ts +91 -0
- package/dist/edit/keep.d.ts +175 -0
- package/dist/edit/log.d.ts +107 -0
- package/dist/edit/replay.d.ts +28 -0
- package/dist/edit/risk.d.ts +33 -0
- package/dist/edit/rule.d.ts +31 -0
- package/dist/edit/source.d.ts +12 -0
- package/dist/edit/text.d.ts +66 -0
- package/dist/elementsview-fyc06wjt.js +3702 -0
- package/dist/elementsview-k6zvvcne.js +3701 -0
- package/dist/engine/dock.d.ts +3 -4
- package/dist/engine/frame.d.ts +1 -1
- package/dist/engine/style.d.ts +15 -0
- package/dist/{framekit-cjz0e4y8.js → framekit-622h6w1f.js} +54 -47
- package/dist/{framekit-yk1jxjv7.js → framekit-yx612r28.js} +54 -47
- package/dist/index-0zp9py56.js +859 -0
- package/dist/{index-prjpx67p.js → index-1mstjadm.js} +126 -2167
- package/dist/{index-begsqdm0.js → index-4a4x1bt2.js} +1 -1
- package/dist/index-58jdczmj.js +44 -0
- package/dist/index-5tv6sr74.js +23 -0
- package/dist/index-6bc2ztfd.js +688 -0
- package/dist/index-7cb4x1vj.js +1885 -0
- package/dist/index-a974q3aa.js +34 -0
- package/dist/{index-q73py563.js → index-aymfvd8s.js} +1 -1
- package/dist/{index-zt3rheck.js → index-aynkv7qk.js} +11 -8
- package/dist/{index-p57fdttx.js → index-dzm8ywq0.js} +492 -2365
- package/dist/{index-9jhatmky.js → index-f60yax1j.js} +13 -8
- package/dist/index-f67wctn3.js +1858 -0
- package/dist/{index-vgfn2n1h.js → index-ftjdt358.js} +8 -171
- package/dist/{index-j1h13ahg.js → index-gm51cthv.js} +2 -45
- package/dist/index-kfdzsyyw.js +1859 -0
- package/dist/index-t4kssacm.js +208 -0
- package/dist/index-v0ht9q0g.js +1518 -0
- package/dist/{index-6wbgqkdz.js → index-x59vz1xx.js} +247 -905
- package/dist/index-xh39jtkq.js +32 -0
- package/dist/index-yb7fc59g.js +718 -0
- package/dist/index-zd6adby9.js +496 -0
- package/dist/index.d.ts +62 -0
- package/dist/index.global.js +410 -152
- package/dist/index.js +504 -482
- package/dist/react-0wepdf60.js +1519 -0
- package/dist/{react-gefkdkdz.js → react-1gqwa2yw.js} +1 -1
- package/dist/{index-sn2y6j09.js → react-3mfz1x2a.js} +126 -2167
- package/dist/react-4rbjw9af.js +33 -0
- package/dist/react-5rq7bnsy.js +210 -0
- package/dist/react-6bz05qk1.js +860 -0
- package/dist/{react-qgz9afa2.js → react-6fnxxs30.js} +8 -171
- package/dist/react-6q2cw2ya.js +689 -0
- package/dist/{react-7vjfsh40.js → react-6t4dbdzn.js} +11 -8
- package/dist/react-88es9b5q.js +719 -0
- package/dist/react-97b5b8j4.js +46 -0
- package/dist/{react-mmq2zya3.js → react-bxzn8vq5.js} +1 -1
- package/dist/{react-3rhdj2k1.js → react-cs62p9qh.js} +62 -720
- package/dist/react-ethftdxp.js +497 -0
- package/dist/react-fp73vhyd.js +36 -0
- package/dist/{react-qfpg79hs.js → react-me102s1a.js} +2 -45
- package/dist/react-t2qnewz2.js +24 -0
- package/dist/react-ttj8f9qp.js +1886 -0
- package/dist/{react-806qmkyz.js → react-v8497a41.js} +13 -8
- package/dist/{react-6tss0r9f.js → react-wqn4sx0n.js} +265 -2137
- package/dist/react.js +500 -482
- package/dist/replay-j18rw92k.js +258 -0
- package/dist/replay-vtg0vqj2.js +257 -0
- package/dist/{storageview-7cv0vpdm.js → storageview-6xj7zb63.js} +11 -7
- package/dist/{storageview-dyhpgt8f.js → storageview-pzn8yaad.js} +11 -7
- package/dist/styles/force.d.ts +66 -0
- package/dist/ui/bindings.d.ts +31 -5
- package/dist/ui/changes.d.ts +49 -0
- package/dist/ui/cssauto.d.ts +119 -0
- package/dist/ui/cssedit.d.ts +80 -0
- package/dist/ui/domedit.d.ts +99 -0
- package/dist/ui/domtree.d.ts +26 -1
- package/dist/ui/elementsview.d.ts +19 -2
- package/dist/ui/htmledit.d.ts +62 -0
- package/dist/ui/inspector.d.ts +6 -1
- package/dist/ui/keys.d.ts +12 -8
- package/dist/ui/pane.d.ts +0 -2
- package/dist/ui/panel.d.ts +3 -0
- package/dist/ui/prefs.d.ts +30 -10
- package/dist/ui/settings.d.ts +2 -0
- package/dist/ui/size.d.ts +14 -22
- package/dist/ui/stylesview.d.ts +30 -1
- package/package.json +1 -1
- package/skills/devknobs/SKILL.md +95 -0
- package/dist/elementsview-1wsxcdtj.js +0 -2874
- package/dist/elementsview-3kv34jfx.js +0 -2873
- package/dist/index-78r0f8pw.js +0 -27
- package/dist/react-adky72h9.js +0 -29
|
@@ -0,0 +1,860 @@
|
|
|
1
|
+
"use client";
|
|
2
|
+
import {
|
|
3
|
+
newer,
|
|
4
|
+
realNow,
|
|
5
|
+
stamped,
|
|
6
|
+
webStorage
|
|
7
|
+
} from "./react-wqn4sx0n.js";
|
|
8
|
+
import {
|
|
9
|
+
__require
|
|
10
|
+
} from "./react-t2qnewz2.js";
|
|
11
|
+
|
|
12
|
+
// src/edit/log.ts
|
|
13
|
+
function copy(edit) {
|
|
14
|
+
const target = { ...edit.target };
|
|
15
|
+
const rule = edit.target.rule;
|
|
16
|
+
if (rule)
|
|
17
|
+
target.rule = { ...rule, path: [...rule.path], context: [...rule.context] };
|
|
18
|
+
const copied = { ...edit, target };
|
|
19
|
+
if (edit.from)
|
|
20
|
+
copied.from = { ...edit.from };
|
|
21
|
+
if (edit.to)
|
|
22
|
+
copied.to = { ...edit.to };
|
|
23
|
+
return copied;
|
|
24
|
+
}
|
|
25
|
+
function gone(change) {
|
|
26
|
+
return { edit: change.edit, apply: () => false, revert: () => {
|
|
27
|
+
return;
|
|
28
|
+
}, view: null };
|
|
29
|
+
}
|
|
30
|
+
function createEditLog() {
|
|
31
|
+
const done = [];
|
|
32
|
+
const undone = [];
|
|
33
|
+
const listeners = new Set;
|
|
34
|
+
let ids = 0;
|
|
35
|
+
const watched = new WeakSet;
|
|
36
|
+
function leave(view) {
|
|
37
|
+
for (const one of [...done, ...undone])
|
|
38
|
+
if (one.change.view === view)
|
|
39
|
+
one.change = gone(one.change);
|
|
40
|
+
}
|
|
41
|
+
function watch(view) {
|
|
42
|
+
if (!view || watched.has(view))
|
|
43
|
+
return;
|
|
44
|
+
watched.add(view);
|
|
45
|
+
try {
|
|
46
|
+
const onHide = (event) => {
|
|
47
|
+
if (Reflect.get(event, "persisted") === true)
|
|
48
|
+
return;
|
|
49
|
+
view.removeEventListener("pagehide", onHide);
|
|
50
|
+
watched.delete(view);
|
|
51
|
+
leave(view);
|
|
52
|
+
};
|
|
53
|
+
view.addEventListener("pagehide", onHide);
|
|
54
|
+
} catch {}
|
|
55
|
+
}
|
|
56
|
+
function tell() {
|
|
57
|
+
for (const listener of Array.from(listeners))
|
|
58
|
+
listener();
|
|
59
|
+
}
|
|
60
|
+
function revert(one) {
|
|
61
|
+
try {
|
|
62
|
+
one.change.revert();
|
|
63
|
+
} catch {}
|
|
64
|
+
}
|
|
65
|
+
function apply(one) {
|
|
66
|
+
try {
|
|
67
|
+
return one.change.apply();
|
|
68
|
+
} catch {
|
|
69
|
+
return false;
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
return {
|
|
73
|
+
record(change) {
|
|
74
|
+
const one = { edit: { id: ++ids, ...change.edit }, change, view: change.view ?? null };
|
|
75
|
+
if (!apply(one))
|
|
76
|
+
return null;
|
|
77
|
+
watch(change.view);
|
|
78
|
+
done.push(one);
|
|
79
|
+
undone.length = 0;
|
|
80
|
+
tell();
|
|
81
|
+
return copy(one.edit);
|
|
82
|
+
},
|
|
83
|
+
undo() {
|
|
84
|
+
const one = done.pop();
|
|
85
|
+
if (!one)
|
|
86
|
+
return null;
|
|
87
|
+
revert(one);
|
|
88
|
+
undone.push(one);
|
|
89
|
+
tell();
|
|
90
|
+
return copy(one.edit);
|
|
91
|
+
},
|
|
92
|
+
redo() {
|
|
93
|
+
const one = undone.pop();
|
|
94
|
+
if (!one)
|
|
95
|
+
return null;
|
|
96
|
+
const took = apply(one);
|
|
97
|
+
if (took)
|
|
98
|
+
done.push(one);
|
|
99
|
+
tell();
|
|
100
|
+
return took ? copy(one.edit) : null;
|
|
101
|
+
},
|
|
102
|
+
undoAll() {
|
|
103
|
+
const count = done.length;
|
|
104
|
+
if (count === 0 && undone.length === 0)
|
|
105
|
+
return 0;
|
|
106
|
+
for (let one = done.pop();one; one = done.pop())
|
|
107
|
+
revert(one);
|
|
108
|
+
undone.length = 0;
|
|
109
|
+
tell();
|
|
110
|
+
return count;
|
|
111
|
+
},
|
|
112
|
+
list: () => done.map((one) => copy(one.edit)),
|
|
113
|
+
recorded: () => done,
|
|
114
|
+
locate(id, patch) {
|
|
115
|
+
const one = [...done, ...undone].find((each) => each.edit.id === id);
|
|
116
|
+
if (!one)
|
|
117
|
+
return;
|
|
118
|
+
one.edit.target = { ...one.edit.target, ...patch };
|
|
119
|
+
tell();
|
|
120
|
+
},
|
|
121
|
+
subscribe(listener) {
|
|
122
|
+
listeners.add(listener);
|
|
123
|
+
return () => listeners.delete(listener);
|
|
124
|
+
}
|
|
125
|
+
};
|
|
126
|
+
}
|
|
127
|
+
var edits = createEditLog();
|
|
128
|
+
|
|
129
|
+
// src/edit/risk.ts
|
|
130
|
+
var RISK = "could run a script";
|
|
131
|
+
var TAGS = new Set(["script", "iframe", "frame", "object", "embed", "base", "meta", "link"]);
|
|
132
|
+
var URL_ATTRIBUTES = new Set(["href", "src", "action", "formaction", "xlink:href", "values", "to", "from", "by"]);
|
|
133
|
+
var LISTS = new Set(["values"]);
|
|
134
|
+
function scriptUrl(value) {
|
|
135
|
+
return value.replace(/[\u0000- \u007f]/g, "").toLowerCase().startsWith("javascript:");
|
|
136
|
+
}
|
|
137
|
+
function riskyAttribute(name, value) {
|
|
138
|
+
const lower = name.trim().toLowerCase();
|
|
139
|
+
if (lower.startsWith("on") || lower === "srcdoc")
|
|
140
|
+
return true;
|
|
141
|
+
if (value === null || !URL_ATTRIBUTES.has(lower))
|
|
142
|
+
return false;
|
|
143
|
+
return (LISTS.has(lower) ? value.split(";") : [value]).some(scriptUrl);
|
|
144
|
+
}
|
|
145
|
+
function riskyElement(element) {
|
|
146
|
+
return TAGS.has(element.localName.toLowerCase());
|
|
147
|
+
}
|
|
148
|
+
function isElement(node) {
|
|
149
|
+
return node.nodeType === 1;
|
|
150
|
+
}
|
|
151
|
+
function isNodeList(value) {
|
|
152
|
+
return typeof value === "object" && value !== null && typeof Reflect.get(value, "length") === "number";
|
|
153
|
+
}
|
|
154
|
+
function templateContent(element) {
|
|
155
|
+
const content = element.localName === "template" ? Reflect.get(element, "content") : null;
|
|
156
|
+
const nodes = typeof content === "object" && content !== null ? Reflect.get(content, "childNodes") : null;
|
|
157
|
+
return isNodeList(nodes) ? Array.from(nodes) : [];
|
|
158
|
+
}
|
|
159
|
+
function riskyNodes(nodes) {
|
|
160
|
+
for (const node of nodes) {
|
|
161
|
+
if (!isElement(node))
|
|
162
|
+
continue;
|
|
163
|
+
for (const one of [node, ...Array.from(node.querySelectorAll("*"))]) {
|
|
164
|
+
if (riskyElement(one))
|
|
165
|
+
return true;
|
|
166
|
+
if (Array.from(one.attributes).some((attr) => riskyAttribute(attr.name, attr.value)))
|
|
167
|
+
return true;
|
|
168
|
+
if (riskyNodes(templateContent(one)))
|
|
169
|
+
return true;
|
|
170
|
+
}
|
|
171
|
+
}
|
|
172
|
+
return false;
|
|
173
|
+
}
|
|
174
|
+
function riskyEdit(edit) {
|
|
175
|
+
if (edit.kind === "attr")
|
|
176
|
+
return riskyAttribute(edit.property, edit.after);
|
|
177
|
+
if (edit.kind !== "html" || edit.after === null)
|
|
178
|
+
return false;
|
|
179
|
+
const markup = edit.after;
|
|
180
|
+
return /<\s*(script|iframe|frame|object|embed|base|meta|link)\b/i.test(markup) || /[\s"'/]on[a-z]+\s*=/i.test(markup) || /srcdoc/i.test(markup) || /javascript\s*:/i.test(markup.replace(/[\u0000- \u007f]/g, "")) || /&#|:|&tab;|&newline;/i.test(markup);
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
// src/edit/keep.ts
|
|
184
|
+
var EDITS_KEY = "devknobs:edits:";
|
|
185
|
+
var EDITS_VERSION = 1;
|
|
186
|
+
var MAX_EDITS = 200;
|
|
187
|
+
var MAX_BYTES = 256 * 1024;
|
|
188
|
+
var MAX_PAGES = 20;
|
|
189
|
+
var FIELD_MAX = 64 * 1024;
|
|
190
|
+
var KINDS = ["css-value", "css-toggle", "css-add", "css-rule", "text", "attr", "html", "hide", "delete", "move"];
|
|
191
|
+
var REASONS = {
|
|
192
|
+
invalid: "not an edit devknobs reads",
|
|
193
|
+
missing: "not found on the page",
|
|
194
|
+
rule: "its rule is not on the page",
|
|
195
|
+
changed: "the page has another value now",
|
|
196
|
+
refused: "the page did not take it"
|
|
197
|
+
};
|
|
198
|
+
function isFields(value) {
|
|
199
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
200
|
+
}
|
|
201
|
+
function text(value, max = FIELD_MAX) {
|
|
202
|
+
return typeof value === "string" && value.length <= max;
|
|
203
|
+
}
|
|
204
|
+
function textOrNull(value) {
|
|
205
|
+
return value === null || text(value);
|
|
206
|
+
}
|
|
207
|
+
function readPlace(value) {
|
|
208
|
+
if (!isFields(value) || !text(value.parent) || value.parent === "" || !(value.next === null || text(value.next) && value.next !== ""))
|
|
209
|
+
return null;
|
|
210
|
+
return { parent: value.parent, next: value.next };
|
|
211
|
+
}
|
|
212
|
+
function readRule(value) {
|
|
213
|
+
if (!isFields(value))
|
|
214
|
+
return null;
|
|
215
|
+
const { selectorText, sheet, owner, sheetId, path, context } = value;
|
|
216
|
+
if (!text(selectorText) || !text(sheet) || !textOrNull(owner))
|
|
217
|
+
return null;
|
|
218
|
+
if (typeof sheetId !== "number" || !Number.isSafeInteger(sheetId))
|
|
219
|
+
return null;
|
|
220
|
+
if (!Array.isArray(path) || path.length > 64 || !path.every((step) => typeof step === "number" && Number.isSafeInteger(step) && step >= 0))
|
|
221
|
+
return null;
|
|
222
|
+
if (!Array.isArray(context) || context.length > 64 || !context.every((one) => text(one)))
|
|
223
|
+
return null;
|
|
224
|
+
return { selectorText, sheet, owner, sheetId, path: path.map(Number), context: context.map(String) };
|
|
225
|
+
}
|
|
226
|
+
function readSavedEdit(value) {
|
|
227
|
+
if (!isFields(value))
|
|
228
|
+
return null;
|
|
229
|
+
const kind = KINDS.find((one) => one === value.kind);
|
|
230
|
+
const target = value.target;
|
|
231
|
+
if (!kind || !isFields(target) || !text(target.selector) || target.selector === "")
|
|
232
|
+
return null;
|
|
233
|
+
if (!text(value.property) || !textOrNull(value.before) || !textOrNull(value.after))
|
|
234
|
+
return null;
|
|
235
|
+
const read = { kind, target: { selector: target.selector }, property: value.property, before: value.before, after: value.after };
|
|
236
|
+
if (target.source !== undefined) {
|
|
237
|
+
if (!text(target.source))
|
|
238
|
+
return null;
|
|
239
|
+
read.target.source = target.source;
|
|
240
|
+
}
|
|
241
|
+
if (target.rule !== undefined) {
|
|
242
|
+
const rule = readRule(target.rule);
|
|
243
|
+
if (!rule)
|
|
244
|
+
return null;
|
|
245
|
+
read.target.rule = rule;
|
|
246
|
+
}
|
|
247
|
+
if (kind === "move") {
|
|
248
|
+
const from = readPlace(value.from);
|
|
249
|
+
const to = readPlace(value.to);
|
|
250
|
+
if (!from || !to)
|
|
251
|
+
return null;
|
|
252
|
+
read.from = from;
|
|
253
|
+
read.to = to;
|
|
254
|
+
}
|
|
255
|
+
return read;
|
|
256
|
+
}
|
|
257
|
+
function readKept(value) {
|
|
258
|
+
if (!isFields(value) || newer(value, EDITS_VERSION) || !Array.isArray(value.edits) || value.edits.length > MAX_EDITS)
|
|
259
|
+
return null;
|
|
260
|
+
if (JSON.stringify(value.edits).length > MAX_BYTES)
|
|
261
|
+
return null;
|
|
262
|
+
const list = [];
|
|
263
|
+
for (const one of value.edits) {
|
|
264
|
+
const read = readSavedEdit(one);
|
|
265
|
+
if (!read || riskyEdit(read))
|
|
266
|
+
return null;
|
|
267
|
+
list.push(read);
|
|
268
|
+
}
|
|
269
|
+
return { v: EDITS_VERSION, edits: list };
|
|
270
|
+
}
|
|
271
|
+
function toKept(list) {
|
|
272
|
+
const kept = [];
|
|
273
|
+
let size = 1;
|
|
274
|
+
for (const edit of list) {
|
|
275
|
+
const { id: _id, ...saved } = edit;
|
|
276
|
+
size += JSON.stringify(saved).length + 1;
|
|
277
|
+
if (kept.length >= MAX_EDITS || size > MAX_BYTES || !readSavedEdit(saved) || riskyEdit(saved))
|
|
278
|
+
break;
|
|
279
|
+
kept.push(saved);
|
|
280
|
+
}
|
|
281
|
+
return { kept: stamped({ edits: kept }, EDITS_VERSION), cut: list.length - kept.length };
|
|
282
|
+
}
|
|
283
|
+
function writtenAt(text2) {
|
|
284
|
+
try {
|
|
285
|
+
const at = text2 ? Reflect.get(Object(JSON.parse(text2)), "at") : 0;
|
|
286
|
+
return typeof at === "number" ? at : 0;
|
|
287
|
+
} catch {
|
|
288
|
+
return 0;
|
|
289
|
+
}
|
|
290
|
+
}
|
|
291
|
+
function otherPages(storage, kept) {
|
|
292
|
+
const pages = [];
|
|
293
|
+
for (let index = 0;index < storage.length; index++) {
|
|
294
|
+
const key = storage.key(index);
|
|
295
|
+
if (key?.startsWith(EDITS_KEY) && key !== kept)
|
|
296
|
+
pages.push({ key, at: writtenAt(storage.getItem(key)) });
|
|
297
|
+
}
|
|
298
|
+
return pages.sort((a, b) => b.at - a.at).map((page) => page.key);
|
|
299
|
+
}
|
|
300
|
+
function evict(storage, kept) {
|
|
301
|
+
for (const key of otherPages(storage, kept).slice(MAX_PAGES - 1))
|
|
302
|
+
storage.removeItem(key);
|
|
303
|
+
}
|
|
304
|
+
function write(storage, key, text2) {
|
|
305
|
+
let older = null;
|
|
306
|
+
for (;; ) {
|
|
307
|
+
try {
|
|
308
|
+
storage.setItem(key, text2);
|
|
309
|
+
return;
|
|
310
|
+
} catch (error) {
|
|
311
|
+
older ??= otherPages(storage, key);
|
|
312
|
+
const oldest = older.pop();
|
|
313
|
+
if (!oldest)
|
|
314
|
+
throw error;
|
|
315
|
+
storage.removeItem(oldest);
|
|
316
|
+
}
|
|
317
|
+
}
|
|
318
|
+
}
|
|
319
|
+
function pathNow() {
|
|
320
|
+
try {
|
|
321
|
+
return window.location?.pathname ?? "/";
|
|
322
|
+
} catch {
|
|
323
|
+
return "/";
|
|
324
|
+
}
|
|
325
|
+
}
|
|
326
|
+
function localEditsStore(path = pathNow()) {
|
|
327
|
+
const pageKey = () => `${EDITS_KEY}${path}`;
|
|
328
|
+
return {
|
|
329
|
+
load() {
|
|
330
|
+
try {
|
|
331
|
+
const kept = webStorage("local")?.getItem(pageKey());
|
|
332
|
+
return kept ? JSON.parse(kept) : null;
|
|
333
|
+
} catch {
|
|
334
|
+
return null;
|
|
335
|
+
}
|
|
336
|
+
},
|
|
337
|
+
save(kept) {
|
|
338
|
+
const storage = webStorage("local");
|
|
339
|
+
if (!storage)
|
|
340
|
+
return;
|
|
341
|
+
try {
|
|
342
|
+
if (kept === null)
|
|
343
|
+
storage.removeItem(pageKey());
|
|
344
|
+
else {
|
|
345
|
+
write(storage, pageKey(), JSON.stringify({ ...kept, at: realNow() }));
|
|
346
|
+
evict(storage, pageKey());
|
|
347
|
+
}
|
|
348
|
+
} catch {}
|
|
349
|
+
},
|
|
350
|
+
subscribe(listener) {
|
|
351
|
+
const onStorage = (event) => {
|
|
352
|
+
if (event.key === null || event.key === pageKey())
|
|
353
|
+
listener();
|
|
354
|
+
};
|
|
355
|
+
window.addEventListener("storage", onStorage);
|
|
356
|
+
return () => window.removeEventListener("storage", onStorage);
|
|
357
|
+
}
|
|
358
|
+
};
|
|
359
|
+
}
|
|
360
|
+
var REPLAYED = Symbol.for("devknobs.edits.replayed");
|
|
361
|
+
var QUIET = 300;
|
|
362
|
+
var SETTLE_MAX = 3000;
|
|
363
|
+
function framedPage(view, inner, path, framed) {
|
|
364
|
+
if (!inner || !framed)
|
|
365
|
+
return null;
|
|
366
|
+
try {
|
|
367
|
+
return inner.location.origin === view.location.origin && inner.location.pathname === path ? inner : null;
|
|
368
|
+
} catch {
|
|
369
|
+
return null;
|
|
370
|
+
}
|
|
371
|
+
}
|
|
372
|
+
async function pageSettled(view, framing, frame, longest = SETTLE_MAX, settle = settled) {
|
|
373
|
+
await settle(view);
|
|
374
|
+
const until = realNow() + longest;
|
|
375
|
+
for (;; ) {
|
|
376
|
+
if (!framing())
|
|
377
|
+
return;
|
|
378
|
+
const inner = frame();
|
|
379
|
+
if (inner)
|
|
380
|
+
return settle(inner);
|
|
381
|
+
if (realNow() > until)
|
|
382
|
+
return;
|
|
383
|
+
await new Promise((resolve) => view.setTimeout(resolve, 50));
|
|
384
|
+
}
|
|
385
|
+
}
|
|
386
|
+
function settled(view, quiet = QUIET, longest = SETTLE_MAX) {
|
|
387
|
+
return new Promise((resolve) => {
|
|
388
|
+
const watch = () => {
|
|
389
|
+
let timer = 0;
|
|
390
|
+
const done = () => {
|
|
391
|
+
observer?.disconnect();
|
|
392
|
+
view.clearTimeout(timer);
|
|
393
|
+
view.clearTimeout(limit);
|
|
394
|
+
resolve();
|
|
395
|
+
};
|
|
396
|
+
const observer = typeof MutationObserver === "function" ? new MutationObserver(() => {
|
|
397
|
+
view.clearTimeout(timer);
|
|
398
|
+
timer = view.setTimeout(done, quiet);
|
|
399
|
+
}) : null;
|
|
400
|
+
observer?.observe(view.document.documentElement, { childList: true, subtree: true });
|
|
401
|
+
timer = view.setTimeout(done, quiet);
|
|
402
|
+
const limit = view.setTimeout(done, longest);
|
|
403
|
+
};
|
|
404
|
+
if (view.document.readyState === "complete")
|
|
405
|
+
watch();
|
|
406
|
+
else
|
|
407
|
+
view.addEventListener("load", watch, { once: true });
|
|
408
|
+
});
|
|
409
|
+
}
|
|
410
|
+
function createKeeper(options) {
|
|
411
|
+
const { log, store, view } = options;
|
|
412
|
+
const loadReplay = options.replay ?? (() => import("./replay-j18rw92k.js").then(({ replayEdits }) => replayEdits));
|
|
413
|
+
const wait = options.settled ?? (() => settled(view));
|
|
414
|
+
const frame = options.frame ?? (() => null);
|
|
415
|
+
const ours = new WeakMap;
|
|
416
|
+
const listeners = new Set;
|
|
417
|
+
let known = false;
|
|
418
|
+
let on = false;
|
|
419
|
+
let restored = null;
|
|
420
|
+
let waiting = [];
|
|
421
|
+
let run = null;
|
|
422
|
+
let kept = 0;
|
|
423
|
+
let cut = 0;
|
|
424
|
+
let pending = false;
|
|
425
|
+
let dirty = false;
|
|
426
|
+
let stopped = false;
|
|
427
|
+
let offs = 0;
|
|
428
|
+
function tell() {
|
|
429
|
+
for (const listener of Array.from(listeners))
|
|
430
|
+
listener();
|
|
431
|
+
}
|
|
432
|
+
function sort() {
|
|
433
|
+
for (const one of log.recorded()) {
|
|
434
|
+
if (ours.has(one))
|
|
435
|
+
continue;
|
|
436
|
+
ours.set(one, !one.view || one.view === view || one.view === frame());
|
|
437
|
+
}
|
|
438
|
+
}
|
|
439
|
+
function keepable() {
|
|
440
|
+
sort();
|
|
441
|
+
const recorded = log.recorded();
|
|
442
|
+
return log.list().filter((_edit, at) => {
|
|
443
|
+
const one = recorded[at];
|
|
444
|
+
return !one || ours.get(one) === true;
|
|
445
|
+
});
|
|
446
|
+
}
|
|
447
|
+
function shown() {
|
|
448
|
+
return (frame() ?? view).document;
|
|
449
|
+
}
|
|
450
|
+
function save() {
|
|
451
|
+
if (pending || waiting.length > 0) {
|
|
452
|
+
dirty = true;
|
|
453
|
+
return;
|
|
454
|
+
}
|
|
455
|
+
dirty = false;
|
|
456
|
+
const list = keepable();
|
|
457
|
+
const result = toKept(list);
|
|
458
|
+
kept = result.kept.edits.length;
|
|
459
|
+
cut = result.cut;
|
|
460
|
+
try {
|
|
461
|
+
store.save(result.kept);
|
|
462
|
+
} catch {}
|
|
463
|
+
}
|
|
464
|
+
function make(replay2, list, hold) {
|
|
465
|
+
let result;
|
|
466
|
+
const changed = dirty;
|
|
467
|
+
pending = true;
|
|
468
|
+
try {
|
|
469
|
+
result = replay2(log, list, hold, shown());
|
|
470
|
+
} finally {
|
|
471
|
+
pending = false;
|
|
472
|
+
dirty = changed;
|
|
473
|
+
}
|
|
474
|
+
waiting = result.waiting;
|
|
475
|
+
restored = { kept: (restored?.kept ?? 0) + result.applied.length, missed: [...restored?.missed ?? [], ...result.skipped] };
|
|
476
|
+
if (on && (dirty || !hold))
|
|
477
|
+
save();
|
|
478
|
+
tell();
|
|
479
|
+
}
|
|
480
|
+
async function replay(list) {
|
|
481
|
+
pending = true;
|
|
482
|
+
const turn = offs;
|
|
483
|
+
try {
|
|
484
|
+
await wait();
|
|
485
|
+
const loaded = await loadReplay();
|
|
486
|
+
if (stopped || turn !== offs) {
|
|
487
|
+
pending = false;
|
|
488
|
+
return;
|
|
489
|
+
}
|
|
490
|
+
Reflect.set(view, REPLAYED, true);
|
|
491
|
+
run = loaded;
|
|
492
|
+
make(loaded, list, true);
|
|
493
|
+
} catch {
|
|
494
|
+
pending = false;
|
|
495
|
+
if (dirty && on && !stopped)
|
|
496
|
+
save();
|
|
497
|
+
}
|
|
498
|
+
}
|
|
499
|
+
function heard() {
|
|
500
|
+
let value;
|
|
501
|
+
try {
|
|
502
|
+
value = store.load();
|
|
503
|
+
} catch {
|
|
504
|
+
value = null;
|
|
505
|
+
}
|
|
506
|
+
if (value === undefined)
|
|
507
|
+
return;
|
|
508
|
+
const read = readKept(value);
|
|
509
|
+
on = read !== null;
|
|
510
|
+
if (!known) {
|
|
511
|
+
known = true;
|
|
512
|
+
if (read && read.edits.length > 0 && Reflect.get(view, REPLAYED) !== true)
|
|
513
|
+
replay(read.edits);
|
|
514
|
+
}
|
|
515
|
+
if (!on) {
|
|
516
|
+
offs++;
|
|
517
|
+
restored = null;
|
|
518
|
+
waiting = [];
|
|
519
|
+
}
|
|
520
|
+
tell();
|
|
521
|
+
}
|
|
522
|
+
const stopStore = store.subscribe(heard);
|
|
523
|
+
const stopLog = log.subscribe(() => {
|
|
524
|
+
sort();
|
|
525
|
+
if (on && known)
|
|
526
|
+
save();
|
|
527
|
+
tell();
|
|
528
|
+
});
|
|
529
|
+
heard();
|
|
530
|
+
return {
|
|
531
|
+
known: () => known,
|
|
532
|
+
on: () => on,
|
|
533
|
+
set(next) {
|
|
534
|
+
if (!known)
|
|
535
|
+
return;
|
|
536
|
+
on = next;
|
|
537
|
+
if (next)
|
|
538
|
+
save();
|
|
539
|
+
else {
|
|
540
|
+
offs++;
|
|
541
|
+
pending = false;
|
|
542
|
+
restored = null;
|
|
543
|
+
waiting = [];
|
|
544
|
+
cut = 0;
|
|
545
|
+
try {
|
|
546
|
+
store.save(null);
|
|
547
|
+
} catch {}
|
|
548
|
+
}
|
|
549
|
+
tell();
|
|
550
|
+
},
|
|
551
|
+
restored: () => restored,
|
|
552
|
+
waiting: () => waiting,
|
|
553
|
+
applyWaiting() {
|
|
554
|
+
if (!on || !run || waiting.length === 0 || pending)
|
|
555
|
+
return;
|
|
556
|
+
make(run, waiting, false);
|
|
557
|
+
},
|
|
558
|
+
kept: () => on ? kept : 0,
|
|
559
|
+
cut: () => on ? cut : 0,
|
|
560
|
+
subscribe(listener) {
|
|
561
|
+
listeners.add(listener);
|
|
562
|
+
return () => listeners.delete(listener);
|
|
563
|
+
},
|
|
564
|
+
stop() {
|
|
565
|
+
stopped = true;
|
|
566
|
+
stopStore();
|
|
567
|
+
stopLog();
|
|
568
|
+
listeners.clear();
|
|
569
|
+
}
|
|
570
|
+
};
|
|
571
|
+
}
|
|
572
|
+
var running = null;
|
|
573
|
+
function startKeep(store = localEditsStore(), page = {}) {
|
|
574
|
+
running?.stop();
|
|
575
|
+
running = createKeeper({ log: edits, store, view: window, ...page });
|
|
576
|
+
return running;
|
|
577
|
+
}
|
|
578
|
+
function stopKeep() {
|
|
579
|
+
running?.stop();
|
|
580
|
+
running = null;
|
|
581
|
+
}
|
|
582
|
+
function forgetReplay() {
|
|
583
|
+
if (typeof window !== "undefined")
|
|
584
|
+
Reflect.deleteProperty(window, REPLAYED);
|
|
585
|
+
}
|
|
586
|
+
function keeper() {
|
|
587
|
+
return running;
|
|
588
|
+
}
|
|
589
|
+
|
|
590
|
+
// src/styles/selector.ts
|
|
591
|
+
var LEGACY = new Set(["before", "after", "first-line", "first-letter"]);
|
|
592
|
+
var HEAVIEST = new Set(["is", "not", "has", "matches", "-webkit-any", "-moz-any"]);
|
|
593
|
+
var HEX = /[0-9a-f]/i;
|
|
594
|
+
function isIdentChar(char) {
|
|
595
|
+
return /[\w-]/.test(char) || char > "";
|
|
596
|
+
}
|
|
597
|
+
function skipEscape(text2, at) {
|
|
598
|
+
let i = at + 1;
|
|
599
|
+
if (!HEX.test(text2[i] ?? ""))
|
|
600
|
+
return i + 1;
|
|
601
|
+
for (let count = 0;count < 6 && HEX.test(text2[i] ?? ""); count++)
|
|
602
|
+
i++;
|
|
603
|
+
return text2[i] === " " ? i + 1 : i;
|
|
604
|
+
}
|
|
605
|
+
function skipIdent(text2, at) {
|
|
606
|
+
let i = at;
|
|
607
|
+
while (i < text2.length) {
|
|
608
|
+
const char = text2[i] ?? "";
|
|
609
|
+
if (char === "\\")
|
|
610
|
+
i = skipEscape(text2, i);
|
|
611
|
+
else if (isIdentChar(char))
|
|
612
|
+
i++;
|
|
613
|
+
else
|
|
614
|
+
break;
|
|
615
|
+
}
|
|
616
|
+
return i;
|
|
617
|
+
}
|
|
618
|
+
function skipString(text2, at) {
|
|
619
|
+
const quote = text2[at];
|
|
620
|
+
let i = at + 1;
|
|
621
|
+
while (i < text2.length && text2[i] !== quote)
|
|
622
|
+
i += text2[i] === "\\" ? 2 : 1;
|
|
623
|
+
return i + 1;
|
|
624
|
+
}
|
|
625
|
+
function skipBlock(text2, at) {
|
|
626
|
+
let depth = 0;
|
|
627
|
+
let i = at;
|
|
628
|
+
while (i < text2.length) {
|
|
629
|
+
const char = text2[i];
|
|
630
|
+
if (char === "\\") {
|
|
631
|
+
i += 2;
|
|
632
|
+
continue;
|
|
633
|
+
}
|
|
634
|
+
if (char === '"' || char === "'") {
|
|
635
|
+
i = skipString(text2, i);
|
|
636
|
+
continue;
|
|
637
|
+
}
|
|
638
|
+
if (char === "(" || char === "[")
|
|
639
|
+
depth++;
|
|
640
|
+
else if (char === ")" || char === "]")
|
|
641
|
+
depth--;
|
|
642
|
+
i++;
|
|
643
|
+
if (depth === 0)
|
|
644
|
+
break;
|
|
645
|
+
}
|
|
646
|
+
return i;
|
|
647
|
+
}
|
|
648
|
+
function splitList(text2) {
|
|
649
|
+
const parts = [];
|
|
650
|
+
let start = 0;
|
|
651
|
+
let i = 0;
|
|
652
|
+
while (i < text2.length) {
|
|
653
|
+
const char = text2[i];
|
|
654
|
+
if (char === "\\")
|
|
655
|
+
i += 2;
|
|
656
|
+
else if (char === '"' || char === "'")
|
|
657
|
+
i = skipString(text2, i);
|
|
658
|
+
else if (char === "(" || char === "[")
|
|
659
|
+
i = skipBlock(text2, i);
|
|
660
|
+
else {
|
|
661
|
+
if (char === ",") {
|
|
662
|
+
parts.push(text2.slice(start, i));
|
|
663
|
+
start = i + 1;
|
|
664
|
+
}
|
|
665
|
+
i++;
|
|
666
|
+
}
|
|
667
|
+
}
|
|
668
|
+
parts.push(text2.slice(start));
|
|
669
|
+
return parts.map((part) => part.trim()).filter((part) => part.length > 0);
|
|
670
|
+
}
|
|
671
|
+
function readPseudo(text2, at) {
|
|
672
|
+
const double = text2[at + 1] === ":";
|
|
673
|
+
const nameStart = at + (double ? 2 : 1);
|
|
674
|
+
const nameEnd = skipIdent(text2, nameStart);
|
|
675
|
+
const name = text2.slice(nameStart, nameEnd).toLowerCase();
|
|
676
|
+
let end = nameEnd;
|
|
677
|
+
let args = null;
|
|
678
|
+
if (text2[nameEnd] === "(") {
|
|
679
|
+
end = skipBlock(text2, nameEnd);
|
|
680
|
+
args = text2.slice(nameEnd + 1, text2[end - 1] === ")" ? end - 1 : end).trim();
|
|
681
|
+
}
|
|
682
|
+
return { start: at, end, name, args, element: double || args === null && LEGACY.has(name) };
|
|
683
|
+
}
|
|
684
|
+
function add(a, b) {
|
|
685
|
+
return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
|
|
686
|
+
}
|
|
687
|
+
function compareSpecificity(a, b) {
|
|
688
|
+
return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
|
|
689
|
+
}
|
|
690
|
+
function heaviest(list) {
|
|
691
|
+
let best = [0, 0, 0];
|
|
692
|
+
for (const selector of splitList(list)) {
|
|
693
|
+
const found = specificity(selector);
|
|
694
|
+
if (compareSpecificity(found, best) > 0)
|
|
695
|
+
best = found;
|
|
696
|
+
}
|
|
697
|
+
return best;
|
|
698
|
+
}
|
|
699
|
+
function pseudoWeight(pseudo) {
|
|
700
|
+
const { name, args } = pseudo;
|
|
701
|
+
if (pseudo.element) {
|
|
702
|
+
return name === "slotted" && args ? add([0, 0, 1], specificity(args)) : [0, 0, 1];
|
|
703
|
+
}
|
|
704
|
+
if (args === null)
|
|
705
|
+
return [0, 1, 0];
|
|
706
|
+
if (name === "where")
|
|
707
|
+
return [0, 0, 0];
|
|
708
|
+
if (HEAVIEST.has(name))
|
|
709
|
+
return heaviest(args);
|
|
710
|
+
if (name === "nth-child" || name === "nth-last-child") {
|
|
711
|
+
const of = args.search(/\sof\s/i);
|
|
712
|
+
return of < 0 ? [0, 1, 0] : add([0, 1, 0], heaviest(args.slice(of + 4)));
|
|
713
|
+
}
|
|
714
|
+
if (name === "host" || name === "host-context")
|
|
715
|
+
return add([0, 1, 0], heaviest(args));
|
|
716
|
+
return [0, 1, 0];
|
|
717
|
+
}
|
|
718
|
+
function specificity(selector) {
|
|
719
|
+
let total = [0, 0, 0];
|
|
720
|
+
let i = 0;
|
|
721
|
+
while (i < selector.length) {
|
|
722
|
+
const char = selector[i] ?? "";
|
|
723
|
+
if (char === "#") {
|
|
724
|
+
total = add(total, [1, 0, 0]);
|
|
725
|
+
i = skipIdent(selector, i + 1);
|
|
726
|
+
} else if (char === ".") {
|
|
727
|
+
total = add(total, [0, 1, 0]);
|
|
728
|
+
i = skipIdent(selector, i + 1);
|
|
729
|
+
} else if (char === "[") {
|
|
730
|
+
total = add(total, [0, 1, 0]);
|
|
731
|
+
i = skipBlock(selector, i);
|
|
732
|
+
} else if (char === ":") {
|
|
733
|
+
const pseudo = readPseudo(selector, i);
|
|
734
|
+
total = add(total, pseudoWeight(pseudo));
|
|
735
|
+
i = Math.max(pseudo.end, i + 1);
|
|
736
|
+
} else if (char === "\\" || isIdentChar(char) && !/[\d]/.test(char)) {
|
|
737
|
+
const end = Math.max(skipIdent(selector, i), i + 1);
|
|
738
|
+
const namespace = selector[end] === "|" && selector[end + 1] !== "|";
|
|
739
|
+
if (!namespace)
|
|
740
|
+
total = add(total, [0, 0, 1]);
|
|
741
|
+
i = end;
|
|
742
|
+
} else {
|
|
743
|
+
i++;
|
|
744
|
+
}
|
|
745
|
+
}
|
|
746
|
+
return total;
|
|
747
|
+
}
|
|
748
|
+
function scan(selector) {
|
|
749
|
+
const pseudos = [];
|
|
750
|
+
const combinators = [];
|
|
751
|
+
let i = 0;
|
|
752
|
+
while (i < selector.length) {
|
|
753
|
+
const char = selector[i] ?? "";
|
|
754
|
+
if (char === "\\")
|
|
755
|
+
i += 2;
|
|
756
|
+
else if (char === "[" || char === "(")
|
|
757
|
+
i = skipBlock(selector, i);
|
|
758
|
+
else if (char === ":") {
|
|
759
|
+
const pseudo = readPseudo(selector, i);
|
|
760
|
+
pseudos.push(pseudo);
|
|
761
|
+
i = Math.max(pseudo.end, i + 1);
|
|
762
|
+
} else {
|
|
763
|
+
if (/[\s>+~]/.test(char))
|
|
764
|
+
combinators.push(i);
|
|
765
|
+
i++;
|
|
766
|
+
}
|
|
767
|
+
}
|
|
768
|
+
return { pseudos, combinators };
|
|
769
|
+
}
|
|
770
|
+
function isEdge(char) {
|
|
771
|
+
return char === undefined || /[\s>+~]/.test(char);
|
|
772
|
+
}
|
|
773
|
+
function cut(selector, start, end) {
|
|
774
|
+
const empty = isEdge(selector[start - 1]) && isEdge(selector[end]);
|
|
775
|
+
return `${selector.slice(0, start)}${empty ? "*" : ""}${selector.slice(end)}`;
|
|
776
|
+
}
|
|
777
|
+
function normalizePseudo(pseudo) {
|
|
778
|
+
const text2 = pseudo.trim();
|
|
779
|
+
const colons = text2.startsWith("::") ? 2 : text2.startsWith(":") ? 1 : 0;
|
|
780
|
+
const open = text2.indexOf("(");
|
|
781
|
+
const name = (open < 0 ? text2 : text2.slice(0, open)).slice(colons).toLowerCase();
|
|
782
|
+
return `::${name}${open < 0 ? "" : text2.slice(open)}`;
|
|
783
|
+
}
|
|
784
|
+
function hostForm(selector) {
|
|
785
|
+
const { pseudos, combinators } = scan(selector);
|
|
786
|
+
const hosts = pseudos.filter(({ name }) => name === "host" || name === "host-context");
|
|
787
|
+
if (hosts.length === 0 || combinators.length > 0)
|
|
788
|
+
return null;
|
|
789
|
+
let next = selector;
|
|
790
|
+
for (const host of hosts.reverse()) {
|
|
791
|
+
let own = ":scope";
|
|
792
|
+
if (host.args !== null && host.name === "host")
|
|
793
|
+
own = `:scope:is(${host.args})`;
|
|
794
|
+
if (host.args !== null && host.name === "host-context") {
|
|
795
|
+
own = `:scope:is(${host.args}, :is(${host.args}) *)`;
|
|
796
|
+
}
|
|
797
|
+
next = `${next.slice(0, host.start)}${own}${next.slice(host.end)}`;
|
|
798
|
+
}
|
|
799
|
+
return next;
|
|
800
|
+
}
|
|
801
|
+
function parseSubject(selector) {
|
|
802
|
+
const text2 = selector.trim();
|
|
803
|
+
const elements = scan(text2).pseudos.filter((pseudo2) => pseudo2.element);
|
|
804
|
+
let match = text2;
|
|
805
|
+
let pseudo = null;
|
|
806
|
+
let slotted = null;
|
|
807
|
+
for (const found of elements.reverse()) {
|
|
808
|
+
if (found.name === "slotted" && found.args !== null)
|
|
809
|
+
slotted = found.args;
|
|
810
|
+
else
|
|
811
|
+
pseudo ??= normalizePseudo(text2.slice(found.start, found.end));
|
|
812
|
+
match = cut(match, found.start, found.end);
|
|
813
|
+
}
|
|
814
|
+
return { match, pseudo, slotted, host: slotted === null ? hostForm(match) : null };
|
|
815
|
+
}
|
|
816
|
+
function hasNesting(selector) {
|
|
817
|
+
let i = 0;
|
|
818
|
+
while (i < selector.length) {
|
|
819
|
+
const char = selector[i];
|
|
820
|
+
if (char === "\\")
|
|
821
|
+
i += 2;
|
|
822
|
+
else if (char === "[")
|
|
823
|
+
i = skipBlock(selector, i);
|
|
824
|
+
else if (char === '"' || char === "'")
|
|
825
|
+
i = skipString(selector, i);
|
|
826
|
+
else if (char === "&")
|
|
827
|
+
return true;
|
|
828
|
+
else
|
|
829
|
+
i++;
|
|
830
|
+
}
|
|
831
|
+
return false;
|
|
832
|
+
}
|
|
833
|
+
function replaceNesting(selector, parent) {
|
|
834
|
+
let next = "";
|
|
835
|
+
let i = 0;
|
|
836
|
+
while (i < selector.length) {
|
|
837
|
+
const char = selector[i] ?? "";
|
|
838
|
+
let end = i + 1;
|
|
839
|
+
if (char === "\\")
|
|
840
|
+
end = i + 2;
|
|
841
|
+
else if (char === "[")
|
|
842
|
+
end = skipBlock(selector, i);
|
|
843
|
+
else if (char === '"' || char === "'")
|
|
844
|
+
end = skipString(selector, i);
|
|
845
|
+
next += char === "&" ? parent : selector.slice(i, end);
|
|
846
|
+
i = end;
|
|
847
|
+
}
|
|
848
|
+
return next;
|
|
849
|
+
}
|
|
850
|
+
function resolveNesting(selector, parent) {
|
|
851
|
+
const text2 = selector.trim();
|
|
852
|
+
const stands = parent === null ? ":scope" : `:is(${parent})`;
|
|
853
|
+
if (hasNesting(text2))
|
|
854
|
+
return replaceNesting(text2, stands);
|
|
855
|
+
if (parent === null)
|
|
856
|
+
return text2;
|
|
857
|
+
return `${stands} ${text2}`;
|
|
858
|
+
}
|
|
859
|
+
|
|
860
|
+
export { edits, RISK, riskyAttribute, riskyElement, riskyNodes, splitList, compareSpecificity, specificity, normalizePseudo, parseSubject, hasNesting, resolveNesting, REASONS, readSavedEdit, pathNow, framedPage, pageSettled, startKeep, stopKeep, forgetReplay, keeper };
|