@syzlm/ofdparser 0.0.1

package/src/core/ofd-core/utils.ts

@@ -0,0 +1,86 @@
+import { Element } from 'xml-js';
+import { OFD_Q } from './constant';
+
+export const reHex = /^\s*(?:[0-9A-Fa-f][0-9A-Fa-f]\s*)+$/;
+
+export function recursion(
+  elements: Array<Element>,
+  result: { [key: string]: any },
+  flatResult: { [key: string]: any },
+) {
+  if (elements && elements.length) {
+    elements.forEach(item => {
+      const { type, name, elements } = item;
+      if (name) {
+        // 获取子集是否是text
+        result[name] = null;
+        flatResult[name] = null;
+        if (type === 'element') {
+          if (elements && elements.length === 1 && elements[0].type === 'text') {
+            result[name] = elements[0].text;
+            flatResult[name] = elements[0].text;
+          }
+
+          // 递归
+          if (elements && elements.length && elements[0].type !== 'text') {
+            result[name] = {};
+            recursion(elements, result[name], flatResult);
+          }
+          if (!elements && item.attributes) {
+            result[name] = { ...item.attributes };
+            flatResult[name] = { ...item.attributes };
+          }
+        }
+      }
+    });
+  }
+}
+
+export function recursionGet(elements: Array<Element>, qName: string): Element | null {
+  if (elements && elements.length) {
+    for (let i = 0; i < elements.length; i++) {
+      const item = elements[i];
+      const { name, elements: cElements, type } = item;
+      if (qName === name) {
+        return { ...item };
+      }
+      if (type === 'element' && cElements?.length) {
+        const result = recursionGet(cElements, qName);
+        if (result) {
+          return result;
+        }
+      }
+      continue;
+    }
+  }
+  return null;
+}
+
+export const NameREG = new RegExp(OFD_Q);
+
+/**
+ * @description
+ * 包结构内文件的路径，“”表示当前路径,“”表示父路径。
+ * 约定：
+ * 1.“/”代表根节点；
+ * 2. 未显式指定时代表当前路径；
+ * 3.路径区分大小写
+ * @param STLoc
+ * @param pathString
+ * @returns
+ */
+export const replacePathPriex = (STLoc: string, pathString: string) => {
+  const pathReg = new RegExp(`${STLoc}/${STLoc}`);
+  if (pathString.startsWith('/')) {
+    return pathString.replace('/', '');
+  }
+  if (pathString.startsWith('..')) {
+    // TODO: 多层路径无实际文件测试
+    return `${STLoc}${pathString}`.replace(pathReg, `${STLoc}`);
+  }
+  if (pathString.startsWith('.')) {
+    // TODO: 多层路径无实际文件测试
+    return `${STLoc}${pathString}`.replace(pathReg, `${STLoc}`);
+  }
+  return `${STLoc}${pathString}`.replace(pathReg, `${STLoc}`);
+};

package/src/dicom/dicom.ts

@@ -0,0 +1,42 @@
+// import dicomParser from 'dicom-parser';
+
+interface Options {
+  file: string | File | ArrayBuffer;
+  container?: Element;
+  requestOptions?: undefined | { [key: string]: any };
+  requestData?: undefined | { [key: string]: any };
+  responseFilter?: (key: { [key: string]: string | number }) => string;
+}
+const parse = ({ file }: Options) => {
+  if (file instanceof File) {
+    var reader = new FileReader();
+    reader.onload = function () {
+      // var arrayBuffer = reader.result as ArrayBuffer;
+
+      // Here we have the file data as an ArrayBuffer.  dicomParser requires as input a
+      // Uint8Array so we create that here
+      // var byteArray = new Uint8Array(arrayBuffer);
+
+      // var kb = byteArray.length / 1024;
+      // var mb = kb / 1024;
+      // var byteStr = mb > 1 ? mb.toFixed(3) + ' MB' : kb.toFixed(0) + ' KB';
+
+      // set a short timeout to do the parse so the DOM has time to update itself with the above message
+      setTimeout(function () {
+        // Invoke the paresDicom function and get back a DataSet object with the contents
+        try {
+          // var start = new Date().getTime();
+          // const dataSet = dicomParser.parseDicom(byteArray);
+          // Here we call dumpDataSet to update the DOM with the contents of the dataSet
+          // dumpDataSet(dataSet);
+        } catch (err) {
+          console.error('err:', err);
+        }
+      }, 20);
+    };
+
+    reader.readAsArrayBuffer(file);
+  }
+};
+
+export default parse;

package/src/dicom/index.ts

@@ -0,0 +1 @@
+export { default } from './dicom';

package/src/errors/ErrorHandle.ts

@@ -0,0 +1,14 @@
+import errorMsg from './error-msg';
+
+export type ErrorCode = 400 | 404 | 403 | 500 | 9999;
+
+export default class ErrorHandle extends Error {
+  code: ErrorCode;
+  type: string;
+  constructor(code: ErrorCode, type: string) {
+    super();
+    this.code = code;
+    this.type = type;
+    this.message = errorMsg[code];
+  }
+}

package/src/errors/FetchErrors.ts

@@ -0,0 +1,8 @@
+import { ERROR_TYPE_FETCH } from '../constant';
+import ErrorHandle, { ErrorCode } from './ErrorHandle';
+
+export default class VaildFetchError extends ErrorHandle {
+  constructor(code: ErrorCode) {
+    super(code, ERROR_TYPE_FETCH);
+  }
+}

package/src/errors/MimeError.ts

@@ -0,0 +1,9 @@
+import { ERROR_TYPE_MAGIC } from '../constant';
+
+import ErrorHandle, { ErrorCode } from './ErrorHandle';
+
+export default class VaildMimeError extends ErrorHandle {
+  constructor(code: ErrorCode) {
+    super(code, ERROR_TYPE_MAGIC);
+  }
+}

package/src/errors/OFDErrors.ts

@@ -0,0 +1,11 @@
+import { FILE_TYPE_OFD } from '../constant';
+import ErrorHandle, { ErrorCode } from './ErrorHandle';
+
+export default class VaildOFDError extends ErrorHandle {
+  constructor(code: ErrorCode, msg?: string) {
+    super(code, FILE_TYPE_OFD);
+    if (msg) {
+      this.message = msg;
+    }
+  }
+}

package/src/errors/UnzipErrors.ts

@@ -0,0 +1,9 @@
+import { ERROR_TYPE_UNZIP } from '../constant';
+
+import ErrorHandle, { ErrorCode } from './ErrorHandle';
+
+export default class VaildUnzipError extends ErrorHandle {
+  constructor(code: ErrorCode) {
+    super(code, ERROR_TYPE_UNZIP);
+  }
+}

package/src/errors/XmlErrors.ts

@@ -0,0 +1,11 @@
+import { FILE_TYPE_XML } from '../constant';
+import ErrorHandle, { ErrorCode } from './ErrorHandle';
+
+export default class VaildXmlError extends ErrorHandle {
+  constructor(code: ErrorCode, msg?: string) {
+    super(code, FILE_TYPE_XML);
+    if (msg) {
+      this.message = msg;
+    }
+  }
+}

package/src/errors/error-msg.ts

@@ -0,0 +1,17 @@
+interface ErrorMsg {
+  400: string;
+  403: string;
+  404: string;
+  500: string;
+  9999: string;
+}
+
+const errorMsg: ErrorMsg = {
+  '400': '参数传递错误',
+  '403': '类型不支持',
+  '404': '文件不存在',
+  '500': '文件解析错误',
+  '9999': '未知错误'
+};
+
+export default errorMsg;

package/src/es.ts

@@ -0,0 +1,3 @@
+export { default as XMLRender } from './xml';
+
+export { default as OFDParse, getSVGDoms } from './ofd';

package/src/global.d.ts

@@ -0,0 +1,7 @@
+import * as Opentype from 'opentype.js';
+
+export declare global {
+  interface Window {
+    opentype: Opentype;
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import XMLRender from './xml';
+import OFDParse, { getSVGDoms } from './ofd';
+import getMime from './lib/mime';
+
+export { getSVGDoms, XMLRender, getMime, OFDParse };
+
+export default () => {};

package/src/lib/ParseFile.ts

@@ -0,0 +1,12 @@
+import JSZip from 'jszip';
+class ParseFile {
+  static zip: JSZip;
+
+  init(zip: JSZip) {
+    ParseFile.zip = zip;
+  }
+
+  // parseImageFromZip(data: { Path: string }) {}
+}
+
+export default new ParseFile();

package/src/lib/README.md

@@ -0,0 +1,69 @@
+## 记录文件类型
+
+| 文件后缀 | 文件mime                                                                  |
+| -------- | ------------------------------------------------------------------------- |
+| .3gp     | video/3gpp                                                                |
+| .apk     | application/vnd.android.package-archive                                   |
+| .asf     | video/x-ms-asf                                                            |
+| .avi     | video/x-msvideo                                                           |
+| .bin     | application/octet-stream                                                  |
+| .bmp     | image/bmp                                                                 |
+| .c       | text/plain                                                                |
+| .class   | application/octet-stream                                                  |
+| .conf    | text/plain                                                                |
+| .cpp     | text/plain                                                                |
+| .doc     | application/msword                                                        |
+| .docx    | application/vnd.openxmlformats-officedocument.wordprocessingml.document   |
+| .xls     | application/vnd.ms-excel                                                  |
+| .xlsx    | application/vnd.openxmlformats-officedocument.spreadsheetml.sheet         |
+| .exe     | application/octet-stream                                                  |
+| .gif     | image/gif                                                                 |
+| .gtar    | application/x-gtar                                                        |
+| .gz      | application/x-gzip                                                        |
+| .h       | text/plain                                                                |
+| .htm     | text/html                                                                 |
+| .html    | text/html                                                                 |
+| .jar     | application/java-archive                                                  |
+| .java    | text/plain                                                                |
+| .jpeg    | image/jpeg                                                                |
+| .jpg     | image/jpeg                                                                |
+| .js      | application/x-javascript                                                  |
+| .log     | text/plain                                                                |
+| .m3u     | audio/x-mpegurl                                                           |
+| .m4a     | audio/mp4a-latm                                                           |
+| .m4b     | audio/mp4a-latm                                                           |
+| .m4p     | audio/mp4a-latm                                                           |
+| .m4u     | video/vnd.mpegurl                                                         |
+| .m4v     | video/x-m4v                                                               |
+| .mov     | video/quicktime                                                           |
+| .mp2     | audio/x-mpeg                                                              |
+| .mp3     | audio/x-mpeg                                                              |
+| .mp4     | video/mp4                                                                 |
+| .mpc     | application/vnd.mpohun.certificate                                        |
+| .mpe     | video/mpeg                                                                |
+| .mpeg    | video/mpeg                                                                |
+| .mpg     | video/mpeg                                                                |
+| .mpg4    | video/mp4                                                                 |
+| .mpga    | audio/mpeg                                                                |
+| .msg     | application/vnd.ms-outlook                                                |
+| .ogg     | audio/ogg                                                                 |
+| .pdf     | application/pdf                                                           |
+| .png     | image/png                                                                 |
+| .pps     | application/vnd.ms-powerpoint                                             |
+| .ppt     | application/vnd.ms-powerpoint                                             |
+| .pptx    | application/vnd.openxmlformats-officedocument.presentationml.presentation |
+| .prop    | text/plain                                                                |
+| .rc      | text/plain                                                                |
+| .rmvb    | audio/x-pn-realaudio                                                      |
+| .rtf     | application/rtf                                                           |
+| .sh      | text/plain                                                                |
+| .tar     | application/x-tar                                                         |
+| .tgz     | application/x-compressed                                                  |
+| .txt     | text/plain                                                                |
+| .wav     | audio/x-wav                                                               |
+| .wma     | audio/x-ms-wma                                                            |
+| .wmv     | audio/x-ms-wmv                                                            |
+| .wps     | application/vnd.ms-works                                                  |
+| .xml     | text/plain                                                                |
+| .z       | application/x-compress                                                    |
+| .zip     | application/x-zip-compressed                                              |

package/src/lib/UnitCoversion.ts

@@ -0,0 +1,55 @@
+/**
+ * @desc mm 转 px
+ */
+class UnitCoversion {
+  /**
+   * Description placeholder
+   * @date 2022/8/2 - 15:49:57
+   *
+   * @static
+   * @type {number}
+   */
+  static multiple: number;
+
+  /**
+   * 设置1mm单位
+   */
+  setUnit() {
+    if (document?.body) {
+      const div = document.createElement('div');
+      div.setAttribute('style', 'width:1mm');
+      document.body.appendChild(div);
+      const { width } = div.getBoundingClientRect();
+      UnitCoversion.multiple = width;
+      document.body.removeChild(div);
+    }
+  }
+
+  /**
+   * px转换MM
+   * @param millimeter 待转换毫米
+   * @returns number
+   */
+  CoversionMill(px: number): number {
+    if (!px) return 0;
+    if (!UnitCoversion.multiple) {
+      this.setUnit();
+    }
+    return Number(px) / UnitCoversion.multiple;
+  }
+
+  /**
+   * 毫米转换PX
+   * @param millimeter 待转换毫米
+   * @returns number
+   */
+  CoversionPx(millimeter: number | string): number {
+    if (!millimeter) return 0;
+    if (!UnitCoversion.multiple) {
+      this.setUnit();
+    }
+    return Number(millimeter) * UnitCoversion.multiple;
+  }
+}
+
+export default new UnitCoversion();

package/src/lib/asn1/Asn.1.ts

@@ -0,0 +1,284 @@
+import Stream from './Stream';
+import Int10 from './int10';
+import stringCut from './string-cut';
+
+function recurse(el: Asn1, parser: string | number, maxLength: number) {
+  let avoidRecurse = true;
+  if (el.tag.tagConstructed && el.sub) {
+    avoidRecurse = false;
+    el.sub.forEach(function (e1: any) {
+      if (
+        e1.tag.tagClass != el.tag.tagClass ||
+        e1.tag.tagNumber != el.tag.tagNumber
+      )
+        avoidRecurse = true;
+    });
+  }
+  if (avoidRecurse) {
+    return el.stream[parser](
+      el.posContent(),
+      el.posContent() + Math.abs(el.length),
+      maxLength
+    );
+  }
+  const d = { size: 0, str: '' };
+  el.sub.forEach(function (el: any) {
+    const d1 = recurse(el, parser, maxLength - d.str.length);
+    d.size += d1.size;
+    d.str += d1.str;
+  });
+  return d;
+}
+
+export class ASN1Tag {
+  tagClass: number;
+  tagNumber: number;
+  tagConstructed: boolean;
+  constructor(stream: Stream) {
+    let buf = stream.get();
+    this.tagClass = buf >> 6;
+    this.tagConstructed = (buf & 0x20) !== 0;
+    this.tagNumber = buf & 0x1f;
+    if (this.tagNumber == 0x1f) {
+      // long tag
+
+      const int10 = new Int10();
+      do {
+        buf = stream.get();
+        int10.mulAdd(128, buf & 0x7f);
+      } while (buf & 0x80);
+      this.tagNumber = int10.simplify() as number;
+    }
+  }
+  isUniversal() {
+    return this.tagClass === 0x00;
+  }
+  isEOC() {
+    return this.tagClass === 0x00 && this.tagNumber === 0x00;
+  }
+}
+
+export class Asn1 {
+  stream: { [k: string | number]: any };
+  header: number;
+  length: number;
+  tag: ASN1Tag;
+  tagLen: number;
+  sub: any[];
+  constructor(
+    stream: { [k: string | number]: any },
+    header: number,
+    length: number,
+    tag: ASN1Tag,
+    tagLen: number,
+    sub: any[]
+  ) {
+    if (!(tag instanceof ASN1Tag)) throw 'Invalid tag value.';
+    this.stream = stream;
+    this.header = header;
+    this.length = length;
+    this.tag = tag;
+    this.tagLen = tagLen;
+    this.sub = sub;
+  }
+  typeName() {
+    switch (this.tag.tagClass) {
+      case 0: // universal
+        switch (this.tag.tagNumber) {
+          case 0x00:
+            return 'EOC';
+          case 0x01:
+            return 'BOOLEAN';
+          case 0x02:
+            return 'INTEGER';
+          case 0x03:
+            return 'BIT_STRING';
+          case 0x04:
+            return 'OCTET_STRING';
+          case 0x05:
+            return 'NULL';
+          case 0x06:
+            return 'OBJECT_IDENTIFIER';
+          case 0x07:
+            return 'ObjectDescriptor';
+          case 0x08:
+            return 'EXTERNAL';
+          case 0x09:
+            return 'REAL';
+          case 0x0a:
+            return 'ENUMERATED';
+          case 0x0b:
+            return 'EMBEDDED_PDV';
+          case 0x0c:
+            return 'UTF8String';
+          case 0x10:
+            return 'SEQUENCE';
+          case 0x11:
+            return 'SET';
+          case 0x12:
+            return 'NumericString';
+          case 0x13:
+            return 'PrintableString'; // ASCII subset
+          case 0x14:
+            return 'TeletexString'; // aka T61String
+          case 0x15:
+            return 'VideotexString';
+          case 0x16:
+            return 'IA5String'; // ASCII
+          case 0x17:
+            return 'UTCTime';
+          case 0x18:
+            return 'GeneralizedTime';
+          case 0x19:
+            return 'GraphicString';
+          case 0x1a:
+            return 'VisibleString'; // ASCII subset
+          case 0x1b:
+            return 'GeneralString';
+          case 0x1c:
+            return 'UniversalString';
+          case 0x1e:
+            return 'BMPString';
+        }
+
+        return 'Universal_' + this.tag.tagNumber.toString();
+      case 1:
+        return 'Application_' + this.tag.tagNumber.toString();
+      case 2:
+        return '[' + this.tag.tagNumber.toString() + ']'; // Context
+      case 3:
+        return 'Private_' + this.tag.tagNumber.toString();
+    }
+  }
+
+  content(maxLength?: number) {
+    if (this.tag === undefined) return null;
+    if (maxLength === undefined) maxLength = Infinity;
+    const content = this.posContent();
+    const len = Math.abs(this.length);
+    if (!this.tag.isUniversal()) {
+      if (this.sub !== null) return '(' + this.sub.length + ' elem)';
+      const d1 = this.stream.parseOctetString(
+        content,
+        content + len,
+        maxLength
+      );
+      return '(' + d1.size + ' byte)\n' + d1.str;
+    }
+    switch (this.tag.tagNumber) {
+      case 0x01: // BOOLEAN
+        return this.stream.get(content) === 0 ? 'false' : 'true';
+      case 0x02: // INTEGER
+        return this.stream.parseInteger(content, content + len);
+      case 0x03: // BIT_STRING
+        var d = recurse(this, 'parseBitString', maxLength);
+        return '(' + d.size + ' bit)\n' + d.str;
+      case 0x04: // OCTET_STRING
+        d = recurse(this, 'parseOctetString', maxLength);
+        return '(' + d.size + ' byte)\n' + d.str;
+      //case 0x05: // NULL
+      case 0x06: // OBJECT_IDENTIFIER
+        return this.stream.parseOID(content, content + len, maxLength);
+      //case 0x07: // ObjectDescriptor
+      //case 0x08: // EXTERNAL
+      //case 0x09: // REAL
+      case 0x0a: // ENUMERATED
+        return this.stream.parseInteger(content, content + len);
+      //case 0x0B: // EMBEDDED_PDV
+      case 0x10: // SEQUENCE
+      case 0x11: // SET
+        if (this.sub !== null) return '(' + this.sub.length + ' elem)';
+        else return '(no elem)';
+      case 0x0c: // UTF8String
+        return stringCut(
+          this.stream.parseStringUTF(content, content + len),
+          maxLength
+        );
+      case 0x12: // NumericString
+      case 0x13: // PrintableString
+      case 0x14: // TeletexString
+      case 0x15: // VideotexString
+      case 0x16: // IA5String
+      case 0x1a: // VisibleString
+      case 0x1b: // GeneralString
+        //case 0x19: // GraphicString
+        //case 0x1C: // UniversalString
+        return stringCut(
+          this.stream.parseStringISO(content, content + len),
+          maxLength
+        );
+      case 0x1e: // BMPString
+        return stringCut(
+          this.stream.parseStringBMP(content, content + len),
+          maxLength
+        );
+      case 0x17: // UTCTime
+      case 0x18: // GeneralizedTime
+        return this.stream.parseTime(
+          content,
+          content + len,
+          this.tag.tagNumber == 0x17
+        );
+    }
+    return null;
+  }
+
+  toString() {
+    return (
+      this.typeName() +
+      '@' +
+      this.stream.pos +
+      '[header:' +
+      this.header +
+      ',length:' +
+      this.length +
+      ',sub:' +
+      (this.sub === null ? 'null' : this.sub.length) +
+      ']'
+    );
+  }
+
+  toPrettyString(indent: any) {
+    if (indent === undefined) indent = '';
+    let s = indent + this.typeName() + ' @' + this.stream.pos;
+    if (this.length >= 0) s += '+';
+    s += this.length;
+    if (this.tag.tagConstructed) s += ' (constructed)';
+    else if (
+      this.tag.isUniversal() &&
+      (this.tag.tagNumber == 0x03 || this.tag.tagNumber == 0x04) &&
+      this.sub !== null
+    )
+      s += ' (encapsulates)';
+    const content = this.content();
+    if (content) s += ': ' + content.replace(/\n/g, '|');
+    s += '\n';
+    if (this.sub !== null) {
+      indent += '  ';
+      for (let i = 0, max = this.sub.length; i < max; ++i)
+        s += this.sub[i].toPrettyString(indent);
+    }
+    return s;
+  }
+  posStart() {
+    return this.stream.pos;
+  }
+  posContent() {
+    return this.stream.pos + this.header;
+  }
+  posEnd() {
+    return this.stream.pos + this.header + Math.abs(this.length);
+  }
+  /** Position of the length. */
+  posLen() {
+    return this.stream.pos + this.tagLen;
+  }
+  toHexString() {
+    return this.stream.hexDump(this.posStart(), this.posEnd(), true);
+  }
+  toB64String() {
+    return this.stream.b64Dump(this.posStart(), this.posEnd());
+  }
+}
+
+export default Asn1;

package/src/lib/asn1/README.md

@@ -0,0 +1 @@
+# 参考 https://github.com/lapo-luchini/asn1js.git