bbcode-compiler 0.1.8 → 0.1.10

package/package.json

@@ -1,85 +1,85 @@
 {
-    "name": "bbcode-compiler",
-    "type": "module",
-    "version": "0.1.8",
-    "description": "Parses BBCode and generates HTML ",
-    "license": "MIT",
-    "private": false,
-    "sideEffects": false,
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "import": "./dist/index.js",
-            "require": "./dist/index.umd.cjs"
-        }
-    },
-    "files": [
-        "README.md",
-        "dist/*",
-        "src/*"
-    ],
-    "homepage": "https://trinovantes.github.io/bbcode-compiler/",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/Trinovantes/bbcode-compiler"
-    },
-    "author": {
-        "name": "Stephen",
-        "email": "hello@stephenli.ca",
-        "url": "https://www.stephenli.ca"
-    },
-    "scripts": {
-        "demoDev": "    vite         --config vite.config.demo.ts",
-        "demoBuild": "  vite build   --config vite.config.demo.ts",
-        "demoPreview": "vite preview --config vite.config.demo.ts",
-        "clean": "rm -rf ./dist ./demo/dist",
-        "build": "yarn clean && vite build",
-        "prepublishOnly": "yarn build",
-        "postinstall": "patch-package",
-        "lint": "vue-tsc --noEmit && eslint",
-        "test": "vitest",
-        "benchmark": " node --loader ts-node/esm --experimental-specifier-resolution=node                                 tests/benchmarks/benchmark.ts",
-        "profile": "   node --loader ts-node/esm --experimental-specifier-resolution=node --prof --no-logfile-per-isolate tests/benchmarks/profile.ts && node --prof-process v8.log > v8.txt"
-    },
-    "dependencies": {
-        "patch-package": "^8.0.0"
-    },
-    "devDependencies": {
-        "@bbob/html": "^3.0.0",
-        "@bbob/preset-html5": "^3.0.0",
-        "@eslint/compat": "^1.1.0",
-        "@eslint/js": "^9.4.0",
-        "@quasar/extras": "^1.16.11",
-        "@quasar/vite-plugin": "^1.7.0",
-        "@stylistic/eslint-plugin": "^2.1.0",
-        "@thoughtsunificator/bbcode-parser-template": "^1.0.9",
-        "@types/benchmark": "^2.1.1",
-        "@types/lodash.debounce": "^4.0.9",
-        "@types/markdown-it": "^14.1.1",
-        "@types/node": "^20.7.0",
-        "@vitejs/plugin-vue": "^5.0.5",
-        "bbcode": "^0.1.5",
-        "bbcode-parser": "^1.0.10",
-        "bbcodejs": "^0.0.4",
-        "benchmark": "^2.1.4",
-        "eslint": "^9.4.0",
-        "eslint-plugin-n": "^17.7.0",
-        "eslint-plugin-vue": "^9.9.0",
-        "lodash.debounce": "^4.0.8",
-        "lz-string": "^1.5.0",
-        "markdown-it": "^14.0.0",
-        "mitt": "^3.0.1",
-        "monaco-editor": "^0.50.0",
-        "quasar": "^2.16.4",
-        "sass": "^1.77.6",
-        "shiki": "^1.9.0",
-        "ts-bbcode-parser": "^1.0.4",
-        "ts-node": "^10.8.1",
-        "typescript": "^5.0.2",
-        "typescript-eslint": "^8.0.0-alpha.24",
-        "vite-plugin-dts": "^3.9.1",
-        "vitest": "^1.2.1",
-        "vue": "^3.4.30",
-        "ya-bbcode": "^4.0.0"
+  "name": "bbcode-compiler",
+  "type": "module",
+  "version": "0.1.10",
+  "description": "Parses BBCode and generates HTML ",
+  "license": "MIT",
+  "private": false,
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.umd.cjs"
     }
-}
+  },
+  "files": [
+    "README.md",
+    "dist/*",
+    "src/*"
+  ],
+  "homepage": "https://trinovantes.github.io/bbcode-compiler/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Trinovantes/bbcode-compiler"
+  },
+  "author": {
+    "name": "Stephen",
+    "email": "hello@stephenli.ca",
+    "url": "https://www.stephenli.ca"
+  },
+  "devDependencies": {
+    "@bbob/html": "^4.2.0",
+    "@bbob/preset-html5": "^4.2.0",
+    "@eslint/compat": "^1.1.0",
+    "@eslint/js": "^9.4.0",
+    "@quasar/extras": "^1.16.11",
+    "@quasar/vite-plugin": "^1.7.0",
+    "@stylistic/eslint-plugin": "^5.1.0",
+    "@thoughtsunificator/bbcode-parser-template": "^1.0.9",
+    "@types/benchmark": "^2.1.1",
+    "@types/lodash.debounce": "^4.0.9",
+    "@types/markdown-it": "^14.1.1",
+    "@types/node": "^22.10.0",
+    "@vitejs/plugin-vue": "^6.0.0",
+    "bbcode": "^0.1.5",
+    "bbcode-parser": "^1.0.10",
+    "bbcodejs": "^0.0.4",
+    "benchmark": "^2.1.4",
+    "eslint": "^9.4.0",
+    "eslint-plugin-n": "^17.7.0",
+    "eslint-plugin-vue": "^10.0.0",
+    "globals": "^16.4.0",
+    "lodash.debounce": "^4.0.8",
+    "lz-string": "^1.5.0",
+    "markdown-it": "^14.0.0",
+    "mitt": "^3.0.1",
+    "monaco-editor": "^0.53.0",
+    "quasar": "^2.16.4",
+    "sass": "^1.77.6",
+    "shiki": "^3.1.0",
+    "ts-bbcode-parser": "^1.0.4",
+    "ts-node": "^10.8.1",
+    "tsx": "^4.15.7",
+    "typescript": "^5.8.1-rc",
+    "typescript-eslint": "^8.0.0-alpha.24",
+    "vite": "^7.1.5",
+    "vite-plugin-dts": "^4.2.2",
+    "vitest": "^3.0.7",
+    "vue": "^3.4.30",
+    "vue-eslint-parser": "^10.1.3",
+    "vue-tsc": "^3.0.6",
+    "ya-bbcode": "^4.0.0"
+  },
+  "scripts": {
+    "demoDev": "    vite         --config vite.config.demo.ts",
+    "demoBuild": "  vite build   --config vite.config.demo.ts",
+    "demoPreview": "vite preview --config vite.config.demo.ts",
+    "clean": "rm -rf ./dist ./demo/dist",
+    "build": "vite build",
+    "lint": "vue-tsc && eslint",
+    "test": "vitest",
+    "benchmark": "tsx tests/benchmarks/benchmark.ts",
+    "profile": "tsx --prof --no-logfile-per-isolate tests/benchmarks/profile.ts && node --prof-process v8.log > v8.txt"
+  }
+}

package/src/generator/Generator.ts

@@ -1,4 +1,4 @@
-import { AstNode, AstNodeType, RootNode } from '../parser/AstNode.js'
+import { AstNode, RootNode } from '../parser/AstNode.js'
 import { nodeIsType } from '../parser/nodeIsType.js'
 import { htmlTransforms } from './transforms/htmlTransforms.js'
 import type { Transform } from './transforms/Transform.js'
@@ -14,7 +14,7 @@ export class Generator {
         const stringify = (node: AstNode): string => {
             let output = ''
 
-            if (nodeIsType(node, AstNodeType.TagNode)) {
+            if (nodeIsType(node, 'TagNode')) {
                 const tagName = node.tagName
                 const transform = this.transforms.get(tagName)
                 if (!transform) {
@@ -42,9 +42,9 @@ export class Generator {
                 } else {
                     output += renderedEndTag
                 }
-            } else if (nodeIsType(node, AstNodeType.TextNode)) {
+            } else if (nodeIsType(node, 'TextNode')) {
                 output += node.str
-            } else if (nodeIsType(node, AstNodeType.LinebreakNode)) {
+            } else if (nodeIsType(node, 'LinebreakNode')) {
                 output += '\n'
             } else {
                 for (const child of node.children) {

package/src/generator/utils/getTagImmediateText.ts

@@ -1,4 +1,4 @@
-import { AstNodeType, TagNode } from '../../parser/AstNode.js'
+import { TagNode } from '../../parser/AstNode.js'
 import { nodeIsType } from '../../parser/nodeIsType.js'
 
 /**
@@ -16,7 +16,7 @@ export function getTagImmediateText(tagNode: TagNode): string | undefined {
     }
 
     const child = tagNode.children[0]
-    if (!nodeIsType(child, AstNodeType.RootNode)) {
+    if (!nodeIsType(child, 'RootNode')) {
         return undefined
     }
 
@@ -25,7 +25,7 @@ export function getTagImmediateText(tagNode: TagNode): string | undefined {
     }
 
     const textNode = child.children[0]
-    if (!nodeIsType(textNode, AstNodeType.TextNode)) {
+    if (!nodeIsType(textNode, 'TextNode')) {
         return undefined
     }
 

package/src/lexer/Lexer.ts

@@ -1,4 +1,4 @@
-import { symbolTable, TokenType } from './TokenType.js'
+import { symbolTable } from './TokenType.js'
 import type { Token } from './Token.js'
 
 export class Lexer {
@@ -25,7 +25,7 @@ export class Lexer {
             const length = match.index - offset
             if (length > 0) {
                 tokens.push({
-                    type: TokenType.STR,
+                    type: 'STR',
                     offset,
                     length,
                 })
@@ -37,21 +37,21 @@ export class Lexer {
             // In the regex '[/' takes precedence over '['
             if (match[0] === '[/') {
                 tokens.push({
-                    type: TokenType.L_BRACKET,
+                    type: 'L_BRACKET',
                     offset,
                     length: 1,
                 })
                 offset += 1
 
                 tokens.push({
-                    type: TokenType.BACKSLASH,
+                    type: 'BACKSLASH',
                     offset,
                     length: 1,
                 })
                 offset += 1
             } else if (match[0].startsWith('[')) {
                 tokens.push({
-                    type: TokenType.L_BRACKET,
+                    type: 'L_BRACKET',
                     offset,
                     length: 1,
                 })
@@ -59,14 +59,14 @@ export class Lexer {
 
                 const length = match[0].length - 1
                 tokens.push({
-                    type: TokenType.STR,
+                    type: 'STR',
                     offset,
                     length,
                 })
                 offset += length
             } else {
                 tokens.push({
-                    type: symbolTable[match[0]] ?? TokenType.STR,
+                    type: symbolTable[match[0]] ?? 'STR',
                     offset,
                     length: 1,
                 })
@@ -78,7 +78,7 @@ export class Lexer {
         const length = input.length - offset
         if (length > 0) {
             tokens.push({
-                type: TokenType.STR,
+                type: 'STR',
                 offset,
                 length,
             })

package/src/lexer/Token.ts

@@ -1,4 +1,4 @@
-import { TokenType } from './TokenType.js'
+import type { TokenType } from './TokenType.js'
 
 export type Token = {
     type: TokenType
@@ -11,49 +11,49 @@ export function stringifyTokens(ogText: string, tokens: ReadonlyArray<Token>): s
 
     for (const token of tokens) {
         switch (token.type) {
-            case TokenType.STR: {
+            case 'STR': {
                 s += ogText.substring(token.offset, token.offset + token.length)
                 break
             }
-            case TokenType.LINEBREAK: {
+            case 'LINEBREAK': {
                 s += '\n'
                 break
             }
 
-            case TokenType.L_BRACKET: {
+            case 'L_BRACKET': {
                 s += '['
                 break
             }
-            case TokenType.R_BRACKET: {
+            case 'R_BRACKET': {
                 s += ']'
                 break
             }
-            case TokenType.BACKSLASH: {
+            case 'BACKSLASH': {
                 s += '/'
                 break
             }
-            case TokenType.EQUALS: {
+            case 'EQUALS': {
                 s += '='
                 break
             }
 
-            case TokenType.XSS_AMP: {
+            case 'XSS_AMP': {
                 s += '&amp;'
                 break
             }
-            case TokenType.XSS_LT: {
+            case 'XSS_LT': {
                 s += '&lt;'
                 break
             }
-            case TokenType.XSS_GT: {
+            case 'XSS_GT': {
                 s += '&gt;'
                 break
             }
-            case TokenType.XSS_D_QUOTE: {
+            case 'XSS_D_QUOTE': {
                 s += '&quot;'
                 break
             }
-            case TokenType.XSS_S_QUOTE: {
+            case 'XSS_S_QUOTE': {
                 s += '&#x27;'
                 break
             }

package/src/lexer/TokenType.ts

@@ -1,47 +1,46 @@
-export const enum TokenType {
-    STR,
-    LINEBREAK,
+export type TokenType =
+    | 'STR'
+    | 'LINEBREAK'
 
     // BBCode symbols
-    L_BRACKET,
-    R_BRACKET,
-    BACKSLASH,
-    EQUALS,
+    | 'L_BRACKET'
+    | 'R_BRACKET'
+    | 'BACKSLASH'
+    | 'EQUALS'
 
     // XSS symbols
-    XSS_AMP,
-    XSS_LT,
-    XSS_GT,
-    XSS_D_QUOTE,
-    XSS_S_QUOTE,
-}
+    | 'XSS_AMP'
+    | 'XSS_LT'
+    | 'XSS_GT'
+    | 'XSS_D_QUOTE'
+    | 'XSS_S_QUOTE'
 
 export function tokenTypeToString(tokenType: TokenType): string {
     switch (tokenType) {
-        case TokenType.STR: return 'STR'
-        case TokenType.LINEBREAK: return 'LINEBREAK'
+        case 'STR': return 'STR'
+        case 'LINEBREAK': return 'LINEBREAK'
 
-        case TokenType.L_BRACKET: return 'L_BRACKET'
-        case TokenType.R_BRACKET: return 'R_BRACKET'
-        case TokenType.BACKSLASH: return 'BACKSLASH'
-        case TokenType.EQUALS: return 'EQUALS'
+        case 'L_BRACKET': return 'L_BRACKET'
+        case 'R_BRACKET': return 'R_BRACKET'
+        case 'BACKSLASH': return 'BACKSLASH'
+        case 'EQUALS': return 'EQUALS'
 
-        case TokenType.XSS_AMP: return 'XSS_AMP'
-        case TokenType.XSS_LT: return 'XSS_LT'
-        case TokenType.XSS_GT: return 'XSS_GT'
-        case TokenType.XSS_D_QUOTE: return 'XSS_D_QUOTE'
-        case TokenType.XSS_S_QUOTE: return 'XSS_S_QUOTE'
+        case 'XSS_AMP': return 'XSS_AMP'
+        case 'XSS_LT': return 'XSS_LT'
+        case 'XSS_GT': return 'XSS_GT'
+        case 'XSS_D_QUOTE': return 'XSS_D_QUOTE'
+        case 'XSS_S_QUOTE': return 'XSS_S_QUOTE'
     }
 }
 
 export function isStringToken(tokenType: TokenType): boolean {
     switch (tokenType) {
-        case TokenType.XSS_AMP:
-        case TokenType.XSS_LT:
-        case TokenType.XSS_GT:
-        case TokenType.XSS_D_QUOTE:
-        case TokenType.XSS_S_QUOTE:
-        case TokenType.STR: {
+        case 'XSS_AMP':
+        case 'XSS_LT':
+        case 'XSS_GT':
+        case 'XSS_D_QUOTE':
+        case 'XSS_S_QUOTE':
+        case 'STR': {
             return true
         }
     }
@@ -50,16 +49,16 @@ export function isStringToken(tokenType: TokenType): boolean {
 }
 
 export const symbolTable: Record<string, TokenType | undefined> = {
-    '\n': TokenType.LINEBREAK,
+    '\n': 'LINEBREAK',
 
-    '[': TokenType.L_BRACKET,
-    ']': TokenType.R_BRACKET,
-    '/': TokenType.BACKSLASH,
-    '=': TokenType.EQUALS,
+    '[': 'L_BRACKET',
+    ']': 'R_BRACKET',
+    '/': 'BACKSLASH',
+    '=': 'EQUALS',
 
-    '&': TokenType.XSS_AMP,
-    '<': TokenType.XSS_LT,
-    '>': TokenType.XSS_GT,
-    '"': TokenType.XSS_D_QUOTE,
-    "'": TokenType.XSS_S_QUOTE,
+    '&': 'XSS_AMP',
+    '<': 'XSS_LT',
+    '>': 'XSS_GT',
+    '"': 'XSS_D_QUOTE',
+    "'": 'XSS_S_QUOTE',
 }

package/src/parser/AstNode.ts

@@ -39,15 +39,14 @@ import { nodeIsType } from './nodeIsType.js'
 // MARK: AstNode
 // ----------------------------------------------------------------------------
 
-export const enum AstNodeType {
-    RootNode = 'RootNode',
-    TextNode = 'TextNode',
-    LinebreakNode = 'LinebreakNode',
-    TagNode = 'TagNode',
-    StartTagNode = 'StartTagNode',
-    EndTagNode = 'EndTagNode',
-    AttrNode = 'AttrNode',
-}
+export type AstNodeType =
+    | 'RootNode'
+    | 'TextNode'
+    | 'LinebreakNode'
+    | 'TagNode'
+    | 'StartTagNode'
+    | 'EndTagNode'
+    | 'AttrNode'
 
 export type AstNodeJson = {
     type: AstNodeType
@@ -58,10 +57,12 @@ export type AstNodeJson = {
 export abstract class AstNode {
     readonly abstract nodeType: AstNodeType
 
+    readonly children: Array<AstNode>
+
     constructor(
-        readonly children: Array<AstNode> = [],
+        children = new Array<AstNode>(),
     ) {
-        // nop
+        this.children = children
     }
 
     addChild(node: AstNode): void {
@@ -112,13 +113,13 @@ export abstract class AstNode {
 // ----------------------------------------------------------------------------
 
 export class RootNode extends AstNode {
-    readonly nodeType = AstNodeType.RootNode
+    readonly nodeType = 'RootNode'
 
     override isValid(): boolean {
         for (const child of this.children) {
-            if (child.nodeType !== AstNodeType.TagNode &&
-                child.nodeType !== AstNodeType.TextNode &&
-                child.nodeType !== AstNodeType.LinebreakNode) {
+            if (child.nodeType !== 'TagNode' &&
+                child.nodeType !== 'TextNode' &&
+                child.nodeType !== 'LinebreakNode') {
                 return false
             }
         }
@@ -132,7 +133,7 @@ export class RootNode extends AstNode {
 // ----------------------------------------------------------------------------
 
 export class TextNode extends AstNode {
-    readonly nodeType = AstNodeType.TextNode
+    readonly nodeType = 'TextNode'
     readonly str: string
 
     constructor(str: string) {
@@ -160,7 +161,7 @@ export class TextNode extends AstNode {
 }
 
 export class LinebreakNode extends AstNode {
-    readonly nodeType = AstNodeType.LinebreakNode
+    readonly nodeType = 'LinebreakNode'
 
     override toShortString(): string {
         return `${super.toShortString()} "\\n"`
@@ -172,7 +173,7 @@ export class LinebreakNode extends AstNode {
 // ----------------------------------------------------------------------------
 
 export class AttrNode extends AstNode {
-    readonly nodeType = AstNodeType.AttrNode
+    readonly nodeType = 'AttrNode'
 
     static readonly DEFAULT_KEY = 'default'
 
@@ -182,7 +183,7 @@ export class AttrNode extends AstNode {
                 return AttrNode.DEFAULT_KEY
             }
             case 2: {
-                if (!nodeIsType(this.children[0], AstNodeType.TextNode)) {
+                if (!nodeIsType(this.children[0], 'TextNode')) {
                     throw new Error('Invalid TextNode')
                 }
 
@@ -196,14 +197,14 @@ export class AttrNode extends AstNode {
     get val(): string {
         switch (this.children.length) {
             case 1: {
-                if (!nodeIsType(this.children[0], AstNodeType.TextNode)) {
+                if (!nodeIsType(this.children[0], 'TextNode')) {
                     throw new Error('Invalid TextNode')
                 }
 
                 return this.children[0].str.trim()
             }
             case 2: {
-                if (!nodeIsType(this.children[1], AstNodeType.TextNode)) {
+                if (!nodeIsType(this.children[1], 'TextNode')) {
                     throw new Error('Invalid TextNode')
                 }
 
@@ -265,7 +266,7 @@ export class AttrNode extends AstNode {
 // ----------------------------------------------------------------------------
 
 export class StartTagNode extends AstNode {
-    readonly nodeType = AstNodeType.StartTagNode
+    readonly nodeType = 'StartTagNode'
     readonly tagName: string
     readonly ogTag: string
 
@@ -277,7 +278,7 @@ export class StartTagNode extends AstNode {
 
     override isValid(): boolean {
         for (const child of this.children) {
-            if (child.nodeType !== AstNodeType.AttrNode) {
+            if (child.nodeType !== 'AttrNode') {
                 return false
             }
         }
@@ -301,7 +302,7 @@ export class StartTagNode extends AstNode {
 }
 
 export class EndTagNode extends AstNode {
-    readonly nodeType = AstNodeType.EndTagNode
+    readonly nodeType = 'EndTagNode'
     readonly tagName: string
     readonly ogTag: string
 
@@ -331,7 +332,7 @@ export class EndTagNode extends AstNode {
 }
 
 export class TagNode extends AstNode {
-    readonly nodeType = AstNodeType.TagNode
+    readonly nodeType = 'TagNode'
     private readonly _startTag: StartTagNode
     private readonly _endTag?: EndTagNode | LinebreakNode
 
@@ -358,7 +359,7 @@ export class TagNode extends AstNode {
             return ''
         }
 
-        if (nodeIsType(this._endTag, AstNodeType.LinebreakNode)) {
+        if (nodeIsType(this._endTag, 'LinebreakNode')) {
             return '\n'
         } else {
             return this._endTag.ogTag
@@ -366,11 +367,11 @@ export class TagNode extends AstNode {
     }
 
     override isValid(): boolean {
-        if (this._endTag && nodeIsType(this._endTag, AstNodeType.EndTagNode) && this._startTag.tagName !== this._endTag.tagName) {
+        if (this._endTag && nodeIsType(this._endTag, 'EndTagNode') && this._startTag.tagName !== this._endTag.tagName) {
             return false
         }
 
-        if (this.children.length === 1 && this.children[0].nodeType !== AstNodeType.RootNode) {
+        if (this.children.length === 1 && this.children[0].nodeType !== 'RootNode') {
             return false
         }