u2ui 1.5.3 → 1.5.4

package/js/rte/src/command/pending-marks.js

@@ -0,0 +1,216 @@
+import {Edit} from './edit.js';
+import {applyMark, removeMark, toggleMark} from './mark.js';
+import {editingHost, elementOf, isEditingBoundary, isPlainTextHost} from '../selection/ownership/ownership.js';
+import {Mark} from '../mark/mark.js';
+import {Point} from '../selection/point/point.js';
+
+// Pending mark overrides for one surface. They remain valid only while the
+// surface keeps the same captured selection, so moving the caret invalidates
+// them without another selection listener.
+export class PendingMarks {
+    #surface;
+    #selection = null;
+    #entries = new Map();
+    #insertText;
+    #composition = null;
+    #controller;
+
+    constructor(surface) {
+        if (surface?.element?.nodeType !== Node.ELEMENT_NODE || typeof surface?.capture !== 'function') {
+            throw new TypeError('Pending marks require an editor surface');
+        }
+        this.#surface = surface;
+        this.#insertText = {
+            inputTypes: ['insertText'],
+            enabled: edit => this.#current(edit) && typeof edit.data === 'string' && !!edit.data,
+            run: edit => this.#insert(edit),
+        };
+        const root = surface.element;
+        this.#controller = new root.ownerDocument.defaultView.AbortController();
+        const listen = {signal: this.#controller.signal};
+        root.addEventListener('compositionstart', this.#compositionStart, listen);
+        root.addEventListener('compositionend', this.#compositionEnd, listen);
+        surface.addEventListener('u2-rte-disconnect', () => this.dispose(), listen);
+    }
+
+    get surface() { return this.#surface; }
+    get insertText() { return this.#insertText; }
+    get connected() { return !this.#controller.signal.aborted; }
+
+    toggle(adapter, value) {
+        const hasValue = arguments.length > 1;
+        const toggle = hasValue ? toggleMark(adapter, value) : toggleMark(adapter);
+        const apply = hasValue ? applyMark(adapter, value) : applyMark(adapter);
+        const remove = hasValue ? removeMark(adapter, value) : removeMark(adapter);
+        const mark = value instanceof Mark ? value : adapter.type.create(hasValue ? value : true);
+        const key = {};
+        return {
+            enabled: edit => this.#owns(edit) && (!!edit.range && (edit.range.collapsed
+                ? markable(edit, adapter, mark, toggle.state(edit) === true)
+                : toggle.enabled(edit))),
+            state: edit => this.#entry(edit, key)?.active ?? toggle.state(edit),
+            run: edit => {
+                this.#assert(edit);
+                if (!edit.range?.collapsed) {
+                    this.clear();
+                    return toggle.run(edit);
+                }
+                if (!markable(edit, adapter, mark, toggle.state(edit) === true)) return;
+                const base = toggle.state(edit);
+                const active = (this.#entry(edit, key)?.active ?? base) !== true;
+                this.#prepare(edit);
+                if (active === base) this.#entries.delete(key);
+                else this.#entries.set(key, {active, apply, remove, adapter, mark, model: edit.model});
+                return active;
+            },
+        };
+    }
+
+    clear() {
+        this.#selection = null;
+        this.#entries.clear();
+        this.#composition = null;
+    }
+
+    dispose() {
+        if (!this.connected) return;
+        this.#controller.abort();
+        this.clear();
+    }
+
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+
+    #insert(edit) {
+        this.#assert(edit);
+        const entries = [...this.#entries.values()];
+        const text = insert(edit, edit.data);
+        this.clear();
+        for (const entry of entries) {
+            const current = new Edit(this.#surface, edit.transaction, {
+                model: edit.model,
+                inputType: edit.inputType,
+                data: edit.data,
+            });
+            (entry.active ? entry.apply : entry.remove).run(current);
+        }
+        const selection = this.#surface.core.selection;
+        const range = selection.getRangeAt(0);
+        edit.select(Point.fromRange(range, 'end'));
+        return text;
+    }
+
+    #prepare(edit) {
+        if (this.#selection !== this.#surface.selection) this.#entries.clear();
+        this.#selection = this.#surface.selection;
+    }
+
+    #current(edit) {
+        return this.#owns(edit)
+            && edit.range?.collapsed
+            && [...this.#entries.values()].every(entry => markable(edit, entry.adapter, entry.mark, !entry.active))
+            && this.#selection === this.#surface.selection
+            && this.#entries.size > 0;
+    }
+
+    #entry(edit, key) {
+        return this.#current(edit) ? this.#entries.get(key) : null;
+    }
+
+    #owns(edit) {
+        return this.connected && edit?.surface === this.#surface && !isPlainTextHost(this.#surface.element);
+    }
+
+    #assert(edit) {
+        if (!this.#owns(edit)) throw new RangeError('Pending marks belong to one rich-text surface');
+    }
+
+    #compositionStart = event => {
+        if (!this.#ownsEvent(event)) return;
+        const edit = new Edit(this.#surface);
+        const entries = [...this.#entries.values()];
+        if (!edit.range?.collapsed || this.#selection !== this.#surface.selection || !entries.length) return;
+        this.#composition = {
+            start: edit.range.start.withAffinity('backward'),
+            entries,
+        };
+    };
+
+    #compositionEnd = event => {
+        if (!this.#ownsEvent(event) || !this.#composition) return;
+        const {start, entries} = this.#composition;
+        this.#composition = null;
+        const current = new Edit(this.#surface).range;
+        if (!current?.collapsed || !start.within(this.#surface.element)) {
+            this.clear();
+            return;
+        }
+        const end = current.end.withAffinity('forward');
+        if (start.compare(end) === 0) {
+            this.#selection = this.#surface.capture();
+            return;
+        }
+        if (start.compare(end) > 0) {
+            this.clear();
+            return;
+        }
+        const range = start.range();
+        range.setEnd(end.node, end.offset);
+        if (!range.toString()) {
+            this.clear();
+            return;
+        }
+        this.clear();
+        this.#surface.transact(transaction => {
+            let active = range;
+            for (const entry of entries) {
+                const edit = new Edit(this.#surface, transaction, {
+                    model: entry.model,
+                    range: active,
+                    inputType: 'insertCompositionText',
+                    data: typeof event.data === 'string' ? event.data : null,
+                });
+                (entry.active ? entry.apply : entry.remove).run(edit);
+                active = this.#surface.core.selection.getRangeAt(0).cloneRange();
+            }
+            const edit = new Edit(this.#surface, transaction, {range: active});
+            edit.select(edit.range.end);
+        }, {trigger: 'input', inputType: 'insertCompositionText', composition: true});
+    };
+
+    #ownsEvent(event) {
+        const target = event.composedPath()[0];
+        return target === this.#surface.element || editingHost(target) === this.#surface.element;
+    }
+}
+
+function insert(edit, data) {
+    const start = edit.range.start.withAffinity('backward');
+    const end = edit.range.end.withAffinity('forward');
+    edit.map.add(start).add(end);
+    const node = start.node;
+    let text;
+    if (node.nodeType === Node.TEXT_NODE) {
+        text = node;
+        edit.map.insertText(node, start.offset, data);
+    } else {
+        text = edit.document.createTextNode(data);
+        edit.map.insert(node, start.offset, text);
+    }
+    edit.transaction.touch(text.parentNode);
+    edit.select(edit.map.get(start), edit.map.get(end));
+    return text;
+}
+
+function markable(edit, adapter, mark, removing) {
+    if (!edit.range?.collapsed) return false;
+    for (let element = elementOf(edit.range.start.node); element && element !== edit.element; element = element.parentElement) {
+        if (isEditingBoundary(element) || edit.model.atomic(element)) return false;
+    }
+    if (removing) return true;
+    const node = edit.range.start.node;
+    const parent = node.nodeType === Node.TEXT_NODE ? node.parentNode : node;
+    return edit.model.allows(parent, adapter.render(mark, edit.document));
+}
+

package/js/rte/src/command/table.js

@@ -0,0 +1,207 @@
+import {elementOf} from '../selection/ownership/ownership.js';
+import {fill} from './block-boundary.js';
+import {Point} from '../selection/point/point.js';
+
+// Table structure commands.
+//
+// Sections, rows, and cells are never named: they come from the model's default
+// child, so a configured table-like structure works the same way. Every change
+// is an ordinary mapped mutation, which is what makes it one undo step and lets
+// the caret land where the edit happened.
+export class Tables {
+    #tag;
+    #commands;
+
+    constructor(tag = 'table') {
+        if (typeof tag !== 'string' || !tag.trim()) throw new TypeError('A table command group requires a tag name');
+        this.#tag = tag.trim().toLowerCase();
+        this.#commands = Object.freeze({
+            insertTable: {
+                enabled: edit => !!this.#target(edit),
+                run: edit => this.#insert(edit),
+            },
+            rowBefore: this.#rows('before'),
+            rowAfter: this.#rows('after'),
+            rowDelete: this.#rows(null),
+            columnBefore: this.#columns('before'),
+            columnAfter: this.#columns('after'),
+            columnDelete: this.#columns(null),
+            deleteTable: {
+                enabled: edit => !!this.#at(edit),
+                run: edit => this.#remove(edit, this.#at(edit)?.table),
+            },
+        });
+    }
+
+    get tag() { return this.#tag; }
+    get commands() { return this.#commands; }
+
+    // The tags one level apart, taken from the model rather than assumed.
+    #shape(edit) {
+        const section = edit.model.defaultChild(this.#tag);
+        const row = section && edit.model.defaultChild(section);
+        const cell = row && edit.model.defaultChild(row);
+        return cell ? {table: this.#tag, section, row, cell} : null;
+    }
+
+    // The cell the caret sits in, with everything around it.
+    #at(edit) {
+        const shape = this.#shape(edit);
+        if (!shape || !edit.range) return null;
+        for (let element = elementOf(edit.range.start.node); element && element !== edit.element;
+            element = element.parentElement) {
+            if (element.parentElement?.localName !== shape.row) continue;
+            const cell = element;
+            const row = cell.parentElement;
+            const table = row.closest(shape.table);
+            if (!table || !edit.element.contains(table)) return null;
+            return {shape, cell, row, table, column: [...row.children].indexOf(cell)};
+        }
+        return null;
+    }
+
+    // Where a new table may go: the nearest container that accepts one. A
+    // selection is not deleted first; the table lands where it starts.
+    #target(edit) {
+        const shape = this.#shape(edit);
+        const start = edit.range?.start;
+        if (!shape || !start || this.#at(edit)) return null;
+        const table = edit.document.createElement(shape.table);
+        for (let element = elementOf(start.node); element; element = element.parentElement) {
+            if (edit.model.atomic(element)) return null;
+            if (edit.model.allows(element, table)) return element;
+            if (element === edit.element) return null;
+        }
+        return null;
+    }
+
+    #rows(where) {
+        return {
+            enabled: edit => {
+                const found = this.#at(edit);
+                return !!found && !spans(found.table, 'rowSpan') && (!!where || rows(found.table).length > 0);
+            },
+            run: edit => where ? this.#addRow(edit, where) : this.#dropRow(edit),
+        };
+    }
+
+    #columns(where) {
+        return {
+            enabled: edit => {
+                const found = this.#at(edit);
+                return !!found && !spans(found.table, 'rowSpan') && !spans(found.table, 'colSpan');
+            },
+            run: edit => where ? this.#addColumn(edit, where) : this.#dropColumn(edit),
+        };
+    }
+
+    #insert(edit, {rows: height = 2, columns: width = 2} = edit.value || {}) {
+        const parent = this.#target(edit);
+        const shape = this.#shape(edit);
+        if (!parent) return null;
+        const table = build(edit, shape, Math.max(1, height), Math.max(1, width));
+        const start = edit.range.start;
+        const at = edit.map.split(parent, start.node, start.offset);
+        edit.map.insert(parent, at, table);
+        edit.transaction.touch(parent);
+        edit.select(Point.start(table.querySelector(shape.cell)));
+        return table;
+    }
+
+    #addRow(edit, where) {
+        const found = this.#at(edit);
+        if (!found) return null;
+        const row = edit.document.createElement(found.shape.row);
+        for (const cell of found.row.children) row.append(edit.document.createElement(cell.localName));
+        const section = found.row.parentElement;
+        edit.map.insert(section, [...section.childNodes].indexOf(found.row) + (where === 'after' ? 1 : 0), row);
+        for (const cell of row.children) fill(edit, cell);
+        edit.transaction.touch(section);
+        edit.select(Point.start(row.firstElementChild));
+        return row;
+    }
+
+    #dropRow(edit) {
+        const found = this.#at(edit);
+        if (!found) return null;
+        const remaining = rows(found.table).filter(row => row !== found.row);
+        if (!remaining.length) return this.#remove(edit, found.table);
+        const next = neighbour(rows(found.table), found.row);
+        const section = found.row.parentElement;
+        edit.map.remove(found.row);
+        if (!section.children.length && section !== found.table) edit.map.remove(section);
+        edit.transaction.touch(found.table);
+        edit.select(Point.start(next.children[Math.min(found.column, next.children.length - 1)]));
+        return found.row;
+    }
+
+    #addColumn(edit, where) {
+        const found = this.#at(edit);
+        if (!found) return null;
+        let landed = null;
+        for (const row of rows(found.table)) {
+            const at = Math.min(found.column + (where === 'after' ? 1 : 0), row.children.length);
+            const reference = row.children[at] || null;
+            const model = row.children[Math.min(found.column, row.children.length - 1)];
+            const cell = edit.document.createElement(model?.localName || found.shape.cell);
+            edit.map.insert(row, reference ? [...row.childNodes].indexOf(reference) : row.childNodes.length, cell);
+            fill(edit, cell);
+            if (row === found.row) landed = cell;
+        }
+        edit.transaction.touch(found.table);
+        if (landed) edit.select(Point.start(landed));
+        return landed;
+    }
+
+    #dropColumn(edit) {
+        const found = this.#at(edit);
+        if (!found) return null;
+        if (found.row.children.length <= 1) return this.#remove(edit, found.table);
+        for (const row of rows(found.table)) {
+            const cell = row.children[found.column];
+            if (cell) edit.map.remove(cell);
+        }
+        edit.transaction.touch(found.table);
+        const cells = [...found.row.children];
+        edit.select(Point.start(cells[Math.min(found.column, cells.length - 1)]));
+        return found.table;
+    }
+
+    #remove(edit, table) {
+        if (!table) return null;
+        const parent = table.parentElement;
+        const at = [...parent.childNodes].indexOf(table);
+        edit.map.remove(table);
+        edit.transaction.touch(parent);
+        edit.select(new Point(parent, Math.min(at, parent.childNodes.length), 'forward'));
+        return table;
+    }
+}
+
+function build(edit, shape, height, width) {
+    const table = edit.document.createElement(shape.table);
+    const section = shape.section ? table.appendChild(edit.document.createElement(shape.section)) : table;
+    for (let y = 0; y < height; y++) {
+        const row = section.appendChild(edit.document.createElement(shape.row));
+        for (let x = 0; x < width; x++) {
+            const cell = row.appendChild(edit.document.createElement(shape.cell));
+            cell.append(edit.document.createElement('br'));
+        }
+    }
+    return table;
+}
+
+function rows(table) {
+    return [...table.rows || []];
+}
+
+// Spanning cells make an index no longer name a column, so the commands that
+// count on one stay unavailable rather than shifting the wrong cells.
+function spans(table, property) {
+    return rows(table).some(row => [...row.children].some(cell => (cell[property] || 1) > 1));
+}
+
+function neighbour(list, item) {
+    const at = list.indexOf(item);
+    return list[at + 1] || list[at - 1];
+}

package/js/rte/src/command/unstyle.js

@@ -0,0 +1,248 @@
+import {Edit} from './edit.js';
+import {EditRange} from '../selection/range/edit-range.js';
+import {elementOf, isEditingBoundary} from '../selection/ownership/ownership.js';
+import {Point} from '../selection/point/point.js';
+import {Unstyle, declared, defaultUnstyle, keepFor, removable, strip as stripAttributes} from '../unstyle/unstyle.js';
+import {indexOf} from '../selection/point/point.js';
+
+// The structural rung is the ladder's end: presentation levels only ever strip
+// attributes and unwrap inline elements, so without it a selection that is
+// already plain inline content has nothing left to give. It needs the content
+// model and mapped mutation, which is why it lives here rather than in the
+// `Unstyle` policy that also runs on detached paste fragments.
+const BLOCKS = Object.freeze({name: 'blocks'});
+
+export function unstyleCommand(policy = defaultUnstyle, {blocks = true} = {}) {
+    if (!(policy instanceof Unstyle)) throw new TypeError('An unstyle command requires a policy');
+    const levels = blocks ? [...policy.levels, BLOCKS] : policy.levels;
+    return {
+        inputTypes: ['formatRemove'],
+        enabled: edit => !!next(edit, levels),
+        state: edit => next(edit, levels)?.name || null,
+        run: edit => run(edit, next(edit, levels)),
+    };
+}
+
+function next(edit, levels) {
+    if (!edit.range) return null;
+    const scope = reach(edit);
+    if (!scope.range || scope.range.collapsed) return null;
+    for (const level of levels) {
+        const found = level === BLOCKS
+            ? structural(scope).length
+            : targets(scope, level, scope.range, true).length;
+        if (found) return level;
+    }
+    return null;
+}
+
+function run(edit, level) {
+    if (!level) return;
+    // Someone who presses with nothing selected wants the content cleaned, not
+    // nothing to happen, so the caret is put back afterwards rather than the
+    // whole document being left selected.
+    const caret = edit.range?.collapsed
+        ? new Point(edit.range.start.node, edit.range.start.offset, 'forward')
+        : null;
+    const scope = reach(edit);
+    if (caret) scope.map.add(caret);
+    const result = level === BLOCKS ? flatten(scope) : strip(scope, level);
+    if (caret) scope.select(scope.map.get(caret));
+    return result;
+}
+
+// A collapsed caret reaches everything the surface holds.
+function reach(edit) {
+    if (!edit.range?.collapsed) return edit;
+    const range = edit.document.createRange();
+    range.selectNodeContents(edit.element);
+    return new Edit(edit.surface, edit.transaction, {model: edit.model, range, value: edit.value});
+}
+
+function strip(edit, level) {
+    const state = prepare(edit);
+    isolate(edit, level, state.end);
+    isolate(edit, level, state.start);
+    const range = mappedRange(edit, state);
+    const changed = targets(edit, level, range);
+    for (const element of changed.reverse()) clear(edit, level, element);
+    edit.select(edit.map.get(state.start), edit.map.get(state.end), state.backward);
+    return {level: level.name, changed};
+}
+
+// Reduces every selected structure to the host's default block. One pass is
+// enough: each outermost block is replaced by one default block per unit of
+// content it holds, so lists, tables, quotes, and headings all collapse the
+// same way without naming a single tag.
+function flatten(edit) {
+    const state = prepare(edit);
+    const changed = [];
+    for (const block of structural(edit).reverse()) changed.push(...reduce(edit, block));
+    edit.select(edit.map.get(state.start), edit.map.get(state.end), state.backward);
+    return {level: BLOCKS.name, changed};
+}
+
+function reduce(edit, block) {
+    const parent = block.parentElement;
+    const tag = edit.config.block;
+    let at = indexOf(block);
+    const created = [];
+    const emit = nodes => {
+        const target = edit.document.createElement(tag);
+        edit.map.insert(parent, at++, target);
+        for (const node of nodes) edit.map.move(node, target, target.childNodes.length);
+        created.push(target);
+    };
+    // Content of its own and each nested structure become separate blocks, so
+    // nothing is lost and nothing is merged that was not adjacent before.
+    const visit = element => {
+        let own = [];
+        for (const node of [...element.childNodes]) {
+            if (structure(edit, node)) {
+                if (own.length) emit(own);
+                own = [];
+                visit(node);
+            } else {
+                own.push(node);
+            }
+        }
+        if (own.length) emit(own);
+    };
+    visit(block);
+    edit.map.remove(block);
+    edit.transaction.touch(parent);
+    return created;
+}
+
+// The outermost blocks in the selection that still hold structure to remove.
+function structural(edit) {
+    const tag = edit.config.block;
+    if (!tag || !edit.range || edit.range.collapsed) return [];
+    const found = new Set();
+    for (const block of edit.range.blocks(element => element !== edit.element && structure(edit, element))) {
+        let outermost = null;
+        for (let element = block; element && element !== edit.element; element = element.parentElement) {
+            if (structure(edit, element)) outermost = element;
+        }
+        if (outermost && reducible(edit, outermost, tag)) found.add(outermost);
+    }
+    return [...found];
+}
+
+// An atomic block is content, not structure: a rule or an image stays.
+function structure(edit, node) {
+    return node.nodeType === Node.ELEMENT_NODE
+        && !isEditingBoundary(node)
+        && edit.model.block(node)
+        && !edit.model.atomic(node);
+}
+
+function reducible(edit, block, tag) {
+    if (!edit.model.allows(block.parentElement, edit.document.createElement(tag))) return false;
+    return block.localName !== tag || [...block.children].some(child => structure(edit, child));
+}
+
+function targets(edit, level, range, preview = false) {
+    const result = [];
+    const visit = parent => {
+        for (const element of parent.children) {
+            if (isEditingBoundary(element) || !range.intersects(element)) continue;
+            if (!edit.model.atomic(element)) visit(element);
+            if (!applicable(edit, level, element)) continue;
+            if (covered(range, element) || preview && inline(edit, element)) result.push(element);
+        }
+    };
+    visit(edit.element);
+    return result;
+}
+
+function clear(edit, level, element) {
+    const parent = element.parentNode;
+    stripAttributes(level, element, kept(edit, level));
+    const unwrap = level.elements.includes(element.localName)
+        || element.localName === 'span' && !element.attributes.length;
+    if (unwrap && inline(edit, element)) edit.map.unwrap(element);
+    edit.transaction.touch(unwrap ? parent : element).touch(parent);
+}
+
+function prepare(edit) {
+    const start = new Point(edit.range.start.node, edit.range.start.offset, 'forward');
+    const end = new Point(edit.range.end.node, edit.range.end.offset, 'backward');
+    edit.map.add(start).add(end);
+    splitText(edit, end);
+    splitText(edit, start);
+    return {start, end, backward: !!edit.surface.selection?.backward};
+}
+
+function splitText(edit, point) {
+    const current = edit.map.get(point);
+    if (current.node.nodeType === Node.TEXT_NODE && current.offset > 0 && current.offset < current.node.length) {
+        edit.map.splitText(current.node, current.offset);
+    }
+}
+
+function isolate(edit, level, point) {
+    const current = edit.map.get(point);
+    const wrapper = matchingWrapper(edit, level, current.node);
+    if (!wrapper || !inside(current, wrapper)) return;
+    edit.transaction.touch(wrapper.parentNode);
+    edit.map.split(wrapper.parentNode, current.node, current.offset);
+}
+
+function matchingWrapper(edit, level, node) {
+    let found = null;
+    for (let element = elementOf(node); element && element !== edit.element; element = element.parentElement) {
+        if (isEditingBoundary(element) || !inline(edit, element)) break;
+        if (applicable(edit, level, element)) found = element;
+    }
+    return found;
+}
+
+function applicable(edit, level, element) {
+    const keep = kept(edit, level);
+    return level.attributes.some(name => removable(name, element, keep))
+        || level.elements.includes(element.localName) && !declared(element, keep) && inline(edit, element);
+}
+
+// The host's content classes survive the foreign-presentation rungs, exactly as
+// they survive paste cleanup; the rungs below that scope take them too.
+function kept(edit, level) {
+    const names = edit.config.classes;
+    return keepFor(level, names.length ? new Set(names) : null);
+}
+
+function covered(range, element) {
+    if (!element.childNodes.length) return range.contains(element);
+    return [...element.childNodes].every(node => {
+        if (node.nodeType === Node.TEXT_NODE) return !node.data || range.contains(node);
+        if (node.nodeType !== Node.ELEMENT_NODE || !node.childNodes.length) return range.contains(node);
+        return covered(range, node);
+    });
+}
+
+function inline(edit, element) {
+    return element !== edit.element && !isEditingBoundary(element)
+        && !edit.model.block(element) && !edit.model.atomic(element);
+}
+
+function mappedRange(edit, state) {
+    return EditRange.fromPoints(edit.map.get(state.start), edit.map.get(state.end), edit.element);
+}
+
+function inside(point, element) {
+    return point.within(element) && !atEdge(point, element, 'start') && !atEdge(point, element, 'end');
+}
+
+function atEdge(point, element, edge) {
+    let node = point.node;
+    let offset = point.offset;
+    while (node !== element) {
+        const length = typeof node.length === 'number' ? node.length : node.childNodes.length;
+        if (offset !== (edge === 'start' ? 0 : length)) return false;
+        const parent = node.parentNode;
+        offset = Array.prototype.indexOf.call(parent.childNodes, node) + (edge === 'end' ? 1 : 0);
+        node = parent;
+    }
+    return offset === (edge === 'start' ? 0 : element.childNodes.length);
+}
+