@storyteller-platform/align 0.1.25 → 0.1.26

package/dist/markup/segmentation.d.ts

@@ -1,12 +1,7 @@
 import { SegmentationResult } from '@echogarden/text-segmentation';
-import { ParsedXml } from '@storyteller-platform/epub';
-import { Mapping } from './map.js';
 
-declare function getXhtmlSegmentation(xml: ParsedXml, options: {
+declare function segmentChapter(text: string, options: {
     primaryLocale?: Intl.Locale | null | undefined;
-}): Promise<{
-    result: SegmentationResult["sentences"];
-    mapping: Mapping;
-}>;
+}): Promise<SegmentationResult["sentences"]>;
 
-export { getXhtmlSegmentation };
+export { segmentChapter };

package/dist/markup/segmentation.js

@@ -2,19 +2,15 @@ import "../chunk-BIEQXUOY.js";
 import {
   segmentText
 } from "@echogarden/text-segmentation";
-import { parseDom } from "./parseDom.js";
-import { liftText } from "./transform.js";
-async function getXhtmlSegmentation(xml, options) {
-  const root = parseDom(xml);
-  const { result: text, mapping } = liftText(root);
+async function segmentChapter(text, options) {
   const result = await segmentText(text, {
     ...options.primaryLocale && {
       language: options.primaryLocale.language
     },
     enableEastAsianPostprocessing: true
   });
-  return { result: result.sentences, mapping };
+  return result.sentences;
 }
 export {
-  getXhtmlSegmentation
+  segmentChapter
 };

package/dist/markup/serializeDom.d.cts

@@ -1,5 +1,5 @@
 import { ParsedXml } from '@storyteller-platform/epub';
-import { Root } from './model.cjs';
+import { R as Root } from '../model-Bv3yPEdd.cjs';
 
 declare function serializeDom(doc: Root): ParsedXml;
 

package/dist/markup/serializeDom.d.ts

@@ -1,5 +1,5 @@
 import { ParsedXml } from '@storyteller-platform/epub';
-import { Root } from './model.js';
+import { R as Root } from '../model-Bv3yPEdd.js';
 
 declare function serializeDom(doc: Root): ParsedXml;
 

package/dist/markup/transform.cjs

@@ -19,11 +19,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var transform_exports = {};
 __export(transform_exports, {
   addMark: () => addMark,
-  liftText: () => liftText
+  inlineFootnotes: () => inlineFootnotes,
+  liftText: () => liftText,
+  replaceFootnotes: () => replaceFootnotes
 });
 module.exports = __toCommonJS(transform_exports);
 var import_map = require("./map.cjs");
 var import_model = require("./model.cjs");
+var import_parseDom = require("./parseDom.cjs");
 function addMark(root, from, to, mark) {
   const result = root.split(from).split(to);
   let pos = 0;
@@ -55,6 +58,11 @@ function liftText(root) {
   let textLength = 0;
   let lastTextEnd = 0;
   (0, import_model.descendants)(root, (node, pos, parent, index) => {
+    if (node instanceof import_model.FootnoteNode) {
+      if (!text.endsWith("\n")) {
+        text += "\n";
+      }
+    }
     if (node.isBlock) {
       return !!node.textContent.match(/\S/);
     }
@@ -90,8 +98,57 @@ function liftText(root) {
   });
   return { result: text, mapping };
 }
+function inlineFootnotes(root) {
+  const footnotePairs = (0, import_parseDom.findFootnotePairs)(root);
+  const mapping = new import_map.Mapping();
+  let transformed = root;
+  for (const [noterefPos, footnotePos] of footnotePairs.entries()) {
+    const noteref = root.resolve(noterefPos).nodeAfter;
+    const footnote = root.resolve(footnotePos).nodeAfter;
+    if (!noteref || !(footnote instanceof import_model.Node)) continue;
+    transformed = transformed.replace(mapping.map(noterefPos), footnote);
+    mapping.appendMap(
+      new import_map.StepMap([
+        mapping.map(noterefPos),
+        noteref.nodeSize,
+        footnote.nodeSize
+      ])
+    );
+    transformed = transformed.replace(
+      mapping.map(footnotePos),
+      new import_model.Node(footnote.tagName)
+    );
+    mapping.appendMap(
+      new import_map.StepMap([mapping.map(footnotePos), footnote.nodeSize, 1])
+    );
+  }
+  return { root: transformed, footnotePairs, mapping };
+}
+function replaceFootnotes(original, root, footnotePairs, mapping) {
+  let transformed = root;
+  for (const [noterefPos, footnotePos] of footnotePairs.entries()) {
+    const noteref = original.resolve(noterefPos).nodeAfter;
+    const footnote = transformed.resolve(mapping.map(noterefPos)).nodeAfter;
+    if (!(noteref instanceof import_model.Node) || !(footnote instanceof import_model.Node)) continue;
+    transformed = transformed.replace(mapping.map(noterefPos), noteref);
+    mapping.appendMap(
+      new import_map.StepMap([
+        mapping.map(noterefPos),
+        footnote.nodeSize,
+        noteref.nodeSize
+      ])
+    );
+    transformed = transformed.replace(mapping.map(footnotePos), footnote);
+    mapping.appendMap(
+      new import_map.StepMap([mapping.map(footnotePos), 1, footnote.nodeSize])
+    );
+  }
+  return transformed;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addMark,
-  liftText
+  inlineFootnotes,
+  liftText,
+  replaceFootnotes
 });

package/dist/markup/transform.d.cts

@@ -1,5 +1,5 @@
 import { Mapping } from './map.cjs';
-import { Root, Mark } from './model.cjs';
+import { R as Root, M as Mark } from '../model-Bv3yPEdd.cjs';
 import '@storyteller-platform/epub';
 
 declare function addMark(root: Root, from: number, to: number, mark: Mark): Root;
@@ -7,5 +7,11 @@ declare function liftText(root: Root): {
     result: string;
     mapping: Mapping;
 };
+declare function inlineFootnotes(root: Root): {
+    root: Root;
+    footnotePairs: Map<number, number>;
+    mapping: Mapping;
+};
+declare function replaceFootnotes(original: Root, root: Root, footnotePairs: Map<number, number>, mapping: Mapping): Root;
 
-export { addMark, liftText };
+export { addMark, inlineFootnotes, liftText, replaceFootnotes };

package/dist/markup/transform.d.ts

@@ -1,5 +1,5 @@
 import { Mapping } from './map.js';
-import { Root, Mark } from './model.js';
+import { R as Root, M as Mark } from '../model-Bv3yPEdd.js';
 import '@storyteller-platform/epub';
 
 declare function addMark(root: Root, from: number, to: number, mark: Mark): Root;
@@ -7,5 +7,11 @@ declare function liftText(root: Root): {
     result: string;
     mapping: Mapping;
 };
+declare function inlineFootnotes(root: Root): {
+    root: Root;
+    footnotePairs: Map<number, number>;
+    mapping: Mapping;
+};
+declare function replaceFootnotes(original: Root, root: Root, footnotePairs: Map<number, number>, mapping: Mapping): Root;
 
-export { addMark, liftText };
+export { addMark, inlineFootnotes, liftText, replaceFootnotes };

package/dist/markup/transform.js

@@ -1,9 +1,12 @@
 import "../chunk-BIEQXUOY.js";
 import { Mapping, StepMap } from "./map.js";
 import {
+  FootnoteNode,
+  Node,
   TextNode,
   descendants
 } from "./model.js";
+import { findFootnotePairs } from "./parseDom.js";
 function addMark(root, from, to, mark) {
   const result = root.split(from).split(to);
   let pos = 0;
@@ -35,6 +38,11 @@ function liftText(root) {
   let textLength = 0;
   let lastTextEnd = 0;
   descendants(root, (node, pos, parent, index) => {
+    if (node instanceof FootnoteNode) {
+      if (!text.endsWith("\n")) {
+        text += "\n";
+      }
+    }
     if (node.isBlock) {
       return !!node.textContent.match(/\S/);
     }
@@ -70,7 +78,56 @@ function liftText(root) {
   });
   return { result: text, mapping };
 }
+function inlineFootnotes(root) {
+  const footnotePairs = findFootnotePairs(root);
+  const mapping = new Mapping();
+  let transformed = root;
+  for (const [noterefPos, footnotePos] of footnotePairs.entries()) {
+    const noteref = root.resolve(noterefPos).nodeAfter;
+    const footnote = root.resolve(footnotePos).nodeAfter;
+    if (!noteref || !(footnote instanceof Node)) continue;
+    transformed = transformed.replace(mapping.map(noterefPos), footnote);
+    mapping.appendMap(
+      new StepMap([
+        mapping.map(noterefPos),
+        noteref.nodeSize,
+        footnote.nodeSize
+      ])
+    );
+    transformed = transformed.replace(
+      mapping.map(footnotePos),
+      new Node(footnote.tagName)
+    );
+    mapping.appendMap(
+      new StepMap([mapping.map(footnotePos), footnote.nodeSize, 1])
+    );
+  }
+  return { root: transformed, footnotePairs, mapping };
+}
+function replaceFootnotes(original, root, footnotePairs, mapping) {
+  let transformed = root;
+  for (const [noterefPos, footnotePos] of footnotePairs.entries()) {
+    const noteref = original.resolve(noterefPos).nodeAfter;
+    const footnote = transformed.resolve(mapping.map(noterefPos)).nodeAfter;
+    if (!(noteref instanceof Node) || !(footnote instanceof Node)) continue;
+    transformed = transformed.replace(mapping.map(noterefPos), noteref);
+    mapping.appendMap(
+      new StepMap([
+        mapping.map(noterefPos),
+        footnote.nodeSize,
+        noteref.nodeSize
+      ])
+    );
+    transformed = transformed.replace(mapping.map(footnotePos), footnote);
+    mapping.appendMap(
+      new StepMap([mapping.map(footnotePos), 1, footnote.nodeSize])
+    );
+  }
+  return transformed;
+}
 export {
   addMark,
-  liftText
+  inlineFootnotes,
+  liftText,
+  replaceFootnotes
 };

package/dist/model-Bv3yPEdd.d.cts

@@ -0,0 +1,96 @@
+import { ElementName } from '@storyteller-platform/epub';
+
+declare class ResolvedPos {
+    readonly pos: number;
+    readonly path: (Node | Root | number)[];
+    readonly parentOffset: number;
+    depth: number;
+    private constructor();
+    static resolve(doc: Root, pos: number): ResolvedPos;
+    get parent(): Root | Node;
+    node(depth?: number | null): Root | Node | TextNode;
+    index(depth?: number | null): number;
+    get nodeAfter(): Node | TextNode | null;
+    before(depth?: number | null): number;
+    private resolveDepth;
+}
+
+declare class Root {
+    children: (Node | TextNode)[];
+    constructor(children: (Node | TextNode)[]);
+    isInline: boolean;
+    isBlock: boolean;
+    get border(): number;
+    get textContent(): string;
+    get nodeSize(): number;
+    get contentSize(): number;
+    split(at: number): Root;
+    copy(opts?: {
+        children?: (Node | TextNode)[];
+    }): Root;
+    findIndex(pos: number): {
+        index: number;
+        offset: number;
+    };
+    replace(at: number, withNode: Node): Root;
+    cut(pos: number): Node | TextNode | null;
+    resolve(pos: number): ResolvedPos;
+}
+declare class Node {
+    tagName: ElementName;
+    attrs: Record<string, string>;
+    children: (Node | TextNode)[];
+    marks: Mark[];
+    constructor(tagName: ElementName, attrs?: Record<string, string>, children?: (Node | TextNode)[], marks?: Mark[]);
+    get isLeaf(): boolean;
+    get isInline(): boolean;
+    get isBlock(): boolean;
+    get border(): 0 | 1;
+    get nodeSize(): number;
+    get contentSize(): number;
+    get textContent(): string;
+    split(at: number): Node;
+    static instance(): typeof Node;
+    private static create;
+    copy(opts?: {
+        attrs?: Record<string, string>;
+        children?: (Node | TextNode)[];
+        marks?: Mark[];
+    }): Node;
+    replace(at: number, withNode: Node): Node;
+    cut(pos: number): Node | TextNode | null;
+    findIndex(pos: number): {
+        index: number;
+        offset: number;
+    };
+}
+declare class NoterefNode extends Node {
+}
+declare class FootnoteNode extends Node {
+}
+declare class Mark {
+    tagName: ElementName;
+    attrs: Record<string, string>;
+    constructor(tagName: ElementName, attrs?: Record<string, string>);
+    eq(other: Mark | undefined): boolean;
+}
+declare class TextNode {
+    text: string;
+    marks: Mark[];
+    constructor(text: string, marks?: Mark[]);
+    isLeaf: boolean;
+    isInline: boolean;
+    isBlock: boolean;
+    border: number;
+    get nodeSize(): number;
+    get contentSize(): number;
+    get textContent(): string;
+    split(at: number): TextNode[];
+    copy(opts?: {
+        marks?: Mark[];
+    }): TextNode;
+    cut(pos: number): TextNode;
+}
+declare function descendants(node: Root | Node, cb: (node: Node | TextNode, pos: number, parent: Node | Root, index: number) => boolean, pos?: number): void;
+
+export { FootnoteNode as F, Mark as M, Node as N, Root as R, TextNode as T, ResolvedPos as a, NoterefNode as b, descendants as d };

package/dist/model-Bv3yPEdd.d.ts

@@ -0,0 +1,96 @@
+import { ElementName } from '@storyteller-platform/epub';
+
+declare class ResolvedPos {
+    readonly pos: number;
+    readonly path: (Node | Root | number)[];
+    readonly parentOffset: number;
+    depth: number;
+    private constructor();
+    static resolve(doc: Root, pos: number): ResolvedPos;
+    get parent(): Root | Node;
+    node(depth?: number | null): Root | Node | TextNode;
+    index(depth?: number | null): number;
+    get nodeAfter(): Node | TextNode | null;
+    before(depth?: number | null): number;
+    private resolveDepth;
+}
+
+declare class Root {
+    children: (Node | TextNode)[];
+    constructor(children: (Node | TextNode)[]);
+    isInline: boolean;
+    isBlock: boolean;
+    get border(): number;
+    get textContent(): string;
+    get nodeSize(): number;
+    get contentSize(): number;
+    split(at: number): Root;
+    copy(opts?: {
+        children?: (Node | TextNode)[];
+    }): Root;
+    findIndex(pos: number): {
+        index: number;
+        offset: number;
+    };
+    replace(at: number, withNode: Node): Root;
+    cut(pos: number): Node | TextNode | null;
+    resolve(pos: number): ResolvedPos;
+}
+declare class Node {
+    tagName: ElementName;
+    attrs: Record<string, string>;
+    children: (Node | TextNode)[];
+    marks: Mark[];
+    constructor(tagName: ElementName, attrs?: Record<string, string>, children?: (Node | TextNode)[], marks?: Mark[]);
+    get isLeaf(): boolean;
+    get isInline(): boolean;
+    get isBlock(): boolean;
+    get border(): 0 | 1;
+    get nodeSize(): number;
+    get contentSize(): number;
+    get textContent(): string;
+    split(at: number): Node;
+    static instance(): typeof Node;
+    private static create;
+    copy(opts?: {
+        attrs?: Record<string, string>;
+        children?: (Node | TextNode)[];
+        marks?: Mark[];
+    }): Node;
+    replace(at: number, withNode: Node): Node;
+    cut(pos: number): Node | TextNode | null;
+    findIndex(pos: number): {
+        index: number;
+        offset: number;
+    };
+}
+declare class NoterefNode extends Node {
+}
+declare class FootnoteNode extends Node {
+}
+declare class Mark {
+    tagName: ElementName;
+    attrs: Record<string, string>;
+    constructor(tagName: ElementName, attrs?: Record<string, string>);
+    eq(other: Mark | undefined): boolean;
+}
+declare class TextNode {
+    text: string;
+    marks: Mark[];
+    constructor(text: string, marks?: Mark[]);
+    isLeaf: boolean;
+    isInline: boolean;
+    isBlock: boolean;
+    border: number;
+    get nodeSize(): number;
+    get contentSize(): number;
+    get textContent(): string;
+    split(at: number): TextNode[];
+    copy(opts?: {
+        marks?: Mark[];
+    }): TextNode;
+    cut(pos: number): TextNode;
+}
+declare function descendants(node: Root | Node, cb: (node: Node | TextNode, pos: number, parent: Node | Root, index: number) => boolean, pos?: number): void;
+
+export { FootnoteNode as F, Mark as M, Node as N, Root as R, TextNode as T, ResolvedPos as a, NoterefNode as b, descendants as d };

package/dist/snapshot/snapshot.cjs

@@ -71,7 +71,9 @@ var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
 var import_posix = require("node:path/posix");
 var import_epub = require("@storyteller-platform/epub");
+var import_parseDom = require("../markup/parseDom.cjs");
 var import_segmentation = require("../markup/segmentation.cjs");
+var import_transform = require("../markup/transform.cjs");
 async function snapshotAlignment(epubPath, transcriptionsPath, outputPath) {
   var _stack = [];
   try {
@@ -117,12 +119,12 @@ async function createAlignmentSnapshot(epub, transcriptionFilepaths, textRef) {
       "utf-8"
     );
     const chapterXml = import_epub.Epub.xhtmlParser.parse(chapterContents);
-    const { result: segmentation } = await (0, import_segmentation.getXhtmlSegmentation)(
-      import_epub.Epub.getXhtmlBody(chapterXml),
-      {
-        primaryLocale: new Intl.Locale("en-US")
-      }
-    );
+    const original = (0, import_parseDom.parseDom)(import_epub.Epub.getXhtmlBody(chapterXml));
+    const inlined = (0, import_transform.inlineFootnotes)(original);
+    const lifted = (0, import_transform.liftText)(inlined.root);
+    const segmentation = await (0, import_segmentation.segmentChapter)(lifted.result, {
+      primaryLocale: new Intl.Locale("en-US")
+    });
     let lastChapterSentence = -1;
     const chapterSentences = segmentation.filter((s) => s.text.match(/\S/));
     for (const par of import_epub.Epub.getXmlChildren(seq)) {

package/dist/snapshot/snapshot.js

@@ -9,7 +9,9 @@ import {
   extname as posixExtname
 } from "node:path/posix";
 import { Epub } from "@storyteller-platform/epub";
-import { getXhtmlSegmentation } from "../markup/segmentation.js";
+import { parseDom } from "../markup/parseDom.js";
+import { segmentChapter } from "../markup/segmentation.js";
+import { inlineFootnotes, liftText } from "../markup/transform.js";
 async function snapshotAlignment(epubPath, transcriptionsPath, outputPath) {
   var _stack = [];
   try {
@@ -55,12 +57,12 @@ async function createAlignmentSnapshot(epub, transcriptionFilepaths, textRef) {
       "utf-8"
     );
     const chapterXml = Epub.xhtmlParser.parse(chapterContents);
-    const { result: segmentation } = await getXhtmlSegmentation(
-      Epub.getXhtmlBody(chapterXml),
-      {
-        primaryLocale: new Intl.Locale("en-US")
-      }
-    );
+    const original = parseDom(Epub.getXhtmlBody(chapterXml));
+    const inlined = inlineFootnotes(original);
+    const lifted = liftText(inlined.root);
+    const segmentation = await segmentChapter(lifted.result, {
+      primaryLocale: new Intl.Locale("en-US")
+    });
     let lastChapterSentence = -1;
     const chapterSentences = segmentation.filter((s) => s.text.match(/\S/));
     for (const par of Epub.getXmlChildren(seq)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storyteller-platform/align",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "A library and CLI for automatically aligning audiobooks and EPUBs to produce Media Overlays",
   "author": "Shane Friedman",
   "license": "MIT",