@opensumi/ide-theme 2.21.13 → 2.22.0

package/src/common/plistParser.ts

@@ -0,0 +1,525 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Some code copied and modified from https://github.com/microsoft/vscode/blob/1.44.0/src/vs/workbench/services/themes/common/plistParser.ts
+
+const enum ChCode {
+  BOM = 65279,
+
+  SPACE = 32,
+  TAB = 9,
+  CARRIAGE_RETURN = 13,
+  LINE_FEED = 10,
+
+  SLASH = 47,
+
+  LESS_THAN = 60,
+  QUESTION_MARK = 63,
+  EXCLAMATION_MARK = 33,
+}
+
+const enum State {
+  ROOT_STATE = 0,
+  DICT_STATE = 1,
+  ARR_STATE = 2,
+}
+
+export function parseWithLocation(content: string, filename: string, locationKeyName: string): any {
+  return _parse(content, filename, locationKeyName);
+}
+
+/**
+ * A very fast plist parser
+ */
+export function parse(content: string): any {
+  return _parse(content, null, null);
+}
+
+function _parse(content: string, filename: string | null, locationKeyName: string | null): any {
+  const len = content.length;
+
+  let pos = 0;
+  let line = 1;
+  let char = 0;
+
+  // Skip UTF8 BOM
+  if (len > 0 && content.charCodeAt(0) === ChCode.BOM) {
+    pos = 1;
+  }
+
+  function advancePosBy(by: number): void {
+    if (locationKeyName === null) {
+      pos = pos + by;
+    } else {
+      while (by > 0) {
+        const chCode = content.charCodeAt(pos);
+        if (chCode === ChCode.LINE_FEED) {
+          pos++;
+          line++;
+          char = 0;
+        } else {
+          pos++;
+          char++;
+        }
+        by--;
+      }
+    }
+  }
+  function advancePosTo(to: number): void {
+    if (locationKeyName === null) {
+      pos = to;
+    } else {
+      advancePosBy(to - pos);
+    }
+  }
+
+  function skipWhitespace(): void {
+    while (pos < len) {
+      const chCode = content.charCodeAt(pos);
+      if (
+        chCode !== ChCode.SPACE &&
+        chCode !== ChCode.TAB &&
+        chCode !== ChCode.CARRIAGE_RETURN &&
+        chCode !== ChCode.LINE_FEED
+      ) {
+        break;
+      }
+      advancePosBy(1);
+    }
+  }
+
+  function advanceIfStartsWith(str: string): boolean {
+    if (content.substr(pos, str.length) === str) {
+      advancePosBy(str.length);
+      return true;
+    }
+    return false;
+  }
+
+  function advanceUntil(str: string): void {
+    const nextOccurence = content.indexOf(str, pos);
+    if (nextOccurence !== -1) {
+      advancePosTo(nextOccurence + str.length);
+    } else {
+      // EOF
+      advancePosTo(len);
+    }
+  }
+
+  function captureUntil(str: string): string {
+    const nextOccurence = content.indexOf(str, pos);
+    if (nextOccurence !== -1) {
+      const r = content.substring(pos, nextOccurence);
+      advancePosTo(nextOccurence + str.length);
+      return r;
+    } else {
+      // EOF
+      const r = content.substr(pos);
+      advancePosTo(len);
+      return r;
+    }
+  }
+
+  let state = State.ROOT_STATE;
+
+  let cur: any = null;
+  const stateStack: State[] = [];
+  const objStack: any[] = [];
+  let curKey: string | null = null;
+
+  function pushState(newState: State, newCur: any): void {
+    stateStack.push(state);
+    objStack.push(cur);
+    state = newState;
+    cur = newCur;
+  }
+
+  function popState(): void {
+    if (stateStack.length === 0) {
+      return fail('illegal state stack');
+    }
+    state = stateStack.pop()!;
+    cur = objStack.pop();
+  }
+
+  function fail(msg: string): void {
+    throw new Error('Near offset ' + pos + ': ' + msg + ' ~~~' + content.substr(pos, 50) + '~~~');
+  }
+
+  const dictState = {
+    enterDict() {
+      if (curKey === null) {
+        return fail('missing <key>');
+      }
+      const newDict = {};
+      if (locationKeyName !== null) {
+        newDict[locationKeyName] = {
+          filename,
+          line,
+          char,
+        };
+      }
+      cur[curKey] = newDict;
+      curKey = null;
+      pushState(State.DICT_STATE, newDict);
+    },
+    enterArray() {
+      if (curKey === null) {
+        return fail('missing <key>');
+      }
+      const newArr: any[] = [];
+      cur[curKey] = newArr;
+      curKey = null;
+      pushState(State.ARR_STATE, newArr);
+    },
+  };
+
+  const arrState = {
+    enterDict() {
+      const newDict = {};
+      if (locationKeyName !== null) {
+        newDict[locationKeyName] = {
+          filename,
+          line,
+          char,
+        };
+      }
+      cur.push(newDict);
+      pushState(State.DICT_STATE, newDict);
+    },
+    enterArray() {
+      const newArr: any[] = [];
+      cur.push(newArr);
+      pushState(State.ARR_STATE, newArr);
+    },
+  };
+
+  function enterDict() {
+    if (state === State.DICT_STATE) {
+      dictState.enterDict();
+    } else if (state === State.ARR_STATE) {
+      arrState.enterDict();
+    } else {
+      // ROOT_STATE
+      cur = {};
+      if (locationKeyName !== null) {
+        cur[locationKeyName] = {
+          filename,
+          line,
+          char,
+        };
+      }
+      pushState(State.DICT_STATE, cur);
+    }
+  }
+  function leaveDict() {
+    if (state === State.DICT_STATE) {
+      popState();
+    } else if (state === State.ARR_STATE) {
+      return fail('unexpected </dict>');
+    } else {
+      // ROOT_STATE
+      return fail('unexpected </dict>');
+    }
+  }
+  function enterArray() {
+    if (state === State.DICT_STATE) {
+      dictState.enterArray();
+    } else if (state === State.ARR_STATE) {
+      arrState.enterArray();
+    } else {
+      // ROOT_STATE
+      cur = [];
+      pushState(State.ARR_STATE, cur);
+    }
+  }
+  function leaveArray() {
+    if (state === State.DICT_STATE) {
+      return fail('unexpected </array>');
+    } else if (state === State.ARR_STATE) {
+      popState();
+    } else {
+      // ROOT_STATE
+      return fail('unexpected </array>');
+    }
+  }
+  function acceptKey(val: string) {
+    if (state === State.DICT_STATE) {
+      if (curKey !== null) {
+        return fail('too many <key>');
+      }
+      curKey = val;
+    } else if (state === State.ARR_STATE) {
+      return fail('unexpected <key>');
+    } else {
+      // ROOT_STATE
+      return fail('unexpected <key>');
+    }
+  }
+  function acceptString(val: string) {
+    if (state === State.DICT_STATE) {
+      if (curKey === null) {
+        return fail('missing <key>');
+      }
+      cur[curKey] = val;
+      curKey = null;
+    } else if (state === State.ARR_STATE) {
+      cur.push(val);
+    } else {
+      // ROOT_STATE
+      cur = val;
+    }
+  }
+  function acceptReal(val: number) {
+    if (isNaN(val)) {
+      return fail('cannot parse float');
+    }
+    if (state === State.DICT_STATE) {
+      if (curKey === null) {
+        return fail('missing <key>');
+      }
+      cur[curKey] = val;
+      curKey = null;
+    } else if (state === State.ARR_STATE) {
+      cur.push(val);
+    } else {
+      // ROOT_STATE
+      cur = val;
+    }
+  }
+  function acceptInteger(val: number) {
+    if (isNaN(val)) {
+      return fail('cannot parse integer');
+    }
+    if (state === State.DICT_STATE) {
+      if (curKey === null) {
+        return fail('missing <key>');
+      }
+      cur[curKey] = val;
+      curKey = null;
+    } else if (state === State.ARR_STATE) {
+      cur.push(val);
+    } else {
+      // ROOT_STATE
+      cur = val;
+    }
+  }
+  function acceptDate(val: Date) {
+    if (state === State.DICT_STATE) {
+      if (curKey === null) {
+        return fail('missing <key>');
+      }
+      cur[curKey] = val;
+      curKey = null;
+    } else if (state === State.ARR_STATE) {
+      cur.push(val);
+    } else {
+      // ROOT_STATE
+      cur = val;
+    }
+  }
+  function acceptData(val: string) {
+    if (state === State.DICT_STATE) {
+      if (curKey === null) {
+        return fail('missing <key>');
+      }
+      cur[curKey] = val;
+      curKey = null;
+    } else if (state === State.ARR_STATE) {
+      cur.push(val);
+    } else {
+      // ROOT_STATE
+      cur = val;
+    }
+  }
+  function acceptBool(val: boolean) {
+    if (state === State.DICT_STATE) {
+      if (curKey === null) {
+        return fail('missing <key>');
+      }
+      cur[curKey] = val;
+      curKey = null;
+    } else if (state === State.ARR_STATE) {
+      cur.push(val);
+    } else {
+      // ROOT_STATE
+      cur = val;
+    }
+  }
+
+  function escapeVal(str: string): string {
+    return str
+      .replace(/&#([0-9]+);/g, function (_: string, m0: string) {
+        return (<any>String).fromCodePoint(parseInt(m0, 10));
+      })
+      .replace(/&#x([0-9a-f]+);/g, function (_: string, m0: string) {
+        return (<any>String).fromCodePoint(parseInt(m0, 16));
+      })
+      .replace(/&amp;|&lt;|&gt;|&quot;|&apos;/g, function (_: string) {
+        switch (_) {
+          case '&amp;':
+            return '&';
+          case '&lt;':
+            return '<';
+          case '&gt;':
+            return '>';
+          case '&quot;':
+            return '"';
+          case '&apos;':
+            return "'";
+        }
+        return _;
+      });
+  }
+
+  interface IParsedTag {
+    name: string;
+    isClosed: boolean;
+  }
+
+  function parseOpenTag(): IParsedTag {
+    let r = captureUntil('>');
+    let isClosed = false;
+    if (r.charCodeAt(r.length - 1) === ChCode.SLASH) {
+      isClosed = true;
+      r = r.substring(0, r.length - 1);
+    }
+
+    return {
+      name: r.trim(),
+      isClosed,
+    };
+  }
+
+  function parseTagValue(tag: IParsedTag): string {
+    if (tag.isClosed) {
+      return '';
+    }
+    const val = captureUntil('</');
+    advanceUntil('>');
+    return escapeVal(val);
+  }
+
+  while (pos < len) {
+    skipWhitespace();
+    if (pos >= len) {
+      break;
+    }
+
+    const chCode = content.charCodeAt(pos);
+    advancePosBy(1);
+    if (chCode !== ChCode.LESS_THAN) {
+      return fail('expected <');
+    }
+
+    if (pos >= len) {
+      return fail('unexpected end of input');
+    }
+
+    const peekChCode = content.charCodeAt(pos);
+
+    if (peekChCode === ChCode.QUESTION_MARK) {
+      advancePosBy(1);
+      advanceUntil('?>');
+      continue;
+    }
+
+    if (peekChCode === ChCode.EXCLAMATION_MARK) {
+      advancePosBy(1);
+
+      if (advanceIfStartsWith('--')) {
+        advanceUntil('-->');
+        continue;
+      }
+
+      advanceUntil('>');
+      continue;
+    }
+
+    if (peekChCode === ChCode.SLASH) {
+      advancePosBy(1);
+      skipWhitespace();
+
+      if (advanceIfStartsWith('plist')) {
+        advanceUntil('>');
+        continue;
+      }
+
+      if (advanceIfStartsWith('dict')) {
+        advanceUntil('>');
+        leaveDict();
+        continue;
+      }
+
+      if (advanceIfStartsWith('array')) {
+        advanceUntil('>');
+        leaveArray();
+        continue;
+      }
+
+      return fail('unexpected closed tag');
+    }
+
+    const tag = parseOpenTag();
+
+    switch (tag.name) {
+      case 'dict':
+        enterDict();
+        if (tag.isClosed) {
+          leaveDict();
+        }
+        continue;
+
+      case 'array':
+        enterArray();
+        if (tag.isClosed) {
+          leaveArray();
+        }
+        continue;
+
+      case 'key':
+        acceptKey(parseTagValue(tag));
+        continue;
+
+      case 'string':
+        acceptString(parseTagValue(tag));
+        continue;
+
+      case 'real':
+        acceptReal(parseFloat(parseTagValue(tag)));
+        continue;
+
+      case 'integer':
+        acceptInteger(parseInt(parseTagValue(tag), 10));
+        continue;
+
+      case 'date':
+        acceptDate(new Date(parseTagValue(tag)));
+        continue;
+
+      case 'data':
+        acceptData(parseTagValue(tag));
+        continue;
+
+      case 'true':
+        parseTagValue(tag);
+        acceptBool(true);
+        continue;
+
+      case 'false':
+        parseTagValue(tag);
+        acceptBool(false);
+        continue;
+    }
+
+    if (/^plist/.test(tag.name)) {
+      continue;
+    }
+
+    return fail('unexpected opened tag ' + tag.name);
+  }
+
+  return cur;
+}