├── .github
    └── workflows
    │   └── test.yml
├── .gitignore
├── .vscode
    ├── extensions.json
    └── settings.json
├── CHANGELOG.md
├── LICENSE
├── README.md
├── biome.json
├── deno.json
├── src
    └── index.ts
└── tests
    ├── perf
        └── benchmark
        │   ├── baseline.js
        │   ├── benchmark.js
        │   └── package.json
    └── unit
        ├── examples.test.ts
        ├── html.test.ts
        └── plain-text.test.ts


/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | name: Test
 2 | on:
 3 |   push:
 4 |     branches: [main]
 5 |   pull_request:
 6 |     branches: [main]
 7 | 
 8 | jobs:
 9 |   build:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - uses: actions/checkout@v4
13 | 
14 |       - name: Setup Biome
15 |         uses: biomejs/setup-biome@v2
16 |         with:
17 |           version: "1.8.3"
18 | 
19 |       - name: Lint and formatting
20 |         run: biome ci .
21 | 
22 |       - name: Set up Deno
23 |         uses: denoland/setup-deno@v1
24 |         with:
25 |           deno-version: 1.x
26 | 
27 |       - name: Run tests
28 |         run: deno test
29 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | dist
2 | node_modules
3 | package-lock.json
4 | yarn.lock
5 | 


--------------------------------------------------------------------------------
/.vscode/extensions.json:
--------------------------------------------------------------------------------
1 | {
2 |     "recommendations": ["biomejs.biome", "denoland.vscode-deno"]
3 | }
4 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |     "deno.enable": true,
3 |     "editor.defaultFormatter": "biomejs.biome"
4 | }
5 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # CHANGELOG
 2 | 
 3 | ## 3.0.0
 4 | 
 5 | -   `text-clipper` has become a Deno-first library and is now available on [Jsr.io](https://jsr.io).
 6 |     Instructions for installation on Node.js/Bun are still included.
 7 | -   Fix #18: Don't include spaces before the indicator.
 8 | -   Fix #19: Introduce a new option `insertIndicatorAtLinebreak` (default: `true`). If you want to
 9 |     keep the behavior of `text-clipper` v2, you should set this back to `false`.
10 | -   Tweak in behavior: The indicator is never inserted if only whitespace remains after the
11 |     clipping point.
12 | 
13 | ## 2.2.0
14 | 
15 | -   Implement #14: Add `stripTags` option.
16 | -   Tiny Unicode fix.
17 | -   Treat `<audio>` and `<video>` as unbreakable elements.
18 | 
19 | ## 2.1.0
20 | 
21 | -   Implement #12: Improve support for clipping HTML tables.
22 | 
23 | ## 2.0.0
24 | 
25 | -   Use TypeScript primarily to ease Deno support.
26 | -   Assume `Array.prototype.includes()` is available.
27 | -   Upgraded development dependencies.
28 | 
29 | ## 1.3.0
30 | 
31 | -   Add TypeScript definition.
32 | 
33 | ## 1.2.4
34 | 
35 | -   Fix #7: Fix two edge cases:
36 |     -   Incorrect result when `maxLength` is less than the size of the indicator.
37 |     -   Incorrect indicator when the remaining HTML contains a mix of block and inline elements.
38 | -   Tiny optimization when processing HTML tags.
39 | 
40 | ## 1.2.3
41 | 
42 | -   Fix #4: Correct clip length when using no indicator (indicator is an empty string).
43 | -   Fix #5: Support ampersands that do not start an HTML character reference.
44 | 
45 | ## 1.2.2
46 | 
47 | -   Fix building in React Native.
48 | 
49 | ## 1.2.1
50 | 
51 | -   Improved tag handling and newline counting (#2, thanks to @churchs19).
52 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016-2024 Arend van Beelen jr., Speakap B.V.
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # text-clipper.js
  2 | 
  3 | Fast and correct clip functions for HTML and plain text.
  4 | 
  5 | ## Why use text-clipper?
  6 | 
  7 | text-clipper offers the following advantages over similar libraries that allow clipping HTML:
  8 | 
  9 | -   **Correctness**
 10 |     -   HTML is processed through a proper state machine, no regular expression hacks.
 11 |     -   Valid HTML input always produces valid HTML output.
 12 |     -   Heavily unit-tested to support the above statement.
 13 | -   **Proper Unicode handling**
 14 |     -   Unicode-awareness makes sure Unicode characters such as emojis don't get clipped halfway.
 15 | -   **Performance**
 16 |     -   Text-clipper has been carefully optimized and is typically as fast as or faster than its
 17 |         competitors (see: [blog](http://www.arendjr.nl/2016/09/how-i-made-text-clipper-fastest-html.html)).
 18 | -   **Consistent API and behavior for both HTML and plain text**
 19 | 
 20 | ## Usage
 21 | 
 22 | ### Deno
 23 | 
 24 | First install the package:
 25 | 
 26 | ```sh
 27 | $ deno add @arendjr/text-clipper
 28 | ```
 29 | 
 30 | Once installed, you can use it as follows:
 31 | 
 32 | ```js
 33 | import clip from "@arendjr/text-clipper";
 34 | 
 35 | const clippedString = clip(string, 80); // returns a string of at most 80 characters
 36 | 
 37 | const clippedHtml = clip(htmlString, 140, { html: true, maxLines: 5 });
 38 | ```
 39 | 
 40 | ### Bun
 41 | 
 42 | Install using the following command instead:
 43 | 
 44 | ```sh
 45 | $ bunx jsr add @arendjr/text-clipper
 46 | ```
 47 | 
 48 | For usage instructions, see above.
 49 | 
 50 | ### Node.js
 51 | 
 52 | Install using one of the following commands, depending on your package manager:
 53 | 
 54 | ```sh
 55 | $ npx jsr add @arendjr/text-clipper # If using NPM
 56 | $ yarn dlx jsr add @arendjr/text-clipper # If using Yarn
 57 | $ pnpm dlx jsr add @arendjr/text-clipper # If using PNPM
 58 | ```
 59 | 
 60 | For usage instructions, see above.
 61 | 
 62 | ## Options
 63 | 
 64 | ### breakWords
 65 | 
 66 | By default, text-clipper tries to break only at word boundaries so words don't get clipped halfway.
 67 | Set this option to `true` if you want words to be broken up.
 68 | 
 69 | ### html
 70 | 
 71 | By default, text-clipper treats the input string as plain text. This is undesirable if the input
 72 | string is HTML, because it might result in broken HTML tags. Set this option to `true` to make
 73 | text-clipper treat the input as HTML, in which case it will try to always return valid HTML,
 74 | provided the input is valid as well.
 75 | 
 76 | ### imageWeight
 77 | 
 78 | The amount of characters to assume for images. This is used whenever an image is encountered, but
 79 | also for embedded SVG and MathML content. The default is 2.
 80 | 
 81 | ### indicator
 82 | 
 83 | The string to insert to indicate the string was clipped. Default: `'…'`.
 84 | 
 85 | Note that the indicator is never inserted if only whitespace remains after the clipping point.
 86 | 
 87 | ### insertIndicatorAtLinebreak
 88 | 
 89 | Whether the indicator should be inserted when the text is clipped at a linebreak. Default: `true`.
 90 | 
 91 | ### maxLines
 92 | 
 93 | Maximum amount of lines allowed. If given, the string will be clipped either at the moment the
 94 | maximum amount of characters is exceeded or the moment maxLines newlines are discovered, whichever
 95 | comes first.
 96 | 
 97 | Note when in HTML mode, block-level elements trigger newlines and text-clipper assumes the text
 98 | will be displayed with a CSS white-space setting that treats `\n` as a line break. Of course the
 99 | HTML tag `<br>` is also counted.
100 | 
101 | ### stripTags
102 | 
103 | Optional list of tags to be stripped from the input HTML. May be set to `true` to strip all tags.
104 | Only supported in combination with `html: true`.
105 | 
106 | Example:
107 | 
108 | ```js
109 | // Strips all images from the input string:
110 | clip(input, 140, { html: true, stripTags: ["img", "svg"] });
111 | ```
112 | 
113 | Tag names must be specified in lowercase.
114 | 
115 | ## Changelog
116 | 
117 | See [CHANGELOG.md](CHANGELOG.md).
118 | 
119 | ## License
120 | 
121 | Licensed under the MIT License.
122 | 
123 | See [LICENSE](LICENSE).
124 | 


--------------------------------------------------------------------------------
/biome.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
 3 |     "formatter": {
 4 |         "enabled": true,
 5 |         "formatWithErrors": false,
 6 |         "indentStyle": "space",
 7 |         "indentWidth": 4,
 8 |         "lineEnding": "lf",
 9 |         "lineWidth": 100,
10 |         "attributePosition": "auto"
11 |     },
12 |     "files": {
13 |         "ignore": ["dist"]
14 |     },
15 |     "organizeImports": { "enabled": true },
16 |     "linter": {
17 |         "enabled": true,
18 |         "rules": {
19 |             "recommended": true,
20 |             "style": {
21 |                 "noNonNullAssertion": "off",
22 |                 "noParameterAssign": "off",
23 |                 "noUselessElse": "off",
24 |                 "useNumberNamespace": "off"
25 |             }
26 |         }
27 |     },
28 |     "javascript": {
29 |         "formatter": {
30 |             "jsxQuoteStyle": "double",
31 |             "quoteProperties": "asNeeded",
32 |             "trailingCommas": "all",
33 |             "semicolons": "always",
34 |             "arrowParentheses": "always",
35 |             "bracketSpacing": true,
36 |             "bracketSameLine": false,
37 |             "quoteStyle": "double",
38 |             "attributePosition": "auto"
39 |         }
40 |     },
41 |     "overrides": [{ "include": ["tests/perf/benchmark/*"], "linter": { "enabled": false } }]
42 | }
43 | 


--------------------------------------------------------------------------------
/deno.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "@arendjr/text-clipper",
 3 |     "version": "3.0.0",
 4 |     "compilerOptions": {
 5 |         "allowJs": true,
 6 |         "strict": true
 7 |     },
 8 |     "exports": "./src/index.ts",
 9 |     "lock": false,
10 |     "publish": {
11 |         "include": ["src"]
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
  1 | interface CommonClipOptions {
  2 |     /**
  3 |      * By default, we try to break only at word boundaries. Set to true if this is undesired.
  4 |      */
  5 |     breakWords?: boolean;
  6 | 
  7 |     /**
  8 |      * Set to `true` if the string is HTML-encoded. If so, this method will take extra care to make
  9 |      * sure the HTML-encoding is correctly maintained.
 10 |      */
 11 |     html?: boolean;
 12 | 
 13 |     /**
 14 |      * The string to insert to indicate clipping. Default: "…".
 15 |      */
 16 |     indicator?: string;
 17 | 
 18 |     /**
 19 |      * Whether the indicator should be inserted when the text is clipped at a linebreak.
 20 |      *
 21 |      * Default: `true`.
 22 |      */
 23 |     insertIndicatorAtLinebreak?: boolean;
 24 | 
 25 |     /**
 26 |      * Maximum amount of lines allowed. If given, the string will be clipped either at the moment
 27 |      * the maximum amount of characters is exceeded or the moment maxLines newlines are discovered,
 28 |      * whichever comes first.
 29 |      */
 30 |     maxLines?: number;
 31 | }
 32 | 
 33 | interface ClipPlainTextOptions extends CommonClipOptions {
 34 |     html?: false;
 35 | }
 36 | 
 37 | interface ClipHtmlOptions extends CommonClipOptions {
 38 |     html: true;
 39 | 
 40 |     /**
 41 |      * The amount of characters to assume for images. This is used whenever an image is encountered,
 42 |      * but also for SVG and MathML content. Default: `2`.
 43 |      */
 44 |     imageWeight?: number;
 45 | 
 46 |     /**
 47 |      * Optional list of tags to be stripped from the output. If `true`, all tags are stripped.
 48 |      *
 49 |      * Tag names must be specified in lowercase.
 50 |      */
 51 |     stripTags?: Array<string> | true;
 52 | }
 53 | 
 54 | type ClipOptions = ClipPlainTextOptions | ClipHtmlOptions;
 55 | 
 56 | // Void elements are elements without inner content,
 57 | // which close themselves regardless of trailing slash.
 58 | // E.g. both <br> and <br /> are self-closing.
 59 | const VOID_ELEMENTS = [
 60 |     "area",
 61 |     "base",
 62 |     "br",
 63 |     "col",
 64 |     "command",
 65 |     "embed",
 66 |     "hr",
 67 |     "img",
 68 |     "input",
 69 |     "keygen",
 70 |     "link",
 71 |     "meta",
 72 |     "param",
 73 |     "source",
 74 |     "track",
 75 |     "wbr",
 76 | ];
 77 | 
 78 | // Block elements trigger newlines where they're inserted,
 79 | // and are always safe places for truncation.
 80 | const BLOCK_ELEMENTS = [
 81 |     "address",
 82 |     "article",
 83 |     "aside",
 84 |     "blockquote",
 85 |     "canvas",
 86 |     "dd",
 87 |     "div",
 88 |     "dl",
 89 |     "dt",
 90 |     "fieldset",
 91 |     "figcaption",
 92 |     "figure",
 93 |     "footer",
 94 |     "form",
 95 |     "h1",
 96 |     "h2",
 97 |     "h3",
 98 |     "h4",
 99 |     "h5",
100 |     "h6",
101 |     "header",
102 |     "hgroup",
103 |     "hr",
104 |     "li",
105 |     "main",
106 |     "nav",
107 |     "noscript",
108 |     "ol",
109 |     "output",
110 |     "p",
111 |     "pre",
112 |     "section",
113 |     "table",
114 |     "tbody",
115 |     "tfoot",
116 |     "thead",
117 |     "tr",
118 |     "ul",
119 |     "video",
120 | ];
121 | 
122 | // Elements that are unbreakable: they are either included verbatim, or omitted entirely.
123 | const UNBREAKABLE_ELEMENTS = ["audio", "math", "svg", "video"];
124 | 
125 | const NEWLINE_CHAR_CODE = 10; // '\n'
126 | const EXCLAMATION_CHAR_CODE = 33; // '!'
127 | const DOUBLE_QUOTE_CHAR_CODE = 34; // '"'
128 | const AMPERSAND_CHAR_CODE = 38; // '&'
129 | const SINGLE_QUOTE_CHAR_CODE = 39; // '\''
130 | const FORWARD_SLASH_CHAR_CODE = 47; // '/'
131 | const SEMICOLON_CHAR_CODE = 59; // ';'
132 | const TAG_OPEN_CHAR_CODE = 60; // '<'
133 | const EQUAL_SIGN_CHAR_CODE = 61; // '='
134 | const TAG_CLOSE_CHAR_CODE = 62; // '>'
135 | 
136 | const CHAR_OF_INTEREST_REGEX = /[<&\n\ud800-\udbff]/;
137 | const CHAR_OF_INTEREST_NO_NEWLINE_REGEX = /[<&\ud800-\udbff]/;
138 | 
139 | const SIMPLIFY_WHITESPACE_REGEX = /\s+/g;
140 | 
141 | /**
142 |  * Clips a string to a maximum length. If the string exceeds the length, it is truncated and an
143 |  * indicator (an ellipsis, by default) is appended.
144 |  *
145 |  * In detail, the clipping rules are as follows:
146 |  * - The resulting clipped string may never contain more than maxLength characters. Examples:
147 |  *   - clip("foo", 3) => "foo"
148 |  *   - clip("foo", 2) => "f…"
149 |  * - The indicator is inserted if and only if the string is clipped at any place other than a
150 |  *   newline. Examples:
151 |  *   - clip("foo bar", 5) => "foo …"
152 |  *   - clip("foo\nbar", 5) => "foo"
153 |  * - If the html option is true and valid HTML is inserted, the clipped output *must* also be valid
154 |  *   HTML. If the input is not valid HTML, the result is undefined (not to be confused with JS'
155 |  *   "undefined" type; some errors might be detected and result in an exception, but this is not
156 |  *   guaranteed).
157 |  *
158 |  * @param string The string to clip.
159 |  * @param maxLength The maximum length of the clipped string in number of characters.
160 |  * @param options Optional options object.
161 |  *
162 |  * @return The clipped string.
163 |  */
164 | export default function clip(string: string, maxLength: number, options: ClipOptions = {}): string {
165 |     if (!string) {
166 |         return "";
167 |     }
168 | 
169 |     string = string.toString();
170 | 
171 |     return options.html
172 |         ? clipHtml(string, maxLength, options)
173 |         : clipPlainText(string, maxLength, options);
174 | }
175 | 
176 | function clipHtml(string: string, maxLength: number, options: ClipHtmlOptions): string {
177 |     const {
178 |         imageWeight = 2,
179 |         indicator = "\u2026",
180 |         insertIndicatorAtLinebreak = true,
181 |         maxLines = Infinity,
182 |         stripTags = false,
183 |     } = options;
184 | 
185 |     let numChars = indicator.length;
186 |     let numLines = 1;
187 | 
188 |     const shouldStrip =
189 |         typeof stripTags === "boolean"
190 |             ? () => stripTags
191 |             : (tagName: string) => stripTags.includes(tagName);
192 | 
193 |     const tagStack: Array<string> = []; // Stack of currently open HTML tags.
194 |     const popTagStack = (result: string) => {
195 |         let tagName: string | undefined;
196 |         // biome-ignore lint/style/noCommaOperator: Otherwise we need to pop...
197 |         // biome-ignore lint/suspicious/noAssignInExpressions: ... in two places.
198 |         while (((tagName = tagStack.pop()), tagName !== undefined)) {
199 |             if (!shouldStrip(tagName)) {
200 |                 result += `</${tagName}>`;
201 |             }
202 |         }
203 |         return result;
204 |     };
205 | 
206 |     let i = 0;
207 |     let unbreakableElementIndex = -1;
208 |     const { length } = string;
209 |     for (; i < length; i++) {
210 |         const rest = i ? string.slice(i) : string;
211 |         const willSimplifyWhiteSpace = shouldSimplifyWhiteSpace(tagStack);
212 |         const regex =
213 |             unbreakableElementIndex > -1 || willSimplifyWhiteSpace
214 |                 ? CHAR_OF_INTEREST_NO_NEWLINE_REGEX
215 |                 : CHAR_OF_INTEREST_REGEX;
216 |         const nextIndex = rest.search(regex);
217 |         let nextBlockSize = nextIndex > -1 ? nextIndex : rest.length;
218 | 
219 |         if (unbreakableElementIndex === -1) {
220 |             if (willSimplifyWhiteSpace) {
221 |                 let simplifiedBlock = simplifyWhiteSpace(
222 |                     nextBlockSize === rest.length ? rest : rest.slice(0, nextIndex),
223 |                 );
224 | 
225 |                 if (shouldStrip(tagStack[tagStack.length - 1]!)) {
226 |                     // We want to strip whitespace, but we need to insert spaces if stripping the
227 |                     // tags and whitespace together would otherwise inadvertently concatenate words:
228 |                     const insertSpaceBefore = i > 0 && !isWhiteSpace(string.charCodeAt(i - 1));
229 |                     const insertSpaceAfter = !isWhiteSpace(string.charCodeAt(i + nextBlockSize));
230 |                     if (simplifiedBlock.length > 0) {
231 |                         simplifiedBlock =
232 |                             (insertSpaceBefore ? " " : "") +
233 |                             simplifiedBlock +
234 |                             (insertSpaceAfter ? " " : "");
235 |                     } else if (insertSpaceBefore && insertSpaceAfter) {
236 |                         simplifiedBlock = " ";
237 |                     }
238 | 
239 |                     string = string.slice(0, i) + simplifiedBlock + string.slice(i + nextBlockSize);
240 |                     nextBlockSize = simplifiedBlock.length;
241 |                 }
242 | 
243 |                 numChars += simplifiedBlock.length;
244 |                 if (numChars > maxLength) {
245 |                     break;
246 |                 }
247 |             } else {
248 |                 numChars += nextBlockSize;
249 |                 if (numChars > maxLength) {
250 |                     i = Math.max(i + nextBlockSize - numChars + maxLength, 0);
251 |                     break;
252 |                 }
253 |             }
254 |         }
255 | 
256 |         i += nextBlockSize;
257 | 
258 |         if (nextIndex === -1) {
259 |             break;
260 |         }
261 | 
262 |         const charCode = string.charCodeAt(i);
263 |         if (charCode === TAG_OPEN_CHAR_CODE) {
264 |             const nextCharCode = string.charCodeAt(i + 1);
265 |             const isSpecialTag = nextCharCode === EXCLAMATION_CHAR_CODE;
266 |             if (isSpecialTag && string.substr(i + 2, 2) === "--") {
267 |                 const commentEndIndex = string.indexOf("-->", i + 4) + 3;
268 |                 i = commentEndIndex - 1; // - 1 because the outer for loop will increment it
269 |             } else if (isSpecialTag && string.substr(i + 2, 7) === "[CDATA[") {
270 |                 const cdataEndIndex = string.indexOf("]]>", i + 9) + 3;
271 |                 i = cdataEndIndex - 1; // - 1 because the outer for loop will increment it
272 | 
273 |                 // note we don't count CDATA text for our character limit because it is only
274 |                 // allowed within SVG and MathML content, both of which we don't clip
275 |             } else {
276 |                 // don't open new tags if we are currently at the limit
277 |                 const isEndTag = nextCharCode === FORWARD_SLASH_CHAR_CODE;
278 |                 if (numChars === maxLength && !isEndTag) {
279 |                     numChars++;
280 |                     break;
281 |                 }
282 | 
283 |                 let attributeQuoteCharCode = 0;
284 |                 let endIndex = i;
285 |                 let isAttributeValue = false;
286 |                 while (true /* eslint-disable-line */) {
287 |                     endIndex++;
288 |                     if (endIndex >= length) {
289 |                         throw new Error(`Invalid HTML: ${string}`);
290 |                     }
291 | 
292 |                     const charCode = string.charCodeAt(endIndex);
293 |                     if (isAttributeValue) {
294 |                         if (attributeQuoteCharCode) {
295 |                             if (charCode === attributeQuoteCharCode) {
296 |                                 isAttributeValue = false;
297 |                             }
298 |                         } else {
299 |                             if (isWhiteSpace(charCode)) {
300 |                                 isAttributeValue = false;
301 |                             } else if (charCode === TAG_CLOSE_CHAR_CODE) {
302 |                                 isAttributeValue = false;
303 |                                 endIndex--; // re-evaluate this character
304 |                             }
305 |                         }
306 |                     } else if (charCode === EQUAL_SIGN_CHAR_CODE) {
307 |                         while (isWhiteSpace(string.charCodeAt(endIndex + 1))) {
308 |                             endIndex++; // skip whitespace
309 |                         }
310 |                         isAttributeValue = true;
311 | 
312 |                         const firstAttributeCharCode = string.charCodeAt(endIndex + 1);
313 |                         if (
314 |                             firstAttributeCharCode === DOUBLE_QUOTE_CHAR_CODE ||
315 |                             firstAttributeCharCode === SINGLE_QUOTE_CHAR_CODE
316 |                         ) {
317 |                             attributeQuoteCharCode = firstAttributeCharCode;
318 |                             endIndex++;
319 |                         } else {
320 |                             attributeQuoteCharCode = 0;
321 |                         }
322 |                     } else if (charCode === TAG_CLOSE_CHAR_CODE) {
323 |                         const tagNameStartIndex = i + (isEndTag ? 2 : 1);
324 |                         const tagNameEndIndex = Math.min(
325 |                             indexOfWhiteSpace(string, tagNameStartIndex),
326 |                             endIndex,
327 |                         );
328 |                         let tagName = string
329 |                             .slice(tagNameStartIndex, tagNameEndIndex)
330 |                             .toLowerCase();
331 |                         if (tagName.charCodeAt(tagName.length - 1) === FORWARD_SLASH_CHAR_CODE) {
332 |                             // Remove trailing slash for self-closing tag names like <br/>
333 |                             tagName = tagName.slice(0, tagName.length - 1);
334 |                         }
335 | 
336 |                         const strip = shouldStrip(tagName);
337 | 
338 |                         if (isEndTag) {
339 |                             const currentTagName = tagStack.pop();
340 |                             if (currentTagName !== tagName) {
341 |                                 throw new Error(`Invalid HTML: ${string}`);
342 |                             }
343 | 
344 |                             if (UNBREAKABLE_ELEMENTS.includes(tagName)) {
345 |                                 if (
346 |                                     UNBREAKABLE_ELEMENTS.some((tagName) =>
347 |                                         tagStack.includes(tagName),
348 |                                     )
349 |                                 ) {
350 |                                     // It's a nested unbreakable element.
351 |                                 } else if (strip) {
352 |                                     i = unbreakableElementIndex;
353 |                                     unbreakableElementIndex = -1;
354 |                                 } else {
355 |                                     unbreakableElementIndex = -1;
356 |                                     numChars += imageWeight;
357 |                                     if (numChars > maxLength) {
358 |                                         break;
359 |                                     }
360 |                                 }
361 |                             }
362 | 
363 |                             // Block level elements should trigger a new line, unless stripped or
364 |                             // part of unbreakable content.
365 |                             const isBlockElement = BLOCK_ELEMENTS.includes(tagName);
366 |                             if (isBlockElement && unbreakableElementIndex === -1 && !strip) {
367 |                                 numLines++;
368 |                                 if (numLines > maxLines) {
369 |                                     // If we exceed the max lines, push the tag back onto the
370 |                                     // stack so that it will be added back correctly after
371 |                                     // truncation.
372 |                                     tagStack.push(tagName);
373 |                                     break;
374 |                                 }
375 |                             }
376 |                         } else if (
377 |                             VOID_ELEMENTS.includes(tagName) ||
378 |                             string.charCodeAt(endIndex - 1) === FORWARD_SLASH_CHAR_CODE
379 |                         ) {
380 |                             if (strip) {
381 |                                 // Stripped elements aren't counted towards anything.
382 |                             } else if (tagName === "br") {
383 |                                 numLines++;
384 |                                 if (numLines > maxLines) {
385 |                                     break;
386 |                                 }
387 |                             } else if (tagName === "img") {
388 |                                 numChars += imageWeight;
389 |                                 if (numChars > maxLength) {
390 |                                     break;
391 |                                 }
392 |                             }
393 |                         } else {
394 |                             if (
395 |                                 UNBREAKABLE_ELEMENTS.some((tagName) => tagStack.includes(tagName))
396 |                             ) {
397 |                                 // It's a nested unbreakable element.
398 |                             } else if (UNBREAKABLE_ELEMENTS.includes(tagName)) {
399 |                                 unbreakableElementIndex = i;
400 |                             }
401 |                             tagStack.push(tagName);
402 |                         }
403 | 
404 |                         if (strip && unbreakableElementIndex === -1) {
405 |                             string = string.slice(0, i) + string.slice(endIndex + 1);
406 |                             i--; // Re-evaluate this index, because its contents changed.
407 |                         } else {
408 |                             i = endIndex;
409 |                         }
410 | 
411 |                         break;
412 |                     }
413 |                 }
414 |                 if (numChars > maxLength || numLines > maxLines) {
415 |                     break;
416 |                 }
417 |             }
418 |         } else if (charCode === AMPERSAND_CHAR_CODE) {
419 |             let endIndex = i + 1;
420 |             let isCharacterReference = true;
421 |             while (true /* eslint-disable-line */) {
422 |                 const charCode = string.charCodeAt(endIndex);
423 |                 if (isCharacterReferenceCharacter(charCode)) {
424 |                     endIndex++;
425 |                 } else if (charCode === SEMICOLON_CHAR_CODE) {
426 |                     break;
427 |                 } else {
428 |                     isCharacterReference = false;
429 |                     break;
430 |                 }
431 |             }
432 | 
433 |             if (unbreakableElementIndex === -1) {
434 |                 numChars++;
435 |                 if (numChars > maxLength) {
436 |                     break;
437 |                 }
438 |             }
439 | 
440 |             if (isCharacterReference) {
441 |                 i = endIndex;
442 |             }
443 |         } else if (charCode === NEWLINE_CHAR_CODE) {
444 |             numChars++;
445 |             if (numChars > maxLength) {
446 |                 break;
447 |             }
448 | 
449 |             numLines++;
450 |             if (numLines > maxLines) {
451 |                 break;
452 |             }
453 |         } else {
454 |             if (unbreakableElementIndex === -1) {
455 |                 numChars++;
456 |                 if (numChars > maxLength) {
457 |                     break;
458 |                 }
459 |             }
460 | 
461 |             if ((charCode & 0xfc00) === 0xd800) {
462 |                 // high Unicode surrogate should never be separated from its matching low surrogate
463 |                 const nextCharCode = string.charCodeAt(i + 1);
464 |                 if ((nextCharCode & 0xfc00) === 0xdc00) {
465 |                     i++;
466 |                 }
467 |             }
468 |         }
469 |     }
470 | 
471 |     if (numChars > maxLength) {
472 |         let nextChar = takeHtmlCharAt(string, i);
473 |         if (indicator) {
474 |             let peekIndex = i + nextChar.length;
475 |             while (
476 |                 string.charCodeAt(peekIndex) === TAG_OPEN_CHAR_CODE &&
477 |                 string.charCodeAt(peekIndex + 1) === FORWARD_SLASH_CHAR_CODE
478 |             ) {
479 |                 const nextPeekIndex = string.indexOf(">", peekIndex + 2) + 1;
480 |                 if (nextPeekIndex) {
481 |                     peekIndex = nextPeekIndex;
482 |                 } else {
483 |                     break;
484 |                 }
485 |             }
486 | 
487 |             if (peekIndex && (peekIndex === string.length || isLineBreak(string, peekIndex))) {
488 |                 // if there's only a single character remaining in the input string, or the next
489 |                 // character is followed by a line-break, we can include it instead of the clipping
490 |                 // indicator (provided it's not a special HTML character)
491 |                 i += nextChar.length;
492 |                 nextChar = string.charAt(i);
493 |             }
494 |         }
495 | 
496 |         // include closing tags before adding the clipping indicator if that's where they
497 |         // are in the input string
498 |         while (nextChar === "<" && string.charCodeAt(i + 1) === FORWARD_SLASH_CHAR_CODE) {
499 |             const tagName = tagStack.pop();
500 |             if (!tagName) {
501 |                 break;
502 |             }
503 | 
504 |             const tagEndIndex = string.indexOf(">", i + 2);
505 |             if (tagEndIndex === -1 || string.slice(i + 2, tagEndIndex).trim() !== tagName) {
506 |                 throw new Error(`Invalid HTML: ${string}`);
507 |             }
508 | 
509 |             if (shouldStrip(tagName)) {
510 |                 string = string.slice(0, i) + string.slice(tagEndIndex + 1);
511 |             } else {
512 |                 i = tagEndIndex + 1;
513 |             }
514 | 
515 |             nextChar = string.charAt(i);
516 |         }
517 | 
518 |         if (i < string.length) {
519 |             if (!options.breakWords) {
520 |                 // try to clip at word boundaries, if desired
521 |                 for (let j = i - indicator.length; j >= 0; j--) {
522 |                     const charCode = string.charCodeAt(j);
523 |                     if (charCode === TAG_CLOSE_CHAR_CODE || charCode === SEMICOLON_CHAR_CODE) {
524 |                         // these characters could be just regular characters, so if they occur in
525 |                         // the middle of a word, they would "break" our attempt to prevent breaking
526 |                         // of words, but given this seems highly unlikely and the alternative is
527 |                         // doing another full parsing of the preceding text, this seems acceptable.
528 |                         break;
529 |                     } else if (charCode === NEWLINE_CHAR_CODE || charCode === TAG_OPEN_CHAR_CODE) {
530 |                         i = j;
531 |                         break;
532 |                     } else if (isWhiteSpace(charCode)) {
533 |                         i = j + (indicator ? 1 : 0);
534 |                         break;
535 |                     }
536 |                 }
537 |             }
538 | 
539 |             const insertIndicator =
540 |                 (insertIndicatorAtLinebreak || !isLineBreak(string, i)) &&
541 |                 hasHtmlNonWhitespace(string, i);
542 | 
543 |             // Don't leave awkward whitespace at the end.
544 |             while (i > 0 && isWhiteSpace(string.charCodeAt(i - 1)!)) {
545 |                 i--;
546 |             }
547 | 
548 |             return popTagStack(string.slice(0, i) + (insertIndicator ? indicator : ""));
549 |         }
550 |     } else if (numLines > maxLines) {
551 |         const insertIndicator = insertIndicatorAtLinebreak && hasHtmlNonWhitespace(string, i);
552 | 
553 |         // Don't leave awkward whitespace at the end.
554 |         while (i > 0 && isWhiteSpace(string.charCodeAt(i - 1)!)) {
555 |             i--;
556 |         }
557 | 
558 |         return popTagStack(string.slice(0, i) + (insertIndicator ? indicator : ""));
559 |     }
560 | 
561 |     return string;
562 | }
563 | 
564 | function clipPlainText(string: string, maxLength: number, options: CommonClipOptions): string {
565 |     const {
566 |         indicator = "\u2026",
567 |         insertIndicatorAtLinebreak = true,
568 |         maxLines = Infinity,
569 |     } = options;
570 | 
571 |     let numChars = indicator.length;
572 |     let numLines = 1;
573 | 
574 |     let i = 0;
575 |     const { length } = string;
576 |     for (; i < length; i++) {
577 |         numChars++;
578 |         if (numChars > maxLength) {
579 |             break;
580 |         }
581 | 
582 |         const charCode = string.charCodeAt(i);
583 |         if (charCode === NEWLINE_CHAR_CODE) {
584 |             numLines++;
585 |             if (numLines > maxLines) {
586 |                 break;
587 |             }
588 |         } else if ((charCode & 0xfc00) === 0xd800) {
589 |             // high Unicode surrogate should never be separated from its matching low surrogate
590 |             const nextCharCode = string.charCodeAt(i + 1);
591 |             if ((nextCharCode & 0xfc00) === 0xdc00) {
592 |                 i++;
593 |             }
594 |         }
595 |     }
596 | 
597 |     if (numChars > maxLength) {
598 |         let nextChar = takeCharAt(string, i);
599 |         if (indicator) {
600 |             const peekIndex = i + nextChar.length;
601 |             if (peekIndex === string.length) {
602 |                 return string;
603 |             } else if (string.charCodeAt(peekIndex) === NEWLINE_CHAR_CODE) {
604 |                 const insertIndicator =
605 |                     insertIndicatorAtLinebreak && hasNonWhitespace(string, peekIndex);
606 |                 return string.slice(0, peekIndex) + (insertIndicator ? indicator : "");
607 |             }
608 |         }
609 | 
610 |         if (!options.breakWords) {
611 |             // try to clip at word boundaries, if desired
612 |             for (let j = i - indicator.length; j >= 0; j--) {
613 |                 const charCode = string.charCodeAt(j);
614 |                 if (charCode === NEWLINE_CHAR_CODE) {
615 |                     i = j;
616 |                     nextChar = "\n";
617 |                     break;
618 |                 } else if (isWhiteSpace(charCode)) {
619 |                     i = j + (indicator ? 1 : 0);
620 |                     break;
621 |                 }
622 |             }
623 |         }
624 | 
625 |         const insertIndicator =
626 |             (insertIndicatorAtLinebreak || nextChar !== "\n") && hasNonWhitespace(string, i);
627 | 
628 |         // Don't leave awkward whitespace at the end.
629 |         while (i > 0 && isWhiteSpace(string.charCodeAt(i - 1)!)) {
630 |             i--;
631 |         }
632 | 
633 |         return string.slice(0, i) + (insertIndicator ? indicator : "");
634 |     } else if (numLines > maxLines) {
635 |         const insertIndicator = insertIndicatorAtLinebreak && hasNonWhitespace(string, i);
636 | 
637 |         // Don't leave awkward whitespace at the end.
638 |         while (i > 0 && isWhiteSpace(string.charCodeAt(i - 1)!)) {
639 |             i--;
640 |         }
641 | 
642 |         return string.slice(0, i) + (insertIndicator ? indicator : "");
643 |     }
644 | 
645 |     return string;
646 | }
647 | 
648 | function hasHtmlNonWhitespace(string: string, fromIndex: number): boolean {
649 |     const { length } = string;
650 |     for (let i = fromIndex; i < length; i++) {
651 |         const charCode = string.charCodeAt(i);
652 |         if (charCode === TAG_OPEN_CHAR_CODE) {
653 |             do {
654 |                 i++;
655 |             } while (i < length && isWhiteSpace(string.charCodeAt(i)));
656 |             if (string.charCodeAt(i) === FORWARD_SLASH_CHAR_CODE) {
657 |                 do {
658 |                     i++;
659 |                 } while (i < length && string.charCodeAt(i) !== TAG_CLOSE_CHAR_CODE);
660 |             } else {
661 |                 return true;
662 |             }
663 |         } else if (!isWhiteSpace(charCode)) {
664 |             return true;
665 |         }
666 |     }
667 |     return false;
668 | }
669 | 
670 | function hasNonWhitespace(string: string, fromIndex: number): boolean {
671 |     const { length } = string;
672 |     for (let i = fromIndex; i < length; i++) {
673 |         if (!isWhiteSpace(string.charCodeAt(i))) {
674 |             return true;
675 |         }
676 |     }
677 |     return false;
678 | }
679 | 
680 | function indexOfWhiteSpace(string: string, fromIndex: number): number {
681 |     const { length } = string;
682 |     for (let i = fromIndex; i < length; i++) {
683 |         if (isWhiteSpace(string.charCodeAt(i))) {
684 |             return i;
685 |         }
686 |     }
687 |     // Rather than -1, this function returns the length of the string if no match is found,
688 |     // so it works well with the Math.min() usage above:
689 |     return length;
690 | }
691 | 
692 | function isCharacterReferenceCharacter(charCode: number): boolean {
693 |     return (
694 |         (charCode >= 48 && charCode <= 57) ||
695 |         (charCode >= 65 && charCode <= 90) ||
696 |         (charCode >= 97 && charCode <= 122)
697 |     );
698 | }
699 | 
700 | function isLineBreak(string: string, index: number): boolean {
701 |     switch (string.charCodeAt(index)) {
702 |         case NEWLINE_CHAR_CODE:
703 |             return true;
704 |         case TAG_OPEN_CHAR_CODE: {
705 |             const newlineElements = `(${BLOCK_ELEMENTS.join("|")}|br)`;
706 |             const newlineRegExp = new RegExp(`^<${newlineElements}[\t\n\f\r ]*/?>`, "i");
707 |             return newlineRegExp.test(string.slice(index));
708 |         }
709 |         default:
710 |             return false;
711 |     }
712 | }
713 | 
714 | function isWhiteSpace(charCode: number): boolean {
715 |     return (
716 |         charCode === 9 || charCode === 10 || charCode === 12 || charCode === 13 || charCode === 32
717 |     );
718 | }
719 | 
720 | /**
721 |  * Certain tags don't display their whitespace-only content. In such cases, we
722 |  * should simplify the whitespace before counting it.
723 |  */
724 | function shouldSimplifyWhiteSpace(tagStack: Array<string>): boolean {
725 |     for (let i = tagStack.length - 1; i >= 0; i--) {
726 |         const tagName = tagStack[i];
727 |         if (tagName === "li" || tagName === "td") {
728 |             return false;
729 |         }
730 |         if (tagName === "ol" || tagName === "table" || tagName === "ul") {
731 |             return true;
732 |         }
733 |     }
734 |     return false;
735 | }
736 | 
737 | function simplifyWhiteSpace(string: string): string {
738 |     return string.trim().replace(SIMPLIFY_WHITESPACE_REGEX, " ");
739 | }
740 | 
741 | function takeCharAt(string: string, index: number): string {
742 |     const charCode = string.charCodeAt(index);
743 |     if ((charCode & 0xfc00) === 0xd800) {
744 |         // high Unicode surrogate should never be separated from its matching low surrogate
745 |         const nextCharCode = string.charCodeAt(index + 1);
746 |         if ((nextCharCode & 0xfc00) === 0xdc00) {
747 |             return String.fromCharCode(charCode, nextCharCode);
748 |         }
749 |     }
750 |     return String.fromCharCode(charCode);
751 | }
752 | 
753 | function takeHtmlCharAt(string: string, index: number): string {
754 |     let char = takeCharAt(string, index);
755 |     if (char === "&") {
756 |         while (true /* eslint-disable-line */) {
757 |             index++;
758 |             const nextCharCode = string.charCodeAt(index);
759 |             if (isCharacterReferenceCharacter(nextCharCode)) {
760 |                 char += String.fromCharCode(nextCharCode);
761 |             } else if (nextCharCode === SEMICOLON_CHAR_CODE) {
762 |                 char += String.fromCharCode(nextCharCode);
763 |                 break;
764 |             } else {
765 |                 break;
766 |             }
767 |         }
768 |     }
769 |     return char;
770 | }
771 | 


--------------------------------------------------------------------------------
/tests/perf/benchmark/baseline.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | Object.defineProperty(exports, "__esModule", { value: true });
  3 | // Void elements are elements without inner content,
  4 | // which close themselves regardless of trailing slash.
  5 | // E.g. both <br> and <br /> are self-closing.
  6 | var VOID_ELEMENTS = [
  7 |     "area",
  8 |     "base",
  9 |     "br",
 10 |     "col",
 11 |     "command",
 12 |     "embed",
 13 |     "hr",
 14 |     "img",
 15 |     "input",
 16 |     "keygen",
 17 |     "link",
 18 |     "meta",
 19 |     "param",
 20 |     "source",
 21 |     "track",
 22 |     "wbr",
 23 | ];
 24 | // Block elements trigger newlines where they're inserted,
 25 | // and are always safe places for truncation.
 26 | var BLOCK_ELEMENTS = [
 27 |     "address",
 28 |     "article",
 29 |     "aside",
 30 |     "blockquote",
 31 |     "canvas",
 32 |     "dd",
 33 |     "div",
 34 |     "dl",
 35 |     "dt",
 36 |     "fieldset",
 37 |     "figcaption",
 38 |     "figure",
 39 |     "footer",
 40 |     "form",
 41 |     "h1",
 42 |     "h2",
 43 |     "h3",
 44 |     "h4",
 45 |     "h5",
 46 |     "h6",
 47 |     "header",
 48 |     "hgroup",
 49 |     "hr",
 50 |     "li",
 51 |     "main",
 52 |     "nav",
 53 |     "noscript",
 54 |     "ol",
 55 |     "output",
 56 |     "p",
 57 |     "pre",
 58 |     "section",
 59 |     "table",
 60 |     "tbody",
 61 |     "tfoot",
 62 |     "thead",
 63 |     "tr",
 64 |     "ul",
 65 |     "video",
 66 | ];
 67 | var NEWLINE_CHAR_CODE = 10; // '\n'
 68 | var EXCLAMATION_CHAR_CODE = 33; // '!'
 69 | var DOUBLE_QUOTE_CHAR_CODE = 34; // '"'
 70 | var AMPERSAND_CHAR_CODE = 38; // '&'
 71 | var SINGLE_QUOTE_CHAR_CODE = 39; // '\''
 72 | var FORWARD_SLASH_CHAR_CODE = 47; // '/'
 73 | var SEMICOLON_CHAR_CODE = 59; // ';'
 74 | var TAG_OPEN_CHAR_CODE = 60; // '<'
 75 | var EQUAL_SIGN_CHAR_CODE = 61; // '='
 76 | var TAG_CLOSE_CHAR_CODE = 62; // '>'
 77 | var CHAR_OF_INTEREST_REGEX = /[<&\n\ud800-\udbff]/;
 78 | var SIMPLIFY_WHITESPACE_REGEX = /\s{2,}/g;
 79 | /**
 80 |  * Clips a string to a maximum length. If the string exceeds the length, it is truncated and an
 81 |  * indicator (an ellipsis, by default) is appended.
 82 |  *
 83 |  * In detail, the clipping rules are as follows:
 84 |  * - The resulting clipped string may never contain more than maxLength characters. Examples:
 85 |  *   - clip("foo", 3) => "foo"
 86 |  *   - clip("foo", 2) => "f…"
 87 |  * - The indicator is inserted if and only if the string is clipped at any place other than a
 88 |  *   newline. Examples:
 89 |  *   - clip("foo bar", 5) => "foo …"
 90 |  *   - clip("foo\nbar", 5) => "foo"
 91 |  * - If the html option is true and valid HTML is inserted, the clipped output *must* also be valid
 92 |  *   HTML. If the input is not valid HTML, the result is undefined (not to be confused with JS'
 93 |  *   "undefined" type; some errors might be detected and result in an exception, but this is not
 94 |  *   guaranteed).
 95 |  *
 96 |  * @param string The string to clip.
 97 |  * @param maxLength The maximum length of the clipped string in number of characters.
 98 |  * @param options Optional options object.
 99 |  *
100 |  * @return The clipped string.
101 |  */
102 | function clip(string, maxLength, options) {
103 |     if (options === void 0) {
104 |         options = {};
105 |     }
106 |     if (!string) {
107 |         return "";
108 |     }
109 |     string = string.toString();
110 |     return options.html
111 |         ? clipHtml(string, maxLength, options)
112 |         : clipPlainText(string, maxLength, options);
113 | }
114 | exports.default = clip;
115 | function clipHtml(string, maxLength, options) {
116 |     var _a = options.imageWeight,
117 |         imageWeight = _a === void 0 ? 2 : _a,
118 |         _b = options.indicator,
119 |         indicator = _b === void 0 ? "\u2026" : _b,
120 |         _c = options.maxLines,
121 |         maxLines = _c === void 0 ? Infinity : _c;
122 |     var numChars = indicator.length;
123 |     var numLines = 1;
124 |     var i = 0;
125 |     var isUnbreakableContent = false;
126 |     var tagStack = []; // Stack of currently open HTML tags.
127 |     var length = string.length;
128 |     for (; i < length; i++) {
129 |         var rest = i ? string.slice(i) : string;
130 |         var nextIndex = rest.search(CHAR_OF_INTEREST_REGEX);
131 |         var nextBlockSize = nextIndex > -1 ? nextIndex : rest.length;
132 |         i += nextBlockSize;
133 |         if (!isUnbreakableContent) {
134 |             if (shouldSimplifyWhiteSpace(tagStack)) {
135 |                 numChars += simplifyWhiteSpace(
136 |                     nextBlockSize === rest.length ? rest : rest.slice(0, nextIndex),
137 |                 ).length;
138 |                 if (numChars > maxLength) {
139 |                     i -= nextBlockSize; // We just cut off the entire incorrectly placed text...
140 |                     break;
141 |                 }
142 |             } else {
143 |                 numChars += nextBlockSize;
144 |                 if (numChars > maxLength) {
145 |                     i = Math.max(i - numChars + maxLength, 0);
146 |                     break;
147 |                 }
148 |             }
149 |         }
150 |         if (nextIndex === -1) {
151 |             break;
152 |         }
153 |         var charCode = string.charCodeAt(i);
154 |         if (charCode === TAG_OPEN_CHAR_CODE) {
155 |             var nextCharCode = string.charCodeAt(i + 1);
156 |             var isSpecialTag = nextCharCode === EXCLAMATION_CHAR_CODE;
157 |             if (isSpecialTag && string.substr(i + 2, 2) === "--") {
158 |                 var commentEndIndex = string.indexOf("-->", i + 4) + 3;
159 |                 i = commentEndIndex - 1; // - 1 because the outer for loop will increment it
160 |             } else if (isSpecialTag && string.substr(i + 2, 7) === "[CDATA[") {
161 |                 var cdataEndIndex = string.indexOf("]]>", i + 9) + 3;
162 |                 i = cdataEndIndex - 1; // - 1 because the outer for loop will increment it
163 |                 // note we don't count CDATA text for our character limit because it is only
164 |                 // allowed within SVG and MathML content, both of which we don't clip
165 |             } else {
166 |                 // don't open new tags if we are currently at the limit
167 |                 if (
168 |                     numChars === maxLength &&
169 |                     string.charCodeAt(i + 1) !== FORWARD_SLASH_CHAR_CODE
170 |                 ) {
171 |                     numChars++;
172 |                     break;
173 |                 }
174 |                 var attributeQuoteCharCode = 0;
175 |                 var endIndex = i;
176 |                 var isAttributeValue = false;
177 |                 while (true /* eslint-disable-line */) {
178 |                     endIndex++;
179 |                     if (endIndex >= length) {
180 |                         throw new Error("Invalid HTML: " + string);
181 |                     }
182 |                     var charCode_1 = string.charCodeAt(endIndex);
183 |                     if (isAttributeValue) {
184 |                         if (attributeQuoteCharCode) {
185 |                             if (charCode_1 === attributeQuoteCharCode) {
186 |                                 isAttributeValue = false;
187 |                             }
188 |                         } else {
189 |                             if (isWhiteSpace(charCode_1)) {
190 |                                 isAttributeValue = false;
191 |                             } else if (charCode_1 === TAG_CLOSE_CHAR_CODE) {
192 |                                 isAttributeValue = false;
193 |                                 endIndex--; // re-evaluate this character
194 |                             }
195 |                         }
196 |                     } else if (charCode_1 === EQUAL_SIGN_CHAR_CODE) {
197 |                         while (isWhiteSpace(string.charCodeAt(endIndex + 1))) {
198 |                             endIndex++; // skip whitespace
199 |                         }
200 |                         isAttributeValue = true;
201 |                         var firstAttributeCharCode = string.charCodeAt(endIndex + 1);
202 |                         if (
203 |                             firstAttributeCharCode === DOUBLE_QUOTE_CHAR_CODE ||
204 |                             firstAttributeCharCode === SINGLE_QUOTE_CHAR_CODE
205 |                         ) {
206 |                             attributeQuoteCharCode = firstAttributeCharCode;
207 |                             endIndex++;
208 |                         } else {
209 |                             attributeQuoteCharCode = 0;
210 |                         }
211 |                     } else if (charCode_1 === TAG_CLOSE_CHAR_CODE) {
212 |                         var isEndTag = string.charCodeAt(i + 1) === FORWARD_SLASH_CHAR_CODE;
213 |                         var tagNameStartIndex = i + (isEndTag ? 2 : 1);
214 |                         var tagNameEndIndex = Math.min(
215 |                             indexOfWhiteSpace(string, tagNameStartIndex),
216 |                             endIndex,
217 |                         );
218 |                         var tagName = string
219 |                             .slice(tagNameStartIndex, tagNameEndIndex)
220 |                             .toLowerCase();
221 |                         if (tagName.charCodeAt(tagName.length - 1) === FORWARD_SLASH_CHAR_CODE) {
222 |                             // Remove trailing slash for self-closing tag names like <br/>
223 |                             tagName = tagName.slice(0, tagName.length - 1);
224 |                         }
225 |                         if (isEndTag) {
226 |                             var currentTagName = tagStack.pop();
227 |                             if (currentTagName !== tagName) {
228 |                                 throw new Error("Invalid HTML: " + string);
229 |                             }
230 |                             if (tagName === "math" || tagName === "svg") {
231 |                                 isUnbreakableContent =
232 |                                     tagStack.includes("math") || tagStack.includes("svg");
233 |                                 if (!isUnbreakableContent) {
234 |                                     numChars += imageWeight;
235 |                                     if (numChars > maxLength) {
236 |                                         break;
237 |                                     }
238 |                                 }
239 |                             }
240 |                             if (BLOCK_ELEMENTS.includes(tagName)) {
241 |                                 // All block level elements should trigger a new line
242 |                                 // when truncating
243 |                                 if (!isUnbreakableContent) {
244 |                                     numLines++;
245 |                                     if (numLines > maxLines) {
246 |                                         // If we exceed the max lines, push the tag back onto the
247 |                                         // stack so that it will be added back correctly after
248 |                                         // truncation
249 |                                         tagStack.push(tagName);
250 |                                         break;
251 |                                     }
252 |                                 }
253 |                             }
254 |                         } else if (
255 |                             VOID_ELEMENTS.includes(tagName) ||
256 |                             string.charCodeAt(endIndex - 1) === FORWARD_SLASH_CHAR_CODE
257 |                         ) {
258 |                             if (tagName === "br") {
259 |                                 numLines++;
260 |                                 if (numLines > maxLines) {
261 |                                     break;
262 |                                 }
263 |                             } else if (tagName === "img") {
264 |                                 numChars += imageWeight;
265 |                                 if (numChars > maxLength) {
266 |                                     break;
267 |                                 }
268 |                             }
269 |                         } else {
270 |                             tagStack.push(tagName);
271 |                             if (tagName === "math" || tagName === "svg") {
272 |                                 isUnbreakableContent = true;
273 |                             }
274 |                         }
275 |                         i = endIndex;
276 |                         break;
277 |                     }
278 |                 }
279 |                 if (numChars > maxLength || numLines > maxLines) {
280 |                     break;
281 |                 }
282 |             }
283 |         } else if (charCode === AMPERSAND_CHAR_CODE) {
284 |             var endIndex = i + 1;
285 |             var isCharacterReference = true;
286 |             while (true /* eslint-disable-line */) {
287 |                 var charCode_2 = string.charCodeAt(endIndex);
288 |                 if (isCharacterReferenceCharacter(charCode_2)) {
289 |                     endIndex++;
290 |                 } else if (charCode_2 === SEMICOLON_CHAR_CODE) {
291 |                     break;
292 |                 } else {
293 |                     isCharacterReference = false;
294 |                     break;
295 |                 }
296 |             }
297 |             if (!isUnbreakableContent) {
298 |                 numChars++;
299 |                 if (numChars > maxLength) {
300 |                     break;
301 |                 }
302 |             }
303 |             if (isCharacterReference) {
304 |                 i = endIndex;
305 |             }
306 |         } else if (charCode === NEWLINE_CHAR_CODE) {
307 |             if (!isUnbreakableContent && !shouldSimplifyWhiteSpace(tagStack)) {
308 |                 numChars++;
309 |                 if (numChars > maxLength) {
310 |                     break;
311 |                 }
312 |                 numLines++;
313 |                 if (numLines > maxLines) {
314 |                     break;
315 |                 }
316 |             }
317 |         } else {
318 |             if (!isUnbreakableContent) {
319 |                 numChars++;
320 |                 if (numChars > maxLength) {
321 |                     break;
322 |                 }
323 |             }
324 |             // high Unicode surrogate should never be separated from its matching low surrogate
325 |             var nextCharCode = string.charCodeAt(i + 1);
326 |             if ((nextCharCode & 0xfc00) === 0xdc00) {
327 |                 i++;
328 |             }
329 |         }
330 |     }
331 |     if (numChars > maxLength) {
332 |         var nextChar = takeHtmlCharAt(string, i);
333 |         if (indicator) {
334 |             var peekIndex = i + nextChar.length;
335 |             while (
336 |                 string.charCodeAt(peekIndex) === TAG_OPEN_CHAR_CODE &&
337 |                 string.charCodeAt(peekIndex + 1) === FORWARD_SLASH_CHAR_CODE
338 |             ) {
339 |                 var nextPeekIndex = string.indexOf(">", peekIndex + 2) + 1;
340 |                 if (nextPeekIndex) {
341 |                     peekIndex = nextPeekIndex;
342 |                 } else {
343 |                     break;
344 |                 }
345 |             }
346 |             if (peekIndex && (peekIndex === string.length || isLineBreak(string, peekIndex))) {
347 |                 // if there's only a single character remaining in the input string, or the next
348 |                 // character is followed by a line-break, we can include it instead of the clipping
349 |                 // indicator (provided it's not a special HTML character)
350 |                 i += nextChar.length;
351 |                 nextChar = string.charAt(i);
352 |             }
353 |         }
354 |         // include closing tags before adding the clipping indicator if that's where they
355 |         // are in the input string
356 |         while (nextChar === "<" && string.charCodeAt(i + 1) === FORWARD_SLASH_CHAR_CODE) {
357 |             var tagName = tagStack.pop();
358 |             var tagEndIndex = tagName ? string.indexOf(">", i + 2) : -1;
359 |             if (tagEndIndex === -1 || string.slice(i + 2, tagEndIndex).trim() !== tagName) {
360 |                 throw new Error("Invalid HTML: " + string);
361 |             }
362 |             i = tagEndIndex + 1;
363 |             nextChar = string.charAt(i);
364 |         }
365 |         if (i < string.length) {
366 |             if (!options.breakWords) {
367 |                 // try to clip at word boundaries, if desired
368 |                 for (var j = i - indicator.length; j >= 0; j--) {
369 |                     var charCode = string.charCodeAt(j);
370 |                     if (charCode === TAG_CLOSE_CHAR_CODE || charCode === SEMICOLON_CHAR_CODE) {
371 |                         // these characters could be just regular characters, so if they occur in
372 |                         // the middle of a word, they would "break" our attempt to prevent breaking
373 |                         // of words, but given this seems highly unlikely and the alternative is
374 |                         // doing another full parsing of the preceding text, this seems acceptable.
375 |                         break;
376 |                     } else if (charCode === NEWLINE_CHAR_CODE || charCode === TAG_OPEN_CHAR_CODE) {
377 |                         i = j;
378 |                         break;
379 |                     } else if (isWhiteSpace(charCode)) {
380 |                         i = j + (indicator ? 1 : 0);
381 |                         break;
382 |                     }
383 |                 }
384 |             }
385 |             var result = string.slice(0, i);
386 |             if (!isLineBreak(string, i)) {
387 |                 result += indicator;
388 |             }
389 |             while (tagStack.length) {
390 |                 var tagName = tagStack.pop();
391 |                 result += "</" + tagName + ">";
392 |             }
393 |             return result;
394 |         }
395 |     } else if (numLines > maxLines) {
396 |         var result = string.slice(0, i);
397 |         while (tagStack.length) {
398 |             var tagName = tagStack.pop();
399 |             result += "</" + tagName + ">";
400 |         }
401 |         return result;
402 |     }
403 |     return string;
404 | }
405 | function clipPlainText(string, maxLength, options) {
406 |     var _a = options.indicator,
407 |         indicator = _a === void 0 ? "\u2026" : _a,
408 |         _b = options.maxLines,
409 |         maxLines = _b === void 0 ? Infinity : _b;
410 |     var numChars = indicator.length;
411 |     var numLines = 1;
412 |     var i = 0;
413 |     var length = string.length;
414 |     for (; i < length; i++) {
415 |         numChars++;
416 |         if (numChars > maxLength) {
417 |             break;
418 |         }
419 |         var charCode = string.charCodeAt(i);
420 |         if (charCode === NEWLINE_CHAR_CODE) {
421 |             numLines++;
422 |             if (numLines > maxLines) {
423 |                 break;
424 |             }
425 |         } else if ((charCode & 0xfc00) === 0xd800) {
426 |             // high Unicode surrogate should never be separated from its matching low surrogate
427 |             var nextCharCode = string.charCodeAt(i + 1);
428 |             if ((nextCharCode & 0xfc00) === 0xdc00) {
429 |                 i++;
430 |             }
431 |         }
432 |     }
433 |     if (numChars > maxLength) {
434 |         var nextChar = takeCharAt(string, i);
435 |         if (indicator) {
436 |             var peekIndex = i + nextChar.length;
437 |             if (peekIndex === string.length) {
438 |                 return string;
439 |             } else if (string.charCodeAt(peekIndex) === NEWLINE_CHAR_CODE) {
440 |                 return string.slice(0, i + nextChar.length);
441 |             }
442 |         }
443 |         if (!options.breakWords) {
444 |             // try to clip at word boundaries, if desired
445 |             for (var j = i - indicator.length; j >= 0; j--) {
446 |                 var charCode = string.charCodeAt(j);
447 |                 if (charCode === NEWLINE_CHAR_CODE) {
448 |                     i = j;
449 |                     nextChar = "\n";
450 |                     break;
451 |                 } else if (isWhiteSpace(charCode)) {
452 |                     i = j + (indicator ? 1 : 0);
453 |                     break;
454 |                 }
455 |             }
456 |         }
457 |         return string.slice(0, i) + (nextChar === "\n" ? "" : indicator);
458 |     } else if (numLines > maxLines) {
459 |         return string.slice(0, i);
460 |     }
461 |     return string;
462 | }
463 | function indexOfWhiteSpace(string, fromIndex) {
464 |     var length = string.length;
465 |     for (var i = fromIndex; i < length; i++) {
466 |         if (isWhiteSpace(string.charCodeAt(i))) {
467 |             return i;
468 |         }
469 |     }
470 |     // Rather than -1, this function returns the length of the string if no match is found,
471 |     // so it works well with the Math.min() usage above:
472 |     return length;
473 | }
474 | function isCharacterReferenceCharacter(charCode) {
475 |     return (
476 |         (charCode >= 48 && charCode <= 57) ||
477 |         (charCode >= 65 && charCode <= 90) ||
478 |         (charCode >= 97 && charCode <= 122)
479 |     );
480 | }
481 | function isLineBreak(string, index) {
482 |     var firstCharCode = string.charCodeAt(index);
483 |     if (firstCharCode === NEWLINE_CHAR_CODE) {
484 |         return true;
485 |     } else if (firstCharCode === TAG_OPEN_CHAR_CODE) {
486 |         var newlineElements = "(" + BLOCK_ELEMENTS.join("|") + "|br)";
487 |         var newlineRegExp = new RegExp("^<" + newlineElements + "[\t\n\f\r ]*/?>", "i");
488 |         return newlineRegExp.test(string.slice(index));
489 |     } else {
490 |         return false;
491 |     }
492 | }
493 | function isWhiteSpace(charCode) {
494 |     return (
495 |         charCode === 9 || charCode === 10 || charCode === 12 || charCode === 13 || charCode === 32
496 |     );
497 | }
498 | /**
499 |  * Certain tags don't display their whitespace-only content. In such cases, we
500 |  * should simplify the whitespace before counting it.
501 |  */
502 | function shouldSimplifyWhiteSpace(tagStack) {
503 |     for (var i = tagStack.length - 1; i >= 0; i--) {
504 |         var tagName = tagStack[i];
505 |         if (tagName === "li" || tagName === "td") {
506 |             return false;
507 |         }
508 |         if (tagName === "ol" || tagName === "table" || tagName === "ul") {
509 |             return true;
510 |         }
511 |     }
512 |     return false;
513 | }
514 | function simplifyWhiteSpace(string) {
515 |     return string.trim().replace(SIMPLIFY_WHITESPACE_REGEX, " ");
516 | }
517 | function takeCharAt(string, index) {
518 |     var charCode = string.charCodeAt(index);
519 |     if ((charCode & 0xfc00) === 0xd800) {
520 |         // high Unicode surrogate should never be separated from its matching low surrogate
521 |         var nextCharCode = string.charCodeAt(index + 1);
522 |         if ((nextCharCode & 0xfc00) === 0xdc00) {
523 |             return String.fromCharCode(charCode, nextCharCode);
524 |         }
525 |     }
526 |     return String.fromCharCode(charCode);
527 | }
528 | function takeHtmlCharAt(string, index) {
529 |     var char = takeCharAt(string, index);
530 |     if (char === "&") {
531 |         while (true /* eslint-disable-line */) {
532 |             index++;
533 |             var nextCharCode = string.charCodeAt(index);
534 |             if (isCharacterReferenceCharacter(nextCharCode)) {
535 |                 char += String.fromCharCode(nextCharCode);
536 |             } else if (nextCharCode === SEMICOLON_CHAR_CODE) {
537 |                 char += String.fromCharCode(nextCharCode);
538 |                 break;
539 |             } else {
540 |                 break;
541 |             }
542 |         }
543 |     }
544 |     return char;
545 | }
546 | 


--------------------------------------------------------------------------------
/tests/perf/benchmark/benchmark.js:
--------------------------------------------------------------------------------
 1 | const { performance } = require("node:perf_hooks");
 2 | 
 3 | const clip = require("../../../dist").default;
 4 | const baseline = require("./baseline").default;
 5 | const trimHtml = require("trim-html");
 6 | const truncateHtml = require("truncate-html");
 7 | const htmlTruncate = require("html-truncate");
 8 | 
 9 | /* var TEST_STRING = (
10 |     //'Dit is allemaal best een mooi verhaal, maar ik geloof er eigenlijk niet zo heel veel van.\n' +
11 |     //'<table><tbody><tr><td>Hoi</td></tr></tbody></table>' +
12 |     '<p>Laten we alvast brainstormen over een aantal van de belangrijkste thema&#39;s voor de ' +
13 |     'vergadering die wij hebben over <img src=\'blaat\'> een paar dagen.of ' +
14 |     '<a class="highlightable" href="http://www.nu.nl" rel="noopener noreferrer" target="_blank">' +
15 |     'http://www.nu.nl</a></p>'
16 | );*/
17 | /* var TEST_STRING = '';
18 | for (var i = 0; i < 100000; i++) {
19 |     TEST_STRING += 'abcdefeghi';
20 | }*/
21 | const TEST_STRING = "Dit is een string die eigenlijk nog makkelijk past binnen de limiet.";
22 | const TEST_LIMIT = 100;
23 | 
24 | const MAX_RUN_TIME = 5000; // ms
25 | 
26 | const NUM_ITERATIONS_PER_MEASURE = 100;
27 | const MAX_NUM_MEASURES = 1000;
28 | 
29 | const benchmarks = {
30 |     "text-clipper": (string, limit) => clip(string, limit, { html: true }),
31 |     "text-clipper-baseline": (string, limit) => baseline(string, limit, { html: true }),
32 |     "trim-html": (string, limit) => trimHtml(string, { limit }),
33 |     "truncate-html": truncateHtml,
34 |     "html-truncate": htmlTruncate,
35 | };
36 | 
37 | for (const [name, fn] of Object.entries(benchmarks)) {
38 |     console.log(`Benchmarking ${name}...`);
39 | 
40 |     let fastest = Infinity;
41 |     let slowest = 0;
42 | 
43 |     const begin = performance.now();
44 |     const measures = [];
45 | 
46 |     for (let i = 0; i < MAX_NUM_MEASURES; i++) {
47 |         const start = performance.now();
48 |         for (let j = 0; j < NUM_ITERATIONS_PER_MEASURE; j++) {
49 |             const clipped = fn(TEST_STRING, TEST_LIMIT);
50 | 
51 |             // Just test to make sure the compiler doesn't eliminate everything.
52 |             if (clipped.length > TEST_STRING.length) {
53 |                 process.exit("Clipped string is longer than input: " + clipped);
54 |             }
55 |         }
56 |         const finish = performance.now();
57 | 
58 |         const time = finish - start;
59 |         fastest = Math.min(fastest, time);
60 |         slowest = Math.max(slowest, time);
61 |         measures.push(time);
62 | 
63 |         if (finish - begin > MAX_RUN_TIME) {
64 |             break;
65 |         }
66 |     }
67 | 
68 |     const average = measures.reduce((sum, measure) => sum + measure, 0) / measures.length;
69 | 
70 |     console.log(
71 |         `Average ops/s: ${toOps(average)} (fastest: ${toOps(fastest)}, slowest: ${toOps(slowest)})`,
72 |     );
73 | }
74 | 
75 | function toOps(measure) {
76 |     return 1 / (measure / NUM_ITERATIONS_PER_MEASURE);
77 | }
78 | 


--------------------------------------------------------------------------------
/tests/perf/benchmark/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "text-clipper-benchmark",
 3 |     "version": "0.0.0",
 4 |     "description": "text-clipper benchmark",
 5 |     "devDependencies": {
 6 |         "html-truncate": "^1.2.1",
 7 |         "trim-html": "^0.1.7",
 8 |         "truncate-html": "^0.1.1"
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/unit/examples.test.ts:
--------------------------------------------------------------------------------
 1 | import { assertEquals } from "jsr:@std/assert";
 2 | 
 3 | import clip from "../../src/index.ts";
 4 | 
 5 | Deno.test("examples: test examples from the README", () => {
 6 |     assertEquals(clip("foo", 3), "foo");
 7 |     assertEquals(clip("foo", 2), "f…");
 8 |     assertEquals(clip("foo bar", 5), "foo…");
 9 |     assertEquals(clip("foo\nbar", 5), "foo…");
10 | });
11 | 


--------------------------------------------------------------------------------
/tests/unit/html.test.ts:
--------------------------------------------------------------------------------
  1 | import { assertEquals } from "jsr:@std/assert";
  2 | 
  3 | import clip from "../../src/index.ts";
  4 | 
  5 | Deno.test("html: test basic HTML", () => {
  6 |     const options = { html: true };
  7 | 
  8 |     assertEquals(clip("<p>Lorum ipsum</p>", 5, options), "<p>Loru\u2026</p>");
  9 |     assertEquals(clip("<p><i>Lorum</i> <i>ipsum</i></p>", 5, options), "<p><i>Loru\u2026</i></p>");
 10 |     assertEquals(clip("<p><i>Lorum</i> <i>ipsum</i></p>", 6, options), "<p><i>Lorum</i>\u2026</p>");
 11 |     assertEquals(clip("<p><i>Lorum</i> <i>ipsum</i></p>", 7, options), "<p><i>Lorum</i>\u2026</p>");
 12 |     assertEquals(
 13 |         clip("<p><i>Lorum</i>\n<i>ipsum</i></p>", 5, options),
 14 |         "<p><i>Lorum</i>\u2026</p>",
 15 |     );
 16 |     assertEquals(
 17 |         clip("<p><i>Lorum</i><br><i>ipsum</i></p>", 5, options),
 18 |         "<p><i>Lorum</i>\u2026</p>",
 19 |     );
 20 | 
 21 |     assertEquals(clip("<p><i>Lorum</i></p>", 5, options), "<p><i>Lorum</i></p>");
 22 | 
 23 |     assertEquals(clip("<p><i>Lorum</i>a</p>", 5, options), "<p><i>Loru\u2026</i></p>");
 24 |     assertEquals(clip("<p><i>Lorum</i></p>a", 5, options), "<p><i>Loru\u2026</i></p>");
 25 |     assertEquals(clip("<p><i>Lorum</i>a</p>", 6, options), "<p><i>Lorum</i>a</p>");
 26 |     assertEquals(clip("<p><i>Lorum</i></p>a", 6, options), "<p><i>Lorum</i></p>a");
 27 |     assertEquals(clip("<p><i>Lorum</i>aA</p>", 6, options), "<p><i>Lorum</i>\u2026</p>");
 28 |     assertEquals(clip("<p><i>Lorum</i></p>aA", 6, options), "<p><i>Lorum</i></p>\u2026");
 29 |     assertEquals(clip("<p><i>Lorum</i>a</p>", 7, options), "<p><i>Lorum</i>a</p>");
 30 |     assertEquals(clip("<p><i>Lorum</i></p>a", 7, options), "<p><i>Lorum</i></p>a");
 31 |     assertEquals(clip("<p><i>Lorum</i>aA</p>", 7, options), "<p><i>Lorum</i>aA</p>");
 32 |     assertEquals(clip("<p><i>Lorum</i></p>aA", 7, options), "<p><i>Lorum</i></p>aA");
 33 | 
 34 |     assertEquals(clip("<p><i>Lorum</i> </p>", 5, options), "<p><i>Loru\u2026</i></p>");
 35 |     assertEquals(clip("<p><i>Lorum</i></p> ", 5, options), "<p><i>Loru\u2026</i></p>");
 36 |     assertEquals(clip("<p><i>Lorum</i> </p>", 6, options), "<p><i>Lorum</i> </p>");
 37 |     assertEquals(clip("<p><i>Lorum</i></p> ", 6, options), "<p><i>Lorum</i></p> ");
 38 |     assertEquals(clip("<p><i>Lorum</i>  </p>", 6, options), "<p><i>Lorum</i></p>");
 39 |     assertEquals(clip("<p><i>Lorum</i></p>  ", 6, options), "<p><i>Lorum</i></p>");
 40 |     assertEquals(clip("<p><i>Lorum</i> </p>", 7, options), "<p><i>Lorum</i> </p>");
 41 |     assertEquals(clip("<p><i>Lorum</i></p> ", 7, options), "<p><i>Lorum</i></p> ");
 42 |     assertEquals(clip("<p><i>Lorum</i>  </p>", 7, options), "<p><i>Lorum</i>  </p>");
 43 |     assertEquals(clip("<p><i>Lorum</i></p>  ", 7, options), "<p><i>Lorum</i></p>  ");
 44 | 
 45 |     assertEquals(clip("Lo<ins>rum</ins>", 4, options), "Lo<ins>r\u2026</ins>");
 46 |     assertEquals(clip("Lo<del>rum</del>", 4, options), "Lo<del>r\u2026</del>");
 47 | 
 48 |     assertEquals(
 49 |         clip('<a href="http://just-a-link.com">Just a link</a>', 8, options),
 50 |         '<a href="http://just-a-link.com">Just a\u2026</a>',
 51 |     );
 52 | 
 53 |     assertEquals(
 54 |         clip('<a href="http://just-a-link.com">Just a link</a>, yo', 13, options),
 55 |         '<a href="http://just-a-link.com">Just a link</a>,\u2026',
 56 |     );
 57 | });
 58 | 
 59 | Deno.test("html: test HTML comments", () => {
 60 |     const options = { html: true };
 61 | 
 62 |     assertEquals(
 63 |         clip("<b><!-- this is bold -->bold</b>", 4, options),
 64 |         "<b><!-- this is bold -->bold</b>",
 65 |     );
 66 | 
 67 |     assertEquals(
 68 |         clip("<b><!-- this is bold -->bold</b>", 3, options),
 69 |         "<b><!-- this is bold -->bo\u2026</b>",
 70 |     );
 71 | });
 72 | 
 73 | Deno.test("html: test special characters in attribute values", () => {
 74 |     const options = { html: true };
 75 | 
 76 |     assertEquals(clip('<b class="<i>">bold</b>', 4, options), '<b class="<i>">bold</b>');
 77 |     assertEquals(clip('<b class="<i>">bold</b>', 3, options), '<b class="<i>">bo\u2026</b>');
 78 |     assertEquals(clip("<b class=\"'test'\">bold</b>", 4, options), "<b class=\"'test'\">bold</b>");
 79 | 
 80 |     assertEquals(
 81 |         clip("<b class=\"'test'\">bold</b>", 3, options),
 82 |         "<b class=\"'test'\">bo\u2026</b>",
 83 |     );
 84 | 
 85 |     assertEquals(
 86 |         clip("<b class='javascript:alert(\"hoi\");'>bold</b>", 4, options),
 87 |         "<b class='javascript:alert(\"hoi\");'>bold</b>",
 88 |     );
 89 | 
 90 |     assertEquals(
 91 |         clip("<b class='javascript:alert(\"hoi\");'>bold</b>", 3, options),
 92 |         "<b class='javascript:alert(\"hoi\");'>bo\u2026</b>",
 93 |     );
 94 | });
 95 | 
 96 | Deno.test("html: test embedded SVG", () => {
 97 |     assertEquals(
 98 |         clip(
 99 |             "<p>" +
100 |                 '<svg width="100%" height="100%" viewBox="0 0 100 100"' +
101 |                 ' xmlns="http://www.w3.org/2000/svg">\n' +
102 |                 "<style>\n" +
103 |                 "/* <![CDATA[ */\n" +
104 |                 "circle {\n" +
105 |                 "fill: orange;\n" +
106 |                 "stroke: black;\n" +
107 |                 "stroke-width: 10px; " +
108 |                 "// Note that the value of a pixel depend on the viewBox\n" +
109 |                 "}\n" +
110 |                 "/* ]]> */\n" +
111 |                 "</style>\n" +
112 |                 "\n" +
113 |                 '<circle cx="50" cy="50" r="40" />\n' +
114 |                 "</svg>test\n" +
115 |                 "</p>",
116 |             9,
117 |             { html: true, imageWeight: 5 },
118 |         ),
119 |         "<p>" +
120 |             '<svg width="100%" height="100%" viewBox="0 0 100 100"' +
121 |             ' xmlns="http://www.w3.org/2000/svg">\n' +
122 |             "<style>\n" +
123 |             "/* <![CDATA[ */\n" +
124 |             "circle {\n" +
125 |             "fill: orange;\n" +
126 |             "stroke: black;\n" +
127 |             "stroke-width: 10px; " +
128 |             "// Note that the value of a pixel depend on the viewBox\n" +
129 |             "}\n" +
130 |             "/* ]]> */\n" +
131 |             "</style>\n" +
132 |             "\n" +
133 |             '<circle cx="50" cy="50" r="40" />\n' +
134 |             "</svg>test" +
135 |             "</p>",
136 |     );
137 | });
138 | 
139 | Deno.test("html: test unicode surrogate pairs", () => {
140 |     const options = { html: true };
141 | 
142 |     assertEquals(clip("Lorum 𝌆", 7, options), "Lorum 𝌆");
143 |     assertEquals(clip("𝌆𝌆𝌆𝌆", 4, options), "𝌆𝌆𝌆𝌆");
144 |     assertEquals(clip("𝌆𝌆𝌆𝌆", 3, options), "𝌆𝌆…");
145 |     assertEquals(clip("😔🙏👙😃🏧", 6, options), "😔🙏👙😃🏧");
146 |     assertEquals(clip("😔🙏👙😃🏧", 5, options), "😔🙏👙😃🏧");
147 |     assertEquals(clip("😔🙏👙😃🏧", 4, options), "😔🙏👙…");
148 |     assertEquals(clip("😔🙏👙😃🏧", 3, options), "😔🙏…");
149 | });
150 | 
151 | Deno.test("html: test plain text", () => {
152 |     const options = { html: true };
153 | 
154 |     assertEquals(clip("Lorum ipsum", 5, options), "Loru\u2026");
155 |     assertEquals(clip("Lorum ipsum", 6, options), "Lorum\u2026");
156 |     assertEquals(clip("Lorum ipsum", 7, options), "Lorum\u2026");
157 |     assertEquals(clip("Lorum ipsum", 8, options), "Lorum\u2026");
158 |     assertEquals(clip("Lorum ipsum", 9, options), "Lorum\u2026");
159 |     assertEquals(clip("Lorum ipsum", 10, options), "Lorum\u2026");
160 |     assertEquals(clip("Lorum ipsum", 11, options), "Lorum ipsum");
161 | 
162 |     assertEquals(clip("Lorum\nipsum", 10, options), "Lorum\u2026");
163 | 
164 |     assertEquals(clip("Lorum i", 7, options), "Lorum i");
165 |     assertEquals(clip("Lorum \u2026", 7, options), "Lorum \u2026");
166 | });
167 | 
168 | Deno.test("html: test word breaking", () => {
169 |     const options = { breakWords: true, html: true };
170 | 
171 |     assertEquals(clip("Lorum ipsum", 5, options), "Loru\u2026");
172 |     assertEquals(clip("Lorum ipsum", 6, options), "Lorum\u2026");
173 |     assertEquals(clip("Lorum ipsum", 7, options), "Lorum\u2026");
174 |     assertEquals(clip("Lorum ipsum", 8, options), "Lorum i\u2026");
175 |     assertEquals(clip("Lorum ipsum", 9, options), "Lorum ip\u2026");
176 |     assertEquals(clip("Lorum ipsum", 10, options), "Lorum ips\u2026");
177 |     assertEquals(clip("Lorum ipsum", 11, options), "Lorum ipsum");
178 | });
179 | 
180 | Deno.test("html: test word breaking without indicator", () => {
181 |     const options = { breakWords: true, html: true, indicator: "" };
182 | 
183 |     assertEquals(clip("Lorum ipsum", 5, options), "Lorum");
184 |     assertEquals(clip("Lorum ipsum", 6, options), "Lorum");
185 |     assertEquals(clip("Lorum ipsum", 7, options), "Lorum i");
186 |     assertEquals(clip("Lorum ipsum", 8, options), "Lorum ip");
187 |     assertEquals(clip("Lorum ipsum", 9, options), "Lorum ips");
188 |     assertEquals(clip("Lorum ipsum", 10, options), "Lorum ipsu");
189 |     assertEquals(clip("Lorum ipsum", 11, options), "Lorum ipsum");
190 | });
191 | 
192 | Deno.test("html: test max lines", () => {
193 |     assertEquals(clip("Lorum\nipsum", 100, { html: true, maxLines: 2 }), "Lorum\nipsum");
194 |     assertEquals(clip("Lorum\nipsum", 100, { html: true, maxLines: 1 }), "Lorum\u2026");
195 |     assertEquals(clip("Lorum<br/>ipsum", 100, { html: true, maxLines: 1 }), "Lorum\u2026");
196 |     assertEquals(clip("Lorum\n\nipsum", 100, { html: true, maxLines: 2 }), "Lorum\u2026");
197 | 
198 |     // If there is *only* whitespace left, we don't insert an indicator regardless.
199 |     assertEquals(clip("Lorum\nipsum\n", 100, { html: true, maxLines: 2 }), "Lorum\nipsum");
200 |     assertEquals(clip("Lorum\nipsum\n\n", 100, { html: true, maxLines: 2 }), "Lorum\nipsum");
201 | 
202 |     assertEquals(
203 |         clip("<p>Lorem ipsum</p><p>Lorem ipsum</p>", 100, {
204 |             html: true,
205 |             maxLines: 2,
206 |         }),
207 |         "<p>Lorem ipsum</p><p>Lorem ipsum</p>",
208 |     );
209 |     assertEquals(
210 |         clip("<p>Lorem ipsum</p><p>Lorem ipsum</p>", 100, {
211 |             html: true,
212 |             maxLines: 1,
213 |         }),
214 |         "<p>Lorem ipsum\u2026</p>",
215 |     );
216 |     assertEquals(
217 |         clip("<div>Lorem ipsum</div><div>Lorem ipsum</div>", 100, {
218 |             html: true,
219 |             maxLines: 2,
220 |         }),
221 |         "<div>Lorem ipsum</div><div>Lorem ipsum</div>",
222 |     );
223 |     assertEquals(
224 |         clip("<div>Lorem ipsum</div><div>Lorem ipsum</div>", 100, {
225 |             html: true,
226 |             maxLines: 1,
227 |         }),
228 |         "<div>Lorem ipsum\u2026</div>",
229 |     );
230 | });
231 | 
232 | Deno.test("html: test odd HTML", () => {
233 |     const options = { html: true };
234 | 
235 |     assertEquals(clip("<p>foo > bar</p>", 9, options), "<p>foo > bar</p>");
236 |     assertEquals(
237 |         clip("<p><i>Lorum>>></i> <i>ipsum</i></p>", 7, options),
238 |         "<p><i>Lorum>\u2026</i></p>",
239 |     );
240 | });
241 | 
242 | Deno.test("html: test ampersand", () => {
243 |     const options = { html: true };
244 | 
245 |     assertEquals(clip("&", 1, options), "&");
246 |     assertEquals(clip("&", 2, options), "&");
247 |     assertEquals(clip("&lt;", 1, options), "&lt;");
248 |     assertEquals(clip("&lt;", 2, options), "&lt;");
249 |     assertEquals(clip("&amp;", 1, options), "&amp;");
250 |     assertEquals(clip("&amp;", 2, options), "&amp;");
251 |     assertEquals(clip("<p>&</p>", 1, options), "\u2026");
252 |     assertEquals(clip("<p>&</p>", 2, options), "<p>&</p>");
253 |     assertEquals(clip("<p>&lt;</p>", 1, options), "\u2026");
254 |     assertEquals(clip("<p>&lt;</p>", 2, options), "<p>&lt;</p>");
255 |     assertEquals(clip("<p>&amp;</p>", 1, options), "\u2026");
256 |     assertEquals(clip("<p>&amp;</p>", 2, options), "<p>&amp;</p>");
257 | 
258 |     assertEquals(clip("foo & bar", 5, options), "foo\u2026");
259 |     assertEquals(clip("foo & bar", 9, options), "foo & bar");
260 |     assertEquals(clip("foo&<i>bar</i>", 5, options), "foo&\u2026");
261 |     assertEquals(clip("foo&<i>bar</i>", 7, options), "foo&<i>bar</i>");
262 |     assertEquals(clip("foo&&& bar", 5, options), "foo&\u2026");
263 |     assertEquals(clip("foo&&& bar", 10, options), "foo&&& bar");
264 | 
265 |     assertEquals(
266 |         clip('<a href="http://example.com/?x=1&y=2">foo</a>', 3, options),
267 |         '<a href="http://example.com/?x=1&y=2">foo</a>',
268 |     );
269 |     assertEquals(clip("&123", 4, options), "&123");
270 |     assertEquals(clip("&abc", 4, options), "&abc");
271 |     assertEquals(clip("foo &0 bar", 10, options), "foo &0 bar");
272 |     assertEquals(clip("foo &lolwat bar", 15, options), "foo &lolwat bar");
273 | });
274 | 
275 | Deno.test("html: test ampersand without indicator", () => {
276 |     const options = { html: true, indicator: "" };
277 | 
278 |     assertEquals(clip("&", 1, options), "&");
279 |     assertEquals(clip("&", 2, options), "&");
280 |     assertEquals(clip("&lt;", 1, options), "&lt;");
281 |     assertEquals(clip("&lt;", 2, options), "&lt;");
282 |     assertEquals(clip("&amp;", 1, options), "&amp;");
283 |     assertEquals(clip("&amp;", 2, options), "&amp;");
284 |     assertEquals(clip("<p>&</p>", 1, options), "<p>&</p>");
285 |     assertEquals(clip("<p>&</p>", 2, options), "<p>&</p>");
286 |     assertEquals(clip("<p>&lt;</p>", 1, options), "<p>&lt;</p>");
287 |     assertEquals(clip("<p>&lt;</p>", 2, options), "<p>&lt;</p>");
288 |     assertEquals(clip("<p>&amp;</p>", 1, options), "<p>&amp;</p>");
289 |     assertEquals(clip("<p>&amp;</p>", 2, options), "<p>&amp;</p>");
290 | 
291 |     assertEquals(clip("foo & bar", 5, options), "foo &");
292 |     assertEquals(clip("foo & bar", 9, options), "foo & bar");
293 |     // Ideally "bar" wouldn't have been broken, but we accept this
294 |     // limitation when encountering tags during backtracking:
295 |     assertEquals(clip("foo&<i>bar</i>", 5, options), "foo&<i>b</i>");
296 |     assertEquals(clip("foo&<i>bar</i>", 7, options), "foo&<i>bar</i>");
297 |     assertEquals(clip("foo&&& bar", 5, options), "foo&&");
298 |     assertEquals(clip("foo&&& bar", 10, options), "foo&&& bar");
299 | 
300 |     assertEquals(
301 |         clip('<a href="http://example.com/?x=1&y=2">foo</a>', 3, options),
302 |         '<a href="http://example.com/?x=1&y=2">foo</a>',
303 |     );
304 |     assertEquals(clip("&123", 4, options), "&123");
305 |     assertEquals(clip("&abc", 4, options), "&abc");
306 |     assertEquals(clip("foo &0 bar", 10, options), "foo &0 bar");
307 |     assertEquals(clip("foo &lolwat bar", 15, options), "foo &lolwat bar");
308 | });
309 | 
310 | Deno.test("html: test ampersand without indicator and break words", () => {
311 |     const options = { breakWords: true, html: true, indicator: "" };
312 | 
313 |     assertEquals(clip("&", 1, options), "&");
314 |     assertEquals(clip("&", 2, options), "&");
315 |     assertEquals(clip("&lt;", 1, options), "&lt;");
316 |     assertEquals(clip("&lt;", 2, options), "&lt;");
317 |     assertEquals(clip("&amp;", 1, options), "&amp;");
318 |     assertEquals(clip("&amp;", 2, options), "&amp;");
319 |     assertEquals(clip("<p>&</p>", 1, options), "<p>&</p>");
320 |     assertEquals(clip("<p>&</p>", 2, options), "<p>&</p>");
321 |     assertEquals(clip("<p>&lt;</p>", 1, options), "<p>&lt;</p>");
322 |     assertEquals(clip("<p>&lt;</p>", 2, options), "<p>&lt;</p>");
323 |     assertEquals(clip("<p>&amp;</p>", 1, options), "<p>&amp;</p>");
324 |     assertEquals(clip("<p>&amp;</p>", 2, options), "<p>&amp;</p>");
325 | 
326 |     assertEquals(clip("foo & bar", 5, options), "foo &");
327 |     assertEquals(clip("foo & bar", 9, options), "foo & bar");
328 |     assertEquals(clip("foo&<i>bar</i>", 5, options), "foo&<i>b</i>");
329 |     assertEquals(clip("foo&<i>bar</i>", 7, options), "foo&<i>bar</i>");
330 |     assertEquals(clip("foo&&& bar", 5, options), "foo&&");
331 |     assertEquals(clip("foo&&& bar", 10, options), "foo&&& bar");
332 | 
333 |     assertEquals(
334 |         clip('<a href="http://example.com/?x=1&y=2">foo</a>', 3, options),
335 |         '<a href="http://example.com/?x=1&y=2">foo</a>',
336 |     );
337 |     assertEquals(clip("&123", 4, options), "&123");
338 |     assertEquals(clip("&abc", 4, options), "&abc");
339 |     assertEquals(clip("foo &0 bar", 10, options), "foo &0 bar");
340 |     assertEquals(clip("foo &lolwat bar", 15, options), "foo &lolwat bar");
341 | });
342 | 
343 | Deno.test("html: test edge cases", () => {
344 |     const options = { breakWords: true, html: true, indicator: "..." };
345 | 
346 |     assertEquals(clip('one <a href="#">two - three <br>four</a> five', 0, options), "...");
347 |     assertEquals(clip('<p>one <a href="#">two - three <br>four</a> five</p>', 0, options), "...");
348 |     assertEquals(
349 |         clip('<p>one <a href="#">two - three <br>four</a> five</p>', 6, options),
350 |         "<p>one...</p>",
351 |     );
352 | });
353 | 
354 | Deno.test("html: issue #12: split tables", () => {
355 |     const html = getHtmlTable();
356 | 
357 |     assertEquals(
358 |         clip(html, 26, { html: true, breakWords: true }),
359 |         `<table border="1" cellpadding="1" cellspacing="1" style="width: 500px">
360 |     <tbody>
361 |         <tr>
362 |             <td>fb</td>
363 |             <td>fbfbfb</td>
364 |         </tr>
365 |         <tr>
366 |             <td>google</td>
367 |             <td>twitter</td>
368 |         </tr>
369 |         <tr>
370 |             <td>intel</td>\u2026</tr></tbody></table>`,
371 |     );
372 | 
373 |     assertEquals(
374 |         clip(html, 25, { html: true, breakWords: true }),
375 |         `<table border="1" cellpadding="1" cellspacing="1" style="width: 500px">
376 |     <tbody>
377 |         <tr>
378 |             <td>fb</td>
379 |             <td>fbfbfb</td>
380 |         </tr>
381 |         <tr>
382 |             <td>google</td>
383 |             <td>twitter</td>
384 |         </tr>
385 |         <tr>
386 |             <td>int\u2026</td></tr></tbody></table>`,
387 |     );
388 | 
389 |     assertEquals(
390 |         clip(html, 25, { html: true, breakWords: true, maxLines: 2 }),
391 |         `<table border="1" cellpadding="1" cellspacing="1" style="width: 500px">
392 |     <tbody>
393 |         <tr>
394 |             <td>fb</td>
395 |             <td>fbfbfb</td>
396 |         </tr>
397 |         <tr>
398 |             <td>google</td>
399 |             <td>twitter</td>\u2026</tr></tbody></table>`,
400 |     );
401 | });
402 | 
403 | Deno.test("html: test strip tags", () => {
404 |     // Basic stripping of tags:
405 |     const htmlWithImage = '<p>Image <img alt="blup" src="#"> and such</p>';
406 |     assertEquals(
407 |         clip(htmlWithImage, 12, { html: true, stripTags: [] }),
408 |         clip(htmlWithImage, 12, { html: true }),
409 |     );
410 |     assertEquals(
411 |         clip(htmlWithImage, 12, { html: true, stripTags: ["img"] }),
412 |         "<p>Image  and\u2026</p>",
413 |     );
414 |     assertEquals(
415 |         clip(htmlWithImage, 12, { html: true, stripTags: ["img", "p"] }),
416 |         "Image  and\u2026",
417 |     );
418 |     assertEquals(clip(htmlWithImage, 12, { html: true, stripTags: true }), "Image  and\u2026");
419 |     assertEquals(
420 |         clip(htmlWithImage, 15, { html: true, stripTags: ["img"] }),
421 |         "<p>Image  and such</p>",
422 |     );
423 | 
424 |     // Links are stripped (but content is preserved):
425 |     const htmlWithLink = '<a href="http://example.com/?x=1&y=2">foo</a>';
426 |     assertEquals(clip(htmlWithLink, 3, { html: true, stripTags: ["a"] }), "foo");
427 |     assertEquals(clip(htmlWithLink, 3, { html: true, stripTags: ["b"] }), htmlWithLink);
428 | 
429 |     // Same for tables, but whitespace is also simplified:
430 |     const htmlWithTable = `hello <table border="1" cellpadding="1" cellspacing="1" style="width: 500px">
431 |     <tbody>
432 |         <tr>
433 |             <td>fb</td>
434 |             <td>fbfbfb</td>
435 |         </tr>
436 |         <tr>
437 |             <td>google</td>
438 |             <td>twitter</td>
439 |         </tr>
440 |         <tr>
441 |             <td>intel</td>
442 |             <td>amazon</td>
443 |         </tr>
444 |     </tbody>
445 | </table> world`;
446 |     assertEquals(clip(htmlWithTable, 10, { html: true, stripTags: true }), "hello fb\u2026");
447 |     assertEquals(clip(htmlWithTable, 16, { html: true, stripTags: true }), "hello fb fbfbfb\u2026");
448 |     assertEquals(
449 |         clip(htmlWithTable, 24, { html: true, stripTags: true }),
450 |         "hello fb fbfbfb google\u2026",
451 |     );
452 | 
453 |     // SVG's `imageWeight` should not be counted when stripped:
454 |     const htmlWithSvg = getHtmlWithSvg();
455 |     assertEquals(clip(htmlWithSvg, 3, { html: true, stripTags: ["svg"] }), "<p>te\u2026</p>");
456 |     assertEquals(clip(htmlWithSvg, 4, { html: true, stripTags: ["svg"] }), "<p>test</p>");
457 | });
458 | 
459 | Deno.test("html: disable indicator at line break", () => {
460 |     const options = { html: true, insertIndicatorAtLinebreak: false };
461 | 
462 |     assertEquals(clip("Lorum\nipsum", 10, options), "Lorum");
463 |     assertEquals(clip("Lorum\nipsum", 100, { ...options, maxLines: 1 }), "Lorum");
464 | 
465 |     assertEquals(clip("Lorum<br/>ipsum", 100, { ...options, maxLines: 1 }), "Lorum");
466 |     assertEquals(clip("Lorum\n\nipsum", 100, { ...options, maxLines: 2 }), "Lorum");
467 | 
468 |     assertEquals(clip("<p>&</p>", 1, options), "");
469 |     assertEquals(clip("<p>&lt;</p>", 1, options), "");
470 | 
471 |     assertEquals(
472 |         clip("<p>Lorem ipsum</p><p>Lorem ipsum</p>", 100, { ...options, maxLines: 1 }),
473 |         "<p>Lorem ipsum</p>",
474 |     );
475 | 
476 |     assertEquals(
477 |         clip('<p>one <a href="#">two - three <br>four</a> five</p>', 0, {
478 |             ...options,
479 |             indicator: "...",
480 |         }),
481 |         "",
482 |     );
483 | 
484 |     assertEquals(
485 |         clip(getHtmlTable(), 26, { ...options, breakWords: true }),
486 |         `<table border="1" cellpadding="1" cellspacing="1" style="width: 500px">
487 |     <tbody>
488 |         <tr>
489 |             <td>fb</td>
490 |             <td>fbfbfb</td>
491 |         </tr>
492 |         <tr>
493 |             <td>google</td>
494 |             <td>twitter</td>
495 |         </tr>
496 |         <tr>
497 |             <td>intel</td></tr></tbody></table>`,
498 |     );
499 | 
500 |     assertEquals(clip(getHtmlWithSvg(), 4, { ...options, stripTags: ["svg"] }), "<p>test</p>");
501 | });
502 | 
503 | function getHtmlTable(): string {
504 |     return `<table border="1" cellpadding="1" cellspacing="1" style="width: 500px">
505 |     <tbody>
506 |         <tr>
507 |             <td>fb</td>
508 |             <td>fbfbfb</td>
509 |         </tr>
510 |         <tr>
511 |             <td>google</td>
512 |             <td>twitter</td>
513 |         </tr>
514 |         <tr>
515 |             <td>intel</td>
516 |             <td>amazon</td>
517 |         </tr>
518 |     </tbody>
519 | </table>`;
520 | }
521 | 
522 | function getHtmlWithSvg(): string {
523 |     return (
524 |         "<p>" +
525 |         '<svg width="100%" height="100%" viewBox="0 0 100 100"' +
526 |         ' xmlns="http://www.w3.org/2000/svg">\n' +
527 |         "<style>\n" +
528 |         "/* <![CDATA[ */\n" +
529 |         "circle {\n" +
530 |         "fill: orange;\n" +
531 |         "stroke: black;\n" +
532 |         "stroke-width: 10px; " +
533 |         "// Note that the value of a pixel depend on the viewBox\n" +
534 |         "}\n" +
535 |         "/* ]]> */\n" +
536 |         "</style>\n" +
537 |         "\n" +
538 |         '<circle cx="50" cy="50" r="40" />\n' +
539 |         "</svg>test\n" +
540 |         "</p>"
541 |     );
542 | }
543 | 


--------------------------------------------------------------------------------
/tests/unit/plain-text.test.ts:
--------------------------------------------------------------------------------
 1 | import { assertEquals } from "jsr:@std/assert";
 2 | 
 3 | import clip from "../../src/index.ts";
 4 | 
 5 | Deno.test("plain-text: test basics", () => {
 6 |     assertEquals(clip("Lorum ipsum", 5), "Loru\u2026");
 7 |     assertEquals(clip("Lorum ipsum", 6), "Lorum\u2026");
 8 |     assertEquals(clip("Lorum ipsum", 7), "Lorum\u2026");
 9 |     assertEquals(clip("Lorum ipsum", 8), "Lorum\u2026");
10 |     assertEquals(clip("Lorum ipsum", 9), "Lorum\u2026");
11 |     assertEquals(clip("Lorum ipsum", 10), "Lorum\u2026");
12 |     assertEquals(clip("Lorum ipsum", 11), "Lorum ipsum");
13 | 
14 |     assertEquals(clip("Lorum\nipsum", 10), "Lorum\u2026");
15 | 
16 |     assertEquals(clip("Lorum i", 7), "Lorum i");
17 |     assertEquals(clip("Lorum \u2026", 7), "Lorum \u2026");
18 | });
19 | 
20 | Deno.test("plain-text: test unicode surrogate pairs", () => {
21 |     assertEquals(clip("Lorum 𝌆", 7), "Lorum 𝌆");
22 |     assertEquals(clip("𝌆𝌆𝌆𝌆", 4), "𝌆𝌆𝌆𝌆");
23 |     assertEquals(clip("𝌆𝌆𝌆𝌆", 3), "𝌆𝌆…");
24 |     assertEquals(clip("😔🙏👙😃🏧", 6), "😔🙏👙😃🏧");
25 |     assertEquals(clip("😔🙏👙😃🏧", 5), "😔🙏👙😃🏧");
26 |     assertEquals(clip("😔🙏👙😃🏧", 4), "😔🙏👙…");
27 |     assertEquals(clip("😔🙏👙😃🏧", 3), "😔🙏…");
28 | });
29 | 
30 | Deno.test("plain-text: test word breaking", () => {
31 |     const options = { breakWords: true };
32 | 
33 |     assertEquals(clip("Lorum ipsum", 5, options), "Loru\u2026");
34 |     assertEquals(clip("Lorum ipsum", 6, options), "Lorum\u2026");
35 |     assertEquals(clip("Lorum ipsum", 7, options), "Lorum\u2026");
36 |     assertEquals(clip("Lorum ipsum", 8, options), "Lorum i\u2026");
37 |     assertEquals(clip("Lorum ipsum", 9, options), "Lorum ip\u2026");
38 |     assertEquals(clip("Lorum ipsum", 10, options), "Lorum ips\u2026");
39 |     assertEquals(clip("Lorum ipsum", 11, options), "Lorum ipsum");
40 | });
41 | 
42 | Deno.test("plain-text: test word breaking without indicator", () => {
43 |     const options = { breakWords: true, indicator: "" };
44 | 
45 |     assertEquals(clip("Lorum ipsum", 5, options), "Lorum");
46 |     assertEquals(clip("Lorum ipsum", 6, options), "Lorum");
47 |     assertEquals(clip("Lorum ipsum", 7, options), "Lorum i");
48 |     assertEquals(clip("Lorum ipsum", 8, options), "Lorum ip");
49 |     assertEquals(clip("Lorum ipsum", 9, options), "Lorum ips");
50 |     assertEquals(clip("Lorum ipsum", 10, options), "Lorum ipsu");
51 |     assertEquals(clip("Lorum ipsum", 11, options), "Lorum ipsum");
52 | });
53 | 
54 | Deno.test("plain-text: test max lines", () => {
55 |     assertEquals(clip("Lorum\nipsum", 100, { maxLines: 2 }), "Lorum\nipsum");
56 |     assertEquals(clip("Lorum\nipsum", 100, { maxLines: 1 }), "Lorum\u2026");
57 |     assertEquals(clip("Lorum\n\nipsum", 100, { maxLines: 2 }), "Lorum\u2026");
58 | 
59 |     assertEquals(clip("Lorum\nipsum\n", 100, { maxLines: 2 }), "Lorum\nipsum");
60 |     assertEquals(clip("Lorum\nipsum\n\n", 100, { maxLines: 2 }), "Lorum\nipsum");
61 | });
62 | 
63 | Deno.test("plain-text: disable indicator at line break", () => {
64 |     const options = { insertIndicatorAtLinebreak: false };
65 | 
66 |     assertEquals(clip("Lorum\nipsum", 10, options), "Lorum");
67 |     assertEquals(clip("Lorum\nipsum", 100, { ...options, maxLines: 1 }), "Lorum");
68 |     assertEquals(clip("Lorum\n\nipsum", 100, { ...options, maxLines: 2 }), "Lorum");
69 | });
70 | 
71 | Deno.test("plain-text: test edge cases", () => {
72 |     const options = { breakWords: true, html: true, indicator: "..." };
73 | 
74 |     assertEquals(clip("one two - three \nfour five", 0, options), "...");
75 |     assertEquals(clip("one two - three \nfour five", 6, options), "one...");
76 | });
77 | 


--------------------------------------------------------------------------------