@discord/intl 0.2.0 → 0.2.1-canary.11837d1

package/dist/message-loader.js

@@ -64,6 +64,9 @@ var __read = (this && this.__read) || function (o, n) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageLoader = void 0;
+exports.loadAllMessagesInLocale = loadAllMessagesInLocale;
+exports.waitForAllDefaultIntlMessagesLoaded = waitForAllDefaultIntlMessagesLoaded;
+exports.createLoader = createLoader;
 var message_1 = require("./message");
 var MessageLoader = /** @class */ (function () {
     function MessageLoader(messageKeys, localeImportMap, defaultLocale) {
@@ -78,17 +81,24 @@ var MessageLoader = /** @class */ (function () {
         this._parseCache = new Map();
         this._subscribers = new Set();
         this._loadLocale(this.defaultLocale);
-        this.fallbackMessage = new message_1.InternalIntlMessage('THIS MESSAGE FAILED TO LOAD', 'en-US');
+        this.fallbackMessage = new message_1.InternalIntlMessage([], this.defaultLocale);
         // In cases where hot module replacement is available, set up cache clearing whenever the
         // targets change so that values are always replaced.
         // @ts-expect-error `hot` not defined in types.
         if (module.hot) {
             var _loop_1 = function (locale, file) {
                 // @ts-expect-error `hot` not defined in types.
-                module.hot.accept(file, function () {
-                    _this._parseCache.clear();
-                    _this._loadLocale(locale);
-                });
+                module.hot.accept(file, function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, this._loadLocale(locale)];
+                            case 1:
+                                _a.sent();
+                                this._parseCache.clear();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
             };
             try {
                 for (var _b = __values(Object.entries(localeImportMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -119,9 +129,8 @@ var MessageLoader = /** @class */ (function () {
     MessageLoader.prototype.get = function (key, locale) {
         var _a;
         var value = (_a = this.getMessageValue(key, locale)) !== null && _a !== void 0 ? _a : this.getMessageValue(key, this.defaultLocale);
-        if (value != null) {
+        if (value != null)
             return value;
-        }
         // If the message couldn't be found in either the requested nor the default locale, then
         // nothing can be done.
         var errorKey = this._debugKeyMap != null ? "\"".concat(this._debugKeyMap[key], "\" (").concat(key, ")") : undefined;
@@ -146,13 +155,11 @@ var MessageLoader = /** @class */ (function () {
         var cachedValue = this._parseCache.get(cacheKey);
         if (cachedValue != null)
             return cachedValue;
-        // Return early if this locale is still in the process of being loaded.
-        if (this._localeLoadingPromises[locale] != null) {
-            return undefined;
-        }
-        // If not, check whether it's been loaded and trigger a load if not.
+        // Check whether the locale exists in memory. If not, start a request to
+        // load the locale if one has not already started. It's impossible for
+        // the request to finish within the same tick, so return undefined in any
+        // case then.
         if (this.messages[locale] == null) {
-            // Ensure the locale is loaded, if it is supported
             if (this.supportedLocales.includes(locale)) {
                 this._loadLocale(locale);
             }
@@ -186,12 +193,13 @@ var MessageLoader = /** @class */ (function () {
     };
     MessageLoader.prototype._loadLocale = function (locale) {
         return __awaiter(this, void 0, void 0, function () {
-            var loadingPromise, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var current, _a, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         // Don't re-load a locale that's already in progress.
-                        if (this._localeLoadingPromises[locale] != null) {
+                        if (((_c = this._localeLoadingPromises[locale]) === null || _c === void 0 ? void 0 : _c.current) != null) {
                             return [2 /*return*/];
                         }
                         // Safety check in case the locale map doesn't include a require for the
@@ -203,14 +211,14 @@ var MessageLoader = /** @class */ (function () {
                         // If the locale is already set in `messages`, then it doesn't need to be loaded again.
                         if (this.messages[locale] != null)
                             return [2 /*return*/];
-                        loadingPromise = this.localeImportMap[locale]();
-                        this._localeLoadingPromises[locale] = loadingPromise;
+                        current = this.localeImportMap[locale]();
+                        this._localeLoadingPromises[locale] = { initialized: false, current: current };
                         _a = this.messages;
                         _b = locale;
-                        return [4 /*yield*/, loadingPromise];
+                        return [4 /*yield*/, current];
                     case 1:
-                        _a[_b] = (_c.sent()).default;
-                        delete this._localeLoadingPromises[locale];
+                        _a[_b] = (_d.sent()).default;
+                        this._localeLoadingPromises[locale] = { initialized: true, current: undefined };
                         this.emitChange();
                         return [2 /*return*/];
                 }
@@ -245,6 +253,111 @@ var MessageLoader = /** @class */ (function () {
         this._subscribers.add(callback);
         return function () { return _this._subscribers.delete(callback); };
     };
+    MessageLoader.prototype.isLocaleLoaded = function (locale, requireCurrent) {
+        if (requireCurrent === void 0) { requireCurrent = false; }
+        var ref = this._localeLoadingPromises[locale];
+        // Ensure the locale at least exists and is initialized.
+        if (ref == null || ref.initialized == false)
+            return false;
+        // `current` will be deleted once the locale has loaded, so if it is null,
+        // then the locale data is current.
+        if (requireCurrent)
+            return ref.current == null;
+        // Otherwise, initialization is enough.
+        return true;
+    };
+    MessageLoader.prototype.waitForLocaleLoaded = function (locale_1) {
+        return __awaiter(this, arguments, void 0, function (locale, requireCurrent) {
+            var ref;
+            if (requireCurrent === void 0) { requireCurrent = false; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ref = this._localeLoadingPromises[locale];
+                        // If the locale hasn't been loaded at all, kick off the load and return
+                        // that Promise directly.
+                        if (ref == null)
+                            return [2 /*return*/, this._loadLocale(locale)];
+                        // If initialization is enough for this request, just resolve immediately.
+                        if (ref.initialized && !requireCurrent)
+                            return [2 /*return*/];
+                        // Otherwise, check the `current` loading state on the object, and if that
+                        // doesn't exist, then the locale data is already finished loading, and the
+                        // containing Promise will just resolve with `undefined`.
+                        return [4 /*yield*/, ref.current];
+                    case 1:
+                        // Otherwise, check the `current` loading state on the object, and if that
+                        // doesn't exist, then the locale data is already finished loading, and the
+                        // containing Promise will just resolve with `undefined`.
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Returns true if this loader's default locale has finished loading. When
+     * true, all messages managed by this loader are guaranteed to have _a_
+     * render-able value, even if one does not exist in the current locale.
+     */
+    MessageLoader.prototype.waitForDefaultLocale = function () {
+        return __awaiter(this, arguments, void 0, function (requireCurrent) {
+            if (requireCurrent === void 0) { requireCurrent = false; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.waitForLocaleLoaded(this.defaultLocale, requireCurrent)];
+            });
+        });
+    };
     return MessageLoader;
 }());
 exports.MessageLoader = MessageLoader;
+var LOADER_REGISTRY = [];
+/**
+ * Kick off a load request for the given locale across all currently-registered
+ * message loaders, returning a Promise that resolves when all loaders have
+ * finished loading that locale.
+ */
+function loadAllMessagesInLocale(locale) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all(LOADER_REGISTRY.map(function (loader) { return loader._loadLocale(locale); }))];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Returns a new Promise that resolves after all currently-registered message
+ * loaders have finished successfully loading their default locale content.
+ * Once this Promise has resolved, all messages that currently exist in the
+ * application (i.e., within all modules that have been imported or required in
+ * the current session) can be guaranteed to have _a_ render-able value.
+ *
+ * This function can be called at any point in an applications life cycle and
+ * will always ensure that _all_ loaders that currently exist are initialized.
+ */
+function waitForAllDefaultIntlMessagesLoaded() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all(LOADER_REGISTRY.map(function (loader) { return loader.waitForDefaultLocale(); }))];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Create a new MessageLoader, which handles lazily loading messages for
+ * different locales and sanity checks as needed to provide accessors for each
+ * message defined in `messageKeys`.
+ */
+function createLoader(messageKeys, localeImportMap, defaultLocale) {
+    var loader = new MessageLoader(messageKeys, localeImportMap, defaultLocale);
+    LOADER_REGISTRY.push(loader);
+    return loader;
+}

package/dist/message.d.ts

@@ -1,20 +1,11 @@
 import { FormatJsNode } from './keyless-json';
 export declare class InternalIntlMessage {
     locale: string;
-    message?: string;
     ast: FormatJsNode[];
+    constructor(messageOrAst: FormatJsNode[], locale: string);
     /**
-     * A stripped-down representation of the message with no rich formatting
-     * elements preserved. This will be lazily created the first time it is
-     * requested (e.g., by calling `formatToPlainString`).
+     * Return a stringified serialization of this message's AST, with no
+     * formatting or values applied.
      */
-    get plainAst(): FormatJsNode[];
-    _plainAst: FormatJsNode[];
-    constructor(messageOrAst: string | FormatJsNode[], locale: string);
-    /**
-     * Returns the same element with any formatting tags removed. If the element
-     * itself is a tag, the children will be hoisted and returned, otherwise the
-     * element is returned as an array of itself.
-     */
-    private _removeRichTags;
+    reserialize(): string;
 }

package/dist/message.js

@@ -26,68 +26,161 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalIntlMessage = void 0;
 var keyless_json_1 = require("./keyless-json");
 var InternalIntlMessage = /** @class */ (function () {
     function InternalIntlMessage(messageOrAst, locale) {
         this.locale = locale;
-        if (typeof messageOrAst === 'string') {
-            this.message = messageOrAst;
-        }
-        else {
-            this.ast = messageOrAst;
-        }
+        this.ast = messageOrAst;
     }
-    Object.defineProperty(InternalIntlMessage.prototype, "plainAst", {
-        /**
-         * A stripped-down representation of the message with no rich formatting
-         * elements preserved. This will be lazily created the first time it is
-         * requested (e.g., by calling `formatToPlainString`).
-         */
-        get: function () {
-            return (this._plainAst = this._removeRichTags(this.ast));
-        },
-        enumerable: false,
-        configurable: true
-    });
     /**
-     * Returns the same element with any formatting tags removed. If the element
-     * itself is a tag, the children will be hoisted and returned, otherwise the
-     * element is returned as an array of itself.
+     * Return a stringified serialization of this message's AST, with no
+     * formatting or values applied.
      */
-    InternalIntlMessage.prototype._removeRichTags = function (nodes) {
-        var e_1, _a;
-        var result = new Array(nodes.length);
-        try {
-            for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
-                var node = nodes_1_1.value;
-                if (node.type === keyless_json_1.FormatJsNodeType.Tag) {
-                    result.push.apply(result, __spreadArray([], __read(this._removeRichTags(node.children)), false));
+    InternalIntlMessage.prototype.reserialize = function () {
+        var value = '';
+        serializeFormatJsAst(this.ast, { value: value });
+        return value;
+    };
+    return InternalIntlMessage;
+}());
+exports.InternalIntlMessage = InternalIntlMessage;
+// Accepting an object as the `result` parameter lets the same string get passed around and
+// appended, rather than creating a bunch of intermediate strings.
+function serializeFormatJsAst(ast, result) {
+    var e_1, _a, e_2, _b, e_3, _c;
+    try {
+        for (var ast_1 = __values(ast), ast_1_1 = ast_1.next(); !ast_1_1.done; ast_1_1 = ast_1.next()) {
+            var node = ast_1_1.value;
+            switch (node.type) {
+                case keyless_json_1.FormatJsNodeType.Literal:
+                    result.value += node.value;
+                    return;
+                case keyless_json_1.FormatJsNodeType.Argument:
+                    // Empties are an artifact of our parsing strategy, not necessary here.
+                    if (result.value === '$_')
+                        return;
+                    result.value += '{' + node.value + '}';
+                    return;
+                case keyless_json_1.FormatJsNodeType.Date:
+                    result.value += '{' + node.value + ', date';
+                    if (node.style != null) {
+                        result.value += ', ' + node.style;
+                    }
+                    result.value += '}';
+                    return;
+                case keyless_json_1.FormatJsNodeType.Time:
+                    result.value += '{' + node.value + ', time';
+                    if (node.style != null) {
+                        result.value += ', ' + node.style;
+                    }
+                    result.value += '}';
+                    return;
+                case keyless_json_1.FormatJsNodeType.Number:
+                    result.value += '{' + node.value + ', number';
+                    if (node.style != null) {
+                        result.value += ', ' + node.style;
+                    }
+                    result.value += '}';
+                    return;
+                case keyless_json_1.FormatJsNodeType.Plural: {
+                    var pluralType = node.pluralType == 'ordinal' ? 'selectordinal' : 'plural';
+                    result.value += '{' + node.value + ', ' + pluralType + ', ';
+                    if (node.offset) {
+                        result.value += 'offset:' + node.offset;
+                    }
+                    try {
+                        for (var _d = (e_2 = void 0, __values(Object.entries(node.options))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                            var _f = __read(_e.value, 2), name = _f[0], arm = _f[1];
+                            result.value += ' ' + name + ' {';
+                            serializeFormatJsAst(arm.value, result);
+                            result.value += '}';
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    return;
                 }
-                else {
-                    result.push(node);
+                case keyless_json_1.FormatJsNodeType.Pound:
+                    result.value += '#';
+                    return;
+                case keyless_json_1.FormatJsNodeType.Select: {
+                    result.value += '{' + node.value + ', select, ';
+                    try {
+                        for (var _g = (e_3 = void 0, __values(Object.entries(node.options))), _h = _g.next(); !_h.done; _h = _g.next()) {
+                            var _j = __read(_h.value, 2), name = _j[0], arm = _j[1];
+                            result.value += ' ' + name + ' {';
+                            serializeFormatJsAst(arm.value, result);
+                            result.value += '}';
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    return;
                 }
+                case keyless_json_1.FormatJsNodeType.Tag:
+                    serializeFormatJsTag(node, result);
+                    return;
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
-            }
-            finally { if (e_1) throw e_1.error; }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (ast_1_1 && !ast_1_1.done && (_a = ast_1.return)) _a.call(ast_1);
         }
-        return result;
-    };
-    return InternalIntlMessage;
-}());
-exports.InternalIntlMessage = InternalIntlMessage;
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+function serializeFormatJsTag(node, result) {
+    switch (node.value) {
+        case '$b':
+            result.value += '**';
+            serializeFormatJsAst(node.children, result);
+            result.value += '**';
+            return;
+        case '$i':
+            result.value += '*';
+            serializeFormatJsAst(node.children, result);
+            result.value += '*';
+            return;
+        case '$code':
+            result.value += '`';
+            serializeFormatJsAst(node.children, result);
+            result.value += '`';
+            return;
+        case '$p':
+            serializeFormatJsAst(node.children, result);
+            result.value += '\n\n';
+            return;
+        case '$link':
+            // The target is the first child of the link. We don't have to care if it's a placeholder
+            // or not, because the serialization will automatically remove the extra empty.
+            var _a = __read(node.children), target = _a[0], children = _a.slice(1);
+            result.value += '[';
+            serializeFormatJsAst(children, result);
+            result.value += '](';
+            if (target != null) {
+                serializeFormatJsAst([target], result);
+            }
+            result.value += ')';
+            return;
+        default:
+            // Any other tag name is a hook, which just adds the `$[` on a link tag.
+            result.value += '$[';
+            serializeFormatJsAst(node.children, result);
+            result.value += '](' + node.value + ')';
+            return;
+    }
+}

package/dist/types.d.ts

@@ -197,9 +197,9 @@ export interface FunctionTypeMap {
   handler: any;
 }
 
-export interface FunctionTypes<Result, HandlerType = (content: Result[]) => Result | Result[]> {
-  link: undefined | ((content: Result[]) => Result | Result[]);
-  hook: undefined | ((content: Result[]) => Result | Result[]);
+export interface FunctionTypes<Result, HandlerType = () => void> {
+  link: undefined | ((content: Result[], key: string) => Result | Result[]);
+  hook: undefined | ((content: Result[], key: string) => Result | Result[]);
   handler: undefined | HandlerType;
 }
 
@@ -276,6 +276,7 @@ export interface RichTextFormattingMap<T = any> {
   $p: T;
   $link: T;
   $code: T;
+  $del: T;
 }
 
 export type RichTextTagNames = keyof RichTextFormattingMap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discord/intl",
-  "version": "0.2.0",
+  "version": "0.2.1-canary.11837d1",
   "license": "MIT",
   "description": "Client runtime for managing messages and translations in a React project.",
   "main": "./dist/index.js",
@@ -16,6 +16,7 @@
   ],
   "dependencies": {
     "@formatjs/intl": "^2.10.1",
+    "@formatjs/icu-skeleton-parser": "1.8.2",
     "intl-messageformat": "^10.5.11"
   },
   "devDependencies": {

package/src/format.ts

@@ -20,6 +20,11 @@
 import { FormatJsNode, FormatJsNodeType } from './keyless-json';
 import { Formats, Formatters, MissingValueError } from 'intl-messageformat';
 import { RichTextTagNames } from './types';
+import {
+  parseDateTimeSkeleton,
+  parseNumberSkeleton,
+  parseNumberSkeletonFromString,
+} from '@formatjs/icu-skeleton-parser';
 
 /**
  * Returns true if the tag name should be considered a rich text tag that
@@ -96,10 +101,12 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
       case FormatJsNodeType.Date: {
         // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
         // so this manages parsing the skeleton as well before passing it onto the date formatter.
-        if (typeof node.style !== 'string') {
-          throw '@discord/intl does not currently support non-string format skeletons';
-        }
-        const style = node.style in formats.date ? formats.date[node.style] : undefined; // TODO: parseSkeleton();
+        const style =
+          node.style in formats.date
+            ? formats.date[node.style]
+            : node.style != null
+              ? parseDateTimeSkeleton(node.style)
+              : undefined;
         // @ts-expect-error Cast string values to dates properly.
         builder.pushLiteralText(formatters.getDateTimeFormat(locales, style).format(value));
         break;
@@ -107,10 +114,12 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
       case FormatJsNodeType.Time: {
         // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
         // so this manages parsing the skeleton as well before passing it onto the date formatter.
-        if (typeof node.style !== 'string') {
-          throw '@discord/intl does not currently support non-string format skeletons';
-        }
-        const style = node.style in formats.time ? formats.time[node.style] : undefined; // TODO: parseSkeleton();
+        const style =
+          node.style in formats.time
+            ? formats.time[node.style]
+            : node.style != null
+              ? parseDateTimeSkeleton(node.style)
+              : undefined; // TODO: parseSkeleton();
         builder.pushLiteralText(
           // @ts-expect-error Cast string values to dates properly.
           formatters.getDateTimeFormat(locales, style).format(value),
@@ -120,14 +129,15 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
       case FormatJsNodeType.Number: {
         // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
         // so this manages parsing the skeleton as well before passing it onto the date formatter.
-        if (typeof node.style !== 'string') {
-          throw '@discord/intl does not currently support non-string format skeletons';
-        }
-        const style = node.style in formats.number ? formats.number[node.style] : undefined; // TODO: parseSkeleton();
-
-        // @ts-expect-error Support `scale` style property.
-        const scaledValue = value as number;
-        // const scaledValue = (value as number) * (style?.scale ?? 1);
+        const style =
+          node.style in formats.number
+            ? formats.number[node.style]
+            : node.style != null
+              ? parseNumberSkeleton(parseNumberSkeletonFromString(node.style))
+              : undefined;
+        const scaledValue =
+          // @ts-expect-error This is a weird cast that's not accurate, but works in the short term.
+          typeof value !== 'number' ? (value as number) : ((value as number) * style?.scale ?? 1);
         builder.pushLiteralText(formatters.getNumberFormat(locales, style).format(scaledValue));
         break;
       }

package/src/formatters/ast.ts

@@ -12,7 +12,7 @@ import { FormatBuilder } from '../format';
  * Types for formatting functions when calling `formatToParts`, ensuring the
  * functions yield value AST nodes.
  */
-export type AstFunctionTypes = FunctionTypes<RichTextNode>;
+export type AstFunctionTypes = FunctionTypes<RichTextNode, object>;
 
 // This structure aims to match `simple-markdown`'s AST, but that type is very
 // loosely defined as just "type" and "arbitrary map of content". This is more
@@ -21,6 +21,7 @@ export enum RichTextNodeType {
   Text = 'text',
   Strong = 'strong',
   Emphasis = 'emphasis',
+  Strikethrough = 'strikethrough',
   Code = 'code',
   Link = 'link',
   Paragraph = 'paragraph',
@@ -36,15 +37,6 @@ export enum RichTextNodeType {
   Object = 'object',
 }
 
-const RICH_TEXT_TAG_TYPES: Record<RichTextTagNames, RichTextNodeType> = {
-  $_: RichTextNodeType.Text,
-  $b: RichTextNodeType.Strong,
-  $i: RichTextNodeType.Emphasis,
-  $code: RichTextNodeType.Code,
-  $link: RichTextNodeType.Link,
-  $p: RichTextNodeType.Paragraph,
-};
-
 interface RichTextNodeBase<ContentType> {
   type: RichTextNodeType;
   content: ContentType;
@@ -58,6 +50,9 @@ interface RichTextStrongNode extends RichTextNodeBase<RichTextNode[]> {
 interface RichTextEmphasisNode extends RichTextNodeBase<RichTextNode[]> {
   type: RichTextNodeType.Emphasis;
 }
+interface RichTextStrikethroughNode extends RichTextNodeBase<RichTextNode[]> {
+  type: RichTextNodeType.Strikethrough;
+}
 interface RichTextCodeNode extends RichTextNodeBase<RichTextNode[]> {
   type: RichTextNodeType.Code;
 }
@@ -76,6 +71,7 @@ export type RichTextNode =
   | RichTextTextNode
   | RichTextStrongNode
   | RichTextEmphasisNode
+  | RichTextStrikethroughNode
   | RichTextCodeNode
   | RichTextParagraphNode
   | RichTextLinkNode
@@ -84,8 +80,9 @@ export type RichTextNode =
 const AST_RICH_TEXT_ELEMENTS: RichTextFormattingMap<AstFunctionTypes['hook']> = {
   $_: () => ({ type: RichTextNodeType.Text, content: '' }),
   $b: (content) => ({ type: RichTextNodeType.Strong, content }),
-  $code: (content) => ({ type: RichTextNodeType.Code, content }),
   $i: (content) => ({ type: RichTextNodeType.Emphasis, content }),
+  $del: (content) => ({ type: RichTextNodeType.Strikethrough, content }),
+  $code: (content) => ({ type: RichTextNodeType.Code, content }),
   $link: ([target, ...content]) => ({
     type: RichTextNodeType.Link,
     target: target.content as string,
@@ -101,7 +98,7 @@ class AstBuilder extends FormatBuilder<RichTextNode> {
     if (!(tag in AST_RICH_TEXT_ELEMENTS)) {
       throw `${tag} is not a known rich text formatting tag`;
     }
-    const result = AST_RICH_TEXT_ELEMENTS[tag](children);
+    const result = AST_RICH_TEXT_ELEMENTS[tag](children, '');
     if (Array.isArray(result)) {
       this.result.push(...result);
     } else {

package/src/formatters/markdown.ts

@@ -21,8 +21,9 @@ export type MarkdownFunctionTypes = FunctionTypes<string>;
 const MARKDOWN_RICH_TEXT_ELEMENTS: RichTextFormattingMap<MarkdownFunctionTypes['hook']> = {
   $_: () => '',
   $b: (content) => '**' + content.join('') + '**',
-  $code: (content) => '`' + content.join('') + '`',
   $i: (content) => '*' + content.join('') + '*',
+  $del: (content) => '~~' + content.join('') + '~~',
+  $code: (content) => '`' + content.join('') + '`',
   $link: ([target, ...content]) => '[' + content.join('') + '](' + target + ')',
   $p: (content) => content.join('') + '\n\n',
 };
@@ -31,7 +32,7 @@ class MarkdownBuilder extends StringBuilder {
   result: string = '';
 
   pushRichTextTag(tag: RichTextTagNames, children: string[]) {
-    this.result += MARKDOWN_RICH_TEXT_ELEMENTS[tag](children);
+    this.result += MARKDOWN_RICH_TEXT_ELEMENTS[tag](children, '');
   }
 }