adofai 2.13.2 → 2.14.0

package/README.md

@@ -1,112 +1,112 @@
-# ADOFAI
-
-A Javascript library for ADOFAI levels.
-
-## Usage
-Preview / Edit the `.adofai` file.
-
-Re_ADOJAS(A Level Player of ADOFAI) uses `adofai` to parse ADOFAI Level file.
-
-## Installation
-
-```bash
-npm install adofai
-# or
-yarn add adofai
-# or
-pnpm install adofai
-```
-
-if you want to display highlight of adofai file, you can use `Rhythm Game Syntax Highlighter` vscode extension.
-
-## Got Started
-
-### Import
-
-For Commonjs:
-```ts
-const adofai = require('adofai');
-```
-
-For ES6 Modules:
-```ts
-import * as adofai from 'adofai';
-```
-
-### Create a Level
-
-```ts
-const file = new adofai.Level(adofaiFileContent);
-
-//or
-
-const parser = new adofai.Parsers.StringParser();
-const file = new adofai.Level(adofaiFileContent,parser);
-
-//The advantage of the latter over the former is that it pre-initializes the Parser, avoiding multiple instantiations.
-```
-
-Format:
-```ts
-class Level {
-    constructor(opt: string | LevelOptions, provider?: ParseProvider)
- }
-
-```
-Available ParseProviders: 
-`StringParser` `ArrayBufferParser` `BufferParser`
-
-
-Usually,only `StringParser` is needed.
-but you can use `BufferParser` to parse ADOFAI files in Node environment.
-
-On browser, you can also use `ArrayBuffer` to parse ADOFAI files.
-(`BufferParser` is not available in browser,but you can use browserify `Buffer` to polyfill)
-
-### Load Level
-```ts
-file.on('load'() => {
-    //logic...
-})
-file.load()
-```
-
-or you can use `then()`
-```ts
-file.load().then(() => {
-
-})
-```
-
-### Export Level
-```ts
-type FileType = 'string'|'object'
-
-file.export(type: FileType = 'string',indent?:number,useAdofaiStyle:boolean = true)
-```
-
-method `export()` returns a Object or String.
-
-Object: return ADOFAI Object.
-String: return ADOFAI String.
-
-```ts
-import fs from 'fs'
-type FileType = 'string'|'object'
-
-const content = file.export('string',null,true);
-fs.writeFileSync('output.adofai',content)
-```
-
-
-## Data Operation
-
-See interfaces to see all data.
-
-```ts
-//Get AngleDatas:
-const angleDatas = file.angleData;
-
-
-
+# ADOFAI
+
+A Javascript library for ADOFAI levels.
+
+## Usage
+Preview / Edit the `.adofai` file.
+
+Re_ADOJAS(A Level Player of ADOFAI) uses `adofai` to parse ADOFAI Level file.
+
+## Installation
+
+```bash
+npm install adofai
+# or
+yarn add adofai
+# or
+pnpm install adofai
+```
+
+if you want to display highlight of adofai file, you can use `Rhythm Game Syntax Highlighter` vscode extension.
+
+## Got Started
+
+### Import
+
+For Commonjs:
+```ts
+const adofai = require('adofai');
+```
+
+For ES6 Modules:
+```ts
+import * as adofai from 'adofai';
+```
+
+### Create a Level
+
+```ts
+const file = new adofai.Level(adofaiFileContent);
+
+//or
+
+const parser = new adofai.Parsers.StringParser();
+const file = new adofai.Level(adofaiFileContent,parser);
+
+//The advantage of the latter over the former is that it pre-initializes the Parser, avoiding multiple instantiations.
+```
+
+Format:
+```ts
+class Level {
+    constructor(opt: string | LevelOptions, provider?: ParseProvider)
+ }
+
+```
+Available ParseProviders: 
+`StringParser` `ArrayBufferParser` `BufferParser`
+
+
+Usually,only `StringParser` is needed.
+but you can use `BufferParser` to parse ADOFAI files in Node environment.
+
+On browser, you can also use `ArrayBuffer` to parse ADOFAI files.
+(`BufferParser` is not available in browser,but you can use browserify `Buffer` to polyfill)
+
+### Load Level
+```ts
+file.on('load'() => {
+    //logic...
+})
+file.load()
+```
+
+or you can use `then()`
+```ts
+file.load().then(() => {
+
+})
+```
+
+### Export Level
+```ts
+type FileType = 'string'|'object'
+
+file.export(type: FileType = 'string',indent?:number,useAdofaiStyle:boolean = true)
+```
+
+method `export()` returns a Object or String.
+
+Object: return ADOFAI Object.
+String: return ADOFAI String.
+
+```ts
+import fs from 'fs'
+type FileType = 'string'|'object'
+
+const content = file.export('string',null,true);
+fs.writeFileSync('output.adofai',content)
+```
+
+
+## Data Operation
+
+See interfaces to see all data.
+
+```ts
+//Get AngleDatas:
+const angleDatas = file.angleData;
+
+
+
 ```

package/dist/src/parser/BufferParser.d.ts

@@ -1,9 +1,11 @@
 import Parser from "./Parser";
-export declare class BufferParser extends Parser<Buffer | string, any> {
-    parse(input: Buffer | string): any;
+/**
+ * 字节流原生 JSON 解析器
+ * 直接在 Uint8Array 上运行状态机，支持非标换行，且无需预转字符串。
+ */
+export declare class BufferParser extends Parser<Uint8Array | Buffer | string, any> {
+    parse(input: Uint8Array | Buffer | string): any;
     stringify(obj: any): string;
 }
-export declare function stripBOM(buffer: Buffer): Buffer;
-export declare function normalizeJsonBuffer(text: Buffer): Buffer;
-export declare function decodeStringFromUTF8BOM(buffer: Buffer): string;
+export declare function stripBOM(buffer: Uint8Array | Buffer): Uint8Array;
 export default BufferParser;

package/dist/src/parser/BufferParser.js

@@ -1,196 +1,215 @@
 import Parser from "./Parser";
-import StringParser from "./StringParser";
-let BOM;
-let COMMA;
-let BufferAvailable = true;
-try {
-    BOM = Buffer.of(0xef, 0xbb, 0xbf);
-    COMMA = Buffer.from(",");
-}
-catch (e) {
-    BufferAvailable = false;
-    console.warn('Buffer is not available in current environment, try to use ArrayBufferParser');
-    // minimal shims to keep types happy; won't be used when BufferUnavailable
-    BOM = { equals: () => false, subarray: () => null };
-    COMMA = { equals: () => false, subarray: () => null };
-}
 /**
- * Inspect buffer to detect an unescaped raw newline inside a quoted string.
- * If found, we must fallback to the more tolerant StringParser.
+ * 字节流原生 JSON 解析器
+ * 直接在 Uint8Array 上运行状态机，支持非标换行，且无需预转字符串。
  */
-function hasRawNewlineInStringBuffer(buf) {
-    let last = "other";
-    for (let i = 0; i < buf.length; i++) {
-        const c = buf[i];
-        if (last === "escape") {
-            last = "string";
-            continue;
+export class BufferParser extends Parser {
+    parse(input) {
+        let u8;
+        if (typeof input === "string") {
+            // 如果输入是字符串，转为字节流处理以保持逻辑统一
+            u8 = new TextEncoder().encode(input);
         }
-        switch (c) {
-            case 34: // "
-                if (last === "string") {
-                    last = "other";
-                }
-                else {
-                    if (last === "comma") {
-                        // entering string after comma
-                    }
-                    last = "string";
-                }
-                break;
-            case 92: // \
-                if (last === "string")
-                    last = "escape";
-                break;
-            case 44: // ,
-                if (last === "other")
-                    last = "comma";
-                break;
-            case 93: // ]
-            case 125: // }
-                if (last === "comma")
-                    last = "other";
-                break;
-            // whitespace bytes
-            case 9:
-            case 10:
-            case 11:
-            case 12:
-            case 13:
-            case 32:
-                // If we see newline (10) or carriage (13) while inside a string AND not escaped,
-                // that's a raw newline in string -> not valid strict JSON; detect and return true.
-                if ((c === 10 || c === 13) && last === "string") {
-                    return true;
-                }
-                break;
-            default:
-                if (last === "comma") {
-                    last = "other";
-                }
-                break;
+        else {
+            u8 = stripBOM(input);
         }
+        const engine = new BufferParserEngine(u8);
+        return engine.parseValue();
+    }
+    stringify(obj) {
+        return JSON.stringify(obj);
     }
-    return false;
 }
-/**
- * Normalize buffer by removing insignificant whitespace outside strings.
- * Works on Uint8Array and returns Buffer (for node) or Uint8Array (for arraybuffer flow).
- * This function keeps contents inside strings untouched.
- */
-function normalizeJsonUint8(buf) {
-    const builder = [];
-    let last = "other";
-    let from = 0;
-    for (let i = 0; i < buf.length; i++) {
-        const charCode = buf[i];
-        if (last === "escape") {
-            last = "string";
-            continue;
+class BufferParserEngine {
+    constructor(data) {
+        this.data = data;
+        this.pos = 0;
+        this.decoder = new TextDecoder("utf-8");
+        this.length = data.length;
+    }
+    parseValue() {
+        this.eatWhitespace();
+        const byte = this.peek();
+        if (byte === -1)
+            return null;
+        switch (byte) {
+            case 123: return this.parseObject(); // {
+            case 91: return this.parseArray(); // [
+            case 34: return this.parseString(); // "
+            case 116: return this.parseKeyword(true); // t(rue)
+            case 102: return this.parseKeyword(false); // f(alse)
+            case 110: return this.parseKeyword(null); // n(ull)
+            case 45: // -
+            case 48:
+            case 49:
+            case 50:
+            case 51:
+            case 52:
+            case 53:
+            case 54:
+            case 55:
+            case 56:
+            case 57:
+                return this.parseNumber();
+            default:
+                this.pos++;
+                return null;
         }
-        else {
-            switch (charCode) {
-                case 34: // "
-                    switch (last) {
-                        case "string":
-                            last = "other";
-                            break;
-                        case "comma":
-                            // when we hit a quote after a comma we keep the comma boundary
-                            builder.push(COMMA ? COMMA : new Uint8Array([44]));
-                        default:
-                            last = "string";
-                            break;
-                    }
-                    break;
-                case 92: // \
-                    if (last === "string")
-                        last = "escape";
-                    break;
-                case 44: // ,
-                    builder.push(buf.subarray(from, i));
-                    from = i + 1;
-                    if (last === "other")
-                        last = "comma";
-                    break;
-                case 93:
-                case 125:
-                    if (last === "comma")
-                        last = "other";
-                    break;
-                case 9:
-                case 10:
-                case 11:
-                case 12:
-                case 13:
-                case 32:
-                    // ignore whitespace outside strings
-                    break;
-                default:
-                    if (last === "comma") {
-                        builder.push(COMMA ? COMMA : new Uint8Array([44]));
-                        last = "other";
-                    }
-                    break;
+    }
+    parseObject() {
+        const obj = {};
+        this.pos++; // skip {
+        while (true) {
+            this.eatWhitespace();
+            if (this.peek() === 125) { // }
+                this.pos++;
+                break;
+            }
+            const key = this.parseString();
+            this.eatWhitespace();
+            if (this.peek() !== 58)
+                break; // :
+            this.pos++;
+            obj[key] = this.parseValue();
+            this.eatWhitespace();
+            if (this.peek() === 44) { // ,
+                this.pos++;
             }
         }
+        return obj;
     }
-    builder.push(buf.subarray(from));
-    // concat
-    let total = 0;
-    for (const piece of builder)
-        total += piece.length;
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const piece of builder) {
-        out.set(piece, offset);
-        offset += piece.length;
+    parseArray() {
+        const arr = [];
+        this.pos++; // skip [
+        while (true) {
+            this.eatWhitespace();
+            if (this.peek() === 93) { // ]
+                this.pos++;
+                break;
+            }
+            arr.push(this.parseValue());
+            this.eatWhitespace();
+            if (this.peek() === 44) { // ,
+                this.pos++;
+            }
+        }
+        return arr;
     }
-    return out;
-}
-export class BufferParser extends Parser {
-    parse(input) {
-        // string input: delegate to StringParser (keeps current behavior)
-        if (typeof input === "string") {
-            return StringParser.prototype.parse.call(StringParser.prototype, input);
+    /**
+     * 核心修改：支持字符串内原始换行 (10, 13)
+     */
+    parseString() {
+        this.pos++; // skip "
+        const start = this.pos;
+        let hasEscapes = false;
+        while (this.pos < this.length) {
+            const b = this.data[this.pos];
+            if (b === 34)
+                break; // "
+            if (b === 92) { // \
+                hasEscapes = true;
+                this.pos += 2; // 简单跳过转义序列
+            }
+            else {
+                this.pos++;
+            }
         }
-        // Node Buffer path
-        const nodeBuf = input;
-        // strip BOM quickly
-        const stripped = stripBOM(nodeBuf);
-        const u8 = new Uint8Array(stripped);
-        // If there is any raw newline inside a quoted string, fallback to StringParser
-        if (hasRawNewlineInStringBuffer(u8)) {
-            // decode exactly and let StringParser tolerant-parse it
-            return StringParser.prototype.parse.call(StringParser.prototype, decodeStringFromUTF8BOM(stripped));
+        const end = this.pos;
+        this.pos++; // skip closing "
+        const raw = this.data.subarray(start, end);
+        if (!hasEscapes) {
+            return this.decoder.decode(raw);
         }
-        // Fast path: normalize then try JSON.parse (much faster than StringParser).
-        try {
-            const normalized = normalizeJsonUint8(u8);
-            const text = decodeStringFromUTF8BOM(Buffer.from(normalized));
-            return JSON.parse(text);
+        else {
+            // 处理转义字符逻辑
+            return this.processEscapes(raw);
         }
-        catch (e) {
-            // Fallback to StringParser if anything unexpected occurs
-            return StringParser.prototype.parse.call(StringParser.prototype, decodeStringFromUTF8BOM(stripped));
+    }
+    processEscapes(raw) {
+        // 降级处理带有转义的字符串：转成文本后用类似 StringParser 的逻辑处理
+        const str = this.decoder.decode(raw);
+        let result = "";
+        for (let i = 0; i < str.length; i++) {
+            if (str[i] === "\\" && i + 1 < str.length) {
+                const next = str[++i];
+                switch (next) {
+                    case '"':
+                    case '\\':
+                    case '/':
+                        result += next;
+                        break;
+                    case 'b':
+                        result += '\b';
+                        break;
+                    case 'f':
+                        result += '\f';
+                        break;
+                    case 'n':
+                        result += '\n';
+                        break;
+                    case 'r':
+                        result += '\r';
+                        break;
+                    case 't':
+                        result += '\t';
+                        break;
+                    case 'u':
+                        result += String.fromCharCode(parseInt(str.substr(i + 1, 4), 16));
+                        i += 4;
+                        break;
+                }
+            }
+            else {
+                result += str[i];
+            }
         }
+        return result;
     }
-    stringify(obj) {
-        return JSON.stringify(obj);
+    parseNumber() {
+        const start = this.pos;
+        while (this.pos < this.length) {
+            const b = this.data[this.pos];
+            // 0-9 . e E + -
+            if ((b >= 48 && b <= 57) || b === 46 || b === 101 || b === 69 || b === 43 || b === 45) {
+                this.pos++;
+            }
+            else {
+                break;
+            }
+        }
+        const s = this.decoder.decode(this.data.subarray(start, this.pos));
+        return parseFloat(s);
+    }
+    parseKeyword(value) {
+        // 简单地跳过 true, false, null 的长度
+        const b = this.data[this.pos];
+        if (b === 116)
+            this.pos += 4; // true
+        else if (b === 102)
+            this.pos += 5; // false
+        else if (b === 110)
+            this.pos += 4; // null
+        return value;
+    }
+    eatWhitespace() {
+        while (this.pos < this.length) {
+            const b = this.data[this.pos];
+            if (b === 32 || b === 10 || b === 13 || b === 9) {
+                this.pos++;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    peek() {
+        return this.pos < this.length ? this.data[this.pos] : -1;
     }
 }
 export function stripBOM(buffer) {
-    if (buffer.length >= 3 && BOM.equals(buffer.subarray(0, 3))) {
+    if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
         return buffer.subarray(3);
     }
     return buffer;
 }
-export function normalizeJsonBuffer(text) {
-    // keep backward compatibility: use the Uint8 normalizer and return a Buffer
-    const u8 = normalizeJsonUint8(new Uint8Array(text));
-    return Buffer.from(u8);
-}
-export function decodeStringFromUTF8BOM(buffer) {
-    return stripBOM(buffer).toString("utf-8");
-}
 export default BufferParser;