@storyteller-platform/align 0.1.4 → 0.1.7

package/dist/align/__tests__/align.test.cjs

@@ -0,0 +1,282 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it2) => {
+    while (it2 = stack.pop()) {
+      try {
+        var result = it2[1] && it2[1].call(it2[2]);
+        if (it2[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_posix = require("node:path/posix");
+var import_node_test = require("node:test");
+var import_audiobook = require("@storyteller-platform/audiobook");
+var import_epub = require("@storyteller-platform/epub");
+var import_logging = require("../../common/logging.cjs");
+var import_segmentation = require("../../markup/segmentation.cjs");
+var import_align = require("../align.cjs");
+function createTestLogger() {
+  return (0, import_logging.createLogger)(process.env["CI"] ? "silent" : "info");
+}
+function sanitizeFilename(title) {
+  return title.replace(/[/\\:*?"<>|]/g, "-").replace(/\s+/g, " ").trim().replace(/[.]+$/, "");
+}
+function truncate(input, byteLimit, suffix = "") {
+  const normalized = input.normalize("NFC");
+  const encoder = new TextEncoder();
+  let result = "";
+  for (const char of normalized) {
+    const withSuffix = result + char + suffix;
+    const byteLength = encoder.encode(withSuffix).length;
+    if (byteLength > byteLimit) break;
+    result += char;
+  }
+  return result + suffix;
+}
+function getSafeFilepathSegment(name, suffix = "") {
+  return truncate(sanitizeFilename(name), 150, suffix);
+}
+async function assertAlignSnapshot(context, epub, transcriptionFilepaths) {
+  var _a, _b, _c, _d, _e, _f;
+  const snapshotFilename = getSafeFilepathSegment(context.fullName, ".snapshot");
+  const snapshotFilepath = (0, import_node_path.join)(
+    "src",
+    "align",
+    "__snapshots__",
+    snapshotFilename
+  );
+  let newSnapshot = "";
+  const manifest = await epub.getManifest();
+  const mediaOverlayItems = Object.values(manifest).map((item) => item.mediaOverlay).filter((mediaOverlayId) => !!mediaOverlayId).map((id) => manifest[id]);
+  const mediaOverlays = [];
+  for (const item of mediaOverlayItems) {
+    const contents = await epub.readItemContents(item.id, "utf-8");
+    const parsed = import_epub.Epub.xmlParser.parse(contents);
+    mediaOverlays.push(parsed);
+    const smil = import_epub.Epub.findXmlChildByName("smil", parsed);
+    if (!smil) continue;
+    const body = import_epub.Epub.findXmlChildByName("body", import_epub.Epub.getXmlChildren(smil));
+    if (!body) continue;
+    const seq = import_epub.Epub.findXmlChildByName("seq", import_epub.Epub.getXmlChildren(body));
+    if (!seq) continue;
+    const textref = (_a = seq[":@"]) == null ? void 0 : _a["@_epub:textref"];
+    if (!textref) continue;
+    newSnapshot += `// ${(0, import_posix.basename)(textref)}
+
+`;
+    const chapterContents = await epub.readFileContents(
+      textref,
+      item.href,
+      "utf-8"
+    );
+    const chapterXml = import_epub.Epub.xhtmlParser.parse(chapterContents);
+    const segmentation = await (0, import_segmentation.getXhtmlSegmentation)(
+      import_epub.Epub.getXhtmlBody(chapterXml),
+      {
+        primaryLocale: new Intl.Locale("en-US")
+      }
+    );
+    const chapterSentences = segmentation.sentences.map((s) => s.text);
+    for (const par of import_epub.Epub.getXmlChildren(seq)) {
+      newSnapshot += `
+`;
+      const text = import_epub.Epub.findXmlChildByName("text", import_epub.Epub.getXmlChildren(par));
+      if (!text) continue;
+      const audio = import_epub.Epub.findXmlChildByName("audio", import_epub.Epub.getXmlChildren(par));
+      if (!audio) continue;
+      const textSrc = (_b = text[":@"]) == null ? void 0 : _b["@_src"];
+      if (!textSrc) continue;
+      const sentenceId = (_c = textSrc.match(/[0-9]+$/)) == null ? void 0 : _c[0];
+      if (sentenceId === void 0) continue;
+      const textSentence = chapterSentences[parseInt(sentenceId)];
+      if (!textSentence) continue;
+      newSnapshot += `Text:  ${textSentence}
+`;
+      const audioSrc = (_d = audio[":@"]) == null ? void 0 : _d["@_src"];
+      if (!audioSrc) continue;
+      const audioStart = (_e = audio[":@"]) == null ? void 0 : _e["@_clipBegin"];
+      const audioEnd = (_f = audio[":@"]) == null ? void 0 : _f["@_clipEnd"];
+      if (!audioStart || !audioEnd) continue;
+      const audioStartTime = parseFloat(audioStart.slice(0, -1));
+      const audioEndTime = parseFloat(audioEnd.slice(0, -1));
+      const audioFilename = (0, import_posix.basename)(audioSrc, (0, import_node_path.extname)(audioSrc));
+      const transcriptionFilepath = transcriptionFilepaths.find(
+        (f) => (0, import_node_path.basename)(f, (0, import_node_path.extname)(f)) === audioFilename
+      );
+      if (!transcriptionFilepath) continue;
+      const transcription = JSON.parse(
+        await (0, import_promises.readFile)(transcriptionFilepath, { encoding: "utf-8" })
+      );
+      const transcriptionWords = [];
+      let started = false;
+      let i = 0;
+      let word = transcription.timeline[i];
+      while (word && word.endTime <= audioEndTime) {
+        if (word.startTime >= audioStartTime) {
+          started = true;
+        }
+        if (started) {
+          transcriptionWords.push(word.text);
+        }
+        word = transcription.timeline[++i];
+      }
+      const transcriptionSentence = transcriptionWords.join(" ");
+      newSnapshot += `Audio: ${transcriptionSentence}
+`;
+    }
+    newSnapshot += `
+`;
+  }
+  if (process.env["UPDATE_SNAPSHOTS"]) {
+    await (0, import_promises.mkdir)((0, import_node_path.dirname)(snapshotFilepath), { recursive: true });
+    await (0, import_promises.writeFile)(snapshotFilepath, newSnapshot, { encoding: "utf-8" });
+    return;
+  }
+  try {
+    const existingSnapshot = await (0, import_promises.readFile)(snapshotFilepath, {
+      encoding: "utf-8"
+    });
+    const existingLines = existingSnapshot.split("\n");
+    const newLines = newSnapshot.split("\n");
+    for (let i = 0; i < existingLines.length; i++) {
+      const existingLine = existingLines[i];
+      const newLine = newLines[i];
+      if (existingLine !== newLine) {
+        import_node_assert.default.strictEqual(
+          newLines.slice(Math.max(0, i - 5), i + 5),
+          existingLines.slice(Math.max(0, i - 5), i + 5)
+        );
+      }
+    }
+  } catch (e) {
+    if (e instanceof import_node_assert.default.AssertionError) {
+      throw e;
+    }
+    throw new import_node_assert.default.AssertionError({
+      actual: newSnapshot,
+      expected: "",
+      diff: "simple"
+    });
+  }
+}
+void (0, import_node_test.describe)("align", () => {
+  void (0, import_node_test.it)("should align Peter and Wendy", async (context) => {
+    var _stack = [];
+    try {
+      const epub = __using(_stack, await import_epub.Epub.from(
+        (0, import_node_path.join)(
+          "src",
+          "align",
+          "__fixtures__",
+          "peter-and-wendy",
+          "text",
+          "Peter and Wendy.epub"
+        )
+      ));
+      const audiobookDir = (0, import_node_path.join)(
+        "src",
+        "align",
+        "__fixtures__",
+        "peter-and-wendy",
+        "audio"
+      );
+      const audiobookFiles = await (0, import_promises.readdir)(audiobookDir).then(
+        (filenames) => filenames.filter((f) => (0, import_audiobook.isAudioFile)(f)).map((f) => (0, import_node_path.join)(audiobookDir, f))
+      );
+      const transcriptionsDir = (0, import_node_path.join)(
+        "src",
+        "align",
+        "__fixtures__",
+        "peter-and-wendy",
+        "transcriptions"
+      );
+      const transcriptionFilepaths = await (0, import_promises.readdir)(transcriptionsDir).then(
+        (filenames) => filenames.filter((f) => f.endsWith(".json")).map((f) => (0, import_node_path.join)(transcriptionsDir, f))
+      );
+      const transcriptions = await Promise.all(
+        transcriptionFilepaths.map(
+          async (p) => (0, import_promises.readFile)(p, { encoding: "utf-8" })
+        )
+      ).then(
+        (contents) => contents.map(
+          (c) => JSON.parse(c)
+        )
+      );
+      const aligner = new import_align.Aligner(
+        epub,
+        audiobookFiles,
+        transcriptions,
+        "sentence",
+        void 0,
+        createTestLogger()
+      );
+      await aligner.alignBook();
+      await assertAlignSnapshot(context, epub, transcriptionFilepaths);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  });
+});

package/dist/align/__tests__/align.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/align/__tests__/align.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/align/__tests__/align.test.js

@@ -0,0 +1,218 @@
+import {
+  __callDispose,
+  __using
+} from "../../chunk-BIEQXUOY.js";
+import assert from "node:assert";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join } from "node:path";
+import { basename as posixBasename } from "node:path/posix";
+import { describe, it } from "node:test";
+import { isAudioFile } from "@storyteller-platform/audiobook";
+import { Epub } from "@storyteller-platform/epub";
+import { createLogger } from "../../common/logging.js";
+import { getXhtmlSegmentation } from "../../markup/segmentation.js";
+import { Aligner } from "../align.js";
+function createTestLogger() {
+  return createLogger(process.env["CI"] ? "silent" : "info");
+}
+function sanitizeFilename(title) {
+  return title.replace(/[/\\:*?"<>|]/g, "-").replace(/\s+/g, " ").trim().replace(/[.]+$/, "");
+}
+function truncate(input, byteLimit, suffix = "") {
+  const normalized = input.normalize("NFC");
+  const encoder = new TextEncoder();
+  let result = "";
+  for (const char of normalized) {
+    const withSuffix = result + char + suffix;
+    const byteLength = encoder.encode(withSuffix).length;
+    if (byteLength > byteLimit) break;
+    result += char;
+  }
+  return result + suffix;
+}
+function getSafeFilepathSegment(name, suffix = "") {
+  return truncate(sanitizeFilename(name), 150, suffix);
+}
+async function assertAlignSnapshot(context, epub, transcriptionFilepaths) {
+  var _a, _b, _c, _d, _e, _f;
+  const snapshotFilename = getSafeFilepathSegment(context.fullName, ".snapshot");
+  const snapshotFilepath = join(
+    "src",
+    "align",
+    "__snapshots__",
+    snapshotFilename
+  );
+  let newSnapshot = "";
+  const manifest = await epub.getManifest();
+  const mediaOverlayItems = Object.values(manifest).map((item) => item.mediaOverlay).filter((mediaOverlayId) => !!mediaOverlayId).map((id) => manifest[id]);
+  const mediaOverlays = [];
+  for (const item of mediaOverlayItems) {
+    const contents = await epub.readItemContents(item.id, "utf-8");
+    const parsed = Epub.xmlParser.parse(contents);
+    mediaOverlays.push(parsed);
+    const smil = Epub.findXmlChildByName("smil", parsed);
+    if (!smil) continue;
+    const body = Epub.findXmlChildByName("body", Epub.getXmlChildren(smil));
+    if (!body) continue;
+    const seq = Epub.findXmlChildByName("seq", Epub.getXmlChildren(body));
+    if (!seq) continue;
+    const textref = (_a = seq[":@"]) == null ? void 0 : _a["@_epub:textref"];
+    if (!textref) continue;
+    newSnapshot += `// ${posixBasename(textref)}
+
+`;
+    const chapterContents = await epub.readFileContents(
+      textref,
+      item.href,
+      "utf-8"
+    );
+    const chapterXml = Epub.xhtmlParser.parse(chapterContents);
+    const segmentation = await getXhtmlSegmentation(
+      Epub.getXhtmlBody(chapterXml),
+      {
+        primaryLocale: new Intl.Locale("en-US")
+      }
+    );
+    const chapterSentences = segmentation.sentences.map((s) => s.text);
+    for (const par of Epub.getXmlChildren(seq)) {
+      newSnapshot += `
+`;
+      const text = Epub.findXmlChildByName("text", Epub.getXmlChildren(par));
+      if (!text) continue;
+      const audio = Epub.findXmlChildByName("audio", Epub.getXmlChildren(par));
+      if (!audio) continue;
+      const textSrc = (_b = text[":@"]) == null ? void 0 : _b["@_src"];
+      if (!textSrc) continue;
+      const sentenceId = (_c = textSrc.match(/[0-9]+$/)) == null ? void 0 : _c[0];
+      if (sentenceId === void 0) continue;
+      const textSentence = chapterSentences[parseInt(sentenceId)];
+      if (!textSentence) continue;
+      newSnapshot += `Text:  ${textSentence}
+`;
+      const audioSrc = (_d = audio[":@"]) == null ? void 0 : _d["@_src"];
+      if (!audioSrc) continue;
+      const audioStart = (_e = audio[":@"]) == null ? void 0 : _e["@_clipBegin"];
+      const audioEnd = (_f = audio[":@"]) == null ? void 0 : _f["@_clipEnd"];
+      if (!audioStart || !audioEnd) continue;
+      const audioStartTime = parseFloat(audioStart.slice(0, -1));
+      const audioEndTime = parseFloat(audioEnd.slice(0, -1));
+      const audioFilename = posixBasename(audioSrc, extname(audioSrc));
+      const transcriptionFilepath = transcriptionFilepaths.find(
+        (f) => basename(f, extname(f)) === audioFilename
+      );
+      if (!transcriptionFilepath) continue;
+      const transcription = JSON.parse(
+        await readFile(transcriptionFilepath, { encoding: "utf-8" })
+      );
+      const transcriptionWords = [];
+      let started = false;
+      let i = 0;
+      let word = transcription.timeline[i];
+      while (word && word.endTime <= audioEndTime) {
+        if (word.startTime >= audioStartTime) {
+          started = true;
+        }
+        if (started) {
+          transcriptionWords.push(word.text);
+        }
+        word = transcription.timeline[++i];
+      }
+      const transcriptionSentence = transcriptionWords.join(" ");
+      newSnapshot += `Audio: ${transcriptionSentence}
+`;
+    }
+    newSnapshot += `
+`;
+  }
+  if (process.env["UPDATE_SNAPSHOTS"]) {
+    await mkdir(dirname(snapshotFilepath), { recursive: true });
+    await writeFile(snapshotFilepath, newSnapshot, { encoding: "utf-8" });
+    return;
+  }
+  try {
+    const existingSnapshot = await readFile(snapshotFilepath, {
+      encoding: "utf-8"
+    });
+    const existingLines = existingSnapshot.split("\n");
+    const newLines = newSnapshot.split("\n");
+    for (let i = 0; i < existingLines.length; i++) {
+      const existingLine = existingLines[i];
+      const newLine = newLines[i];
+      if (existingLine !== newLine) {
+        assert.strictEqual(
+          newLines.slice(Math.max(0, i - 5), i + 5),
+          existingLines.slice(Math.max(0, i - 5), i + 5)
+        );
+      }
+    }
+  } catch (e) {
+    if (e instanceof assert.AssertionError) {
+      throw e;
+    }
+    throw new assert.AssertionError({
+      actual: newSnapshot,
+      expected: "",
+      diff: "simple"
+    });
+  }
+}
+void describe("align", () => {
+  void it("should align Peter and Wendy", async (context) => {
+    var _stack = [];
+    try {
+      const epub = __using(_stack, await Epub.from(
+        join(
+          "src",
+          "align",
+          "__fixtures__",
+          "peter-and-wendy",
+          "text",
+          "Peter and Wendy.epub"
+        )
+      ));
+      const audiobookDir = join(
+        "src",
+        "align",
+        "__fixtures__",
+        "peter-and-wendy",
+        "audio"
+      );
+      const audiobookFiles = await readdir(audiobookDir).then(
+        (filenames) => filenames.filter((f) => isAudioFile(f)).map((f) => join(audiobookDir, f))
+      );
+      const transcriptionsDir = join(
+        "src",
+        "align",
+        "__fixtures__",
+        "peter-and-wendy",
+        "transcriptions"
+      );
+      const transcriptionFilepaths = await readdir(transcriptionsDir).then(
+        (filenames) => filenames.filter((f) => f.endsWith(".json")).map((f) => join(transcriptionsDir, f))
+      );
+      const transcriptions = await Promise.all(
+        transcriptionFilepaths.map(
+          async (p) => readFile(p, { encoding: "utf-8" })
+        )
+      ).then(
+        (contents) => contents.map(
+          (c) => JSON.parse(c)
+        )
+      );
+      const aligner = new Aligner(
+        epub,
+        audiobookFiles,
+        transcriptions,
+        "sentence",
+        void 0,
+        createTestLogger()
+      );
+      await aligner.alignBook();
+      await assertAlignSnapshot(context, epub, transcriptionFilepaths);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  });
+});

package/dist/align/__tests__/slugify.test.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_node_test = require("node:test");
+var import_slugify = require("../slugify.cjs");
+void (0, import_node_test.describe)("slugify", () => {
+  void (0, import_node_test.it)("should slugify numbers", async () => {
+    const input = "There were 10 cars.";
+    const output = "there-were-ten-cars";
+    const { result } = await (0, import_slugify.slugify)(input, new Intl.Locale("en"));
+    import_node_assert.default.strictEqual(result, output);
+  });
+  void (0, import_node_test.it)("should slugify numbers with decimals", async () => {
+    const input = "It was 74.6 degrees out.";
+    const output = "it-was-seventy-four-point-six-degrees-out";
+    const { result } = await (0, import_slugify.slugify)(input, new Intl.Locale("en"));
+    import_node_assert.default.strictEqual(result, output);
+  });
+  void (0, import_node_test.it)("should slugify numbers with groupings", async () => {
+    const input = "It weighed over 1,000 pounds";
+    const output = "it-weighed-over-one-thousand-pounds";
+    const { result } = await (0, import_slugify.slugify)(input, new Intl.Locale("en"));
+    import_node_assert.default.strictEqual(result, output);
+  });
+  void (0, import_node_test.it)("should slugify currency", async () => {
+    const input = "It costs $5,500.50.";
+    const output = "it-costs-five-thousand-five-hundred-dollars-and-fifty-cents";
+    const { result } = await (0, import_slugify.slugify)(input, new Intl.Locale("en"));
+    import_node_assert.default.strictEqual(result, output);
+  });
+  void (0, import_node_test.it)("should slugify German currency", async () => {
+    const input = "Es kostet 5.500,50 \u20AC";
+    const output = "es-kostet-funf-tausend-funf-hundert-euro-und-funfzig-cent";
+    const { result } = await (0, import_slugify.slugify)(input, new Intl.Locale("de"));
+    import_node_assert.default.strictEqual(result, output);
+  });
+  void (0, import_node_test.it)("should slugify Chinese currency", async () => {
+    const input = "\u4EF7\u683C\u4E3A \xA55,500.50";
+    const output = "jie-ge-wei-wu-qian-wu-bai-yuan-wu-shi-fen";
+    const { result } = await (0, import_slugify.slugify)(input, new Intl.Locale("zh"));
+    import_node_assert.default.strictEqual(result, output);
+  });
+});

package/dist/align/__tests__/slugify.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/align/__tests__/slugify.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/align/__tests__/slugify.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { slugify } from "../slugify.js";
+void describe("slugify", () => {
+  void it("should slugify numbers", async () => {
+    const input = "There were 10 cars.";
+    const output = "there-were-ten-cars";
+    const { result } = await slugify(input, new Intl.Locale("en"));
+    assert.strictEqual(result, output);
+  });
+  void it("should slugify numbers with decimals", async () => {
+    const input = "It was 74.6 degrees out.";
+    const output = "it-was-seventy-four-point-six-degrees-out";
+    const { result } = await slugify(input, new Intl.Locale("en"));
+    assert.strictEqual(result, output);
+  });
+  void it("should slugify numbers with groupings", async () => {
+    const input = "It weighed over 1,000 pounds";
+    const output = "it-weighed-over-one-thousand-pounds";
+    const { result } = await slugify(input, new Intl.Locale("en"));
+    assert.strictEqual(result, output);
+  });
+  void it("should slugify currency", async () => {
+    const input = "It costs $5,500.50.";
+    const output = "it-costs-five-thousand-five-hundred-dollars-and-fifty-cents";
+    const { result } = await slugify(input, new Intl.Locale("en"));
+    assert.strictEqual(result, output);
+  });
+  void it("should slugify German currency", async () => {
+    const input = "Es kostet 5.500,50 \u20AC";
+    const output = "es-kostet-funf-tausend-funf-hundert-euro-und-funfzig-cent";
+    const { result } = await slugify(input, new Intl.Locale("de"));
+    assert.strictEqual(result, output);
+  });
+  void it("should slugify Chinese currency", async () => {
+    const input = "\u4EF7\u683C\u4E3A \xA55,500.50";
+    const output = "jie-ge-wei-wu-qian-wu-bai-yuan-wu-shi-fen";
+    const { result } = await slugify(input, new Intl.Locale("zh"));
+    assert.strictEqual(result, output);
+  });
+});