@splendidlabz/utils 1.5.0 → 1.6.0

package/lib/hash.spec.js

@@ -0,0 +1,163 @@
+import { describe, expect, it } from 'vitest'
+import { isHashedValue } from './hash.js'
+
+describe('isHashedValue', () => {
+  describe('SHA256 hashes', () => {
+    it('returns true for valid SHA256 hash', () => {
+      const validSha256 =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
+      expect(isHashedValue(validSha256)).toBe(true) // default type
+    })
+
+    it('returns true for valid SHA256 hash with uppercase letters', () => {
+      const validSha256 =
+        'A665A45920422F9D417E4867EFDC4FB8A04A1F3FFF1FA07E998E86F7F7A27AE3'
+      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
+    })
+
+    it('returns true for valid SHA256 hash with mixed case', () => {
+      const validSha256 =
+        'A665a45920422F9d417E4867efdc4FB8a04a1F3fff1FA07e998E86f7f7A27ae3'
+      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
+    })
+
+    it('returns false for SHA256 hash with wrong length', () => {
+      const shortHash =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae'
+      const longHash =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae33'
+      expect(isHashedValue(shortHash, 'sha256')).toBe(false)
+      expect(isHashedValue(longHash, 'sha256')).toBe(false)
+    })
+
+    it('returns false for SHA256 hash with invalid characters', () => {
+      const invalidHash =
+        'g665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      expect(isHashedValue(invalidHash, 'sha256')).toBe(false)
+    })
+  })
+
+  describe('SHA1 hashes', () => {
+    it('returns true for valid SHA1 hash', () => {
+      const validSha1 = '356a192b7913b04c54574d18c28d46e6395428ab'
+      expect(isHashedValue(validSha1, 'sha1')).toBe(true)
+    })
+
+    it('returns true for valid SHA1 hash with uppercase letters', () => {
+      const validSha1 = '356A192B7913B04C54574D18C28D46E6395428AB'
+      expect(isHashedValue(validSha1, 'sha1')).toBe(true)
+    })
+
+    it('returns false for SHA1 hash with wrong length', () => {
+      const shortHash = '356a192b7913b04c54574d18c28d46e6395428a'
+      const longHash = '356a192b7913b04c54574d18c28d46e6395428abb'
+      expect(isHashedValue(shortHash, 'sha1')).toBe(false)
+      expect(isHashedValue(longHash, 'sha1')).toBe(false)
+    })
+
+    it('returns false for SHA1 hash with invalid characters', () => {
+      const invalidHash = '356g192b7913b04c54574d18c28d46e6395428ab'
+      expect(isHashedValue(invalidHash, 'sha1')).toBe(false)
+    })
+  })
+
+  describe('MD5 hashes', () => {
+    it('returns true for valid MD5 hash', () => {
+      const validMd5 = '5d41402abc4b2a76b9719d911017c592'
+      expect(isHashedValue(validMd5, 'md5')).toBe(true)
+    })
+
+    it('returns true for valid MD5 hash with uppercase letters', () => {
+      const validMd5 = '5D41402ABC4B2A76B9719D911017C592'
+      expect(isHashedValue(validMd5, 'md5')).toBe(true)
+    })
+
+    it('returns false for MD5 hash with wrong length', () => {
+      const shortHash = '5d41402abc4b2a76b9719d911017c59'
+      const longHash = '5d41402abc4b2a76b9719d911017c5922'
+      expect(isHashedValue(shortHash, 'md5')).toBe(false)
+      expect(isHashedValue(longHash, 'md5')).toBe(false)
+    })
+
+    it('returns false for MD5 hash with invalid characters', () => {
+      const invalidHash = '5g41402abc4b2a76b9719d911017c592'
+      expect(isHashedValue(invalidHash, 'md5')).toBe(false)
+    })
+  })
+
+  describe('Type parameter handling', () => {
+    it('handles case insensitive type parameter', () => {
+      const validSha256 =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      expect(isHashedValue(validSha256, 'SHA256')).toBe(true)
+      expect(isHashedValue(validSha256, 'Sha256')).toBe(true)
+      expect(isHashedValue(validSha256, 'sHa256')).toBe(true)
+    })
+
+    it('returns null for unsupported hash type', () => {
+      const validSha256 =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      expect(isHashedValue(validSha256, 'sha512')).toBe(null)
+      expect(isHashedValue(validSha256, 'blake2b')).toBe(null)
+      expect(isHashedValue(validSha256, 'unknown')).toBe(null)
+    })
+  })
+
+  describe('Input validation', () => {
+    it('returns null for non-string inputs', () => {
+      expect(isHashedValue(null)).toBe(null)
+      expect(isHashedValue(undefined)).toBe(null)
+      expect(isHashedValue(123)).toBe(null)
+      expect(isHashedValue([])).toBe(null)
+      expect(isHashedValue({})).toBe(null)
+      expect(isHashedValue(true)).toBe(null)
+    })
+
+    it('handles empty string', () => {
+      expect(isHashedValue('')).toBe(false)
+      expect(isHashedValue('', 'sha1')).toBe(false)
+      expect(isHashedValue('', 'md5')).toBe(false)
+    })
+
+    it('trims whitespace from input', () => {
+      const validSha256 =
+        '  a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3  '
+      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
+    })
+
+    it('returns false for strings with only whitespace', () => {
+      expect(isHashedValue('   ')).toBe(false)
+      expect(isHashedValue('\t\n')).toBe(false)
+    })
+  })
+
+  describe('Edge cases', () => {
+    it('returns false for strings that are all zeros but correct length', () => {
+      const zeroSha256 =
+        '0000000000000000000000000000000000000000000000000000000000000000'
+      const zeroSha1 = '0000000000000000000000000000000000000000'
+      const zeroMd5 = '00000000000000000000000000000000'
+
+      expect(isHashedValue(zeroSha256, 'sha256')).toBe(true)
+      expect(isHashedValue(zeroSha1, 'sha1')).toBe(true)
+      expect(isHashedValue(zeroMd5, 'md5')).toBe(true)
+    })
+
+    it('returns false for correct length but non-hex characters', () => {
+      const nonHexSha256 =
+        'g665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      const nonHexSha1 = '356g192b7913b04c54574d18c28d46e6395428ab'
+      const nonHexMd5 = '5g41402abc4b2a76b9719d911017c592'
+
+      expect(isHashedValue(nonHexSha256, 'sha256')).toBe(false)
+      expect(isHashedValue(nonHexSha1, 'sha1')).toBe(false)
+      expect(isHashedValue(nonHexMd5, 'md5')).toBe(false)
+    })
+
+    it('handles special characters correctly', () => {
+      const specialChars = '!@#$%^&*()_+-=[]{}|;:,.<>?/~`'
+      expect(isHashedValue(specialChars, 'sha256')).toBe(false)
+    })
+  })
+})

package/lib/index.js

@@ -4,9 +4,11 @@ export * from './checks.js'
 export * from './date/index.js'
 export * from './form/index.js'
 export * from './functions/index.js'
+export * from './hash.js'
 export * from './numbers/index.js'
 export * from './objects/index.js'
 export * from './promises/index.js'
+export * from './sse.js'
 export * from './strings/index.js'
 export * from './style/index.js'
 export * from './symbols/index.js'

package/lib/numbers/index.js

@@ -1,3 +1,5 @@
+export * from './math.js'
+
 export function splitUnit(string) {
   // If there are no units, return the number straight.
   if (typeof string === 'number') return [string, null]

package/lib/numbers/math.js

@@ -0,0 +1,9 @@
+// Convert radians to degrees
+export function toDegrees(angle) {
+  return angle * (180 / Math.PI)
+}
+
+// Convert degrees to radians
+export function toRadians(angle) {
+  return angle * (Math.PI / 180)
+}

package/lib/objects/equal.js

@@ -0,0 +1,9 @@
+import deepEqual from 'deep-eql'
+
+export function isEqual(a, b) {
+  return deepEqual(a, b)
+}
+
+export function notEqual(a, b) {
+  return !isEqual(a, b)
+}

package/lib/objects/index.js

@@ -1,5 +1,6 @@
 export * from './camelcase-keys.js'
 export * from './empty.js'
+export * from './equal.js'
 export * from './extend.js'
 export * from './flatten.js'
 export * from './json.js'

package/lib/objects/mix/mix.js

@@ -1,6 +1,8 @@
 export function mix(...sources) {
   const result = {}
   for (const source of sources) {
+    // Skip null or undefined sources
+    if (source == null) continue
     merge(result, source)
   }
   return result

package/lib/objects/mix/mix.test.js

@@ -322,3 +322,27 @@ it('Safe Merge', () => {
   expect(mixed.__proto__).toEqual({})
   /* eslint-enable */
 })
+
+it('should skip null and undefined sources', () => {
+  const obj1 = { a: 1 }
+  const obj2 = { b: 2 }
+  const expected = { a: 1, b: 2 }
+
+  expect(mix(obj1, null, obj2)).toEqual(expected)
+  expect(mix(null, obj1, obj2)).toEqual(expected)
+  expect(mix(obj1, obj2, null)).toEqual(expected)
+
+  expect(mix(obj1, undefined, obj2)).toEqual(expected)
+  expect(mix(undefined, obj1, obj2)).toEqual(expected)
+  expect(mix(obj1, obj2, undefined)).toEqual(expected)
+
+  expect(mix(null, obj1, undefined, obj2, null)).toEqual(expected)
+})
+
+it('should not skip null and false properties', () => {
+  const obj1 = { a: 1, b: 2, c: 3 }
+  const obj2 = { a: null, b: false, c: undefined }
+  const expected = { a: null, b: false, c: undefined }
+
+  expect(mix(obj1, obj2)).toEqual(expected)
+})

package/lib/objects/nested-property.js

@@ -34,3 +34,8 @@ export function getNestedProperty2(object, path) {
   const pathArray = path.split('.')
   return getNestedProperty(object, pathArray)
 }
+
+// Same as dot syntax, but terser and more readable name
+export function getNestedValue(object, path) {
+  return path.split('.').reduce((acc, part) => acc?.[part], object)
+}

package/lib/objects/split.js

@@ -15,5 +15,5 @@ export function splitObject(obj, keys) {
     }
   })
 
-  return { picked, omitted }
+  return { picked, omitted, p: picked, o: omitted }
 }

package/lib/sse.js

@@ -0,0 +1,61 @@
+// Server Sent Events (SSE) 
+import { parseJSON } from './objects/json.js'
+import { omitEmpty } from './objects/omit-empty.js'
+
+export function createSSE({ event, data, id, retry }) {
+  const eventString = event ? `event: ${event}\n` : ''
+  const idString = id ? `id: ${id}\n` : ''
+  const retryString = retry ? `retry: ${retry}\n` : ''
+  
+  if (typeof data === 'object') data = JSON.stringify(data)
+  const dataString = data ? `data: ${data}\n` : ''
+
+  return `${eventString}${dataString}${idString}${retryString}\n`
+}
+
+/**
+ * Parses a single SSE message into a structured object
+ * @param {string} message - The raw SSE message
+ * @returns {Object|null} The parsed message or null if invalid
+ * @property {string} [event] - The event type if specified
+ * @property {string|Object} data - The message data (parsed as JSON if possible)
+ * @property {string} [id] - The message ID if specified
+ * @property {number} [retry] - The retry interval if specified
+ */
+export function parseSSE(message) {
+  const lines = message.split('\n')
+  const result = {
+    event: 'message', // Default event type
+    data: '',
+    id: null,
+    retry: null
+  }
+
+  for (const line of lines) {
+    if (line.startsWith('data:')) {
+      const data = line.slice(5).trim()
+      result.data = parseJSON(data)
+      continue
+    } 
+    
+    if (line.startsWith('event:')) {
+      result.event = line.slice(6).trim()
+      continue
+    } 
+    
+    if (line.startsWith('id:')) {
+      result.id = line.slice(3).trim()
+      continue
+    } 
+
+    if (line.startsWith('retry:')) {
+      result.retry = parseInt(line.slice(6).trim(), 10)
+      continue
+    }
+  }
+
+
+  const ret = omitEmpty(result)
+  return ret.data ? ret : null
+}
+

package/lib/strings/index.js

@@ -1,4 +1,5 @@
 export * from './convert-case/convert-case.js'
 export * from './markdown.js'
+export * from './name.js'
 export * from './pluralize.js'
 export * from './query-string.js'

package/lib/strings/markdown.js

@@ -1,13 +1,34 @@
+import { marked } from 'marked'
+import { gfmHeadingId } from 'marked-gfm-heading-id'
+import { mangle } from 'marked-mangle'
+
 /**
- * Removes leading whitespaces from a Markdown content so they can be rendered appropriately.
- * @param {string} content - The content to treat
- * @param {Boolean} options.inline - Whether content is inline, not block
- * @returns
+ * Converts markdown content to HTML with whitespace handling
+ * @param {string} content - Markdown content to convert
+ * @param {Object} [options={}] - Conversion options
+ * @param {boolean} [options.inline=false] - Whether content should be treated as inline markdown
+ * @returns {string|Promise<string>} HTML string or Promise that resolves to HTML string
  */
-export function treatMarkdownWhitespace(
-  content,
-  { inline, isSlot = false } = {},
-) {
+export function markdown(content, options = {}) {
+  const defaultOptions = { inline: false }
+  const opts = { ...defaultOptions, ...options }
+
+  // Prepare Marked
+  marked.use(mangle())
+  marked.use(gfmHeadingId())
+
+  const { content: treated } = treatMarkdownWhitespace(content, opts)
+  return marked.parse(treated)
+}
+
+/**
+ * Handles whitespace in markdown content to ensure proper rendering
+ * @param {string} content - Markdown content to process
+ * @param {Object} [options={}] - Processing options
+ * @param {boolean} [options.inline=false] - Whether content is inline markdown
+ * @returns {{ content: string, inline: boolean }} Processed content and inline status
+ */
+export function treatMarkdownWhitespace(content, { inline } = {}) {
   if (!content) return { content: '', inline }
   const lines = content.split('\n')
 
@@ -19,9 +40,7 @@ export function treatMarkdownWhitespace(
   const firstLineWithLeadingSpacesIndex = lines.findIndex(line =>
     line.match(/^\s+/),
   )
-
   const firstLineWithLeadingSpaces = lines[firstLineWithLeadingSpacesIndex]
-
   const indentation =
     firstLineWithLeadingSpaces?.match(/^\s+/)?.[0]?.length ?? 0
 

package/lib/strings/name.js

@@ -0,0 +1,24 @@
+export function parseFullName(name) {
+  const parts = name.trim().split(/\s+/)
+
+  if (parts.length === 1) {
+    return { firstName: parts[0], middleName: '', lastName: '' }
+  }
+
+  if (parts.length === 2) {
+    return { firstName: parts[0], middleName: '', lastName: parts[1] }
+  }
+
+  if (parts.length === 3) {
+    const firstName = parts.slice(0, 2).join(' ')
+    const lastName = parts[2]
+    return { firstName, middleName: '', lastName }
+  }
+
+  // 4+ words: first 2 words = firstName, last word = lastName, middle = middleName
+  const firstName = parts.slice(0, 2).join(' ')
+  const lastName = parts[parts.length - 1]
+  const middleName = parts.slice(2, -1).join(' ')
+
+  return { firstName, middleName, lastName }
+}

package/lib/strings/name.test.js

@@ -0,0 +1,67 @@
+import { describe, expect, test } from 'vitest'
+import { parseFullName } from './name.js'
+
+describe('parseFullName', () => {
+  test('handles single name', () => {
+    const result = parseFullName('John')
+    expect(result).toEqual({
+      firstName: 'John',
+      middleName: '',
+      lastName: '',
+    })
+  })
+
+  test('handles two names', () => {
+    const result = parseFullName('John Doe')
+    expect(result).toEqual({
+      firstName: 'John',
+      middleName: '',
+      lastName: 'Doe',
+    })
+  })
+
+  test('handles three names (Chinese pattern)', () => {
+    const result = parseFullName('Wee Keat Liew')
+    expect(result).toEqual({
+      firstName: 'Wee Keat',
+      middleName: '',
+      lastName: 'Liew',
+    })
+  })
+
+  test('handles four names with middle name', () => {
+    const result = parseFullName('Mary Jane Michael Doe')
+    expect(result).toEqual({
+      firstName: 'Mary Jane',
+      middleName: 'Michael',
+      lastName: 'Doe',
+    })
+  })
+
+  test('handles five names with multiple middle names', () => {
+    const result = parseFullName('Mary Jane Catherine Elizabeth Doe')
+    expect(result).toEqual({
+      firstName: 'Mary Jane',
+      middleName: 'Catherine Elizabeth',
+      lastName: 'Doe',
+    })
+  })
+
+  test('handles extra whitespace', () => {
+    const result = parseFullName('  John   Doe  ')
+    expect(result).toEqual({
+      firstName: 'John',
+      middleName: '',
+      lastName: 'Doe',
+    })
+  })
+
+  test('handles multiple spaces between words', () => {
+    const result = parseFullName('Wee    Keat   Liew')
+    expect(result).toEqual({
+      firstName: 'Wee Keat',
+      middleName: '',
+      lastName: 'Liew',
+    })
+  })
+})

package/node/dirname.js

@@ -1,5 +1,5 @@
+import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import path from 'path'
 
 /**
  * Returns __dirname

package/node/file-cache.js

@@ -3,7 +3,18 @@ import glob from 'glob-promise'
 import path from 'node:path'
 import { sort } from '../lib/arrays/index.js'
 
-// Newer and nicer API
+/**
+ * Creates a file cache instance for managing cached files in a directory
+ * @param {string} dir - Relative path to cache directory
+ * @returns {Promise<object>} Cache instance
+ * @property {function(string): Promise<number>} cacheAt - Returns the cached file's modified timestamp, or directory's last modified time if no file specified
+ * @property {function(string): string} getAbsPath - Returns absolute path for a file in cache
+ * @property {function(string): Promise<boolean>} hasFile - Checks if a file exists in cache
+ * @property {function(string): Promise<Buffer|undefined>} loadFile - Loads file contents from cache
+ * @property {function(string, string|Buffer): Promise<void>} saveFile - Saves data to cache file
+ * @property {function(string): Promise<object>} loadJSON - Loads and parses JSON from cache file
+ * @property {function(string, object): Promise<void>} saveJSON - Saves object as JSON to cache file
+ */
 export async function createCache(dir) {
   const absDirpath = path.join(process.cwd(), dir)
   await fs.mkdir(absDirpath, { recursive: true })
@@ -56,7 +67,7 @@ export async function createCache(dir) {
     async loadJSON(file) {
       const data = await this.loadFile(file)
       try {
-        return JSON.parse(data)
+        return JSON.parse(data.toString())
       } catch (err) {
         console.warn(`Error parsing JSON: ${file}`)
         return {}
@@ -69,7 +80,19 @@ export async function createCache(dir) {
   }
 }
 
-// Legacy, not so nice API
+/**
+ * Legacy file cache API for managing a single cached file
+ * @param {Object} options
+ * @param {string} options.dir - Relative path to cache directory
+ * @param {string} options.file - Filename to cache
+ * @returns {Promise<{
+ *   modifiedAt: number,
+ *   load: () => Promise<Buffer>,
+ *   save: (data: string|Buffer) => Promise<void>,
+ *   loadJSON: () => Promise<object>,
+ *   saveJSON: (data: object) => Promise<void>
+ * }>}
+ */
 export async function fileCache({ dir, file }) {
   // Makes the path if it doesn't exist
   await fs.mkdir(path.join(process.cwd(), dir), { recursive: true })
@@ -94,7 +117,8 @@ export async function fileCache({ dir, file }) {
     },
 
     async loadJSON() {
-      return JSON.parse(await fs.readFile(cachePath))
+      const data = await fs.readFile(cachePath)
+      return JSON.parse(data.toString())
     },
     async saveJSON(data) {
       await fs.writeFile(cachePath, JSON.stringify(data))
@@ -102,6 +126,11 @@ export async function fileCache({ dir, file }) {
   }
 }
 
+/**
+ * Gets the most recent modification time of files matching the glob pattern
+ * @param {string|string[]} globPath - Glob pattern(s) to match files
+ * @returns {Promise<number>} Timestamp of most recently modified file, or 0 if no files found
+ */
 export async function getLastModifiedTime(globPath) {
   let files
 
@@ -116,13 +145,18 @@ export async function getLastModifiedTime(globPath) {
     files = a.flat()
   }
 
-  files = await Promise.all(files.map(fs.stat))
-  files = files.map(file => file.mtimeMs)
+  const stats = await Promise.all(files.map(file => fs.stat(file)))
+  const timestamps = stats.map(stat => Number(stat.mtimeMs))
 
-  const sorted = sort(files, { sortBy: 'mtimeMs', order: 'desc' })
+  const sorted = sort(timestamps, { props: 'mtimeMs', reverse: true })
   return sorted[0] || 0
 }
 
+/**
+ * @deprecated Use getLastModifiedTime instead
+ * @param {string|string[]} globPath - Glob pattern(s) to match files
+ * @returns {Promise<number>} Timestamp of most recently modified file, or 0 if no files found
+ */
 export async function getLatestModifiedTime(globPath) {
   console.warn(
     '`getLatestModifiedTime` has been renamed to `getLastModifiedTime` and will be deprecated in future versions. Please use `getLastModifiedTime` instead.',
@@ -130,6 +164,11 @@ export async function getLatestModifiedTime(globPath) {
   return getLastModifiedTime(globPath)
 }
 
+/**
+ * Removes leading slash from a path string
+ * @param {string} x - Path string to process
+ * @returns {string} Path without leading slash
+ */
 export function removeFirstSlash(x) {
   return x.startsWith('/') ? x.slice(1) : x
 }

package/node/index.js

@@ -4,3 +4,4 @@ export * from './file-cache.js'
 export * from './hash.js'
 export * from './pkce.js'
 export * from './random-string.js'
+export * from './sanitize.js'

package/node/random-string.js

@@ -1,10 +1,10 @@
-// For Node only
 import crypto from 'node:crypto'
 
-export async function randomString(length = 32) {
-  return crypto.randomBytes(length).toString('base64')
-}
+export function randomString(length = 32) {
+  // Calculate bytes needed for desired character length
+  // Base64: 4 chars per 3 bytes, so we need ceil(length * 3 / 4) bytes
+  // Add extra bytes to ensure we have enough after encoding
+  const bytesNeeded = Math.ceil((length * 3) / 4) + 3
 
-export function randomStringSync(length = 32) {
-  return crypto.randomBytes(length).toString('hex')
+  return crypto.randomBytes(bytesNeeded).toString('base64').slice(0, length)
 }

package/node/random-string.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+import { randomString } from './random-string.js'
+
+describe('randomString', () => {
+  it('should generate a random string', () => {
+    const str = randomString(32)
+    expect(str).toBeDefined()
+    expect(str.length).toBe(32)
+
+    const str2 = randomString(40)
+    expect(str2).toBeDefined()
+    expect(str2.length).toBe(40)
+    expect(str2).not.toBe(str)
+  })
+})

package/node/sanitize.js

@@ -0,0 +1,13 @@
+import sanitizeHtml from 'sanitize-html'
+import { sanitize as sanitizeLib } from '../lib/form/sanitize.js'
+
+/**
+ * Sanitizes values using sanitize-html
+ * @param {*} value - Value to sanitize (string, array, or object)
+ * @param {Object} [options={}] - sanitize-html options
+ * @returns {*} Sanitized value
+ * @throws {Error} If input is a string but sanitize-html fails
+ */
+export function sanitize(value, options = {}) {
+  return sanitizeLib(value, { sanitizer: sanitizeHtml, ...options })
+}