@sectui/operations 0.0.0-stage → 0.1.0

package/src/operations/data/json-format.ts

@@ -0,0 +1,33 @@
+import { defineOperation } from "../../operation.ts";
+import { mapText } from "../text/lines.ts";
+import { formatJson, INDENT_STRINGS, JSON_INDENTS } from "./json.ts";
+
+export const jsonFormat = defineOperation({
+  id: "json-format",
+  name: "JSON format",
+  description: "Pretty-prints or minifies JSON. Numbers are kept digit for digit, and keys in their original order.",
+  category: "Data format",
+  output: "binary",
+  aliases: ["json beautify", "json prettify", "json minify", "jq"],
+  infoUrl: "https://www.json.org",
+  args: {
+    indent: {
+      type: "select",
+      name: "Indentation",
+      options: JSON_INDENTS,
+      default: "2",
+    },
+  },
+  examples: [
+    {
+      input: '{"a":1,"b":[true,null],"c":{}}',
+      output: '{\n  "a": 1,\n  "b": [\n    true,\n    null\n  ],\n  "c": {}\n}',
+    },
+    {
+      input: '{ "id": 12345678901234567890,\n  "tags": [ "x" ] }',
+      args: { indent: "minify" },
+      output: '{"id":12345678901234567890,"tags":["x"]}',
+    },
+  ],
+  run: (input, { indent }) => mapText(input, (text) => formatJson(text, INDENT_STRINGS[indent])),
+});

package/src/operations/data/json.ts

@@ -0,0 +1,53 @@
+import { OperationError } from "../../errors.ts";
+
+export function parseJson(text: string): unknown {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new OperationError(`Invalid JSON: ${(error as Error).message}`);
+  }
+}
+
+// Strings, or runs of anything else that is not whitespace or punctuation (numbers, literals).
+const TOKEN = /"(?:[^"\\]|\\.)*"|[{}[\],:]|[^\s{}[\],:"]+/g;
+
+/**
+ * Re-indents valid JSON without parsing values, so numbers keep their exact digits (no precision
+ * loss on large integers) and key order and duplicate keys are preserved. An empty `indent` minifies.
+ */
+export function formatJson(text: string, indent: string): string {
+  parseJson(text);
+  const tokens = text.match(TOKEN) ?? [];
+  const newline = (depth: number) => (indent ? "\n" + indent.repeat(depth) : "");
+  let out = "";
+  let depth = 0;
+  for (const [i, token] of tokens.entries()) {
+    const next = tokens[i + 1];
+    if (token === "{" || token === "[") {
+      // Keep empty objects and arrays on one line.
+      if (next === "}" || next === "]") out += token;
+      else out += token + newline(++depth);
+    } else if (token === "}" || token === "]") {
+      const previous = tokens[i - 1];
+      if (previous === "{" || previous === "[") out += token;
+      else out += newline(--depth) + token;
+    } else if (token === ",") out += "," + newline(depth);
+    else if (token === ":") out += indent ? ": " : ":";
+    else out += token;
+  }
+  return out;
+}
+
+export const JSON_INDENTS = [
+  { value: "2", label: "2 spaces" },
+  { value: "4", label: "4 spaces" },
+  { value: "tab", label: "Tab" },
+  { value: "minify", label: "None, on a single line" },
+] as const;
+
+export const INDENT_STRINGS: Record<(typeof JSON_INDENTS)[number]["value"], string> = {
+  "2": "  ",
+  "4": "    ",
+  tab: "\t",
+  minify: "",
+};

package/src/operations/data/yaml.ts

@@ -0,0 +1,56 @@
+import YAML from "yaml";
+import { OperationError } from "../../errors.ts";
+import { defineOperation } from "../../operation.ts";
+import { mapText } from "../text/lines.ts";
+import { INDENT_STRINGS, JSON_INDENTS, parseJson } from "./json.ts";
+
+export const jsonToYaml = defineOperation({
+  id: "json-to-yaml",
+  name: "JSON to YAML",
+  description: 'Converts JSON to YAML. Strings that some YAML parsers would read as another type, such as "yes", are quoted.',
+  category: "Data format",
+  output: "binary",
+  aliases: ["yaml"],
+  inverse: "yaml-to-json",
+  infoUrl: "https://yaml.org",
+  args: {},
+  examples: [
+    { input: '{"name":"ops","tags":["a","b"],"count":1}', output: "name: ops\ntags:\n  - a\n  - b\ncount: 1\n" },
+    { input: '{"enabled":"yes"}', output: 'enabled: "yes"\n' },
+  ],
+  run: (input) =>
+    mapText(input, (text) => {
+      parseJson(text);
+      // JSON is valid YAML: parsing it as such keeps large integers exact.
+      // YAML 1.1 rules quote strings like "yes" or "off" that older parsers would read as booleans.
+      return YAML.stringify(YAML.parse(text, { intAsBigInt: true }), { version: "1.1" });
+    }),
+});
+
+export const yamlToJson = defineOperation({
+  id: "yaml-to-json",
+  name: "YAML to JSON",
+  description: "Converts a YAML document to JSON.",
+  category: "Data format",
+  output: "binary",
+  aliases: ["yml", "yaml"],
+  inverse: "json-to-yaml",
+  infoUrl: "https://yaml.org",
+  args: {
+    indent: { type: "select", name: "Indentation", options: JSON_INDENTS, default: "2" },
+  },
+  examples: [
+    { input: "name: ops\ntags: [a, b]\nn: 1\n", args: { indent: "minify" }, output: '{"name":"ops","tags":["a","b"],"n":1}' },
+    { input: "a:\n  - true\n  - ~\n", output: '{\n  "a": [\n    true,\n    null\n  ]\n}' },
+  ],
+  run: (input, { indent }) =>
+    mapText(input, (text) => {
+      let value: unknown;
+      try {
+        value = YAML.parse(text);
+      } catch (error) {
+        throw new OperationError(`Invalid YAML: ${(error as Error).message}`);
+      }
+      return JSON.stringify(value ?? null, null, INDENT_STRINGS[indent]);
+    }),
+});

package/src/operations/extract/extract.ts

@@ -0,0 +1,135 @@
+import { defineOperation } from "../../operation.ts";
+import { mapText } from "../text/lines.ts";
+
+const OCTET = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
+// Not part of a longer dotted sequence such as a version number (1.2.3.4.5).
+const IPV4 = new RegExp(`(?<![\\d.])${OCTET}(?:\\.${OCTET}){3}(?!\\.?\\d)`, "g");
+// Candidates, checked by isIPv6: runs of hex digits, colons and dots with at least two colons.
+const IPV6_CANDIDATE = /(?<![\w:.])[0-9a-f]*:[0-9a-f.:]*:[0-9a-f.]*(?![\w:])/gi;
+const IPV4_EXACT = new RegExp(`^${OCTET}(?:\\.${OCTET}){3}$`);
+
+export function isIPv6(text: string): boolean {
+  const halves = text.split("::");
+  if (halves.length > 2) return false;
+  let groups = 0;
+  for (const [h, half] of halves.entries()) {
+    if (half === "") continue;
+    const parts = half.split(":");
+    for (const [i, part] of parts.entries()) {
+      // An embedded IPv4 address (::ffff:1.2.3.4) counts as two groups and must come last.
+      if (h === halves.length - 1 && i === parts.length - 1 && IPV4_EXACT.test(part)) groups += 2;
+      else if (/^[0-9a-f]{1,4}$/i.test(part)) groups++;
+      else return false;
+    }
+  }
+  return halves.length === 2 ? groups < 8 : groups === 8;
+}
+
+interface Match {
+  index: number;
+  value: string;
+}
+
+function* matches(text: string, pattern: RegExp): Generator<Match> {
+  for (const m of text.matchAll(pattern)) yield { index: m.index, value: m[0] };
+}
+
+const listArgs = {
+  unique: { type: "boolean", name: "Unique", description: "Only list each value once.", default: false },
+  sort: { type: "boolean", name: "Sort", default: false },
+} as const;
+
+function list(found: Iterable<Match>, { unique, sort }: { unique: boolean; sort: boolean }): string {
+  let values = [...found].sort((a, b) => a.index - b.index).map((m) => m.value);
+  if (unique) values = [...new Set(values)];
+  if (sort) values.sort();
+  return values.join("\n");
+}
+
+const IP_VERSIONS = [
+  { value: "both", label: "IPv4 and IPv6" },
+  { value: "ipv4", label: "IPv4 only" },
+  { value: "ipv6", label: "IPv6 only" },
+] as const;
+
+export const extractIps = defineOperation({
+  id: "extract-ips",
+  name: "Extract IP addresses",
+  description: "Lists the IPv4 and IPv6 addresses found in the text, one per line.",
+  category: "Extractors",
+  output: "binary",
+  aliases: ["ipv4", "ipv6", "find ip", "grep ip"],
+  args: {
+    version: { type: "select", name: "Version", options: IP_VERSIONS, default: "both" },
+    ...listArgs,
+  },
+  examples: [
+    { input: "from 10.0.0.1 to 2001:db8::1, not 1.2.3.4.5 or 256.1.1.1", output: "10.0.0.1\n2001:db8::1" },
+    { input: "::1 ::ffff:192.168.1.1 8.8.8.8", args: { version: "ipv4" }, output: "8.8.8.8" },
+  ],
+  run(input, { version, unique, sort }) {
+    return mapText(input, (text) => {
+      const v6 = [...matches(text, IPV6_CANDIDATE)]
+        // Drop the final dot of a sentence.
+        .map((m) => ({ index: m.index, value: m.value.replace(/\.$/, "") }))
+        .filter((m) => isIPv6(m.value));
+      // IPv4 addresses embedded in an IPv6 one are not listed on their own.
+      const v4 = [...matches(text, IPV4)].filter((m) => !v6.some((v) => m.index >= v.index && m.index < v.index + v.value.length));
+      const found = version === "ipv4" ? v4 : version === "ipv6" ? v6 : [...v4, ...v6];
+      return list(found, { unique, sort });
+    });
+  },
+});
+
+const EMAIL =
+  /[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+(?:\.[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+)*@(?:[\p{L}\p{N}](?:[\p{L}\p{N}-]*[\p{L}\p{N}])?\.)+\p{L}[\p{L}\p{N}-]*[\p{L}\p{N}]/gu;
+
+export const extractEmails = defineOperation({
+  id: "extract-emails",
+  name: "Extract email addresses",
+  description: "Lists the email addresses found in the text, one per line.",
+  category: "Extractors",
+  output: "binary",
+  aliases: ["find email", "grep email"],
+  args: listArgs,
+  examples: [
+    { input: "Contact: <john.doe@example.com>, jane+tag@mail.example.org.", output: "john.doe@example.com\njane+tag@mail.example.org" },
+    { input: "b@x.io a@x.io b@x.io", args: { unique: true, sort: true }, output: "a@x.io\nb@x.io" },
+  ],
+  run: (input, args) => mapText(input, (text) => list(matches(text, EMAIL), args)),
+});
+
+// A scheme followed by "://", up to whitespace, quotes or angle brackets.
+const URL_PATTERN = /\b[a-z][a-z0-9+.-]*:\/\/[^\s<>"'`]+/gi;
+
+/** Removes punctuation that more likely ends the sentence than the URL, and unbalanced closing brackets. */
+function trimUrl(url: string): string {
+  for (;;) {
+    const last = url.at(-1)!;
+    if (/[.,;:!?*]/.test(last)) url = url.slice(0, -1);
+    else if (last === ")" && url.split("(").length < url.split(")").length) url = url.slice(0, -1);
+    else if (last === "]" && url.split("[").length < url.split("]").length) url = url.slice(0, -1);
+    else return url;
+  }
+}
+
+export const extractUrls = defineOperation({
+  id: "extract-urls",
+  name: "Extract URLs",
+  description: "Lists the URLs (anything like scheme://...) found in the text, one per line.",
+  category: "Extractors",
+  output: "binary",
+  aliases: ["find url", "grep url", "links"],
+  args: listArgs,
+  examples: [
+    {
+      input: "See https://example.com/a?b=1, (or http://wiki.org/A_(b)) and ftp://x.org/file.",
+      output: "https://example.com/a?b=1\nhttp://wiki.org/A_(b)\nftp://x.org/file",
+    },
+  ],
+  run: (input, args) =>
+    mapText(input, (text) => {
+      const urls = [...matches(text, URL_PATTERN)].map((m) => ({ index: m.index, value: trimUrl(m.value) }));
+      return list(urls, args);
+    }),
+});

package/src/operations/hash/bcrypt.ts

@@ -0,0 +1,44 @@
+import bcryptjs from "bcryptjs";
+import { OperationError } from "../../errors.ts";
+import { defineOperation } from "../../operation.ts";
+
+const SALT = /^[./A-Za-z0-9]{22}$/;
+
+export const bcrypt = defineOperation({
+  id: "bcrypt",
+  name: "Bcrypt",
+  description: "Hashes the input (a password) with bcrypt, using a random salt unless one is given. Only the first 72 bytes are used.",
+  category: "Hashing",
+  output: "text",
+  aliases: ["password hash", "blowfish"],
+  infoUrl: "https://wikipedia.org/wiki/Bcrypt",
+  args: {
+    rounds: {
+      type: "number",
+      name: "Cost",
+      description: "Log2 of the number of rounds: each step doubles the computing time.",
+      min: 4,
+      max: 31,
+      default: 10,
+    },
+    salt: {
+      type: "string",
+      name: "Salt",
+      description: "22 characters from ./A-Za-z0-9. Leave empty for a random salt.",
+      default: "",
+    },
+  },
+  examples: [
+    {
+      input: "hello",
+      args: { rounds: 4, salt: "abcdefghijklmnopqrstuu" },
+      output: "$2b$04$abcdefghijklmnopqrstuuwHJMEGjfAzmL1lWmUmlphguIbWfjYey",
+    },
+  ],
+  run(input, { rounds, salt }) {
+    if (!Number.isInteger(rounds)) throw new OperationError(`Invalid cost: ${rounds} is not an integer`);
+    if (salt && !SALT.test(salt)) throw new OperationError("Invalid salt: expected 22 characters from ./A-Za-z0-9");
+    const fullSalt = salt ? `$2b$${String(rounds).padStart(2, "0")}$${salt}` : bcryptjs.genSaltSync(rounds);
+    return new TextEncoder().encode(bcryptjs.hashSync(new TextDecoder().decode(input), fullSalt));
+  },
+});

package/src/operations/hash/hashes.ts

@@ -0,0 +1,64 @@
+import { createHash } from "node:crypto";
+import { defineOperation } from "../../operation.ts";
+
+/** An OpenSSL digest name, as accepted by node:crypto createHash(). */
+type Algorithm = "md5" | "sha1" | "sha224" | "sha256" | "sha384" | "sha512" | "sha3-224" | "sha3-256" | "sha3-384" | "sha3-512";
+
+function defineHash<const Id extends string>(id: Id, name: string, algorithm: Algorithm, infoUrl: string, hello: string) {
+  return defineOperation({
+    id,
+    name,
+    description: `Computes the ${name} digest of the input, as lowercase hex.`,
+    category: "Hashing",
+    output: "text",
+    aliases: [`${id}sum`, name],
+    infoUrl,
+    args: {},
+    examples: [{ input: "hello", output: hello }],
+    run: (input) => new TextEncoder().encode(createHash(algorithm).update(input).digest("hex")),
+  });
+}
+
+const SHA2 = "https://wikipedia.org/wiki/SHA-2";
+const SHA3 = "https://wikipedia.org/wiki/SHA-3";
+
+export const md5 = defineHash("md5", "MD5", "md5", "https://wikipedia.org/wiki/MD5", "5d41402abc4b2a76b9719d911017c592");
+export const sha1 = defineHash("sha1", "SHA-1", "sha1", "https://wikipedia.org/wiki/SHA-1", "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d");
+export const sha224 = defineHash("sha224", "SHA-224", "sha224", SHA2, "ea09ae9cc6768c50fcee903ed054556e5bfc8347907f12598aa24193");
+export const sha256 = defineHash("sha256", "SHA-256", "sha256", SHA2, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824");
+export const sha384 = defineHash(
+  "sha384",
+  "SHA-384",
+  "sha384",
+  SHA2,
+  "59e1748777448c69de6b800d7a33bbfb9ff1b463e44354c3553bcdb9c666fa90125a3c79f90397bdf5f6a13de828684f",
+);
+export const sha512 = defineHash(
+  "sha512",
+  "SHA-512",
+  "sha512",
+  SHA2,
+  "9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043",
+);
+export const sha3_224 = defineHash("sha3-224", "SHA3-224", "sha3-224", SHA3, "b87f88c72702fff1748e58b87e9141a42c0dbedc29a78cb0d4a5cd81");
+export const sha3_256 = defineHash(
+  "sha3-256",
+  "SHA3-256",
+  "sha3-256",
+  SHA3,
+  "3338be694f50c5f338814986cdf0686453a888b84f424d792af4b9202398f392",
+);
+export const sha3_384 = defineHash(
+  "sha3-384",
+  "SHA3-384",
+  "sha3-384",
+  SHA3,
+  "720aea11019ef06440fbf05d87aa24680a2153df3907b23631e7177ce620fa1330ff07c0fddee54699a4c3ee0ee9d887",
+);
+export const sha3_512 = defineHash(
+  "sha3-512",
+  "SHA3-512",
+  "sha3-512",
+  SHA3,
+  "75d527c368f2efe848ecf6b073a36767800805e9eef2b1857d5f984f036eb6df891d75f72d9b154518c1cd58835286d1da9a38deba3de98b5a53e5ed78a84976",
+);

package/src/operations/hex/from-hex.ts

@@ -0,0 +1,31 @@
+import { OperationError } from "../../errors.ts";
+import { defineOperation } from "../../operation.ts";
+
+// "0x" and "\x" prefixes, whitespace and common separators.
+const IGNORED = /0x|\\x|[\s:,;.%-]/gi;
+
+export const fromHex = defineOperation({
+  id: "from-hex",
+  name: "From Hex",
+  description:
+    'Decodes hexadecimal text into raw bytes, ignoring case, whitespace, separators (: , ; . % -) and 0x or \\x prefixes. e.g. "68656c6c6f" becomes "hello".',
+  category: "Encoding",
+  output: "binary",
+  aliases: ["hex decode", "base16", "unhex", "xxd -r"],
+  inverse: "to-hex",
+  infoUrl: "https://wikipedia.org/wiki/Hexadecimal",
+  args: {},
+  examples: [
+    { input: "68656c6c6f", output: "hello" },
+    { input: "68:65:6C:6C:6F", output: "hello" },
+    { input: "0x68, 0x69", output: "hi" },
+    { input: "\\x68\\x69", output: "hi" },
+  ],
+  run(input) {
+    const hex = new TextDecoder().decode(input).replace(IGNORED, "");
+    const bad = /[^0-9a-f]/i.exec(hex);
+    if (bad) throw new OperationError(`Invalid hex: unexpected character "${bad[0]}"`);
+    if (hex.length % 2) throw new OperationError("Invalid hex: odd number of digits");
+    return Uint8Array.fromHex(hex);
+  },
+});

package/src/operations/hex/to-hex.ts

@@ -0,0 +1,46 @@
+import { defineOperation } from "../../operation.ts";
+
+const DELIMITERS = [
+  { value: "none", label: "None: 68656c6c6f" },
+  { value: "space", label: "Space: 68 65 6c 6c 6f" },
+  { value: "colon", label: "Colon: 68:65:6c:6c:6f" },
+  { value: "comma", label: "Comma: 68,65,6c,6c,6f" },
+  { value: "escape", label: "Escape sequences: \\x68\\x65\\x6c\\x6c\\x6f" },
+  { value: "0x", label: "C array: 0x68, 0x65, 0x6c, 0x6c, 0x6f" },
+] as const;
+
+const FORMATS: Record<(typeof DELIMITERS)[number]["value"], { prefix: string; separator: string }> = {
+  none: { prefix: "", separator: "" },
+  space: { prefix: "", separator: " " },
+  colon: { prefix: "", separator: ":" },
+  comma: { prefix: "", separator: "," },
+  escape: { prefix: "\\x", separator: "" },
+  "0x": { prefix: "0x", separator: ", " },
+};
+
+export const toHex = defineOperation({
+  id: "to-hex",
+  name: "To Hex",
+  description: 'Encodes raw bytes as hexadecimal text. e.g. "hello" becomes "68656c6c6f".',
+  category: "Encoding",
+  output: "text",
+  aliases: ["hex encode", "base16", "xxd"],
+  inverse: "from-hex",
+  infoUrl: "https://wikipedia.org/wiki/Hexadecimal",
+  args: {
+    delimiter: { type: "select", name: "Delimiter", options: DELIMITERS, default: "none" },
+    uppercase: { type: "boolean", name: "Uppercase", default: false },
+  },
+  examples: [
+    { input: "hello", output: "68656c6c6f" },
+    { input: "hello", args: { delimiter: "colon", uppercase: true }, output: "68:65:6C:6C:6F" },
+    { input: "hi", args: { delimiter: "escape" }, output: "\\x68\\x69" },
+  ],
+  run(input, { delimiter, uppercase }) {
+    const { prefix, separator } = FORMATS[delimiter];
+    const hex = input.toHex();
+    const digits = uppercase ? hex.toUpperCase() : hex;
+    const bytes = digits.match(/../g) ?? [];
+    return new TextEncoder().encode(bytes.map((byte) => prefix + byte).join(separator));
+  },
+});

package/src/operations/html/entities.ts

@@ -0,0 +1,71 @@
+// HTML 4 entities for U+00A0 to U+00FF, in code point order.
+const LATIN1 =
+  "nbsp iexcl cent pound curren yen brvbar sect uml copy ordf laquo not shy reg macr deg plusmn sup2 sup3 acute " +
+  "micro para middot cedil sup1 ordm raquo frac14 frac12 frac34 iquest Agrave Aacute Acirc Atilde Auml Aring AElig " +
+  "Ccedil Egrave Eacute Ecirc Euml Igrave Iacute Icirc Iuml ETH Ntilde Ograve Oacute Ocirc Otilde Ouml times Oslash " +
+  "Ugrave Uacute Ucirc Uuml Yacute THORN szlig agrave aacute acirc atilde auml aring aelig ccedil egrave eacute " +
+  "ecirc euml igrave iacute icirc iuml eth ntilde ograve oacute ocirc otilde ouml divide oslash ugrave uacute ucirc " +
+  "uuml yacute thorn yuml";
+
+const OTHERS: Record<string, number> = {
+  quot: 0x22,
+  amp: 0x26,
+  apos: 0x27,
+  lt: 0x3c,
+  gt: 0x3e,
+  OElig: 0x152,
+  oelig: 0x153,
+  Scaron: 0x160,
+  scaron: 0x161,
+  Yuml: 0x178,
+  fnof: 0x192,
+  circ: 0x2c6,
+  tilde: 0x2dc,
+  ensp: 0x2002,
+  emsp: 0x2003,
+  thinsp: 0x2009,
+  zwnj: 0x200c,
+  zwj: 0x200d,
+  lrm: 0x200e,
+  rlm: 0x200f,
+  ndash: 0x2013,
+  mdash: 0x2014,
+  lsquo: 0x2018,
+  rsquo: 0x2019,
+  sbquo: 0x201a,
+  ldquo: 0x201c,
+  rdquo: 0x201d,
+  bdquo: 0x201e,
+  dagger: 0x2020,
+  Dagger: 0x2021,
+  bull: 0x2022,
+  hellip: 0x2026,
+  permil: 0x2030,
+  prime: 0x2032,
+  Prime: 0x2033,
+  lsaquo: 0x2039,
+  rsaquo: 0x203a,
+  oline: 0x203e,
+  euro: 0x20ac,
+  trade: 0x2122,
+  larr: 0x2190,
+  uarr: 0x2191,
+  rarr: 0x2192,
+  darr: 0x2193,
+  harr: 0x2194,
+  minus: 0x2212,
+  infin: 0x221e,
+  ne: 0x2260,
+  le: 0x2264,
+  ge: 0x2265,
+  spades: 0x2660,
+  clubs: 0x2663,
+  hearts: 0x2665,
+  diams: 0x2666,
+};
+
+/** Named character references supported by `html-decode`: HTML 4 entities and `&apos;`. */
+export const NAMED_ENTITIES = new Map<string, number>([
+  ...LATIN1.split(" ").map((name, i) => [name, 0xa0 + i] as const),
+  ...Object.entries(OTHERS),
+]);

package/src/operations/html/html-decode.ts

@@ -0,0 +1,36 @@
+import { defineOperation } from "../../operation.ts";
+import { NAMED_ENTITIES } from "./entities.ts";
+
+const ENTITY = /&(?:#(\d+)|#x([0-9a-f]+)|([a-z][a-z0-9]*));/gi;
+
+function fromCodePoint(code: number): string {
+  // NUL, surrogates and out of range values are replaced, as browsers do.
+  if (code === 0 || code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) return "�";
+  return String.fromCodePoint(code);
+}
+
+export const htmlDecode = defineOperation({
+  id: "html-decode",
+  name: "HTML Decode",
+  description:
+    'Decodes HTML entities: numeric (&#233; &#xE9;) and named HTML 4 ones (&eacute; &amp; ...). Unknown entities are left as is. e.g. "&lt;b&gt;" becomes "<b>".',
+  category: "Encoding",
+  output: "binary",
+  aliases: ["html unescape", "html entities"],
+  inverse: "html-encode",
+  infoUrl: "https://wikipedia.org/wiki/Character_encodings_in_HTML",
+  args: {},
+  examples: [
+    { input: "&lt;a href=&quot;x&quot;&gt;Tom &amp; Jerry&lt;/a&gt;", output: '<a href="x">Tom & Jerry</a>' },
+    { input: "caf&eacute; &#8364; &#x263A; &unknown;", output: "café € ☺ &unknown;" },
+  ],
+  run(input) {
+    const text = new TextDecoder().decode(input).replace(ENTITY, (entity, dec?: string, hex?: string, name?: string) => {
+      if (dec) return fromCodePoint(Number(dec));
+      if (hex) return fromCodePoint(parseInt(hex, 16));
+      const code = NAMED_ENTITIES.get(name!);
+      return code === undefined ? entity : String.fromCodePoint(code);
+    });
+    return new TextEncoder().encode(text);
+  },
+});

package/src/operations/html/html-encode.ts

@@ -0,0 +1,31 @@
+import { defineOperation } from "../../operation.ts";
+
+const SPECIAL: Record<string, string> = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+
+export const htmlEncode = defineOperation({
+  id: "html-encode",
+  name: "HTML Encode",
+  description: 'Escapes & < > " and \' as HTML entities. e.g. "<b>" becomes "&lt;b&gt;".',
+  category: "Encoding",
+  output: "binary",
+  aliases: ["html escape", "html entities"],
+  inverse: "html-decode",
+  infoUrl: "https://wikipedia.org/wiki/Character_encodings_in_HTML",
+  args: {
+    encodeNonAscii: {
+      type: "boolean",
+      name: "Encode non-ASCII characters",
+      description: "Also write characters outside ASCII as numeric entities, e.g. é as &#233;.",
+      default: false,
+    },
+  },
+  examples: [
+    { input: '<a href="x">Tom & Jerry</a>', output: "&lt;a href=&quot;x&quot;&gt;Tom &amp; Jerry&lt;/a&gt;" },
+    { input: "café €", args: { encodeNonAscii: true }, output: "caf&#233; &#8364;" },
+  ],
+  run(input, { encodeNonAscii }) {
+    const pattern = encodeNonAscii ? /[&<>"']|[^\x00-\x7f]/gu : /[&<>"']/g;
+    const text = new TextDecoder().decode(input).replace(pattern, (ch) => SPECIAL[ch] ?? `&#${ch.codePointAt(0)};`);
+    return new TextEncoder().encode(text);
+  },
+});