nnw-theme 0.0.0 → 1.0.0

package/assets/netnewswire/Shared/newsfoot.js

@@ -0,0 +1,173 @@
+// @ts-check
+ (function () {
+	/** @param {Node | null} el */
+	const remove = (el) => { if (el) el.parentElement.removeChild(el) };
+
+	const stripPx = (s) => +s.slice(0, -2);
+
+	/** @param {string} tag
+	 * @param {string} cls
+	 * @returns HTMLElement
+	 */
+	function newEl(tag, cls) {
+		const el = document.createElement(tag);
+		el.classList.add(cls);
+		return el;
+	}
+
+	/** @type {<T extends any[]>(fn: (...args: T) => void, t: number) => ((...args: T) => void)} */
+	function debounce(f, ms) {
+		let t = Date.now();
+		return (...args) => {
+			const now = Date.now();
+			if (now - t < ms) return;
+			t = now;
+			f(...args);
+		};
+	}
+
+	const clsPrefix = "newsfoot-footnote-";
+	const CONTAINER_CLS = `${clsPrefix}container`;
+	const POPOVER_CLS = `${clsPrefix}popover`;
+    const POPOVER_INNER_CLS = `${clsPrefix}popover-inner`;
+    const POPOVER_ARROW_CLS = `${clsPrefix}popover-arrow`;
+
+	/**
+	 * @param {string} content
+	 * @returns {HTMLElement}
+	 */
+	function footnoteMarkup(content) {
+		const popover = newEl("div", POPOVER_CLS);
+		const arrow = newEl("div", POPOVER_ARROW_CLS);
+        const inner = newEl("div", POPOVER_INNER_CLS);
+		popover.appendChild(inner);
+		popover.appendChild(arrow);
+		inner.innerHTML = content;
+		return popover;
+	}
+
+	class Footnote {
+		/**
+		 * @param {string} content
+		 * @param {Element} fnref
+		 */
+		constructor(content, fnref) {
+			this.popover = footnoteMarkup(content);
+			this.style = window.getComputedStyle(this.popover);
+			this.fnref = fnref;
+			let container = this.fnref.closest(`.${CONTAINER_CLS}`);
+			container.insertBefore(this.popover, fnref);
+			container.style.zIndex = 1;
+			/** @type {HTMLElement} */
+		    this.arrow = this.popover.querySelector(`.${POPOVER_ARROW_CLS}`);
+			this.reposition();
+  
+			/** @type {(ev:MouseEvent) => void} */
+			this.clickoutHandler = (ev) => {
+				if (!(ev.target instanceof Element)) return;
+				// Keep this popover open for clicks anywhere inside it, including a nested footnote popover.
+				// <https://github.com/Ranchero-Software/NetNewsWire/issues/2372>
+				if (this.popover.contains(ev.target)) return;
+				if (ev.target === this.fnref) {
+				    ev.stopPropagation();
+					ev.preventDefault();
+				}
+				this.cleanup();
+			}
+			document.addEventListener("click", this.clickoutHandler, {capture: true});
+  
+			this.resizeHandler = debounce(() => this.reposition(), 20);
+			window.addEventListener("resize", this.resizeHandler);
+		}
+  
+		cleanup() {
+			this.fnref.closest(`.${CONTAINER_CLS}`).style.zIndex = 0;
+			remove(this.popover);
+			document.removeEventListener("click", this.clickoutHandler, {capture: true});
+			window.removeEventListener("resize", this.resizeHandler);
+			delete this.popover;
+			delete this.clickoutHandler;
+			delete this.resizeHandler;
+		}
+  
+		reposition() {
+			const refRect = this.fnref.getBoundingClientRect();
+			const center = refRect.left + (refRect.width / 2);
+			const popoverHalfWidth = this.popover.clientWidth / 2;
+			const marginLeft = stripPx(this.style.marginLeft);
+			const marginRight = stripPx(this.style.marginRight);
+
+			const rightOverhang = center + popoverHalfWidth + marginRight > window.innerWidth;
+			const leftOverhang = center - (popoverHalfWidth + marginLeft) < 0;
+
+			let offset = 0;
+			if (leftOverhang || rightOverhang) {
+				// Popover can't be centered on the ref without overflowing the viewport.
+				// Center it horizontally in the viewport so left/right margins are balanced.
+				// The arrow gets the inverse transform below and stays anchored to the ref.
+				offset = (window.innerWidth / 2) - center;
+			}
+			this.popover.style.transform = `translate(${offset}px)`;
+			this.arrow.style.transform = `translate(${-offset}px) rotate(45deg)`;
+		}
+	}
+
+	/** @param {HTMLAnchorElement} a */
+	function installContainer(a) {
+		if (!a.parentElement.matches(`.${CONTAINER_CLS}`)) {
+			const container = newEl("div", CONTAINER_CLS);
+			a.parentElement.insertBefore(container, a);
+			container.appendChild(a);
+		}
+	}
+			
+	function idFromHash(target) {
+		if (!target.hash) return;
+		return decodeURIComponent(target.hash.substring(1));
+	}
+	/** @type {{fnref(target:HTMLAnchorElement): string|undefined}[]} */
+	const footnoteFormats = [
+		{ // Multimarkdown
+			fnref(target) {
+				if (!target.matches(".footnote")) return;
+				return idFromHash(target);
+			}
+		}
+	];
+	
+	// Handle clicks on the footnote reference
+	document.addEventListener("click", (ev) => {
+		if (!(ev.target && ev.target instanceof HTMLAnchorElement)) return;
+
+		let targetId = undefined;
+		for(const f of footnoteFormats) {
+			targetId = f.fnref(ev.target);
+			if (targetId) break;
+		}
+		if (targetId === undefined) return;
+		
+		// Only override the default behaviour when we know we can find the
+		// target element
+		const targetElement = document.getElementById(targetId);
+		if (targetElement === null) return;
+				
+		ev.preventDefault();
+
+		installContainer(ev.target);
+				
+		void new Footnote(targetElement.innerHTML, ev.target);
+    });
+										   
+	// Handle clicks on the footnote reverse link
+    document.addEventListener("click", (ev) =>
+    {
+	    if (!(ev.target && ev.target instanceof HTMLAnchorElement)) return;
+        if (!ev.target.matches(".footnotes .reversefootnote, .footnotes .footnoteBackLink, .footnotes .footnote-return, .footnotes a[href*='#fn'], .footnotes a[href^='#']")) return;
+		const id = idFromHash(ev.target);
+		if (!id) return;
+		const fnref = document.getElementById(id);
+
+		window.scrollTo({ top: fnref.getBoundingClientRect().top + window.scrollY });
+	    ev.preventDefault();
+	});
+}());

package/assets/netnewswire/iOS/main_ios.js

@@ -0,0 +1,520 @@
+var activeImageViewer = null;
+
+class ImageViewer {
+	constructor(img) {
+		this.img = img;
+		this.loadingInterval = null;
+		this.activityIndicator = "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+PHN2ZyB4bWxuczpzdmc9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2ZXJzaW9uPSIxLjAiIHdpZHRoPSI2NHB4IiBoZWlnaHQ9IjY0cHgiIHZpZXdCb3g9IjAgMCAxMjggMTI4IiB4bWw6c3BhY2U9InByZXNlcnZlIj48Zz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiMwMDAwMDAiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiNjY2NjY2MiIHRyYW5zZm9ybT0icm90YXRlKDMwIDY0IDY0KSIvPjxwYXRoIGQ9Ik01OS42IDBoOHY0MGgtOFYweiIgZmlsbD0iI2NjY2NjYyIgdHJhbnNmb3JtPSJyb3RhdGUoNjAgNjQgNjQpIi8+PHBhdGggZD0iTTU5LjYgMGg4djQwaC04VjB6IiBmaWxsPSIjY2NjY2NjIiB0cmFuc2Zvcm09InJvdGF0ZSg5MCA2NCA2NCkiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiNjY2NjY2MiIHRyYW5zZm9ybT0icm90YXRlKDEyMCA2NCA2NCkiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiNiMmIyYjIiIHRyYW5zZm9ybT0icm90YXRlKDE1MCA2NCA2NCkiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiM5OTk5OTkiIHRyYW5zZm9ybT0icm90YXRlKDE4MCA2NCA2NCkiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiM3ZjdmN2YiIHRyYW5zZm9ybT0icm90YXRlKDIxMCA2NCA2NCkiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiM2NjY2NjYiIHRyYW5zZm9ybT0icm90YXRlKDI0MCA2NCA2NCkiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiM0YzRjNGMiIHRyYW5zZm9ybT0icm90YXRlKDI3MCA2NCA2NCkiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiMzMzMzMzMiIHRyYW5zZm9ybT0icm90YXRlKDMwMCA2NCA2NCkiLz48cGF0aCBkPSJNNTkuNiAwaDh2NDBoLThWMHoiIGZpbGw9IiMxOTE5MTkiIHRyYW5zZm9ybT0icm90YXRlKDMzMCA2NCA2NCkiLz48YW5pbWF0ZVRyYW5zZm9ybSBhdHRyaWJ1dGVOYW1lPSJ0cmFuc2Zvcm0iIHR5cGU9InJvdGF0ZSIgdmFsdWVzPSIwIDY0IDY0OzMwIDY0IDY0OzYwIDY0IDY0OzkwIDY0IDY0OzEyMCA2NCA2NDsxNTAgNjQgNjQ7MTgwIDY0IDY0OzIxMCA2NCA2NDsyNDAgNjQgNjQ7MjcwIDY0IDY0OzMwMCA2NCA2NDszMzAgNjQgNjQiIGNhbGNNb2RlPSJkaXNjcmV0ZSIgZHVyPSIxMDgwbXMiIHJlcGVhdENvdW50PSJpbmRlZmluaXRlIj48L2FuaW1hdGVUcmFuc2Zvcm0+PC9nPjwvc3ZnPg==";
+	}
+
+	isLoaded() {
+		// img.complete covers images that loaded before the onload handler was added.
+		return this.img.classList.contains("nnwLoaded") || this.img.complete;
+	}
+
+	clicked() {
+		this.showLoadingIndicator();
+		if (this.isLoaded()) {
+			this.showViewer();
+		} else {
+			var callback = () => {
+				if (this.isLoaded()) {
+					clearInterval(this.loadingInterval);
+					this.showViewer();
+				}
+			}
+			this.loadingInterval = setInterval(callback, 100);
+		}
+	}
+	cancel() {
+		clearInterval(this.loadingInterval);
+		this.hideLoadingIndicator();
+	}
+
+	showViewer() {
+		this.hideLoadingIndicator();
+		
+		const rect = this.img.getBoundingClientRect();
+		
+		// Instead of trying to convert to canvas (which fails with CORS),
+		// send the original image src URL
+		const message = {
+			x: rect.x,
+			y: rect.y,
+			width: rect.width,
+			height: rect.height,
+			imageTitle: this.img.title,
+			imageURL: this.img.src,
+		};
+
+		var jsonMessage = JSON.stringify(message);
+		window.webkit.messageHandlers.imageWasClicked.postMessage(jsonMessage);
+	}
+
+	hideImage() {
+		this.img.style.opacity = 0;
+	}
+
+	showImage() {
+		this.img.style.opacity = 1
+	}
+
+	showLoadingIndicator() {
+		var wrapper = document.createElement("div");
+		wrapper.classList.add("activityIndicatorWrap");
+		this.img.parentNode.insertBefore(wrapper, this.img);
+		wrapper.appendChild(this.img);
+
+		var activityIndicatorImg = document.createElement("img");
+		activityIndicatorImg.classList.add("activityIndicator");
+		activityIndicatorImg.style.opacity = 0;
+		activityIndicatorImg.src = this.activityIndicator;
+		wrapper.appendChild(activityIndicatorImg);
+
+		activityIndicatorImg.style.opacity = 1;
+	}
+
+	hideLoadingIndicator() {
+		var wrapper = this.img.parentNode;
+		if (wrapper.classList.contains("activityIndicatorWrap")) {
+			var wrapperParent = wrapper.parentNode;
+			wrapperParent.insertBefore(this.img, wrapper);
+			wrapperParent.removeChild(wrapper);
+		}
+	}
+
+	static init() {
+		cancelImageLoad();
+
+		// keep track of when an image has finished downloading for ImageViewer
+		document.querySelectorAll("img").forEach(element => {
+			element.onload = function() {
+				this.classList.add("nnwLoaded");
+			}
+		});
+
+		// Add the click listener for images
+		window.onclick = function(event) {
+			if (event.target.matches("img") && !event.target.classList.contains("nnw-nozoom")) {
+				// An image inside a link navigates — it might be the only link to an
+				// important page. Zoom only standalone images.
+				// <https://github.com/Ranchero-Software/NetNewsWire/issues/3641>
+				if (event.target.closest("a[href]")) {
+					return;
+				}
+				if (activeImageViewer && activeImageViewer.img === event.target) {
+					cancelImageLoad();
+				} else {
+					cancelImageLoad();
+					activeImageViewer = new ImageViewer(event.target);
+					activeImageViewer.clicked();
+				}
+			}
+		}
+	}
+}
+
+function cancelImageLoad() {
+	if (activeImageViewer) {
+		activeImageViewer.cancel();
+		activeImageViewer = null;
+	}
+}
+
+function hideClickedImage() {
+	if (activeImageViewer) {
+		activeImageViewer.hideImage();
+	}
+}
+
+// Used to animate the transition from a fullscreen image
+function showClickedImage() {
+	if (activeImageViewer) {
+		activeImageViewer.showImage();
+	}
+	window.webkit.messageHandlers.imageWasShown.postMessage("");
+}
+
+function showFeedInspectorSetup() {
+	const imageIcon = document.getElementById("nnwImageIcon");
+	if (!imageIcon) {
+		return;
+	}
+
+	// Tell VoiceOver the icon is a button that opens the Feed Info sheet.
+	// <https://github.com/Ranchero-Software/NetNewsWire/issues/4591>
+	imageIcon.setAttribute("role", "button");
+	imageIcon.setAttribute("tabindex", "0");
+	imageIcon.setAttribute("aria-label", nnwGetFeedInfoLabel);
+
+	imageIcon.onclick = function(event) {
+		window.webkit.messageHandlers.showFeedInspector.postMessage("");
+	}
+}
+
+function postRenderProcessing() {
+	ImageViewer.init();
+	showFeedInspectorSetup();
+	postMediaSourceURLs();
+}
+
+// Tell the app which URLs are embedded media, so it can tell a real link tap
+// from WebKit’s synthesized link activation for a video’s source.
+function postMediaSourceURLs() {
+	var urls = new Set();
+	document.querySelectorAll("video, audio, video source, audio source").forEach(element => {
+		if (element.src) {
+			urls.add(element.src);
+		}
+		if (element.currentSrc) {
+			urls.add(element.currentSrc);
+		}
+	});
+	window.webkit.messageHandlers.mediaSourceURLs.postMessage(Array.from(urls));
+}
+
+function onResize() {
+	const meta = document.querySelector("meta[name=viewport]");
+	
+	if (!meta) return;
+	
+	const originalContent = meta.content;
+	meta.setAttribute("content", originalContent + ", maximum-scale=1.0");
+	meta.setAttribute("content", originalContent);
+}
+window.addEventListener("resize", onResize);
+
+
+function makeHighlightRect({left, top, width, height}, offsetTop=0, offsetLeft=0) {
+	const overlay = document.createElement('a');
+
+	Object.assign(overlay.style, {
+		position: 'absolute',
+		left: `${Math.floor(left + offsetLeft)}px`,
+		top: `${Math.floor(top + offsetTop)}px`,
+		width: `${Math.ceil(width)}px`,
+		height: `${Math.ceil(height)}px`,
+		backgroundColor: 'rgba(200, 220, 10, 0.4)',
+		pointerEvents: 'none'
+	});
+
+	return overlay;
+}
+
+function clearHighlightRects() {
+	let container = document.getElementById('nnw:highlightContainer')
+	if (container) container.remove();
+}
+
+function highlightRects(rects, clearOldRects=true, makeHighlightRect=makeHighlightRect) {
+	const article = document.querySelector('article');
+	let container = document.getElementById('nnw:highlightContainer');
+
+	article.style.position = 'relative';
+
+	if (container && clearOldRects)
+		container.remove();
+
+	container = document.createElement('div');
+	container.id = 'nnw:highlightContainer';
+	article.appendChild(container);
+
+	const {top, left} = article.getBoundingClientRect();
+	return Array.from(rects, rect => 
+		container.appendChild(makeHighlightRect(rect, -top, -left))
+	);
+}
+
+FinderResult = class {
+	constructor(result) {
+		Object.assign(this, result);
+	}
+
+	range() {
+		const range = document.createRange();
+		range.setStart(this.node, this.offset);
+		range.setEnd(this.node, this.offsetEnd);
+		return range;
+	}
+
+	bounds() {
+		return this.range().getBoundingClientRect();
+	}
+
+	rects() {
+		return this.range().getClientRects();
+	}
+
+	highlight({clearOldRects=true, fn=makeHighlightRect} = {}) {
+		highlightRects(this.rects(), clearOldRects, fn);
+	}
+
+	scrollTo() {
+		scrollToRect(this.bounds(), this.node);
+	}
+
+	toJSON() {
+		return {
+			rects: Array.from(this.rects()),
+			bounds: this.bounds(),
+			index: this.index,
+			matchGroups: this.match
+		};
+	}
+
+	toJSONString() {
+		return JSON.stringify(this.toJSON());
+	}
+}
+
+Finder = class {
+	constructor(pattern, options) {
+		if (!pattern.global) {
+			pattern = new RegExp(pattern, 'g');
+		}
+
+		this.pattern = pattern;
+		this.lastResult = null;
+		this._nodeMatches = [];
+		this.options = {
+			rootSelector: '.articleBody',
+			startNode: null,
+			startOffset: null,
+		}
+
+		this.resultIndex = -1
+
+		Object.assign(this.options, options);
+
+		this.walker = document.createTreeWalker(this.root, NodeFilter.SHOW_TEXT);
+	}
+
+	get root() {
+		return document.querySelector(this.options.rootSelector)
+	}
+
+	get count() {
+		const node = this.walker.currentNode;
+		const index = this.resultIndex;
+		this.reset();
+
+		let result, count = 0;
+		while ((result = this.next())) ++count;
+
+		this.resultIndex = index;
+		this.walker.currentNode = node;
+
+		return count;
+	}
+
+	reset() {
+		this.walker.currentNode = this.options.startNode || this.root;
+		this.resultIndex = -1;
+	}
+
+	[Symbol.iterator]() {
+		return this;
+	}
+
+	next({wrap = false} = {}) {
+		const { startNode } = this.options;
+		const { pattern, walker } = this;
+
+		let { node, matchIndex = -1 } = this.lastResult || { node: startNode };
+
+		while (true) {
+			if (!node)
+				node = walker.nextNode();
+
+			if (!node) {
+				if (!wrap || this.resultIndex < 0) break;
+
+				this.reset();
+
+				continue;
+			}
+
+			let nextIndex = matchIndex + 1;
+			let matches = this._nodeMatches;
+
+			if (!matches.length) {
+				matches = Array.from(node.textContent.matchAll(pattern));
+				nextIndex = 0;
+			}
+ 
+			if (matches[nextIndex]) {
+				this._nodeMatches = matches;
+				const m = matches[nextIndex];
+
+				this.lastResult = new FinderResult({
+					node,
+					offset: m.index,
+					offsetEnd: m.index + m[0].length,
+					text: m[0],
+					match: m,
+					matchIndex: nextIndex,
+					index: ++this.resultIndex,
+				});
+
+				return { value: this.lastResult, done: false };
+			}
+
+			this._nodeMatches = [];
+			node = null;
+		}
+
+		return { value: undefined, done: true };
+	}
+
+	/// TODO Call when the search text changes
+	retry() {
+		if (this.lastResult) {
+			this.lastResult.offsetEnd = this.lastResult.offset;
+		}
+		
+	}
+
+	toJSON() {
+		const results = Array.from(this);
+	}
+}
+
+function scrollParent(node) {
+	let elt = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
+
+	while (elt) {
+		if (elt.scrollHeight > elt.clientHeight)
+			return elt;
+		elt = elt.parentElement;
+	}
+}
+ 
+function scrollToRect({top, height}, node, pad=20, padBottom=60) {
+	const scrollToTop = top - pad;
+
+	let scrollBy = scrollToTop;
+
+	if (scrollToTop >= 0) {
+		const visible = window.visualViewport;
+		const scrollToBottom = top + height + padBottom - visible.height;
+		// The top of the rect is already in the viewport
+		if (scrollToBottom <= 0 || scrollToTop === 0)
+			// Don't need to scroll up--or can't
+			return;
+
+		scrollBy = Math.min(scrollToBottom, scrollBy);
+	} 
+
+	scrollParent(node).scrollBy({ top: scrollBy });
+}
+
+function withEncodedArg(fn) {
+	return function(encodedData, ...rest) {
+		const data = encodedData && JSON.parse(atob(encodedData));
+		return fn(data, ...rest);
+	}
+}
+
+function escapeRegex(s) {
+	return s.replace(/[.?*+^$\\()[\]{}]/g, '\\$&');
+}
+
+class FindState {
+	constructor(options) {
+		let { text, caseSensitive, regex } = options;
+		
+		if (!regex)
+			text = escapeRegex(text);
+		
+		const finder = new Finder(new RegExp(text, caseSensitive ? 'g' : 'ig'));
+		this.results = Array.from(finder);
+		this.index = -1;
+		this.options = options;
+	}
+	
+	get selected() {
+		return this.index > -1 ? this.results[this.index] : null;
+	}
+	
+	toJSON() {
+		return {
+			index: this.index > -1 ? this.index : null,
+			results: this.results,
+			count: this.results.length
+		};
+	}
+	
+	selectNext(step=1) {
+		const index = this.index + step;
+		const result = this.results[index];
+		if (result) {
+			this.index = index;
+			result.highlight();
+			result.scrollTo();
+		}
+		return result;
+	}
+	
+	selectPrevious() {
+		return this.selectNext(-1);
+	}
+}
+
+CurrentFindState = null;
+
+const ExcludeKeys = new Set(['top', 'right', 'bottom', 'left']);
+updateFind = withEncodedArg(options => {
+	// TODO Start at the current result position
+	// TODO Introduce slight delay, cap the number of results, and report results asynchronously
+	
+	let newFindState;
+	if (!options || !options.text) {
+		clearHighlightRects();
+		return
+	}
+	
+	try {
+		newFindState = new FindState(options);
+	} catch (err) {
+		clearHighlightRects();
+		throw err;
+	}
+	
+	if (newFindState.results.length) {
+		let selected = CurrentFindState && CurrentFindState.selected;
+		let selectIndex = 0;
+		if (selected) {
+			let {node: currentNode, offset: currentOffset} = selected;
+			selectIndex = newFindState.results.findIndex(r => {
+				if (r.node === currentNode) {
+					return r.offset >= currentOffset;
+				}
+				
+				let relation = currentNode.compareDocumentPosition(r.node);
+				return Boolean(relation & Node.DOCUMENT_POSITION_FOLLOWING);
+			});
+		}
+		
+		newFindState.selectNext(selectIndex+1);
+	} else {
+		clearHighlightRects();
+	}
+	
+	CurrentFindState = newFindState;
+	return btoa(JSON.stringify(CurrentFindState, (k, v) => (ExcludeKeys.has(k) ? undefined : v)));
+});
+
+selectNextResult = withEncodedArg(options => {
+	if (CurrentFindState)
+		CurrentFindState.selectNext();
+});
+
+selectPreviousResult = withEncodedArg(options => {
+	if (CurrentFindState)
+		CurrentFindState.selectPrevious();
+});
+
+function endFind() {
+	clearHighlightRects()
+	CurrentFindState = null;
+}

package/assets/netnewswire/iOS/page.html

@@ -0,0 +1,19 @@
+<html dir="auto">
+	<head>
+		<title>[[title]]</title>
+		<meta name="viewport" content="width=device-width, initial-scale=1">
+		<style>
+			[[style]]
+		</style>
+		<script type="text/javascript">
+			document.addEventListener("DOMContentLoaded", function(event) {
+				window.scrollTo(0, [[windowScrollY]]);
+			})
+		</script>
+		<base href="[[baseURL]]">
+	</head>
+	<body>
+		[[body]]
+	</body>
+</html>
+