rapier-markdown-kit 1.1.99 → 1.1.102

package/dist/layout/model.mjs

@@ -85,30 +85,36 @@ export function mapFragment(run, fragment) {
 // The line a picture is measured in (`lines`, spec/md-layout.mjs): the anchor's line box, its type's cap height, and where that
 // cap height stands in the first line box (the half-leading model: the baseline sits half the leading below the box's top plus
 // the ascent). Read from the font as the page lays it out, so a text size or a line spacing moves the picture with the words.
-const fontMetrics = new Map(), measurers = new WeakMap();
-export function lineMetrics(element) {
-  const view = element?.ownerDocument?.defaultView;
-  if (!view) return null;
-  const computed = view.getComputedStyle(element), size = parseFloat(computed.fontSize) || 16;
-  const font = computed.fontStyle + ' ' + computed.fontWeight + ' ' + size + 'px ' + computed.fontFamily;
-  let metrics = fontMetrics.get(font);
-  if (!metrics) {
-    let context = measurers.get(element.ownerDocument);
-    if (!context) measurers.set(element.ownerDocument, context = element.ownerDocument.createElement('canvas').getContext('2d'));
-    if (!context) return null;
-    context.font = font;
-    const capital = context.measureText('H');
-    metrics = {ascent: capital.fontBoundingBoxAscent, descent: capital.fontBoundingBoxDescent, cap: capital.actualBoundingBoxAscent};
-    if (![metrics.ascent, metrics.descent, metrics.cap].every(finite) || !(metrics.cap > 0)) return null;
-    // A face still loading measures as its fallback: keep the answer only once the face is in.
-    if (element.ownerDocument.fonts?.check?.(font) !== false && element.ownerDocument.fonts?.status !== 'loading') fontMetrics.set(font, metrics);
-  }
-  const line = parseFloat(computed.lineHeight) || metrics.ascent + metrics.descent;
-  return {line, cap: metrics.cap, capTop: (line - metrics.ascent - metrics.descent) / 2 + metrics.ascent - metrics.cap};
+export function createLineMeasurer() {
+  const fontMetrics = new Map(), measurers = new WeakMap();
+  const finite = value => typeof value === 'number' && Number.isFinite(value);
+  return function lineMetrics(element) {
+    const view = element?.ownerDocument?.defaultView;
+    if (!view) return null;
+    const computed = view.getComputedStyle(element), size = parseFloat(computed.fontSize) || 16;
+    const font = computed.fontStyle + ' ' + computed.fontWeight + ' ' + size + 'px ' + computed.fontFamily;
+    let metrics = fontMetrics.get(font);
+    if (!metrics) {
+      let context = measurers.get(element.ownerDocument);
+      if (!context) measurers.set(element.ownerDocument, context = element.ownerDocument.createElement('canvas').getContext('2d'));
+      if (!context) return null;
+      context.font = font;
+      const capital = context.measureText('H');
+      metrics = {ascent: capital.fontBoundingBoxAscent, descent: capital.fontBoundingBoxDescent, cap: capital.actualBoundingBoxAscent};
+      if (![metrics.ascent, metrics.descent, metrics.cap].every(finite) || !(metrics.cap > 0)) return null;
+      // A face still loading measures as its fallback: keep the answer only once the face is in.
+      if (element.ownerDocument.fonts?.check?.(font) !== false && element.ownerDocument.fonts?.status !== 'loading') fontMetrics.set(font, metrics);
+    }
+    const line = parseFloat(computed.lineHeight) || metrics.ascent + metrics.descent;
+    return {line, cap: metrics.cap, capTop: (line - metrics.ascent - metrics.descent) / 2 + metrics.ascent - metrics.cap};
+  };
 }
 
+export const lineMetrics = createLineMeasurer();
+
 // `lines` tall: from the first line's cap height to the Nth line's baseline, N - 1 lines and one cap.
 export function linesHeight(lines, metrics) {
+  const finite = value => typeof value === 'number' && Number.isFinite(value);
   const height = Number.isInteger(lines) && lines > 0 && metrics && finite(metrics.line) && finite(metrics.cap)
     ? (lines - 1) * metrics.line + metrics.cap : NaN;
   return height > 0 ? height : null;

package/dist/layout/typography.mjs

@@ -0,0 +1,364 @@
+// SPDX-License-Identifier: MIT
+
+// Layout projections keep the original text in place. The factory also runs in an exported page.
+export function createTypography() {
+  const mark = 'data-rapier-typography', boundary = mark + '-break', hang = mark + '-hang';
+  const protectedInitial = mark + '-protected-initial';
+  const exclude = 'code,kbd,samp,math,script,style,.math-rendered,[hidden]';
+  const candidates = 'p[data-md-hyphens="auto"],p[data-md-lines],p[data-md-hanging="on"],p[' + mark + ']';
+  const properties = ['--md-drop-cap-font', '--md-hang-start'];
+  const states = new WeakMap(), documents = new WeakMap();
+  const graphemes = new Intl.Segmenter(undefined, {granularity: 'grapheme'});
+  const opening = /^[\p{Ps}\p{Pi}\p{Pf}"']+$/u;
+  const closing = /^[\p{Pe}\p{Pi}\p{Pf}"'.,;:!?]+$/u;
+
+  function initialRange(input) {
+    const text = typeof input === 'string' ? input : input?.textContent;
+    if (typeof text !== 'string') return null;
+    const start = /^\s*/u.exec(text)[0].length;
+    if (start === text.length) return null;
+    let end = start;
+    for (const part of graphemes.segment(text.slice(start))) {
+      if (/^\s/u.test(part.segment)) break;
+      end = start + part.index + part.segment.length;
+      if (!opening.test(part.segment)) break;
+    }
+    return end > start ? {start, end, text: text.slice(start, end)} : null;
+  }
+
+  function paragraphs(root, selector = candidates) {
+    return [...(root?.matches?.(selector) ? [root] : []), ...(root?.querySelectorAll?.(selector) || [])];
+  }
+
+  function runs(paragraph) {
+    const walker = paragraph.ownerDocument.createTreeWalker(paragraph, 4), result = [];
+    let start = 0;
+    while (walker.nextNode()) {
+      const node = walker.currentNode;
+      if (node.length) result.push({node, start, end: start + node.length});
+      start += node.length;
+    }
+    return result;
+  }
+
+  function point(items, offset, atEnd = false) {
+    let lo = 0, hi = items.length;
+    while (lo < hi) {
+      const middle = lo + hi >>> 1;
+      if (items[middle].end < offset || !atEnd && items[middle].end === offset) lo = middle + 1;
+      else hi = middle;
+    }
+    const item = items[Math.min(lo, items.length - 1)];
+    return item ? {node: item.node, offset: Math.max(0, Math.min(item.node.length, offset - item.start))} : null;
+  }
+
+  // This data-only guard is safe on an active edit surface, including during composition.
+  function protectInitial(root) {
+    for (const paragraph of paragraphs(root, 'p[data-md-lines],p[data-md-hanging="on"],p[' + protectedInitial + ']')) {
+      const initial = initialRange(paragraph), letter = initial && [...graphemes.segment(initial.text)].at(-1);
+      const at = initial && point(runs(paragraph), initial.start + letter.index);
+      const enabled = paragraph.hasAttribute('data-md-lines') || paragraph.getAttribute('data-md-hanging') === 'on';
+      paragraph.toggleAttribute(protectedInitial, Boolean(enabled && at?.node.parentElement?.closest(exclude)));
+    }
+  }
+
+  function range(items, start, end) {
+    const a = point(items, start), b = point(items, end, true);
+    if (!a || !b) return null;
+    const value = a.node.ownerDocument.createRange();
+    value.setStart(a.node, a.offset); value.setEnd(b.node, b.offset);
+    return value;
+  }
+
+  function boxes(items, start, end, height = Infinity) {
+    return [...(range(items, start, end)?.getClientRects?.() || [])]
+      .filter(box => box.width > .05 && box.height > 0 && box.height <= height);
+  }
+
+  function sameLine(a, b) {
+    return Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top) > Math.min(a.height, b.height) * .35;
+  }
+
+  function ordinaryHeight(paragraph, style) {
+    return paragraph.hasAttribute('data-md-lines') ? Math.max(parseFloat(style.lineHeight) || 0, parseFloat(style.fontSize) * 1.7) : Infinity;
+  }
+
+  // Returns a textContent coordinate, independent of markup, selected fonts or a floated initial.
+  function firstLineEnd(paragraph) {
+    if (!paragraph?.isConnected || !paragraph.getClientRects?.().length) return null;
+    const view = paragraph.ownerDocument.defaultView;
+    if (!view) return null;
+    const style = view.getComputedStyle(paragraph), height = ordinaryHeight(paragraph, style);
+    const items = runs(paragraph), text = paragraph.textContent;
+    const initial = paragraph.hasAttribute('data-md-lines') ? initialRange(text) : null;
+    let first = null, end = null;
+    for (const part of graphemes.segment(text)) {
+      if (initial && part.index < initial.end) continue;
+      if (/^\s+$/u.test(part.segment)) continue;
+      const rects = boxes(items, part.index, part.index + part.segment.length, height);
+      if (!rects.length) continue;
+      const box = rects[rects.length - 1];
+      if (!first) first = box;
+      if (sameLine(first, box)) end = part.index + part.segment.length;
+      else if (box.top >= first.bottom - Math.min(box.height, first.height) * .35) break;
+    }
+    return end ?? initial?.end ?? null;
+  }
+
+  function setProperty(paragraph, state, name, value) {
+    if (!state.properties.has(name)) state.properties.set(name, [paragraph.style.getPropertyValue(name), paragraph.style.getPropertyPriority(name)]);
+    paragraph.style.setProperty(name, value);
+  }
+
+  function selectionBefore(paragraph) {
+    const selection = paragraph.ownerDocument.getSelection();
+    if (!selection?.rangeCount || !paragraph.contains(selection.anchorNode) && !paragraph.contains(selection.focusNode)) return null;
+    const capture = (node, offset) => {
+      if (!paragraph.contains(node)) return {node, offset};
+      const prefix = paragraph.ownerDocument.createRange(); prefix.selectNodeContents(paragraph); prefix.setEnd(node, offset);
+      return {text: prefix.toString().length};
+    };
+    return {selection, anchor: capture(selection.anchorNode, selection.anchorOffset), focus: capture(selection.focusNode, selection.focusOffset)};
+  }
+
+  function restoreSelection(paragraph, saved) {
+    if (!saved) return;
+    const items = runs(paragraph);
+    const resolve = endpoint => endpoint.text == null ? endpoint : point(items, endpoint.text, true) || {node: paragraph, offset: 0};
+    const anchor = resolve(saved.anchor), focus = resolve(saved.focus);
+    if (anchor.node.isConnected && focus.node.isConnected) saved.selection.setBaseAndExtent(anchor.node, anchor.offset, focus.node, focus.offset);
+  }
+
+  // A native initial cannot span inline element boundaries. Move only its opening punctuation
+  // into the letter's text node; the paragraph's text and all original elements stay in place.
+  function unifyInitial(paragraph, state, initial, letterStart) {
+    const items = runs(paragraph), at = point(items, letterStart);
+    if (!at || at.node.parentElement?.closest(exclude)) return;
+    let prefix = '';
+    for (const item of items) {
+      if (item.node === at.node) break;
+      const from = Math.max(initial.start, item.start), to = Math.min(letterStart, item.end);
+      if (from >= to) continue;
+      const before = item.node.data;
+      prefix += before.slice(from - item.start, to - item.start);
+      state.moves.push({node: item.node, parent: item.node.parentNode, next: item.node.nextSibling,
+        before, after: before.slice(0, from - item.start) + before.slice(to - item.start)});
+    }
+    if (!prefix) return;
+    state.moves.push({node: at.node, parent: at.node.parentNode, next: at.node.nextSibling,
+      before: at.node.data, after: prefix + at.node.data});
+    for (const move of state.moves) move.node.data = move.after;
+  }
+
+  function restoreInitial(state) {
+    if (!state?.moves.length) return;
+    const restore = [];
+    for (const move of state.moves) {
+      if (move.node.parentNode !== move.parent) return;
+      const pieces = [move.node]; let cursor = move.node.nextSibling, text = move.node.data;
+      while (cursor !== move.next && cursor?.nodeType === 3) { pieces.push(cursor); text += cursor.data; cursor = cursor.nextSibling; }
+      if (cursor !== move.next || text !== move.after) return;
+      restore.push({move, pieces});
+    }
+    // A changed projection belongs to its current writer; restoration never replaces newer text.
+    for (const {move, pieces} of restore) { move.node.data = move.before; for (const piece of pieces.slice(1)) piece.remove(); }
+  }
+
+  function clear(root) {
+    const list = paragraphs(root, 'p[' + mark + '],p[' + protectedInitial + ']');
+    for (const paragraph of list) {
+      if (!paragraph.hasAttribute(mark)) { paragraph.removeAttribute(protectedInitial); continue; }
+      const selected = selectionBefore(paragraph);
+      for (const node of paragraph.querySelectorAll('[' + boundary + '],[' + hang + ']')) node.replaceWith(...node.childNodes);
+      const state = states.get(paragraph);
+      restoreInitial(state);
+      for (const name of properties) {
+        const previous = state?.properties.get(name);
+        if (previous?.[0]) paragraph.style.setProperty(name, previous[0], previous[1]);
+        else paragraph.style.removeProperty(name);
+      }
+      paragraph.removeAttribute(mark); paragraph.removeAttribute(mark + '-ragged');
+      paragraph.removeAttribute(protectedInitial);
+      if (!paragraph.getAttribute('style')) paragraph.removeAttribute('style');
+      paragraph.normalize();
+      states.delete(paragraph);
+      restoreSelection(paragraph, selected);
+    }
+  }
+
+  function fontEpoch(document) {
+    let entry = documents.get(document);
+    if (!entry) {
+      entry = {epoch: 0}; documents.set(document, entry);
+      document.fonts?.addEventListener('loadingdone', () => { entry.epoch++; });
+    }
+    return entry.epoch;
+  }
+
+  function signature(paragraph, style, width, hangingGeometry) {
+    return [paragraph.innerHTML, width, hangingGeometry, style.font, style.lineHeight, style.letterSpacing, style.wordSpacing,
+      style.writingMode, style.direction, style.textIndent, style.paddingInlineStart, style.paddingInlineEnd,
+      paragraph.getAttribute('data-md-layout'), paragraph.getAttribute('data-md-align'), paragraph.getAttribute('data-md-lines'),
+      paragraph.getAttribute('data-md-hyphens'), paragraph.getAttribute('data-md-caps'), paragraph.getAttribute('data-md-hanging'),
+      paragraph.closest('[lang]')?.getAttribute('lang'), fontEpoch(paragraph.ownerDocument)].join('\u0000');
+  }
+
+  function insertBoundary(paragraph, items, offset) {
+    const at = point(items, offset);
+    if (!at || at.node.parentElement?.closest(exclude + ',[' + boundary + ']')) return false;
+    const separator = /^[\t\n\r\f ]+/.exec(at.node.data.slice(at.offset));
+    if (!separator) return false;
+    let text = at.node;
+    const end = at.offset + separator[0].length;
+    if (end < text.length) text.splitText(end);
+    if (at.offset) text = text.splitText(at.offset);
+    const node = paragraph.ownerDocument.createElement('span'); node.setAttribute(boundary, '');
+    text.before(node); node.append(text);
+    return true;
+  }
+
+  function stretchedLines(paragraph, style, maximum) {
+    const text = paragraph.textContent, items = runs(paragraph), height = ordinaryHeight(paragraph, style), lines = [];
+    for (const match of text.matchAll(/[\t\n\r\f \u00a0\u202f]+/gu)) {
+      const start = point(items, match.index), end = point(items, match.index + match[0].length, true);
+      if (start?.node.parentElement?.closest(exclude) || end?.node.parentElement?.closest(exclude)) continue;
+      for (const box of boxes(items, match.index, match.index + match[0].length, height)) {
+        if (box.width <= maximum + .1 || lines.some(line => sameLine(line.box, box))) continue;
+        lines.push({box, end: -1});
+      }
+    }
+    if (!lines.length) return {items, lines};
+    for (const match of text.matchAll(/[^\t\n\r\f ]+/gu)) {
+      const rects = boxes(items, match.index, match.index + match[0].length, height);
+      if (!rects.length) continue;
+      const last = rects[rects.length - 1];
+      for (const line of lines) if (sameLine(line.box, last)) line.end = match.index + match[0].length;
+    }
+    return {items, lines};
+  }
+
+  function justify(paragraph, style) {
+    const maximum = parseFloat(style.fontSize) * .6;
+    if (!(maximum > 0) || style.writingMode !== 'horizontal-tb') return 0;
+    let count = 0;
+    // Each released line changes the native pretty-wrap solution. Use only the earliest current
+    // line, then measure again so obsolete later endpoints cannot create isolated words.
+    for (let pass = 0; pass < 64; pass++) {
+      const {items, lines} = stretchedLines(paragraph, style, maximum);
+      if (!lines.length) return count;
+      const end = lines.map(line => line.end).filter(end => end > 0 && end < paragraph.textContent.trimEnd().length).sort((a, b) => a - b)[0];
+      if (!end || !insertBoundary(paragraph, items, end)) break;
+      count++;
+    }
+    // If no safe ordinary-word boundary can release the line, retain the natural paragraph flow.
+    for (const node of paragraph.querySelectorAll('[' + boundary + ']')) node.replaceWith(...node.childNodes);
+    paragraph.setAttribute(mark + '-ragged', '');
+    return 0;
+  }
+
+  // Optical alignment uses the available margin; paint containment and narrow pages must not
+  // clip a large quoted initial. Offscreen measurement stages have no viewport clipping edge.
+  function hangingEdge(paragraph, style, box) {
+    const view = paragraph.ownerDocument.defaultView, rtl = style.direction === 'rtl';
+    if (style.visibility !== 'visible' || box.right <= 0 || box.left >= view.innerWidth) return null;
+    let edge = rtl ? view.innerWidth : 0;
+    if (view.matchMedia('print').matches) {
+      const content = paragraph.closest('.md-render')?.getBoundingClientRect();
+      // The PDF painter clips at the content area even when a physical page margin exists.
+      if (content?.width > 0) edge = rtl ? Math.min(edge, content.right) : Math.max(edge, content.left);
+    }
+    for (let element = paragraph; element; element = element.parentElement) {
+      const computed = view.getComputedStyle(element);
+      if (!/^(?:hidden|clip|scroll|auto)$/.test(computed.overflowX) &&
+          !/(?:^|\s)(?:paint|content|strict)(?:\s|$)/.test(computed.contain) && computed.contentVisibility !== 'auto') continue;
+      const bounds = element.getBoundingClientRect();
+      if (!(bounds.width > 0)) continue;
+      const limit = rtl ? bounds.right - (parseFloat(computed.borderRightWidth) || 0) :
+        bounds.left + (parseFloat(computed.borderLeftWidth) || 0);
+      edge = rtl ? Math.min(edge, limit) : Math.max(edge, limit);
+    }
+    return edge;
+  }
+
+  function hangPunctuation(paragraph, state, style, edge) {
+    if (paragraph.ownerDocument.defaultView.CSS.supports('hanging-punctuation', 'first last allow-end')) return;
+    const text = paragraph.textContent, parts = [...graphemes.segment(text)], items = runs(paragraph);
+    const initial = initialRange(text);
+    if (initial && !paragraph.hasAttribute(protectedInitial)) {
+      let end = initial.start;
+      for (const part of graphemes.segment(initial.text)) {
+        if (!opening.test(part.segment)) break;
+        end = initial.start + part.index + part.segment.length;
+      }
+      if (end > initial.start) {
+        const rects = boxes(items, initial.start, end);
+        if (rects.length === 1) {
+          const box = rects[0], view = paragraph.ownerDocument.defaultView;
+          const margin = parseFloat(view.getComputedStyle(paragraph, '::first-letter').marginInlineStart) || 0;
+          const available = style.direction === 'rtl' ? edge - box.right - margin : box.left - edge - margin;
+          const distance = edge == null ? box.width : Math.min(box.width, available);
+          setProperty(paragraph, state, '--md-hang-start', -distance + 'px');
+        }
+      }
+    }
+    const last = parts.findLast(part => !/^\s+$/u.test(part.segment));
+    if (!last || !closing.test(last.segment)) return;
+    const a = point(items, last.index), b = point(items, last.index + last.segment.length, true);
+    if (!a || !b || a.node !== b.node || a.node.parentElement?.closest(exclude)) return;
+    const rects = boxes(items, last.index, last.index + last.segment.length);
+    if (rects.length !== 1) return;
+    let node = a.node;
+    if (b.offset < node.length) node.splitText(b.offset);
+    if (a.offset) node = node.splitText(a.offset);
+    const wrapper = paragraph.ownerDocument.createElement('span');
+    wrapper.setAttribute(hang, 'end'); wrapper.style.marginInlineEnd = -rects[0].width + 'px';
+    node.before(wrapper); wrapper.append(node);
+  }
+
+  function apply(root, {all = false} = {}) {
+    let changed = 0, released = 0;
+    for (const paragraph of paragraphs(root)) {
+      if (paragraph.closest('table,pre,code,h1,h2,h3,h4,h5,h6,.block-edit') ||
+          paragraph.isContentEditable && !paragraph.closest('.block-read') ||
+          !paragraph.isConnected || !all && paragraph.checkVisibility && !paragraph.checkVisibility({contentVisibilityAuto: true})) continue;
+      const view = paragraph.ownerDocument.defaultView;
+      if (!view || !paragraph.getClientRects().length) continue;
+      let style = view.getComputedStyle(paragraph);
+      const box = paragraph.getBoundingClientRect(), width = box.width, prior = states.get(paragraph);
+      const hanging = paragraph.getAttribute('data-md-hanging') === 'on';
+      const edge = hanging ? hangingEdge(paragraph, style, box) : null;
+      const geometry = hanging ? [edge, box.left, box.right].join(',') : '';
+      if (!(width > 0) || prior?.signature === signature(paragraph, style, width, geometry)) continue;
+      const selected = selectionBefore(paragraph);
+      clear(paragraph);
+      const cap = paragraph.hasAttribute('data-md-lines');
+      const justified = paragraph.getAttribute('data-md-hyphens') === 'auto' && paragraph.getAttribute('data-md-align') === 'justify';
+      if (!cap && !hanging && !justified) continue;
+      const state = {properties: new Map(), moves: [], signature: ''}; states.set(paragraph, state);
+      paragraph.setAttribute(mark, '');
+      protectInitial(paragraph);
+      if (cap && !paragraph.hasAttribute(protectedInitial)) {
+        const initial = initialRange(paragraph), letter = initial && [...graphemes.segment(initial.text)].at(-1);
+        const at = initial && point(runs(paragraph), initial.start + letter.index);
+        if (at?.node.parentElement) setProperty(paragraph, state, '--md-drop-cap-font', view.getComputedStyle(at.node.parentElement).fontFamily);
+        if (initial && letter) unifyInitial(paragraph, state, initial, initial.start + letter.index);
+      }
+      if (hanging) hangPunctuation(paragraph, state, style, edge);
+      style = view.getComputedStyle(paragraph);
+      if (justified) released += justify(paragraph, style);
+      state.signature = signature(paragraph, view.getComputedStyle(paragraph), width, geometry);
+      restoreSelection(paragraph, selected);
+      changed++;
+    }
+    return {changed, released};
+  }
+
+  return {apply, clear, firstLineEnd, initialRange, protectInitial};
+}
+
+const typography = createTypography();
+export const apply = typography.apply;
+export const clear = typography.clear;
+export const firstLineEnd = typography.firstLineEnd;
+export const initialRange = typography.initialRange;
+export const protectInitial = typography.protectInitial;

package/dist/packages/rapier-diff/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jack Skipworth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.