securemark 0.261.0 → 0.262.0

package/dist/index.js

@@ -1,4 +1,4 @@
-/*! securemark v0.261.0 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED License */
+/*! securemark v0.262.0 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED License */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
 		module.exports = factory(require("DOMPurify"), require("Prism"));
@@ -92,6 +92,8 @@ exports.splice = exports.pop = exports.push = exports.shift = exports.unshift =
 
 const global_1 = __webpack_require__(4128);
 
+const undefined = void 0;
+
 function indexOf(as, a) {
   if (as.length === 0) return -1;
   return a === a ? as.indexOf(a) : as.findIndex(a => a !== a);
@@ -101,7 +103,10 @@ exports.indexOf = indexOf;
 
 function unshift(as, bs) {
   if ('length' in as) {
-    for (let i = as.length - 1; i >= 0; --i) {
+    if (as.length === 1) return bs.unshift(as[0]), bs;
+    if (global_1.Symbol.iterator in as) return bs.unshift(...as), bs;
+
+    for (let i = as.length; i--;) {
       bs.unshift(as[i]);
     }
   } else {
@@ -115,13 +120,16 @@ exports.unshift = unshift;
 
 function shift(as, count) {
   if (count < 0) throw new Error('Unexpected negative number');
-  return count === void 0 ? [as.shift(), as] : [splice(as, 0, count), as];
+  return count === undefined ? [as.shift(), as] : [splice(as, 0, count), as];
 }
 
 exports.shift = shift;
 
 function push(as, bs) {
   if ('length' in bs) {
+    if (bs.length === 1) return as.push(bs[0]), as;
+    if (global_1.Symbol.iterator in bs && bs.length > 50) return as.push(...bs), as;
+
     for (let i = 0, len = bs.length; i < len; ++i) {
       as.push(bs[i]);
     }
@@ -138,50 +146,39 @@ exports.push = push;
 
 function pop(as, count) {
   if (count < 0) throw new Error('Unexpected negative number');
-  return count === void 0 ? [as, as.pop()] : [as, splice(as, as.length - count, count)];
+  return count === undefined ? [as, as.pop()] : [as, splice(as, as.length - count, count)];
 }
 
 exports.pop = pop;
 
-function splice(as, index, count, ...inserts) {
-  if (count === 0 && inserts.length === 0) return [];
+function splice(as, index, count, ...values) {
+  if (as.length === 0) return push(as, values), [];
+
+  if (index > as.length) {
+    index = as.length;
+  } else if (index < 0) {
+    index = -index > as.length ? 0 : as.length + index;
+  }
+
   count = count > as.length ? as.length : count;
+  if (count === 0 && values.length === 0) return [];
+  if (count === 1 && values.length === 1) return [[as[index], as[index] = values[0]][0]];
 
   switch (index) {
     case 0:
-      switch (count) {
-        case 0:
-          return [[], unshift(inserts, as)][0];
-
-        case 1:
-          return as.length === 0 ? [[], unshift(inserts, as)][0] : [[as.shift()], unshift(inserts, as)][0];
-
-        case void 0:
-          if (as.length > 1 || arguments.length > 2) break;
-          return as.length === 0 ? [] : splice(as, index, 1);
-      }
-
+      if (count === 0) return unshift(values, as), [];
+      if (count === 1) return [[as.shift()], unshift(values, as)][0];
       break;
 
-    case -1:
     case as.length - 1:
-      switch (count) {
-        case 1:
-          return as.length === 0 ? [[], push(as, inserts)][0] : [[as.pop()], push(as, inserts)][0];
-
-        case void 0:
-          if (as.length > 1 || arguments.length > 2) break;
-          return as.length === 0 ? [] : splice(as, index, 1);
-      }
-
+      if (count === 1) return [[as.pop()], push(as, values)][0];
       break;
 
     case as.length:
-    case global_1.Infinity:
-      return [[], push(as, inserts)][0];
+      return push(as, values), [];
   }
 
-  return arguments.length > 2 ? as.splice(index, count, ...inserts) : as.splice(index);
+  return arguments.length > 2 ? as.splice(index, count, ...values) : as.splice(index);
 }
 
 exports.splice = splice;
@@ -369,15 +366,14 @@ const assign_1 = __webpack_require__(4401);
 class Cache {
   constructor(capacity, opts = {}) {
     this.settings = {
-      window: 0,
       capacity: 0,
-      space: global_1.Infinity,
       age: global_1.Infinity,
       earlyExpiring: false,
       capture: {
         delete: true,
         clear: true
       },
+      window: 0,
       resolution: 1,
       offset: 0,
       block: 20,
@@ -391,7 +387,7 @@ class Cache {
       LRU: new invlist_1.List(),
       LFU: new invlist_1.List()
     };
-    this.expiries = new heap_1.Heap((a, b) => a.value.expiry - b.value.expiry);
+    this.expiries = new heap_1.Heap(heap_1.Heap.min);
     this.misses = 0;
     this.sweep = 0;
     this.ratio = 500;
@@ -407,8 +403,7 @@ class Cache {
     this.capacity = settings.capacity;
     if (this.capacity >= 1 === false) throw new Error(`Spica: Cache: Capacity must be 1 or more.`);
     this.window = settings.window || this.capacity;
-    if (this.window * 1000 < this.capacity) throw new Error(`Spica: Cache: Window must be 0.1% of capacity or more.`);
-    this.space = settings.space;
+    if (this.window * 1000 >= this.capacity === false) throw new Error(`Spica: Cache: Window must be 0.1% of capacity or more.`);
     this.block = settings.block;
     this.limit = settings.limit;
     this.earlyExpiring = settings.earlyExpiring;
@@ -438,13 +433,12 @@ class Cache {
 
   ensure(margin, skip) {
     let size = skip?.value.size ?? 0;
-    if (margin - size <= 0) return true;
     const {
       LRU,
       LFU
     } = this.indexes;
 
-    while (this.length === this.capacity || this.size + margin - size > this.space) {
+    while (this.size + margin - size > this.capacity) {
       let target;
 
       switch (true) {
@@ -494,7 +488,7 @@ class Cache {
     size = 1,
     age = this.settings.age
   } = {}) {
-    if (size > this.space || age <= 0) {
+    if (size < 1 || this.capacity < size || age <= 0) {
       this.disposer?.(value, key);
       return false;
     }
@@ -510,7 +504,7 @@ class Cache {
       index.expiry = expiry;
 
       if (this.earlyExpiring && expiry !== global_1.Infinity) {
-        index.enode ? this.expiries.update(index.enode) : index.enode = this.expiries.insert(node);
+        index.enode ? this.expiries.update(index.enode, expiry) : index.enode = this.expiries.insert(node, expiry);
       } else if (index.enode) {
         this.expiries.delete(index.enode);
         index.enode = void 0;
@@ -535,7 +529,7 @@ class Cache {
     }));
 
     if (this.earlyExpiring && expiry !== global_1.Infinity) {
-      LRU.head.value.enode = this.expiries.insert(LRU.head);
+      LRU.head.value.enode = this.expiries.insert(LRU.head, expiry);
     }
 
     return false;
@@ -560,14 +554,14 @@ class Cache {
       ++this.misses;
       this.evict(node, true);
       return;
-    } // Optimization for memoize.
+    }
 
+    this.misses &&= 0;
+    this.sweep &&= 0; // Optimization for memoize.
 
     if (this.capacity > 3 && node === node.list.head) return node.value.value;
     this.access(node);
     this.adjust();
-    this.misses &&= 0;
-    this.sweep = 0;
     return node.value.value;
   }
 
@@ -607,21 +601,35 @@ class Cache {
     const memory = this.memory;
     this.memory = new global_1.Map();
 
-    for (const [key, {
-      value: {
-        value
+    for (const {
+      0: key,
+      1: {
+        value: {
+          value
+        }
       }
-    }] of memory) {
+    } of memory) {
       this.disposer(value, key);
     }
   }
 
+  resize(capacity) {
+    if (this.capacity >= 1 === false) throw new Error(`Spica: Cache: Capacity must be 1 or more.`);
+    this.capacity = capacity;
+    this.window = this.settings.window || this.capacity;
+    if (this.window * 1000 >= this.capacity === false) throw new Error(`Spica: Cache: Window must be 0.1% of capacity or more.`);
+    this.ensure(0);
+  }
+
   *[Symbol.iterator]() {
-    for (const [key, {
-      value: {
-        value
+    for (const {
+      0: key,
+      1: {
+        value: {
+          value
+        }
       }
-    }] of this.memory) {
+    } of this.memory) {
       yield [key, value];
     }
 
@@ -792,58 +800,56 @@ function rate(window, hits1, hits2, offset) {
 Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
-exports.tick = exports.clock = exports.now = void 0;
+exports.tick = exports.promise = exports.clock = exports.now = void 0;
 
 const global_1 = __webpack_require__(4128);
 
-const alias_1 = __webpack_require__(5406);
+const queue_1 = __webpack_require__(4934);
 
 const exception_1 = __webpack_require__(7822);
 
-let mem;
+const undefined = void 0;
+let time;
 let count = 0;
 
-function now(nocache = false) {
-  if (mem === void 0) {
-    tick(() => mem = void 0);
-  } else if (!nocache && ++count !== 100) {
-    return mem;
+function now(nocache) {
+  if (time === undefined) {
+    tick(() => time = undefined);
+  } else if (!nocache && count++ !== 20) {
+    return time;
   }
 
-  count = 0;
-  return mem = global_1.Date.now();
+  count = 1;
+  return time = global_1.Date.now();
 }
 
 exports.now = now;
-exports.clock = Promise.resolve(void 0);
-let queue = [];
-let jobs = [];
-let index = 0;
-const scheduler = Promise.resolve();
+exports.clock = global_1.Promise.resolve(undefined);
+
+function promise(cb) {
+  global_1.Promise.resolve().then(cb);
+}
+
+exports.promise = promise;
+const queue = new queue_1.Queue();
+const scheduler = global_1.Promise.resolve();
 
 function tick(cb) {
-  index === 0 && scheduler.then(run);
-  index++ === queue.length ? queue.push(cb) : queue[index - 1] = cb;
+  queue.isEmpty() && scheduler.then(run);
+  queue.push(cb);
 }
 
 exports.tick = tick;
 
 function run() {
-  const count = index;
-  [index, queue, jobs] = [0, jobs, queue];
-
-  for (let i = 0; i < count; ++i) {
+  for (let count = queue.length; count--;) {
     try {
-      (void 0, jobs[i])(); // Release the reference.
-
-      jobs[i] = void 0;
+      // @ts-expect-error
+      (0, queue.pop())();
     } catch (reason) {
       (0, exception_1.causeAsyncException)(reason);
     }
-  } // Gradually reduce the unused buffer space.
-
-
-  jobs.length > 1000 && count < jobs.length * 0.5 && jobs.splice((0, alias_1.floor)(jobs.length * 0.9), jobs.length);
+  }
 }
 
 /***/ }),
@@ -880,62 +886,51 @@ exports.MultiMap = void 0;
 
 const global_1 = __webpack_require__(4128);
 
-const array_1 = __webpack_require__(8112);
+const ring_1 = __webpack_require__(6395);
 
 class MultiMap {
   constructor(entries = [], memory = new global_1.Map()) {
     this.memory = memory;
 
-    for (const [k, v] of entries) {
+    for (const {
+      0: k,
+      1: v
+    } of entries) {
       this.set(k, v);
     }
   }
 
   get(key) {
-    return this.memory.get(key)?.[0];
+    return this.memory.get(key)?.at(0);
+  }
+
+  getAll(key) {
+    return this.memory.get(key);
   }
 
   set(key, val) {
-    this.memory.get(key)?.push(val) ?? this.memory.set(key, [val]);
+    let vs = this.memory.get(key);
+    if (vs) return vs.push(val), this;
+    vs = new ring_1.Ring();
+    vs.push(val);
+    this.memory.set(key, vs);
     return this;
   }
 
   has(key, value) {
     const vs = this.memory.get(key);
-    if (!vs || vs.length === 0) return false;
+    if (!vs?.length) return false;
     if (arguments.length < 2) return true;
-
-    switch (value) {
-      case vs[0]:
-      case vs[vs.length - 1]:
-        return true;
-
-      default:
-        return (0, array_1.indexOf)(vs, value) > -1;
-    }
+    return vs.includes(value);
   }
 
   delete(key, value) {
     if (arguments.length < 2) return this.memory.delete(key);
     const vs = this.memory.get(key);
-    if (!vs || vs.length === 0) return false;
-
-    switch (value) {
-      case vs[0]:
-        vs.shift();
-        break;
-
-      case vs[vs.length - 1]:
-        vs.pop();
-        break;
-
-      default:
-        const i = (0, array_1.indexOf)(vs, value);
-        if (i === -1) return false;
-        (0, array_1.splice)(vs, i, 1);
-    }
-
-    vs.length === 0 && this.memory.delete(key);
+    if (!vs?.length) return false;
+    const i = vs.indexOf(value);
+    if (i === -1) return false;
+    vs.splice(i, 1);
     return true;
   }
 
@@ -944,22 +939,32 @@ class MultiMap {
   }
 
   take(key, count) {
-    const vs = this.memory.get(key) ?? [];
-    return count === void 0 ? (0, array_1.splice)(vs, 0, 1)[0] : (0, array_1.splice)(vs, 0, count);
+    const vs = this.memory.get(key);
+    if (count === void 0) return vs?.shift();
+    const acc = [];
+
+    while (vs?.length && count--) {
+      acc.push(vs.shift());
+    }
+
+    return acc;
   }
 
   ref(key) {
     let vs = this.memory.get(key);
     if (vs) return vs;
-    vs = [];
+    vs = new ring_1.Ring();
     this.memory.set(key, vs);
     return vs;
   }
 
   *[Symbol.iterator]() {
-    for (const [k, vs] of this.memory) {
+    for (const {
+      0: k,
+      1: vs
+    } of this.memory) {
       for (let i = 0; i < vs.length; ++i) {
-        yield [k, vs[i]];
+        yield [k, vs.at(i)];
       }
     }
 
@@ -981,12 +986,12 @@ exports.MultiMap = MultiMap;
 Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
-exports.duffReduce = exports.duffEach = exports.duffbk = exports.duff = void 0;
+exports.duffReduce = exports.duffEach = exports.duffbk = exports.duff = void 0; // 100,000以上でforより大幅に低速となり実用不可
 
 function duff(count, proc) {
   if (count > 0) {
     let i = 0,
-        m = count % 8,
+        m = count & 7,
         d = (count - m) / 8;
 
     while (m--) {
@@ -1005,7 +1010,7 @@ function duff(count, proc) {
     }
   } else {
     let i = -count,
-        m = i % 8,
+        m = i & 7,
         d = (i - m) / 8;
 
     while (m--) {
@@ -1025,12 +1030,12 @@ function duff(count, proc) {
   }
 }
 
-exports.duff = duff;
+exports.duff = duff; // 100,000以上でforより大幅に低速となり実用不可
 
 function duffbk(count, proc) {
   if (count > 0) {
     let i = 0,
-        m = count % 8,
+        m = count & 7,
         d = (count - m) / 8;
 
     while (m--) {
@@ -1038,18 +1043,21 @@ function duffbk(count, proc) {
     }
 
     while (d--) {
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
+      switch (false) {
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+          return;
+      }
     }
   } else {
     let i = -count,
-        m = i % 8,
+        m = i & 7,
         d = (i - m) / 8;
 
     while (m--) {
@@ -1057,14 +1065,17 @@ function duffbk(count, proc) {
     }
 
     while (d--) {
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
+      switch (false) {
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+          return;
+      }
     }
   }
 }
@@ -1074,7 +1085,7 @@ exports.duffbk = duffbk;
 function duffEach(array, proc) {
   let count = array.length;
   let i = 0,
-      m = count % 8,
+      m = count & 7,
       d = (count - m) / 8;
 
   while (m--) {
@@ -1093,30 +1104,32 @@ function duffEach(array, proc) {
   }
 }
 
-exports.duffEach = duffEach;
+exports.duffEach = duffEach; // ベンチマークの10,000以上で急激な速度低下が見られる場合があるがNodeListなどでの
+// 実際の使用では速度低下は見られない
 
 function duffReduce(array, proc, initial) {
   let count = array.length;
   let i = 0,
-      m = count % 8,
+      m = count & 7,
       d = (count - m) / 8;
+  let acc = initial;
 
   while (m--) {
-    initial = proc(initial, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
   }
 
   while (d--) {
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
   }
 
-  return initial;
+  return acc;
 }
 
 exports.duffReduce = duffReduce;
@@ -1180,18 +1193,22 @@ var global = (/* unused pure expression or super */ null && (globalThis));
 Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
-exports.Heap = void 0;
+exports.MultiHeap = exports.Heap = void 0;
 
-const alias_1 = __webpack_require__(5406); // Min heap
+const global_1 = __webpack_require__(4128);
+
+const invlist_1 = __webpack_require__(7452);
 
+const memoize_1 = __webpack_require__(1808);
 
 const undefined = void 0;
+let size = 16;
 
 class Heap {
-  constructor(cmp = (a, b) => a > b ? 1 : a < b ? -1 : 0, stable = false) {
+  constructor(cmp = Heap.max, stable = false) {
     this.cmp = cmp;
     this.stable = stable;
-    this.array = [];
+    this.array = (0, global_1.Array)(size);
     this.$length = 0;
   }
 
@@ -1199,19 +1216,35 @@ class Heap {
     return this.$length;
   }
 
-  insert(value, order = value) {
+  isEmpty() {
+    return this.array[0] !== undefined;
+  }
+
+  peek() {
+    return this.array[0]?.[1];
+  }
+
+  insert(value, order) {
+    if (arguments.length < 2) {
+      order = value;
+    }
+
     const array = this.array;
     const node = array[this.$length] = [order, value, this.$length++];
-    upHeapify(array, this.cmp, this.$length);
+    upHeapify(this.cmp, array, this.$length);
     return node;
   }
 
-  replace(value, order = value) {
-    const array = this.array;
+  replace(value, order) {
+    if (arguments.length < 2) {
+      order = value;
+    }
+
     if (this.$length === 0) return void this.insert(value, order);
+    const array = this.array;
     const replaced = array[0][1];
     array[0] = [order, value, 0];
-    downHeapify(array, this.cmp, 1, this.$length, this.stable);
+    downHeapify(this.cmp, array, 1, this.$length, this.stable);
     return replaced;
   }
 
@@ -1229,47 +1262,146 @@ class Heap {
     swap(array, index, --this.$length); // @ts-expect-error
 
     array[this.$length] = undefined;
-    index < this.$length && this.sort(array[index]);
-
-    if (array.length >= 2 ** 16 && array.length >= this.$length * 2) {
-      array.splice(array.length / 2, array.length / 2);
-    }
-
+    index < this.$length && sort(this.cmp, array, index, this.$length, this.stable);
     return node[1];
   }
 
-  update(node, order = node[1], value = node[1]) {
+  update(node, order, value) {
+    if (arguments.length < 2) {
+      order = node[0];
+    }
+
     const array = this.array;
     if (array[node[2]] !== node) throw new Error('Invalid node');
-    node[1] = value;
+
+    if (arguments.length > 2) {
+      node[1] = value;
+    }
+
     if (this.cmp(node[0], node[0] = order) === 0) return;
-    this.sort(node);
+    sort(this.cmp, array, node[2], this.$length, this.stable);
   }
 
-  sort(node) {
-    const array = this.array;
-    return upHeapify(array, this.cmp, node[2] + 1) || downHeapify(array, this.cmp, node[2] + 1, this.$length, this.stable);
+  clear() {
+    this.array = (0, global_1.Array)(size);
+    this.$length = 0;
+  }
+
+}
+
+exports.Heap = Heap;
+
+Heap.max = (a, b) => a > b ? -1 : a < b ? 1 : 0;
+
+Heap.min = (a, b) => a > b ? 1 : a < b ? -1 : 0;
+
+class MultiHeap {
+  constructor(cmp = MultiHeap.max, clean = true) {
+    this.cmp = cmp;
+    this.clean = clean;
+    this.heap = new Heap(this.cmp);
+    this.dict = new Map();
+    this.list = (0, memoize_1.memoize)(order => {
+      const list = new invlist_1.List();
+      list[MultiHeap.order] = order;
+      list[MultiHeap.heap] = this.heap.insert(list, order);
+      return list;
+    }, this.dict);
+    this.$length = 0;
+  }
+
+  get length() {
+    return this.$length;
+  }
+
+  isEmpty() {
+    return this.heap.isEmpty();
   }
 
   peek() {
-    return this.array[0]?.[1];
+    return this.heap.peek()?.head.value;
+  }
+
+  insert(value, order) {
+    if (arguments.length < 2) {
+      order = value;
+    }
+
+    ++this.$length;
+    const list = this.list(order);
+    return [order, list.push(value)];
+  }
+
+  extract() {
+    if (this.$length === 0) return;
+    --this.$length;
+    const list = this.heap.peek();
+    const value = list.shift();
+
+    if (list.length === 0) {
+      this.heap.extract();
+      this.clean && this.dict.delete(list[MultiHeap.order]);
+    }
+
+    return value;
+  }
+
+  delete(node) {
+    if (!node[1].list) throw new Error('Invalid node');
+    const {
+      0: order,
+      1: lnode
+    } = node;
+    --this.$length;
+
+    if (lnode.list.length === 1) {
+      this.heap.delete(lnode[MultiHeap.heap]);
+      this.clean && this.dict.delete(order);
+    }
+
+    return lnode.delete();
+  }
+
+  update(node, order, value) {
+    if (!node[1].list) throw new Error('Invalid node');
+
+    if (arguments.length < 2) {
+      order = node[0];
+    }
+
+    if (arguments.length > 2) {
+      node[1].value = value;
+    }
+
+    if (this.cmp(node[0], order) === 0) return node;
+    this.delete(node);
+    return this.insert(node[1].value, order);
   }
 
   clear() {
-    this.array = [];
+    this.heap.clear();
+    this.dict.clear();
     this.$length = 0;
   }
 
 }
 
-exports.Heap = Heap;
+exports.MultiHeap = MultiHeap;
+MultiHeap.order = Symbol('order');
+MultiHeap.heap = Symbol('heap');
+MultiHeap.max = Heap.max;
+MultiHeap.min = Heap.min;
 
-function upHeapify(array, cmp, index) {
+function sort(cmp, array, index, length, stable) {
+  return upHeapify(cmp, array, index + 1) || downHeapify(cmp, array, index + 1, length, stable);
+}
+
+function upHeapify(cmp, array, index) {
   const order = array[index - 1][0];
   let changed = false;
 
   while (index > 1) {
-    const parent = (0, alias_1.floor)(index / 2);
+    const parent = index / 2 | 0;
     if (cmp(array[parent - 1][0], order) <= 0) break;
     swap(array, index - 1, parent - 1);
     index = parent;
@@ -1279,7 +1411,7 @@ function upHeapify(array, cmp, index) {
   return changed;
 }
 
-function downHeapify(array, cmp, index, length, stable) {
+function downHeapify(cmp, array, index, length, stable) {
   let changed = false;
 
   while (index < length) {
@@ -1357,7 +1489,7 @@ __exportStar(__webpack_require__(2310), exports);
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
- // Circular inverse list
+ // Circular Inverse List
 
 var _a;
 
@@ -1395,10 +1527,18 @@ class List {
     return this.head = this.push(value);
   }
 
+  push(value) {
+    return new Node(this, value, this.head, this.head?.prev);
+  }
+
   unshiftNode(node) {
     return this.head = this.pushNode(node);
   }
 
+  pushNode(node) {
+    return this.insert(node, this.head);
+  }
+
   unshiftRotationally(value) {
     const node = this.last;
     if (!node) return this.unshift(value);
@@ -1407,18 +1547,6 @@ class List {
     return node;
   }
 
-  shift() {
-    return this.head?.delete();
-  }
-
-  push(value) {
-    return new Node(value, this.head, this.head?.prev, this);
-  }
-
-  pushNode(node) {
-    return this.insert(node, this.head);
-  }
-
   pushRotationally(value) {
     const node = this.head;
     if (!node) return this.push(value);
@@ -1427,12 +1555,16 @@ class List {
     return node;
   }
 
+  shift() {
+    return this.head?.delete();
+  }
+
   pop() {
     return this.last?.delete();
   }
 
   insert(node, before = this.head) {
-    if (node.list === this) return before && node.move(before), node;
+    if (node.list === this) return node.moveTo(before), node;
     node.delete();
     ++this[LENGTH];
     this.head ??= node; // @ts-expect-error
@@ -1457,11 +1589,11 @@ class List {
 exports.List = List;
 
 class Node {
-  constructor(value, next, prev, list = next?.list ?? new List()) {
+  constructor(list, value, next, prev) {
+    this.list = list;
     this.value = value;
     this.next = next;
     this.prev = prev;
-    this.list = list;
     ++list[LENGTH];
     list.head ??= this;
     next && prev ? next.prev = prev.next = this : this.next = this.prev = this;
@@ -1470,17 +1602,21 @@ class Node {
   delete() {
     if (!this.list) return this.value;
     --this.list[LENGTH];
+    const {
+      next,
+      prev
+    } = this;
 
     if (this.list.head === this) {
-      this.list.head = this.next === this ? undefined : this.next;
+      this.list.head = next === this ? undefined : next;
     }
 
-    if (this.next) {
-      this.next.prev = this.prev;
+    if (next) {
+      next.prev = prev;
     }
 
-    if (this.prev) {
-      this.prev.next = this.next;
+    if (prev) {
+      prev.next = next;
     } // @ts-expect-error
 
 
@@ -1491,20 +1627,19 @@ class Node {
   }
 
   insertBefore(value) {
-    return new Node(value, this, this.prev, this.list);
+    return new Node(this.list, value, this, this.prev);
   }
 
   insertAfter(value) {
-    return new Node(value, this.next, this, this.list);
+    return new Node(this.list, value, this.next, this);
   }
 
-  move(before) {
+  moveTo(before) {
     if (!before) return false;
     if (this === before) return false;
     if (before.list !== this.list) return before.list.insert(this, before), true;
     const a1 = this;
     const b1 = before;
-    if (!b1) return false;
     if (a1.next === b1) return false;
     const b0 = b1.prev;
     const a0 = a1.prev;
@@ -1519,12 +1654,12 @@ class Node {
   }
 
   moveToHead() {
-    this.move(this.list.head);
+    this.moveTo(this.list.head);
     this.list.head = this;
   }
 
   moveToLast() {
-    this.move(this.list.head);
+    this.moveTo(this.list.head);
   }
 
   swap(node) {
@@ -1533,8 +1668,8 @@ class Node {
     if (node1 === node2) return false;
     const node3 = node2.next;
     if (node1.list !== node2.list) throw new Error(`Spica: InvList: Cannot swap nodes across lists.`);
-    node2.move(node1);
-    node1.move(node3);
+    node2.moveTo(node1);
+    node1.moveTo(node3);
 
     switch (this.list.head) {
       case node1:
@@ -1570,12 +1705,14 @@ const alias_1 = __webpack_require__(5406);
 
 const compare_1 = __webpack_require__(5529);
 
+const undefined = void 0;
+
 function memoize(f, identify = (...as) => as[0], memory) {
-  if (typeof identify === 'object') return memoize(f, void 0, identify);
-  if (memory === void 0) return memoize(f, identify, new global_1.Map());
+  if (typeof identify === 'object') return memoize(f, undefined, identify);
+  if (memory === undefined) return memoize(f, identify, new global_1.Map());
   if ((0, alias_1.isArray)(memory)) return memoize(f, identify, {
     has(key) {
-      return memory[key] !== void 0;
+      return memory[key] !== undefined;
     },
 
     get(key) {
@@ -1596,9 +1733,9 @@ function memoize(f, identify = (...as) => as[0], memory) {
   return (...as) => {
     const b = identify(...as);
     let z = memory.get(b);
-    if (z !== void 0 || nullish && memory.has(b)) return z;
+    if (z !== undefined || nullish && memory.has(b)) return z;
     z = f(...as);
-    nullish ||= z === void 0;
+    nullish ||= z === undefined;
     memory.set(b, z);
     return z;
   };
@@ -1607,8 +1744,8 @@ function memoize(f, identify = (...as) => as[0], memory) {
 exports.memoize = memoize;
 
 function reduce(f, identify = (...as) => as[0]) {
-  let key = [];
-  let val = [];
+  let key = {};
+  let val;
   return (...as) => {
     const b = identify(...as);
 
@@ -1623,42 +1760,246 @@ function reduce(f, identify = (...as) => as[0]) {
 
 exports.reduce = reduce;
 
-/***/ }),
+/***/ }),
+
+/***/ 940:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    desc = {
+      enumerable: true,
+      get: function () {
+        return m[k];
+      }
+    };
+  }
+
+  Object.defineProperty(o, k2, desc);
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+
+var __exportStar = this && this.__exportStar || function (m, exports) {
+  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+
+__exportStar(__webpack_require__(5084), exports);
+
+/***/ }),
+
+/***/ 4934:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PriorityQueue = exports.Queue = void 0;
+
+const global_1 = __webpack_require__(4128);
+
+const heap_1 = __webpack_require__(818);
+
+const memoize_1 = __webpack_require__(1808);
+
+const undefined = void 0;
+const size = 2048;
+const initsize = 16;
+
+class Queue {
+  constructor() {
+    this.head = new FixedQueue(initsize);
+    this.tail = this.head;
+    this.count = 0;
+    this.irregular = 0;
+  }
+
+  get length() {
+    return this.count === 0 ? this.head.length : this.head.length + this.tail.length + (size - 1) * (this.count - 2) + (this.irregular || size) - 1;
+  }
+
+  isEmpty() {
+    return this.head.isEmpty();
+  }
+
+  peek(index = 0) {
+    return index === 0 ? this.head.peek(0) : this.tail.peek(-1);
+  }
+
+  push(value) {
+    const tail = this.tail;
+
+    if (tail.isFull()) {
+      if (tail.next.isEmpty()) {
+        this.tail = tail.next;
+      } else {
+        this.tail = tail.next = new FixedQueue(size, tail.next);
+      }
+
+      ++this.count;
+
+      if (tail.size !== size && tail !== this.head) {
+        this.irregular = tail.size;
+      }
+    }
+
+    this.tail.push(value);
+  }
+
+  pop() {
+    const head = this.head;
+    const value = head.pop();
+
+    if (head.isEmpty() && !head.next.isEmpty()) {
+      --this.count;
+      this.head = head.next;
+
+      if (this.head.size === this.irregular) {
+        this.irregular = 0;
+      }
+    }
+
+    return value;
+  }
+
+  clear() {
+    this.head = this.tail = new FixedQueue(initsize);
+    this.count = 0;
+    this.irregular = 0;
+  }
+
+  *[Symbol.iterator]() {
+    while (!this.isEmpty()) {
+      yield this.pop();
+    }
+
+    return;
+  }
+
+}
+
+exports.Queue = Queue;
+
+class FixedQueue {
+  constructor(size, next) {
+    this.size = size;
+    this.array = (0, global_1.Array)(this.size);
+    this.mask = this.array.length - 1;
+    this.head = 0;
+    this.tail = 0;
+    this.next = next ?? this;
+  }
+
+  get length() {
+    return this.tail >= this.head ? this.tail - this.head : this.array.length - this.head + this.tail;
+  }
+
+  isEmpty() {
+    return this.tail === this.head;
+  }
+
+  isFull() {
+    return (this.tail + 1 & this.mask) === this.head;
+  }
+
+  peek(index = 0) {
+    return index === 0 ? this.array[this.head] : this.array[this.tail - 1 & this.mask];
+  }
+
+  push(value) {
+    this.array[this.tail] = value;
+    this.tail = this.tail + 1 & this.mask;
+  }
+
+  pop() {
+    if (this.isEmpty()) return;
+    const value = this.array[this.head];
+    this.array[this.head] = undefined;
+    this.head = this.head + 1 & this.mask;
+    return value;
+  }
+
+}
+
+class PriorityQueue {
+  constructor(cmp = PriorityQueue.max, clean = true) {
+    this.clean = clean;
+    this.dict = new Map();
+    this.queue = (0, memoize_1.memoize)(priority => {
+      const queue = new Queue();
+      queue[PriorityQueue.priority] = priority;
+      this.heap.insert(queue, priority);
+      return queue;
+    }, this.dict);
+    this.$length = 0;
+    this.heap = new heap_1.Heap(cmp);
+  }
+
+  get length() {
+    return this.$length;
+  }
+
+  isEmpty() {
+    return this.$length === 0;
+  }
+
+  peek() {
+    return this.heap.peek()?.peek();
+  }
 
-/***/ 940:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+  push(value, priority) {
+    ++this.$length;
+    this.queue(priority).push(value);
+  }
 
-"use strict";
+  pop() {
+    if (this.$length === 0) return;
+    --this.$length;
+    const queue = this.heap.peek();
+    const value = queue.pop();
 
+    if (queue.isEmpty()) {
+      this.heap.extract();
+      this.clean && this.dict.delete(queue[PriorityQueue.priority]);
+    }
 
-var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
-  if (k2 === undefined) k2 = k;
-  var desc = Object.getOwnPropertyDescriptor(m, k);
+    return value;
+  }
 
-  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-    desc = {
-      enumerable: true,
-      get: function () {
-        return m[k];
-      }
-    };
+  clear() {
+    this.heap.clear();
+    this.dict.clear();
+    this.$length = 0;
   }
 
-  Object.defineProperty(o, k2, desc);
-} : function (o, m, k, k2) {
-  if (k2 === undefined) k2 = k;
-  o[k2] = m[k];
-});
+  *[Symbol.iterator]() {
+    while (!this.isEmpty()) {
+      yield this.pop();
+    }
 
-var __exportStar = this && this.__exportStar || function (m, exports) {
-  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
+    return;
+  }
 
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
+}
 
-__exportStar(__webpack_require__(5084), exports);
+exports.PriorityQueue = PriorityQueue;
+PriorityQueue.priority = Symbol('priority');
+PriorityQueue.max = heap_1.Heap.max;
+PriorityQueue.min = heap_1.Heap.min;
 
 /***/ }),
 
@@ -1695,12 +2036,14 @@ function unique(rnd, len, mem) {
   let limit = 5;
   return () => {
     while (true) {
-      for (let i = 0; i < limit; ++i) {
-        const r = rnd(len);
-        if (mem.has(r)) continue;
-        mem.add(r);
-        return r;
-      }
+      try {
+        for (let i = 0; i < limit; ++i) {
+          const r = rnd(len);
+          if (mem.has(r)) continue;
+          mem.add(r);
+          return r;
+        }
+      } catch {}
 
       clear && mem.clear();
       ++len;
@@ -1761,6 +2104,235 @@ function random(len) {
 
 /***/ }),
 
+/***/ 6395:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Ring = void 0;
+
+const global_1 = __webpack_require__(4128);
+
+const alias_1 = __webpack_require__(5406);
+
+const array_1 = __webpack_require__(8112);
+
+const undefined = void 0;
+const empty = Symbol('empty');
+
+const unempty = value => value === empty ? undefined : value;
+
+const space = Object.freeze((0, global_1.Array)(100).fill(empty));
+let size = 16;
+
+class Ring {
+  constructor() {
+    this.array = (0, global_1.Array)(size);
+    this.head = 0;
+    this.tail = 0;
+    this.$length = 0;
+    this.excess = 0;
+  }
+
+  get length() {
+    return this.$length;
+  }
+
+  at(index) {
+    // Inline the code for optimization.
+    const array = this.array;
+
+    if (index >= 0) {
+      if (index >= this.$length) return;
+      return unempty(array[(this.head - 1 + index) % array.length]);
+    } else {
+      if (-index > this.$length) return;
+      return this.tail + index >= 0 ? unempty(array[this.tail + index]) : unempty(array[array.length + this.tail + index]);
+    }
+  }
+
+  replace(index, value, replacer) {
+    const array = this.array;
+
+    if (index >= 0) {
+      if (index >= this.$length) throw new RangeError('Invalid index');
+      index = (this.head - 1 + index) % array.length;
+    } else {
+      if (-index > this.$length) throw new RangeError('Invalid index');
+      index = this.tail + index >= 0 ? this.tail + index : array.length + this.tail + index;
+    }
+
+    const val = unempty(array[index]);
+    array[index] = replacer ? replacer(val, value) : value;
+    return val;
+  }
+
+  push(value) {
+    const array = this.array;
+    let {
+      head,
+      tail
+    } = this;
+    tail = this.tail = next(head, tail, array.length);
+    head = this.head ||= tail;
+
+    if (head === tail && this.$length !== 0) {
+      (0, array_1.splice)(array, tail - 1, 0, ...space);
+      head = this.head += space.length;
+    }
+
+    array[tail - 1] = value;
+    ++this.$length;
+  }
+
+  unshift(value) {
+    const array = this.array;
+    let {
+      head,
+      tail
+    } = this;
+    head = this.head = prev(head, tail, array.length);
+    tail = this.tail ||= head;
+
+    if (head === tail && this.$length !== 0) {
+      (0, array_1.splice)(array, head, 0, ...space);
+      head = this.head += space.length;
+    }
+
+    array[head - 1] = value;
+    ++this.$length;
+  }
+
+  pop() {
+    if (this.$length === 0) return;
+    const array = this.array;
+    const i = this.tail - 1;
+    const value = unempty(array[i]);
+    array[i] = empty;
+    --this.$length === 0 ? this.head = this.tail = 0 : this.tail = this.tail === 1 ? array.length : this.tail - 1;
+    return value;
+  }
+
+  shift() {
+    if (this.$length === 0) return;
+    const array = this.array;
+    const i = this.head - 1;
+    const value = unempty(array[i]);
+    array[i] = empty;
+    --this.$length === 0 ? this.head = this.tail = 0 : this.head = this.head === array.length ? 1 : this.head + 1;
+    return value;
+  }
+
+  splice(index, count, ...values) {
+    const array = this.array;
+
+    if (this.excess > 100 && array.length - this.$length > 200) {
+      (0, array_1.splice)(array, 0, 100 - (0, array_1.splice)(array, this.tail, 100).length);
+      this.excess -= 100;
+    } else if (-this.excess > array.length * 2) {
+      this.excess = array.length;
+    }
+
+    index = index < 0 ? (0, alias_1.max)(0, this.$length + index) : index <= this.$length ? index : this.$length;
+    count = (0, alias_1.min)((0, alias_1.max)(count, 0), this.$length - index);
+
+    if (values.length === 0) {
+      if (count === 0) return [];
+
+      switch (index) {
+        case 0:
+          if (count === 1) return [this.shift()];
+          break;
+
+        case this.$length - 1:
+          if (count === 1) return [this.pop()];
+          break;
+
+        case this.$length:
+          return [];
+      }
+    }
+
+    index = (this.head || 1) - 1 + index;
+    index = index > array.length ? index % array.length : index;
+    this.excess += values.length - count;
+    this.$length += values.length - count; // |--H>*>T--|
+
+    if (this.head <= this.tail) {
+      this.tail += values.length - count;
+      return (0, array_1.splice)(array, index, count, ...values);
+    } // |*>T---H>>|
+
+
+    if (index < this.tail) {
+      this.head += values.length - count;
+      this.tail += values.length - count;
+      return (0, array_1.splice)(array, index, count, ...values);
+    } // |>>T---H>*|
+
+
+    const cnt = (0, alias_1.min)(count, array.length - index);
+    const vs = (0, array_1.splice)(array, index, cnt, ...(0, array_1.splice)(values, 0, cnt));
+    vs.push(...(0, array_1.splice)(array, 0, count - vs.length, ...values));
+    return vs;
+  }
+
+  clear() {
+    this.array = (0, global_1.Array)(size);
+    this.$length = this.head = this.tail = 0;
+  }
+
+  includes(value) {
+    return this.array.includes(value);
+  }
+
+  relational(index) {
+    if (index === -1) return -1;
+    return index + 1 >= this.head ? index + 1 - this.head : this.array.length - this.head + index;
+  }
+
+  indexOf(value) {
+    return this.relational((0, array_1.indexOf)(this.array, value));
+  }
+
+  findIndex(f) {
+    return this.relational(this.array.findIndex(value => value !== empty && f(value)));
+  }
+
+  find(f) {
+    return unempty(this.array.find(value => value !== empty && f(value)));
+  }
+
+  toArray() {
+    return this.head <= this.tail ? this.array.slice((this.head || 1) - 1, this.tail) : this.array.slice((this.head || 1) - 1).concat(this.array.slice(0, this.tail));
+  }
+
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.$length; ++i) {
+      yield this.at(i);
+    }
+
+    return;
+  }
+
+}
+
+exports.Ring = Ring;
+
+function next(head, tail, length) {
+  return tail === length && head !== 1 ? 1 : tail + 1;
+}
+
+function prev(head, tail, length) {
+  return head === 0 || head === 1 ? tail === length ? length + 1 : length : head - 1;
+}
+
+/***/ }),
+
 /***/ 5177:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
@@ -1847,84 +2419,80 @@ Object.defineProperty(exports, "ReadonlyURL", ({
     return format_3.ReadonlyURL;
   }
 }));
-const internal = Symbol.for('spica/url::internal');
 
 class URL {
   constructor(source, base) {
     this.source = source;
     this.base = base;
-    this[internal] = {
-      url: new format_1.ReadonlyURL(source, base),
-      searchParams: void 0
-    };
+    this.url = new format_1.ReadonlyURL(source, base);
   }
 
   get href() {
-    return this[internal].searchParams?.toString().replace(/^(?=.)/, `${this[internal].url.href.slice(0, -this[internal].url.query.length - this[internal].url.fragment.length || this[internal].url.href.length)}?`).concat(this.fragment) ?? this[internal].url.href;
+    return this.params?.toString().replace(/^(?=.)/, `${this.url.href.slice(0, -this.url.query.length - this.url.fragment.length || this.url.href.length)}?`).concat(this.fragment) ?? this.url.href;
   }
 
   get resource() {
-    return this[internal].searchParams?.toString().replace(/^(?=.)/, `${this[internal].url.href.slice(0, -this[internal].url.query.length - this[internal].url.fragment.length || this[internal].url.href.length)}?`) ?? this[internal].url.resource;
+    return this.params?.toString().replace(/^(?=.)/, `${this.url.href.slice(0, -this.url.query.length - this.url.fragment.length || this.url.href.length)}?`) ?? this.url.resource;
   }
 
   get origin() {
-    return this[internal].url.origin;
+    return this.url.origin;
   }
 
   get scheme() {
-    return this[internal].url.protocol.slice(0, -1);
+    return this.url.protocol.slice(0, -1);
   }
 
   get protocol() {
-    return this[internal].url.protocol;
+    return this.url.protocol;
   }
 
   get username() {
-    return this[internal].url.username;
+    return this.url.username;
   }
 
   get password() {
-    return this[internal].url.password;
+    return this.url.password;
   }
 
   get host() {
-    return this[internal].url.host;
+    return this.url.host;
   }
 
   get hostname() {
-    return this[internal].url.hostname;
+    return this.url.hostname;
   }
 
   get port() {
-    return this[internal].url.port;
+    return this.url.port;
   }
 
   get path() {
-    return this[internal].searchParams?.toString().replace(/^(?=.)/, `${this.pathname}?`) ?? this[internal].url.path;
+    return this.params?.toString().replace(/^(?=.)/, `${this.pathname}?`) ?? this.url.path;
   }
 
   get pathname() {
-    return this[internal].url.pathname;
+    return this.url.pathname;
   }
 
   get search() {
-    return this[internal].searchParams?.toString().replace(/^(?=.)/, '?') ?? this[internal].url.search;
+    return this.params?.toString().replace(/^(?=.)/, '?') ?? this.url.search;
   }
 
   get query() {
-    return this[internal].searchParams?.toString().replace(/^(?=.)/, '?') ?? this[internal].url.query;
+    return this.params?.toString().replace(/^(?=.)/, '?') ?? this.url.query;
   }
 
   get hash() {
-    return this[internal].url.hash;
+    return this.url.hash;
   }
 
   get fragment() {
-    return this[internal].url.fragment;
+    return this.url.fragment;
   }
 
   get searchParams() {
-    return this[internal].searchParams ??= new global_1.URLSearchParams(this.search);
+    return this.params ??= new global_1.URLSearchParams(this.search);
   }
 
   toString() {
@@ -1973,7 +2541,6 @@ function encode(url) {
 }
 
 exports._encode = encode;
-const internal = Symbol.for('spica/url::internal');
 
 class ReadonlyURL {
   constructor(source, base) {
@@ -2006,74 +2573,71 @@ class ReadonlyURL {
 
     }
 
-    this[internal] = {
-      share: ReadonlyURL.get(source, base),
-      searchParams: void 0
-    };
+    this.share = ReadonlyURL.get(source, base);
   }
 
   get href() {
-    return this[internal].share.href ??= this[internal].share.url.href;
+    return this.share.href ??= this.share.url.href;
   }
 
   get resource() {
-    return this[internal].share.resource ??= this.href.slice(0, -this.fragment.length - this.query.length || this.href.length) + this.search;
+    return this.share.resource ??= this.href.slice(0, -this.fragment.length - this.query.length || this.href.length) + this.search;
   }
 
   get origin() {
-    return this[internal].share.origin ??= this[internal].share.url.origin;
+    return this.share.origin ??= this.share.url.origin;
   }
 
   get protocol() {
-    return this[internal].share.protocol ??= this[internal].share.url.protocol;
+    return this.share.protocol ??= this.share.url.protocol;
   }
 
   get username() {
-    return this[internal].share.username ??= this[internal].share.url.username;
+    return this.share.username ??= this.share.url.username;
   }
 
   get password() {
-    return this[internal].share.password ??= this[internal].share.url.password;
+    return this.share.password ??= this.share.url.password;
   }
 
   get host() {
-    return this[internal].share.host ??= this[internal].share.url.host;
+    return this.share.host ??= this.share.url.host;
   }
 
   get hostname() {
-    return this[internal].share.hostname ??= this[internal].share.url.hostname;
+    return this.share.hostname ??= this.share.url.hostname;
   }
 
   get port() {
-    return this[internal].share.port ??= this[internal].share.url.port;
+    return this.share.port ??= this.share.url.port;
   }
 
   get path() {
-    return this[internal].share.path ??= `${this.pathname}${this.search}`;
+    return this.share.path ??= `${this.pathname}${this.search}`;
   }
 
   get pathname() {
-    return this[internal].share.pathname ??= this[internal].share.url.pathname;
+    return this.share.pathname ??= this.share.url.pathname;
   }
 
   get search() {
-    return this[internal].share.search ??= this[internal].share.url.search;
+    return this.share.search ??= this.share.url.search;
   }
 
   get query() {
-    return this[internal].share.query ??= this.search || this.href[this.href.length - this.fragment.length - 1] === '?' && '?' || '';
+    return this.share.query ??= this.search || this.href[this.href.length - this.fragment.length - 1] === '?' && '?' || '';
   }
 
   get hash() {
-    return this[internal].share.hash ??= this[internal].share.url.hash;
+    return this.share.hash ??= this.share.url.hash;
   }
 
   get fragment() {
-    return this[internal].share.fragment ??= this.hash || this.href[this.href.length - 1] === '#' && '#' || '';
+    return this.share.fragment ??= this.hash || this.href[this.href.length - 1] === '#' && '#' || '';
   }
 
   get searchParams() {
-    return this[internal].searchParams ??= new global_1.URLSearchParams(this.search);
+    return this.params ??= new global_1.URLSearchParams(this.search);
   }
 
   toString() {
@@ -3309,7 +3873,7 @@ class Memo {
   clear(position) {
     const memory = this.memory;
 
-    for (let i = position, len = memory.length; i < len; ++i) {
+    for (let len = memory.length, i = position; i < len; ++i) {
       memory.pop();
     } //console.log('clear', position + 1);
 
@@ -3347,7 +3911,7 @@ function inits(parsers, resume) {
     let rest = source;
     let nodes;
 
-    for (let i = 0, len = parsers.length; i < len; ++i) {
+    for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') break;
       if (context.delimiters?.match(rest, context.precedence)) break;
       const result = parsers[i]({
@@ -3394,7 +3958,7 @@ function sequence(parsers, resume) {
     let rest = source;
     let nodes;
 
-    for (let i = 0, len = parsers.length; i < len; ++i) {
+    for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') return;
       if (context.delimiters?.match(rest, context.precedence)) return;
       const result = parsers[i]({
@@ -3858,7 +4422,7 @@ function bind(target, settings) {
   function nearest(index) {
     let el;
 
-    for (let i = 0, len = 0; i < blocks.length; ++i) {
+    for (let len = 0, i = 0; i < blocks.length; ++i) {
       const block = blocks[i];
       len += block[0].length;
       el = block[1][0] ?? el;
@@ -3869,7 +4433,7 @@ function bind(target, settings) {
   }
 
   function index(source) {
-    for (let i = 0, len = 0; i < blocks.length; ++i) {
+    for (let len = 0, i = 0; i < blocks.length; ++i) {
       const block = blocks[i];
       if (block[1].includes(source)) return len;
       len += block[0].length;
@@ -4065,10 +4629,10 @@ const figure_1 = __webpack_require__(9123);
 
 const footnote_1 = __webpack_require__(7529);
 
-const dom_1 = __webpack_require__(3252);
-
 const url_1 = __webpack_require__(2261);
 
+const dom_1 = __webpack_require__(3252);
+
 function parse(source, opts = {}, context) {
   if (!(0, segment_1.validate)(source, segment_1.MAX_SEGMENT_SIZE)) throw new Error(`Too large input over ${segment_1.MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.`);
   const url = (0, header_2.headers)(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
@@ -4207,10 +4771,10 @@ const reply_1 = __webpack_require__(9978);
 
 const paragraph_1 = __webpack_require__(6457);
 
-const dom_1 = __webpack_require__(3252);
-
 const random_1 = __webpack_require__(7325);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.block = (0, combinator_1.creation)(1, false, error((0, combinator_1.reset)({
   resources: {
     clock: 50 * 1000,
@@ -4281,7 +4845,7 @@ const markdown = (0, combinator_1.lazy)(() => (0, combinator_1.fmap)((0, combina
       references
     }
   }, context);
-  return [[(0, dom_1.html)('section', [document, references])], ''];
+  return [[(0, dom_1.html)('section', [document, (0, dom_1.html)('h2', 'References'), references])], ''];
 })))]))), ns => [(0, dom_1.html)('blockquote', ns)]));
 
 /***/ }),
@@ -4382,10 +4946,10 @@ const locale_1 = __webpack_require__(5485);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.dlist = (0, combinator_1.lazy)(() => (0, combinator_1.block)((0, locale_1.localize)((0, combinator_1.fmap)((0, combinator_1.validate)(/^~[^\S\n]+(?=\S)/, (0, combinator_1.some)((0, combinator_1.inits)([(0, combinator_1.state)(128
 /* State.annotation */
 | 64
@@ -4492,7 +5056,7 @@ exports.aside = (0, combinator_1.block)((0, combinator_1.validate)('~~~', (0, co
   return [(0, dom_1.html)('aside', {
     id: (0, indexee_1.identity)((0, indexee_1.text)(heading)),
     class: 'aside'
-  }, [document, references])];
+  }, [document, (0, dom_1.html)('h2', 'References'), references])];
 })));
 
 /***/ }),
@@ -4546,7 +5110,7 @@ exports.example = (0, combinator_1.block)((0, combinator_1.validate)('~~~', (0,
           'data-type': 'markdown'
         }, [(0, dom_1.html)('pre', {
           translate: 'no'
-        }, body.slice(0, -1)), (0, dom_1.html)('hr'), (0, dom_1.html)('section', [document, references])])];
+        }, body.slice(0, -1)), (0, dom_1.html)('hr'), (0, dom_1.html)('section', [document, (0, dom_1.html)('h2', 'References'), references])])];
       }
 
     case 'math':
@@ -4682,10 +5246,10 @@ const locale_1 = __webpack_require__(5485);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const memoize_1 = __webpack_require__(1808);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.segment = (0, combinator_1.block)((0, combinator_1.match)(/^(~{3,})(?:figure[^\S\n])?(?=\[?\$)/, (0, memoize_1.memoize)(([, fence], closer = new RegExp(String.raw`^${fence}[^\S\n]*(?:$|\n)`)) => (0, combinator_1.close)((0, combinator_1.sequence)([source_1.contentline, (0, combinator_1.inits)([// All parsers which can include closing terms.
 (0, combinator_1.union)([codeblock_1.segment_, mathblock_1.segment_, table_2.segment_, blockquote_1.segment, placeholder_1.segment_, (0, combinator_1.some)(source_1.contentline, closer)]), source_1.emptyline, (0, combinator_1.union)([source_1.emptyline, (0, combinator_1.some)(source_1.contentline, closer)])])]), closer), ([, fence]) => fence.length, [])));
 exports.figure = (0, combinator_1.block)((0, combinator_1.fallback)((0, combinator_1.rewrite)(exports.segment, (0, combinator_1.fmap)((0, combinator_1.convert)(source => source.slice(source.match(/^~+(?:\w+\s+)?/)[0].length, source.trimEnd().lastIndexOf('\n')), (0, combinator_1.sequence)([(0, combinator_1.line)((0, combinator_1.sequence)([label_1.label, (0, source_1.str)(/^(?=\s).*\n/)])), (0, combinator_1.inits)([(0, combinator_1.block)((0, combinator_1.union)([ulist_1.ulist, olist_1.olist, table_1.table, codeblock_1.codeblock, mathblock_1.mathblock, example_1.example, table_2.table, blockquote_1.blockquote, placeholder_1.placeholder, (0, combinator_1.line)(inline_1.media), (0, combinator_1.line)(inline_1.shortmedia)])), source_1.emptyline, (0, combinator_1.block)((0, locale_1.localize)((0, combinator_1.state)(4
@@ -4834,10 +5398,10 @@ const blockquote_1 = __webpack_require__(7859);
 
 const paragraph_1 = __webpack_require__(6457);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.message = (0, combinator_1.block)((0, combinator_1.validate)('~~~', (0, combinator_1.fmap)((0, combinator_1.fence)(/^(~{3,})message\/(\S+)([^\n]*)(?:$|\n)/, 300), // Bug: Type mismatch between outer and inner.
 ([body, overflow, closer, opener, delim, type, param], _, context) => {
   if (!closer || overflow || param.trimStart()) return [(0, dom_1.html)('pre', {
@@ -4944,10 +5508,10 @@ const locale_1 = __webpack_require__(5485);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 const opener = /^(~{3,})table(?:\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/;
 exports.segment = (0, combinator_1.block)((0, combinator_1.validate)('~~~', (0, combinator_1.clear)((0, combinator_1.fence)(opener, 10000))));
 exports.segment_ = (0, combinator_1.block)((0, combinator_1.validate)('~~~', (0, combinator_1.clear)((0, combinator_1.fence)(opener, 10000, false))), false);
@@ -5363,14 +5927,12 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const memoize_1 = __webpack_require__(1808);
 
-const duff_1 = __webpack_require__(8099);
-
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 const openers = {
   '.': /^([0-9]+|[a-z]+|[A-Z]+)(?:-(?!-)[0-9]*)*(?![^\S\n])\.?(?:$|\s)/,
   '(': /^\(([0-9]*|[a-z]*)(?![^)\n])\)?(?:-(?!-)[0-9]*)*(?:$|\s)/
@@ -5471,19 +6033,20 @@ function format(el, type, form) {
     'data-type': style(type) || global_1.undefined
   });
   const marker = el.firstElementChild?.getAttribute('data-marker').match(initial(type))?.[0] ?? '';
-  const es = el.children;
-  (0, duff_1.duffbk)(es.length, i => {
+
+  for (let es = el.children, len = es.length, i = 0; i < len; ++i) {
     const el = es[i];
 
     switch (el.getAttribute('data-marker')) {
       case '':
       case marker:
         el.removeAttribute('data-marker');
-        return;
+        continue;
     }
 
-    return false;
-  });
+    break;
+  }
+
   return el;
 }
 
@@ -5539,9 +6102,9 @@ const locale_1 = __webpack_require__(5485);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
+
+const dom_1 = __webpack_require__(3252);
 /*
 必ず対象指定から始まる
 対象がページである場合>>.を表現方法とする
@@ -5726,12 +6289,12 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const duff_1 = __webpack_require__(8099);
 
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.table = (0, combinator_1.lazy)(() => (0, combinator_1.block)((0, combinator_1.fmap)((0, combinator_1.validate)(/^\|[^\n]*(?:\n\|[^\n]*){2}/, (0, combinator_1.sequence)([row((0, combinator_1.some)(head), true), row((0, combinator_1.some)(align), false), (0, combinator_1.some)(row((0, combinator_1.some)(data), true))])), rows => [(0, dom_1.html)('table', [(0, dom_1.html)('thead', [rows.shift()]), (0, dom_1.html)('tbody', format(rows))])])));
 
 const row = (parser, optional) => (0, combinator_1.creation)(1, false, (0, combinator_1.fallback)((0, combinator_1.fmap)((0, combinator_1.line)((0, combinator_1.surround)(/^(?=\|)/, (0, combinator_1.some)((0, combinator_1.union)([parser])), /^[|\\]?\s*$/, optional)), es => [(0, dom_1.html)('tr', es)]), (0, combinator_1.rewrite)(source_1.contentline, ({
@@ -5752,14 +6315,14 @@ function format(rows) {
   const aligns = rows[0].className === 'invalid' ? [] : (0, duff_1.duffReduce)(rows.shift().children, (acc, el) => (0, array_1.push)(acc, [el.textContent]), []);
 
   for (let i = 0; i < rows.length; ++i) {
-    (0, duff_1.duffEach)(rows[i].children, (col, i) => {
-      if (i > 0 && !aligns[i]) {
-        aligns[i] = aligns[i - 1];
+    for (let cols = rows[i].children, len = cols.length, j = 0; j < len; ++j) {
+      if (j > 0 && !aligns[j]) {
+        aligns[j] = aligns[j - 1];
       }
 
-      if (!aligns[i]) return;
-      col.setAttribute('align', aligns[i]);
-    });
+      if (!aligns[j]) continue;
+      cols[j].setAttribute('align', aligns[j]);
+    }
   }
 
   return rows;
@@ -5788,10 +6351,10 @@ const inline_1 = __webpack_require__(1160);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.ulist = (0, combinator_1.lazy)(() => (0, combinator_1.block)((0, combinator_1.validate)(/^-(?=[^\S\n]|\n[^\S\n]*\S)/, (0, combinator_1.state)(4
 /* State.media */
 , exports.ulist_))));
@@ -5886,8 +6449,6 @@ exports.shortmedia = exports.media = exports.indexer = exports.indexee = exports
 
 const combinator_1 = __webpack_require__(2087);
 
-const escape_1 = __webpack_require__(2778);
-
 const annotation_1 = __webpack_require__(2736);
 
 const reference_1 = __webpack_require__(3555);
@@ -5930,7 +6491,7 @@ const bracket_1 = __webpack_require__(5196);
 
 const source_1 = __webpack_require__(6743);
 
-exports.inline = (0, combinator_1.union)([escape_1.escape, annotation_1.annotation, reference_1.reference, template_1.template, comment_1.comment, math_1.math, extension_1.extension, ruby_1.ruby, link_1.link, media_1.media, html_1.html, insertion_1.insertion, deletion_1.deletion, mark_1.mark, strong_1.strong, emphasis_1.emphasis, code_1.code, htmlentity_1.htmlentity, shortmedia_1.shortmedia, autolink_1.autolink, bracket_1.bracket, source_1.text]);
+exports.inline = (0, combinator_1.union)([annotation_1.annotation, reference_1.reference, template_1.template, comment_1.comment, math_1.math, extension_1.extension, ruby_1.ruby, link_1.link, media_1.media, html_1.html, insertion_1.insertion, deletion_1.deletion, mark_1.mark, strong_1.strong, emphasis_1.emphasis, code_1.code, htmlentity_1.htmlentity, shortmedia_1.shortmedia, autolink_1.autolink, bracket_1.bracket, source_1.text]);
 
 var indexee_1 = __webpack_require__(1269);
 
@@ -6283,10 +6844,10 @@ const inline_1 = __webpack_require__(1160);
 
 const source_1 = __webpack_require__(6743);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 exports.bracket = (0, combinator_1.lazy)(() => (0, combinator_1.union)([(0, combinator_1.surround)((0, source_1.str)('('), (0, combinator_1.syntax)(0
 /* Syntax.none */
@@ -6369,12 +6930,12 @@ const inline_1 = __webpack_require__(1160);
 
 const source_1 = __webpack_require__(6743);
 
-const dom_1 = __webpack_require__(3252);
-
 const memoize_1 = __webpack_require__(1808);
 
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.comment = (0, combinator_1.lazy)(() => (0, combinator_1.validate)('[%', (0, combinator_1.syntax)(0
 /* Syntax.none */
 , 4, 1, 0
@@ -6406,11 +6967,11 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
-exports.deletion = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('~~'), (0, combinator_1.syntax)(0
+const dom_1 = __webpack_require__(3252);
+
+exports.deletion = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('~~', '~'), (0, combinator_1.syntax)(0
 /* Syntax.none */
 , 1, 1, 0
 /* State.none */
@@ -6431,60 +6992,21 @@ exports.emphasis = void 0;
 
 const combinator_1 = __webpack_require__(2087);
 
-const inline_1 = __webpack_require__(1160);
-
-const source_1 = __webpack_require__(6743);
-
-const visibility_1 = __webpack_require__(7618);
-
-const dom_1 = __webpack_require__(3252);
-
-const array_1 = __webpack_require__(8112);
-
-exports.emphasis = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('_'), (0, combinator_1.syntax)(0
-/* Syntax.none */
-, 1, 1, 0
-/* State.none */
-, (0, visibility_1.startTight)((0, combinator_1.some)((0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, (0, visibility_1.blankWith)('_')), (0, combinator_1.open)((0, combinator_1.some)(inline_1.inline, '_'), exports.emphasis)])), '_')), (0, source_1.str)('_'), false, ([, bs], rest) => [[(0, dom_1.html)('em', (0, dom_1.defrag)(bs))], rest], ([as, bs], rest) => [(0, array_1.unshift)(as, bs), rest]));
-
-/***/ }),
-
-/***/ 2778:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-exports.escape = void 0;
-
-const global_1 = __webpack_require__(4128);
-
-const combinator_1 = __webpack_require__(2087);
-
+const inline_1 = __webpack_require__(1160);
+
 const source_1 = __webpack_require__(6743);
 
-const repeat = (0, source_1.str)(/^(.)\1*/);
-exports.escape = (0, combinator_1.union)([({
-  source,
-  context
-}) => {
-  switch (source[0]) {
-    case '+':
-    case '~':
-    case '=':
-      if (!source[2]) return;
-      return source[2] === source[0] && source[1] === source[0] ? repeat({
-        source,
-        context
-      }) : global_1.undefined;
+const visibility_1 = __webpack_require__(7618);
 
-    default:
-      return;
-  }
-}]);
+const array_1 = __webpack_require__(8112);
+
+const dom_1 = __webpack_require__(3252);
+
+exports.emphasis = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('_', '_'), (0, combinator_1.syntax)(0
+/* Syntax.none */
+, 1, 1, 0
+/* State.none */
+, (0, visibility_1.startTight)((0, combinator_1.some)((0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, (0, visibility_1.blankWith)('_')), (0, combinator_1.open)((0, combinator_1.some)(inline_1.inline, '_'), exports.emphasis)])))), (0, source_1.str)('_'), false, ([, bs], rest) => [[(0, dom_1.html)('em', (0, dom_1.defrag)(bs))], rest], ([as, bs], rest) => [(0, array_1.unshift)(as, bs), rest]));
 
 /***/ }),
 
@@ -6574,7 +7096,7 @@ const combinator_1 = __webpack_require__(2087);
 
 const dom_1 = __webpack_require__(3252);
 
-const duff_1 = __webpack_require__(8099);
+const query_1 = __webpack_require__(6120);
 
 function indexee(parser, optional) {
   return (0, combinator_1.fmap)(parser, ([el], _, {
@@ -6599,37 +7121,41 @@ function text(source, optional = false) {
   const index = indexer?.getAttribute('data-index');
   if (index) return index;
   const target = source.cloneNode(true);
-  (0, duff_1.duffEach)(target.querySelectorAll('code[data-src], .math[data-src], .comment, rt, rp, .reference, .checkbox, ul, ol'), el => {
+
+  for (let es = (0, query_1.querySelectorAll)(target, 'code[data-src], .math[data-src], .comment, rt, rp, .reference, .checkbox, ul, ol'), i = 0; i < es.length; ++i) {
+    const el = es[i];
+
     switch (el.tagName) {
       case 'CODE':
         (0, dom_1.define)(el, el.getAttribute('data-src'));
-        return;
+        continue;
 
       case 'RT':
       case 'RP':
       case 'UL':
       case 'OL':
         el.remove();
-        return;
+        continue;
     }
 
     switch (el.className) {
       case 'math':
         (0, dom_1.define)(el, el.getAttribute('data-src'));
-        return;
+        continue;
 
       case 'comment':
       case 'checkbox':
         el.remove();
-        return;
+        continue;
 
       case 'reference':
         el.firstChild.remove();
-        return;
+        continue;
     }
-  }); // Better:
+  } // Better:
   //return target.innerText;
 
+
   return target.textContent;
 }
 
@@ -6739,9 +7265,9 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
+const array_1 = __webpack_require__(8112);
 
-const array_1 = __webpack_require__(8112); // Don't use the symbols already used: !#$%@&*+~=
+const dom_1 = __webpack_require__(3252); // Don't use the symbols already used: !#$%@&*+~=
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
 
@@ -6779,14 +7305,14 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const memoize_1 = __webpack_require__(1808);
 
 const cache_1 = __webpack_require__(9210);
 
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 const tags = global_1.Object.freeze(['bdo', 'bdi']);
 const attrspecs = {
   bdo: {
@@ -6912,11 +7438,11 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
-exports.insertion = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('++'), (0, combinator_1.syntax)(0
+const dom_1 = __webpack_require__(3252);
+
+exports.insertion = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('++', '+'), (0, combinator_1.syntax)(0
 /* Syntax.none */
 , 1, 1, 0
 /* State.none */
@@ -6953,10 +7479,10 @@ const visibility_1 = __webpack_require__(7618);
 
 const util_1 = __webpack_require__(9437);
 
-const dom_1 = __webpack_require__(3252);
-
 const url_1 = __webpack_require__(2261);
 
+const dom_1 = __webpack_require__(3252);
+
 const optspec = {
   rel: ['nofollow']
 };
@@ -7118,11 +7644,11 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
-exports.mark = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('=='), (0, combinator_1.syntax)(0
+const dom_1 = __webpack_require__(3252);
+
+exports.mark = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('==', '='), (0, combinator_1.syntax)(0
 /* Syntax.none */
 , 1, 1, 0
 /* State.none */
@@ -7193,12 +7719,12 @@ const htmlentity_1 = __webpack_require__(1562);
 
 const source_1 = __webpack_require__(6743);
 
-const dom_1 = __webpack_require__(3252);
-
 const url_1 = __webpack_require__(2261);
 
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 const optspec = {
   'width': [],
   'height': [],
@@ -7369,10 +7895,10 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.ruby = (0, combinator_1.lazy)(() => (0, combinator_1.validate)('[', (0, combinator_1.syntax)(512
 /* Syntax.ruby */
 , 2, 1, -1
@@ -7506,15 +8032,15 @@ const source_1 = __webpack_require__(6743);
 
 const visibility_1 = __webpack_require__(7618);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
-exports.strong = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('*'), (0, combinator_1.syntax)(0
+const dom_1 = __webpack_require__(3252);
+
+exports.strong = (0, combinator_1.lazy)(() => (0, combinator_1.surround)((0, source_1.str)('*', '*'), (0, combinator_1.syntax)(0
 /* Syntax.none */
 , 1, 1, 0
 /* State.none */
-, (0, visibility_1.startTight)((0, combinator_1.some)((0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, (0, visibility_1.blankWith)('*')), (0, combinator_1.open)((0, combinator_1.some)(inline_1.inline, '*'), exports.strong)])), '*')), (0, source_1.str)('*'), false, ([, bs], rest) => [[(0, dom_1.html)('strong', (0, dom_1.defrag)(bs))], rest], ([as, bs], rest) => [(0, array_1.unshift)(as, bs), rest]));
+, (0, visibility_1.startTight)((0, combinator_1.some)((0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, (0, visibility_1.blankWith)('*')), (0, combinator_1.open)((0, combinator_1.some)(inline_1.inline, '*'), exports.strong)])))), (0, source_1.str)('*'), false, ([, bs], rest) => [[(0, dom_1.html)('strong', (0, dom_1.defrag)(bs))], rest], ([as, bs], rest) => [(0, array_1.unshift)(as, bs), rest]));
 
 /***/ }),
 
@@ -7535,10 +8061,10 @@ const combinator_1 = __webpack_require__(2087);
 
 const source_1 = __webpack_require__(6743);
 
-const dom_1 = __webpack_require__(3252);
-
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
 exports.template = (0, combinator_1.lazy)(() => (0, combinator_1.surround)('{{', (0, combinator_1.syntax)(0
 /* Syntax.none */
 , 2, 1, -1
@@ -7567,16 +8093,19 @@ const ja_1 = __webpack_require__(1499);
 
 const dom_1 = __webpack_require__(3252);
 
-const duff_1 = __webpack_require__(8099);
+const query_1 = __webpack_require__(6120);
 
 function localize(parser) {
   return (0, combinator_1.fmap)(parser, ns => {
     if (ns.length === 0) return ns;
     const el = ns.length === 1 && typeof ns[0] === 'object' ? ns[0] : (0, dom_1.html)('div', ns);
-    (0, duff_1.duffEach)(el.querySelectorAll('.linebreak:not(:empty)'), el => {
-      if (!check(el)) return;
+
+    for (let es = (0, query_1.querySelectorAll)(el, '.linebreak:not(:empty)'), i = 0; i < es.length; ++i) {
+      const el = es[i];
+      if (!check(el)) continue;
       el.firstChild.remove();
-    });
+    }
+
     return ns;
   });
 }
@@ -7640,7 +8169,7 @@ Object.defineProperty(exports, "__esModule", ({
 exports.japanese = void 0;
 
 function japanese(char) {
-  return /^[\p{Ideo}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}～！？]/u.test(char);
+  return /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？]/u.test(char);
 }
 
 exports.japanese = japanese;
@@ -7662,22 +8191,24 @@ const global_1 = __webpack_require__(4128);
 
 const label_1 = __webpack_require__(466);
 
-const dom_1 = __webpack_require__(3252);
-
 const multimap_1 = __webpack_require__(940);
 
 const array_1 = __webpack_require__(8112);
 
+const dom_1 = __webpack_require__(3252);
+
+const query_1 = __webpack_require__(6120);
+
 function* figure(target, footnotes, opts = {}) {
-  const refs = new multimap_1.MultiMap((0, array_1.push)((0, array_1.push)([], target.querySelectorAll('a.label:not(.disabled)[data-label]')), footnotes?.references.querySelectorAll('a.label:not(.disabled)') ?? []).map(el => [el.getAttribute('data-label'), el]));
+  const refs = new multimap_1.MultiMap((0, array_1.push)((0, query_1.querySelectorAll)(target, 'a.label:not(.disabled)[data-label]'), footnotes && (0, query_1.querySelectorAll)(footnotes.references, 'a.label:not(.disabled)') || []).map(el => [el.getAttribute('data-label'), el]));
   const labels = new global_1.Set();
   const numbers = new global_1.Map();
   let base = '0';
   let bases = base.split('.');
   let index = bases; // Bug: Firefox
-  //for (let defs = target.querySelectorAll(':scope > figure[data-label], :scope > h1, :scope > h2'), i = 0, len = defs.length; i < len; ++i) {
+  //for (let defs = querySelectorAll(target, ':scope > figure[data-label], :scope > h1, :scope > h2'), len = defs.length, i = 0; i < len; ++i) {
 
-  for (let defs = target.querySelectorAll('figure[data-label], h1, h2'), i = 0, len = defs.length; i < len; ++i) {
+  for (let defs = (0, query_1.querySelectorAll)(target, 'figure[data-label], h1, h2'), len = defs.length, i = 0; i < len; ++i) {
     yield;
     const def = defs[i];
     if (def.parentNode !== target) continue;
@@ -7778,7 +8309,9 @@ function* figure(target, footnotes, opts = {}) {
     labels.add(label);
     opts.id !== '' && def.setAttribute('id', `label:${opts.id ? `${opts.id}:` : ''}${label}`);
 
-    for (const ref of refs.take(label, global_1.Infinity)) {
+    for (let rs = refs.take(label, global_1.Infinity), i = 0; i < rs.length; ++i) {
+      const ref = rs[i];
+
       if (ref.getAttribute('data-invalid-message') === messages.reference) {
         (0, dom_1.define)(ref, {
           class: void ref.classList.remove('invalid'),
@@ -7857,18 +8390,20 @@ const global_1 = __webpack_require__(4128);
 
 const indexee_1 = __webpack_require__(1269);
 
-const dom_1 = __webpack_require__(3252);
-
 const multimap_1 = __webpack_require__(940);
 
-const duff_1 = __webpack_require__(8099);
+const dom_1 = __webpack_require__(3252);
 
-const array_1 = __webpack_require__(8112);
+const query_1 = __webpack_require__(6120);
 
 function* footnote(target, footnotes, opts = {}, bottom = null) {
   // Bug: Firefox
-  //target.querySelectorAll(`:scope > .annotations`).forEach(el => el.remove());
-  (0, duff_1.duffEach)(target.querySelectorAll(`.annotations`), el => el.parentNode === target && el.remove());
+  //querySelectorAll(target, `:scope > .annotations`).forEach(el => el.remove());
+  for (let es = (0, query_1.querySelectorAll)(target, `.annotations`), i = 0; i < es.length; ++i) {
+    const el = es[i];
+    el.parentNode === target && el.remove();
+  }
+
   yield* (0, exports.reference)(target, footnotes?.references, opts, bottom);
   yield* (0, exports.annotation)(target, footnotes?.annotations, opts, bottom);
   return;
@@ -7885,14 +8420,20 @@ function build(syntax, marker, splitter) {
     const defs = new global_1.Map();
     const buffer = new multimap_1.MultiMap();
     const titles = new global_1.Map(); // Bug: Firefox
-    //const splitters = push([], target.querySelectorAll(`:scope > :is(${splitter ?? '_'})`));
+    //const splitters = push([], querySelectorAll(target, `:scope > :is(${splitter ?? '_'})`));
+
+    const splitters = [];
+
+    for (let es = (0, query_1.querySelectorAll)(target, splitter ?? '_'), i = 0; i < es.length; ++i) {
+      const el = es[i];
+      el.parentNode === target && splitters.push(el);
+    }
 
-    const splitters = (0, duff_1.duffReduce)(target.querySelectorAll(splitter ?? '_'), (acc, el) => el.parentNode === target ? (0, array_1.push)(acc, [el]) : acc, []);
     let count = 0;
     let total = 0;
     let style;
 
-    for (let refs = target.querySelectorAll(`sup.${syntax}:not(.disabled)`), i = 0, len = refs.length; i < len; ++i) {
+    for (let refs = (0, query_1.querySelectorAll)(target, `sup.${syntax}:not(.disabled)`), len = refs.length, i = 0; i < len; ++i) {
       yield;
       const ref = refs[i];
 
@@ -7947,7 +8488,8 @@ function build(syntax, marker, splitter) {
       if (title && !blank && def.childNodes.length === 1) {
         def.insertBefore(content.cloneNode(true), def.lastChild);
 
-        for (const ref of buffer.take(identifier, global_1.Infinity)) {
+        for (let refs = buffer.take(identifier, global_1.Infinity), i = 0; i < refs.length; ++i) {
+          const ref = refs[i];
           if (ref.getAttribute('data-invalid-type') !== 'content') continue;
           (0, dom_1.define)(ref, {
             title,
@@ -8264,17 +8806,19 @@ const global_1 = __webpack_require__(4128);
 
 const combinator_1 = __webpack_require__(2087);
 
-function str(pattern) {
+function str(pattern, not) {
   return typeof pattern === 'string' ? (0, combinator_1.creation)(1, false, ({
     source
   }) => {
     if (source === '') return;
+    if (not && source.slice(pattern.length, pattern.length + not.length) === not) return;
     return source.slice(0, pattern.length) === pattern ? [[pattern], source.slice(pattern.length)] : global_1.undefined;
   }) : (0, combinator_1.creation)(1, false, ({
     source
   }) => {
     if (source === '') return;
     const m = source.match(pattern);
+    if (m && not && source.slice(m[0].length, m[0].length + not.length) === not) return;
     return m && m[0].length > 0 ? [[m[0]], source.slice(m[0].length)] : global_1.undefined;
   });
 }
@@ -8319,10 +8863,10 @@ const str_1 = __webpack_require__(2790);
 
 const dom_1 = __webpack_require__(3252);
 
-exports.delimiter = /[\s\x00-\x7F]|\S[#>]|[\p{Ideo}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}～！？][^\S\n]*(?=\\\n)/u;
+exports.delimiter = /[\s\x00-\x7F]|\S[#>]|[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
 exports.nonWhitespace = /[\S\n]|$/;
 exports.nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/;
-const nssb = /^[\p{Ideo}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}～！？][^\S\n]*(?=\\\n)/u;
+const nssb = /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
 const repeat = (0, str_1.str)(/^(.)\1*/);
 exports.text = (0, combinator_1.creation)(1, false, ({
   source,
@@ -8769,10 +9313,10 @@ const math_1 = __webpack_require__(611);
 
 const media_1 = __webpack_require__(2233);
 
-const query_1 = __webpack_require__(6120);
-
 const memoize_1 = __webpack_require__(1808);
 
+const query_1 = __webpack_require__(6120);
+
 const selector = 'img.media:not(.invalid):not([src])[data-src], a > :not(img).media:not(.invalid), pre.code:not(.invalid), .math:not(.invalid)';
 const extend = (0, memoize_1.reduce)(opts => ({
   code: code_1.code,
@@ -8785,8 +9329,8 @@ function render(source, opts = {}) {
   opts = extend(opts);
   const base = global_1.location.href;
 
-  for (const el of (0, query_1.querySelectorAll)(source, selector)) {
-    render_(base, el, opts);
+  for (let es = (0, query_1.querySelectorAllWith)(source, selector), i = 0; i < es.length; ++i) {
+    render_(base, es[i], opts);
   }
 }
 
@@ -9240,9 +9784,7 @@ exports.info = void 0;
 
 const scope_1 = __webpack_require__(5202);
 
-const duff_1 = __webpack_require__(8099);
-
-const array_1 = __webpack_require__(8112);
+const query_1 = __webpack_require__(6120);
 
 function info(source) {
   const match = (0, scope_1.scope)(source, '.invalid');
@@ -9260,7 +9802,14 @@ function info(source) {
   };
 
   function find(selector) {
-    return (0, duff_1.duffReduce)(source.querySelectorAll(selector), (acc, el) => match(el) ? (0, array_1.push)(acc, [el]) : acc, []);
+    const acc = [];
+
+    for (let es = (0, query_1.querySelectorAll)(source, selector), i = 0; i < es.length; ++i) {
+      const el = es[i];
+      match(el) && acc.push(el);
+    }
+
+    return acc;
   }
 }
 
@@ -9287,7 +9836,7 @@ const cite_1 = __webpack_require__(6315);
 
 const dom_1 = __webpack_require__(3252);
 
-const duff_1 = __webpack_require__(8099);
+const query_1 = __webpack_require__(6120);
 
 function quote(anchor, range) {
   if ((0, parser_1.exec)((0, cite_1.cite)({
@@ -9297,22 +9846,25 @@ function quote(anchor, range) {
   fit(range);
   const node = trim(range.cloneContents());
   if (!node.firstChild) return '';
-  (0, duff_1.duffEach)(node.querySelectorAll('code[data-src], .math[data-src], .media[data-src], rt, rp'), el => {
+
+  for (let es = (0, query_1.querySelectorAll)(node, 'code[data-src], .math[data-src], .media[data-src], rt, rp'), i = 0; i < es.length; ++i) {
+    const el = es[i];
+
     switch (true) {
       case el.matches('code'):
       case el.matches('.math'):
         (0, dom_1.define)(el, el.getAttribute('data-src'));
-        return;
+        continue;
 
       case el.matches('.media'):
         el.replaceWith(/[\s{}]/.test(el.getAttribute('data-src')) ? `!{ ${el.getAttribute('data-src')} }` : `!{${el.getAttribute('data-src')}}`);
-        return;
+        continue;
 
       case el.matches('rt, rp'):
         el.remove();
-        return;
+        continue;
     }
-  });
+  }
 
   if (range.startOffset === 0 && range.startContainer.parentElement?.matches('.cite, .quote') && (!range.startContainer.previousSibling || range.startContainer.previousSibling.nodeName === 'BR')) {
     node.prepend(`>${range.startContainer.parentElement.matches('.quote.invalid') ? ' ' : ''}`);
@@ -9321,26 +9873,29 @@ function quote(anchor, range) {
     anchor = '';
   }
 
-  (0, duff_1.duffEach)(node.querySelectorAll('br'), el => {
+  for (let es = (0, query_1.querySelectorAll)(node, 'br'), i = 0; i < es.length; ++i) {
+    const el = es[i];
+
     if (anchor && el.nextSibling instanceof global_1.Element && el.nextSibling.matches('.cite, .quote')) {
       el.replaceWith(`\n>${el.nextSibling.matches('.quote.invalid') ? ' ' : ''}`);
-      return;
+      continue;
     }
 
     if (anchor && el.parentElement?.closest('.cite, .quote')) {
       el.replaceWith(`\n>${el.parentElement.closest('.quote.invalid') ? ' ' : ''}`);
-      return;
+      continue;
     }
 
     if (anchor) {
       el.replaceWith(`\n>>${anchor}\n> `);
       anchor = '';
-      return;
+      continue;
     } else {
       el.replaceWith(`\n> `);
-      return;
+      continue;
     }
-  });
+  }
+
   anchor && node.append(`\n>>${anchor}`);
   return node.textContent;
 }
@@ -9426,29 +9981,36 @@ exports.toc = void 0;
 
 const global_1 = __webpack_require__(4128);
 
-const dom_1 = __webpack_require__(3252);
+const array_1 = __webpack_require__(8112);
 
-const duff_1 = __webpack_require__(8099);
+const dom_1 = __webpack_require__(3252);
 
-const array_1 = __webpack_require__(8112); // Bug: Firefox
+const query_1 = __webpack_require__(6120); // Bug: Firefox
 //const selector = 'h1 h2 h3 h4 h5 h6 aside.aside'.split(' ').map(s => `:scope > ${s}[id]`).join();
 
 
 const selector = ':is(h1, h2, h3, h4, h5, h6, aside.aside)[id]';
 
 function toc(source) {
-  const hs = (0, duff_1.duffReduce)(source.querySelectorAll(selector), (acc, el) => {
+  const hs = [];
+
+  for (let es = (0, query_1.querySelectorAll)(source, selector), i = 0; i < es.length; ++i) {
+    const el = es[i];
+
     switch (el.tagName) {
       case 'ASIDE':
-        return (0, array_1.push)(acc, [(0, dom_1.html)(el.firstElementChild.tagName.toLowerCase(), {
+        hs.push((0, dom_1.html)(el.firstElementChild.tagName.toLowerCase(), {
           id: el.id,
           class: 'aside'
-        }, el.firstElementChild.cloneNode(true).childNodes)]);
+        }, el.firstElementChild.cloneNode(true).childNodes));
+        continue;
 
       default:
-        return (0, array_1.push)(acc, [el]);
+        hs.push(el);
+        continue;
     }
-  }, []);
+  }
+
   return parse(cons(hs));
 }
 
@@ -9478,7 +10040,11 @@ function level(h) {
 }
 
 function unlink(h) {
-  (0, duff_1.duffEach)(h.getElementsByTagName('a'), el => void el.replaceWith(...el.childNodes));
+  for (let es = h.getElementsByTagName('a'), len = es.length, i = 0; i < len; ++i) {
+    const el = es[i];
+    el.replaceWith(...el.childNodes);
+  }
+
   return h.childNodes;
 }
 
@@ -9487,7 +10053,7 @@ function unlink(h) {
 /***/ 3252:
 /***/ (function(module) {
 
-/*! typed-dom v0.0.301 https://github.com/falsandtru/typed-dom | (c) 2016, falsandtru | (Apache-2.0 AND MPL-2.0) License */
+/*! typed-dom v0.0.305 https://github.com/falsandtru/typed-dom | (c) 2016, falsandtru | (Apache-2.0 AND MPL-2.0) License */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(true)
 		module.exports = factory();
@@ -9505,9 +10071,9 @@ return /******/ (() => { // webpackBootstrap
 Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
-exports.ObjectSetPrototypeOf = exports.ObjectGetPrototypeOf = exports.ObjectCreate = exports.ObjectAssign = exports.toString = exports.isEnumerable = exports.isPrototypeOf = exports.hasOwnProperty = exports.isArray = exports.sign = exports.round = exports.random = exports.min = exports.max = exports.floor = exports.ceil = exports.abs = exports.parseInt = exports.parseFloat = exports.isSafeInteger = exports.isNaN = exports.isInteger = exports.isFinite = exports[NaN] = void 0;
+exports.ObjectSetPrototypeOf = exports.ObjectGetPrototypeOf = exports.ObjectCreate = exports.ObjectAssign = exports.toString = exports.isEnumerable = exports.isPrototypeOf = exports.hasOwnProperty = exports.isArray = exports.sqrt = exports.log = exports.tan = exports.cos = exports.sign = exports.round = exports.random = exports.min = exports.max = exports.floor = exports.ceil = exports.abs = exports.parseInt = exports.parseFloat = exports.isSafeInteger = exports.isNaN = exports.isInteger = exports.isFinite = exports[NaN] = void 0;
 exports[NaN] = Number.NaN, exports.isFinite = Number.isFinite, exports.isInteger = Number.isInteger, exports.isNaN = Number.isNaN, exports.isSafeInteger = Number.isSafeInteger, exports.parseFloat = Number.parseFloat, exports.parseInt = Number.parseInt;
-exports.abs = Math.abs, exports.ceil = Math.ceil, exports.floor = Math.floor, exports.max = Math.max, exports.min = Math.min, exports.random = Math.random, exports.round = Math.round, exports.sign = Math.sign;
+exports.abs = Math.abs, exports.ceil = Math.ceil, exports.floor = Math.floor, exports.max = Math.max, exports.min = Math.min, exports.random = Math.random, exports.round = Math.round, exports.sign = Math.sign, exports.cos = Math.cos, exports.tan = Math.tan, exports.log = Math.log, exports.sqrt = Math.sqrt;
 exports.isArray = Array.isArray;
 exports.hasOwnProperty = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
 exports.isPrototypeOf = Object.prototype.isPrototypeOf.call.bind(Object.prototype.isPrototypeOf);
@@ -9539,11 +10105,11 @@ exports.equal = equal;
 /***/ }),
 
 /***/ 128:
-/***/ ((module, __unused_webpack_exports, __nested_webpack_require_2590__) => {
+/***/ ((module, __unused_webpack_exports, __nested_webpack_require_2745__) => {
 
 
 
-__nested_webpack_require_2590__(921);
+__nested_webpack_require_2745__(921);
 
 const global = void 0 || typeof globalThis !== 'undefined' && globalThis // @ts-ignore
 || typeof self !== 'undefined' && self || Function('return this')();
@@ -9564,7 +10130,7 @@ var global = (/* unused pure expression or super */ null && (0));
 /***/ }),
 
 /***/ 808:
-/***/ ((__unused_webpack_module, exports, __nested_webpack_require_3077__) => {
+/***/ ((__unused_webpack_module, exports, __nested_webpack_require_3232__) => {
 
 
 
@@ -9573,11 +10139,11 @@ Object.defineProperty(exports, "__esModule", ({
 }));
 exports.reduce = exports.memoize = void 0;
 
-const global_1 = __nested_webpack_require_3077__(128);
+const global_1 = __nested_webpack_require_3232__(128);
 
-const alias_1 = __nested_webpack_require_3077__(406);
+const alias_1 = __nested_webpack_require_3232__(406);
 
-const compare_1 = __nested_webpack_require_3077__(529);
+const compare_1 = __nested_webpack_require_3232__(529);
 
 function memoize(f, identify = (...as) => as[0], memory) {
   if (typeof identify === 'object') return memoize(f, void 0, identify);
@@ -9635,7 +10201,7 @@ exports.reduce = reduce;
 /***/ }),
 
 /***/ 521:
-/***/ ((__unused_webpack_module, exports, __nested_webpack_require_4467__) => {
+/***/ ((__unused_webpack_module, exports, __nested_webpack_require_4622__) => {
 
 
 
@@ -9644,11 +10210,11 @@ Object.defineProperty(exports, "__esModule", ({
 }));
 exports.defrag = exports.prepend = exports.append = exports.isChildren = exports.define = exports.element = exports.text = exports.svg = exports.html = exports.frag = exports.shadow = void 0;
 
-const global_1 = __nested_webpack_require_4467__(128);
+const global_1 = __nested_webpack_require_4622__(128);
 
-const alias_1 = __nested_webpack_require_4467__(406);
+const alias_1 = __nested_webpack_require_4622__(406);
 
-const memoize_1 = __nested_webpack_require_4467__(808);
+const memoize_1 = __nested_webpack_require_4622__(808);
 
 var caches;
 
@@ -9689,9 +10255,8 @@ function text(source) {
 exports.text = text;
 
 function element(context, ns) {
-  const cache = (0, memoize_1.memoize)(elem, (_, ns, tag) => `${ns}:${tag}`);
   return (tag, attrs, children) => {
-    const el = tag.includes('-') ? elem(context, ns, tag) : cache(context, ns, tag).cloneNode(true);
+    const el = elem(context, ns, tag);
     return !attrs || isChildren(attrs) ? defineChildren(el, attrs ?? children) : defineChildren(defineAttrs(el, attrs), children);
   };
 }
@@ -9884,7 +10449,7 @@ exports.defrag = defrag;
 /******/ 	var __webpack_module_cache__ = {};
 /******/ 	
 /******/ 	// The require function
-/******/ 	function __nested_webpack_require_11560__(moduleId) {
+/******/ 	function __nested_webpack_require_11575__(moduleId) {
 /******/ 		// Check if module is in cache
 /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
 /******/ 		if (cachedModule !== undefined) {
@@ -9898,7 +10463,7 @@ exports.defrag = defrag;
 /******/ 		};
 /******/ 	
 /******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId](module, module.exports, __nested_webpack_require_11560__);
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __nested_webpack_require_11575__);
 /******/ 	
 /******/ 		// Return the exports of the module
 /******/ 		return module.exports;
@@ -9909,7 +10474,7 @@ exports.defrag = defrag;
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __nested_webpack_require_11560__(521);
+/******/ 	var __webpack_exports__ = __nested_webpack_require_11575__(521);
 /******/ 	
 /******/ 	return __webpack_exports__;
 /******/ })()
@@ -9921,7 +10486,7 @@ exports.defrag = defrag;
 /***/ 6120:
 /***/ (function(module) {
 
-/*! typed-dom v0.0.301 https://github.com/falsandtru/typed-dom | (c) 2016, falsandtru | (Apache-2.0 AND MPL-2.0) License */
+/*! typed-dom v0.0.305 https://github.com/falsandtru/typed-dom | (c) 2016, falsandtru | (Apache-2.0 AND MPL-2.0) License */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(true)
 		module.exports = factory();
@@ -9931,114 +10496,6 @@ return /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 112:
-/***/ ((__unused_webpack_module, exports, __nested_webpack_require_645__) => {
-
-
-
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-exports.splice = exports.pop = exports.push = exports.shift = exports.unshift = exports.indexOf = void 0;
-
-const global_1 = __nested_webpack_require_645__(128);
-
-function indexOf(as, a) {
-  if (as.length === 0) return -1;
-  return a === a ? as.indexOf(a) : as.findIndex(a => a !== a);
-}
-
-exports.indexOf = indexOf;
-
-function unshift(as, bs) {
-  if ('length' in as) {
-    for (let i = as.length - 1; i >= 0; --i) {
-      bs.unshift(as[i]);
-    }
-  } else {
-    bs.unshift(...as);
-  }
-
-  return bs;
-}
-
-exports.unshift = unshift;
-
-function shift(as, count) {
-  if (count < 0) throw new Error('Unexpected negative number');
-  return count === void 0 ? [as.shift(), as] : [splice(as, 0, count), as];
-}
-
-exports.shift = shift;
-
-function push(as, bs) {
-  if ('length' in bs) {
-    for (let i = 0, len = bs.length; i < len; ++i) {
-      as.push(bs[i]);
-    }
-  } else {
-    for (const b of bs) {
-      as.push(b);
-    }
-  }
-
-  return as;
-}
-
-exports.push = push;
-
-function pop(as, count) {
-  if (count < 0) throw new Error('Unexpected negative number');
-  return count === void 0 ? [as, as.pop()] : [as, splice(as, as.length - count, count)];
-}
-
-exports.pop = pop;
-
-function splice(as, index, count, ...inserts) {
-  if (count === 0 && inserts.length === 0) return [];
-  count = count > as.length ? as.length : count;
-
-  switch (index) {
-    case 0:
-      switch (count) {
-        case 0:
-          return [[], unshift(inserts, as)][0];
-
-        case 1:
-          return as.length === 0 ? [[], unshift(inserts, as)][0] : [[as.shift()], unshift(inserts, as)][0];
-
-        case void 0:
-          if (as.length > 1 || arguments.length > 2) break;
-          return as.length === 0 ? [] : splice(as, index, 1);
-      }
-
-      break;
-
-    case -1:
-    case as.length - 1:
-      switch (count) {
-        case 1:
-          return as.length === 0 ? [[], push(as, inserts)][0] : [[as.pop()], push(as, inserts)][0];
-
-        case void 0:
-          if (as.length > 1 || arguments.length > 2) break;
-          return as.length === 0 ? [] : splice(as, index, 1);
-      }
-
-      break;
-
-    case as.length:
-    case global_1.Infinity:
-      return [[], push(as, inserts)][0];
-  }
-
-  return arguments.length > 2 ? as.splice(index, count, ...inserts) : as.splice(index);
-}
-
-exports.splice = splice;
-
-/***/ }),
-
 /***/ 99:
 /***/ ((__unused_webpack_module, exports) => {
 
@@ -10052,7 +10509,7 @@ exports.duffReduce = exports.duffEach = exports.duffbk = exports.duff = void 0;
 function duff(count, proc) {
   if (count > 0) {
     let i = 0,
-        m = count % 8,
+        m = count & 7,
         d = (count - m) / 8;
 
     while (m--) {
@@ -10071,7 +10528,7 @@ function duff(count, proc) {
     }
   } else {
     let i = -count,
-        m = i % 8,
+        m = i & 7,
         d = (i - m) / 8;
 
     while (m--) {
@@ -10096,7 +10553,7 @@ exports.duff = duff;
 function duffbk(count, proc) {
   if (count > 0) {
     let i = 0,
-        m = count % 8,
+        m = count & 7,
         d = (count - m) / 8;
 
     while (m--) {
@@ -10104,18 +10561,21 @@ function duffbk(count, proc) {
     }
 
     while (d--) {
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
-      if (proc(i++) === false) return;
+      switch (false) {
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+        case proc(i++):
+          return;
+      }
     }
   } else {
     let i = -count,
-        m = i % 8,
+        m = i & 7,
         d = (i - m) / 8;
 
     while (m--) {
@@ -10123,14 +10583,17 @@ function duffbk(count, proc) {
     }
 
     while (d--) {
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
-      if (proc(--i) === false) return;
+      switch (false) {
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+        case proc(--i):
+          return;
+      }
     }
   }
 }
@@ -10140,7 +10603,7 @@ exports.duffbk = duffbk;
 function duffEach(array, proc) {
   let count = array.length;
   let i = 0,
-      m = count % 8,
+      m = count & 7,
       d = (count - m) / 8;
 
   while (m--) {
@@ -10159,30 +10622,32 @@ function duffEach(array, proc) {
   }
 }
 
-exports.duffEach = duffEach;
+exports.duffEach = duffEach; // ベンチマークの10,000以上で急激な速度低下が見られるがNodeListなどでの
+// 実際の使用では速度低下は見られない
 
 function duffReduce(array, proc, initial) {
   let count = array.length;
   let i = 0,
-      m = count % 8,
+      m = count & 7,
       d = (count - m) / 8;
+  let acc = initial;
 
   while (m--) {
-    initial = proc(initial, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
   }
 
   while (d--) {
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
-    initial = proc(initial, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
+    acc = proc(acc, array[i], i++, array);
   }
 
-  return initial;
+  return acc;
 }
 
 exports.duffReduce = duffReduce;
@@ -10190,11 +10655,11 @@ exports.duffReduce = duffReduce;
 /***/ }),
 
 /***/ 128:
-/***/ ((module, __unused_webpack_exports, __nested_webpack_require_6113__) => {
+/***/ ((module, __unused_webpack_exports, __nested_webpack_require_3560__) => {
 
 
 
-__nested_webpack_require_6113__(921);
+__nested_webpack_require_3560__(921);
 
 const global = void 0 || typeof globalThis !== 'undefined' && globalThis // @ts-ignore
 || typeof self !== 'undefined' && self || Function('return this')();
@@ -10220,7 +10685,7 @@ var global = (/* unused pure expression or super */ null && (0));
 /******/ 	var __webpack_module_cache__ = {};
 /******/ 	
 /******/ 	// The require function
-/******/ 	function __nested_webpack_require_6765__(moduleId) {
+/******/ 	function __nested_webpack_require_4212__(moduleId) {
 /******/ 		// Check if module is in cache
 /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
 /******/ 		if (cachedModule !== undefined) {
@@ -10234,7 +10699,7 @@ var global = (/* unused pure expression or super */ null && (0));
 /******/ 		};
 /******/ 	
 /******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId](module, module.exports, __nested_webpack_require_6765__);
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __nested_webpack_require_4212__);
 /******/ 	
 /******/ 		// Return the exports of the module
 /******/ 		return module.exports;
@@ -10250,26 +10715,32 @@ var exports = __webpack_exports__;
 Object.defineProperty(exports, "__esModule", ({
   value: true
 }));
-exports.querySelectorAll = exports.querySelector = void 0;
+exports.querySelectorAll = exports.querySelectorAllWith = exports.querySelectorWith = void 0;
 
-const duff_1 = __nested_webpack_require_6765__(99);
+const global_1 = __nested_webpack_require_4212__(128);
 
-const array_1 = __nested_webpack_require_6765__(112);
+const duff_1 = __nested_webpack_require_4212__(99);
 
-function querySelector(node, selector) {
+function querySelectorWith(node, selector) {
   return 'matches' in node && node.matches(selector) ? node : node.querySelector(selector);
 }
 
-exports.querySelector = querySelector;
+exports.querySelectorWith = querySelectorWith;
 
-function querySelectorAll(node, selector) {
+function querySelectorAllWith(node, selector) {
   const acc = [];
 
   if ('matches' in node && node.matches(selector)) {
     acc.push(node);
   }
 
-  return (0, duff_1.duffReduce)(node.querySelectorAll(selector), (acc, node) => (0, array_1.push)(acc, [node]), acc);
+  return (0, duff_1.duffReduce)(node.querySelectorAll(selector), (acc, el) => (acc.push(el), acc), acc);
+}
+
+exports.querySelectorAllWith = querySelectorAllWith;
+
+function querySelectorAll(node, selector) {
+  return (0, duff_1.duffReduce)(node.querySelectorAll(selector), (acc, el) => (acc.push(el), acc), (0, global_1.Array)());
 }
 
 exports.querySelectorAll = querySelectorAll;