decocms 4.113.3 → 4.113.4

package/dist/server/node_modules/unicode-trie/index.js

@@ -0,0 +1,136 @@
+const inflate = require('tiny-inflate');
+const { swap32LE } = require('./swap');
+
+// Shift size for getting the index-1 table offset.
+const SHIFT_1 = 6 + 5;
+
+// Shift size for getting the index-2 table offset.
+const SHIFT_2 = 5;
+
+// Difference between the two shift sizes,
+// for getting an index-1 offset from an index-2 offset. 6=11-5
+const SHIFT_1_2 = SHIFT_1 - SHIFT_2;
+
+// Number of index-1 entries for the BMP. 32=0x20
+// This part of the index-1 table is omitted from the serialized form.
+const OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> SHIFT_1;
+
+// Number of entries in an index-2 block. 64=0x40
+const INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;
+
+// Mask for getting the lower bits for the in-index-2-block offset. */
+const INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;
+
+// Shift size for shifting left the index array values.
+// Increases possible data size with 16-bit index values at the cost
+// of compactability.
+// This requires data blocks to be aligned by DATA_GRANULARITY.
+const INDEX_SHIFT = 2;
+
+// Number of entries in a data block. 32=0x20
+const DATA_BLOCK_LENGTH = 1 << SHIFT_2;
+
+// Mask for getting the lower bits for the in-data-block offset.
+const DATA_MASK = DATA_BLOCK_LENGTH - 1;
+
+// The part of the index-2 table for U+D800..U+DBFF stores values for
+// lead surrogate code _units_ not code _points_.
+// Values for lead surrogate code _points_ are indexed with this portion of the table.
+// Length=32=0x20=0x400>>SHIFT_2. (There are 1024=0x400 lead surrogates.)
+const LSCP_INDEX_2_OFFSET = 0x10000 >> SHIFT_2;
+const LSCP_INDEX_2_LENGTH = 0x400 >> SHIFT_2;
+
+// Count the lengths of both BMP pieces. 2080=0x820
+const INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;
+
+// The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.
+// Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.
+const UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;
+const UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6;  // U+0800 is the first code point after 2-byte UTF-8
+
+// The index-1 table, only used for supplementary code points, at offset 2112=0x840.
+// Variable length, for code points up to highStart, where the last single-value range starts.
+// Maximum length 512=0x200=0x100000>>SHIFT_1.
+// (For 0x100000 supplementary code points U+10000..U+10ffff.)
+//
+// The part of the index-2 table for supplementary code points starts
+// after this index-1 table.
+//
+// Both the index-1 table and the following part of the index-2 table
+// are omitted completely if there is only BMP data.
+const INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
+
+// The alignment size of a data block. Also the granularity for compaction.
+const DATA_GRANULARITY = 1 << INDEX_SHIFT;
+
+class UnicodeTrie {
+  constructor(data) {
+    const isBuffer = (typeof data.readUInt32BE === 'function') && (typeof data.slice === 'function');
+
+    if (isBuffer || data instanceof Uint8Array) {
+      // read binary format
+      let uncompressedLength;
+      if (isBuffer) {
+        this.highStart = data.readUInt32LE(0);
+        this.errorValue = data.readUInt32LE(4);
+        uncompressedLength = data.readUInt32LE(8);
+        data = data.slice(12);
+      } else {
+        const view = new DataView(data.buffer);
+        this.highStart = view.getUint32(0, true);
+        this.errorValue = view.getUint32(4, true);
+        uncompressedLength = view.getUint32(8, true);
+        data = data.subarray(12);
+      }
+
+      // double inflate the actual trie data
+      data = inflate(data, new Uint8Array(uncompressedLength));
+      data = inflate(data, new Uint8Array(uncompressedLength));
+
+      // swap bytes from little-endian
+      swap32LE(data);
+
+      this.data = new Uint32Array(data.buffer);
+
+    } else {
+      // pre-parsed data
+      ({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);
+    }
+  }
+
+  get(codePoint) {
+    let index;
+    if ((codePoint < 0) || (codePoint > 0x10ffff)) {
+      return this.errorValue;
+    }
+
+    if ((codePoint < 0xd800) || ((codePoint > 0xdbff) && (codePoint <= 0xffff))) {
+      // Ordinary BMP code point, excluding leading surrogates.
+      // BMP uses a single level lookup.  BMP index starts at offset 0 in the index.
+      // data is stored in the index array itself.
+      index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+
+    if (codePoint <= 0xffff) {
+      // Lead Surrogate Code Point.  A Separate index section is stored for
+      // lead surrogate code units and code points.
+      //   The main index has the code unit data.
+      //   For this function, we need the code point data.
+      index = (this.data[LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+
+    if (codePoint < this.highStart) {
+      // Supplemental code point, use two-level lookup.
+      index = this.data[(INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH) + (codePoint >> SHIFT_1)];
+      index = this.data[index + ((codePoint >> SHIFT_2) & INDEX_2_MASK)];
+      index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);
+      return this.data[index];
+    }
+
+    return this.data[this.data.length - DATA_GRANULARITY];
+  }
+}
+
+module.exports = UnicodeTrie;

package/dist/server/node_modules/unicode-trie/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "unicode-trie",
+  "version": "2.0.0",
+  "description": "Unicode Trie data structure for fast character metadata lookup, ported from ICU",
+  "devDependencies": {
+    "mocha": "^6.1.4",
+    "nyc": "^14.1.1"
+  },
+  "scripts": {
+    "test": "mocha",
+    "coverage": "nyc mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/devongovett/unicode-trie.git"
+  },
+  "author": "Devon Govett <devongovett@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/devongovett/unicode-trie/issues"
+  },
+  "homepage": "https://github.com/devongovett/unicode-trie",
+  "dependencies": {
+    "pako": "^0.2.5",
+    "tiny-inflate": "^1.0.0"
+  }
+}

package/dist/server/node_modules/unicode-trie/swap.js

@@ -0,0 +1,25 @@
+const isBigEndian = (new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x12);
+
+const swap = (b, n, m) => {
+  let i = b[n];
+  b[n] = b[m];
+  b[m] = i;
+};
+
+const swap32 = array => {
+  const len = array.length;
+  for (let i = 0; i < len; i += 4) {
+    swap(array, i, i + 3);
+    swap(array, i + 1, i + 2);
+  }
+};
+
+const swap32LE = array => {
+  if (isBigEndian) {
+    swap32(array);
+  }
+};
+
+module.exports = {
+  swap32LE: swap32LE
+};

package/dist/server/node_modules/unicode-trie/test/mocha.opts

@@ -0,0 +1 @@
+--reporter spec

package/dist/server/node_modules/unicode-trie/test/test.js

@@ -0,0 +1,243 @@
+const assert = require('assert');
+const UnicodeTrieBuilder = require('../builder');
+const UnicodeTrie = require('../');
+
+describe('unicode trie', () => {
+  it('set', () => {
+    const trie = new UnicodeTrieBuilder(10, 666);
+    trie.set(0x4567, 99);
+    assert.equal(trie.get(0x4566), 10);
+    assert.equal(trie.get(0x4567), 99);
+    assert.equal(trie.get(-1), 666);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  it('set -> compacted trie', () => {
+    const t = new UnicodeTrieBuilder(10, 666);
+    t.set(0x4567, 99);
+
+    const trie = t.freeze();
+    assert.equal(trie.get(0x4566), 10);
+    assert.equal(trie.get(0x4567), 99);
+    assert.equal(trie.get(-1), 666);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  it('setRange', () => {
+    const trie = new UnicodeTrieBuilder(10, 666);
+    trie.setRange(13, 6666, 7788, false);
+    trie.setRange(6000, 7000, 9900, true);
+
+    assert.equal(trie.get(12), 10);
+    assert.equal(trie.get(13), 7788);
+    assert.equal(trie.get(5999), 7788);
+    assert.equal(trie.get(6000), 9900);
+    assert.equal(trie.get(7000), 9900);
+    assert.equal(trie.get(7001), 10);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  it('setRange -> compacted trie', () => {
+    const t = new UnicodeTrieBuilder(10, 666);
+    t.setRange(13, 6666, 7788, false);
+    t.setRange(6000, 7000, 9900, true);
+
+    const trie = t.freeze();
+    assert.equal(trie.get(12), 10);
+    assert.equal(trie.get(13), 7788);
+    assert.equal(trie.get(5999), 7788);
+    assert.equal(trie.get(6000), 9900);
+    assert.equal(trie.get(7000), 9900);
+    assert.equal(trie.get(7001), 10);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  it('toBuffer written in little-endian', () => {
+    const trie = new UnicodeTrieBuilder();
+    trie.set(0x4567, 99);
+
+    const buf = trie.toBuffer();
+    const bufferExpected = new Buffer.from([0, 72, 0, 0, 0, 0, 0, 0, 128, 36, 0, 0, 123, 123, 206, 144, 235, 128, 2, 143, 67, 96, 225, 171, 23, 55, 54, 38, 231, 47, 44, 127, 233, 90, 109, 194, 92, 246, 126, 197, 131, 223, 31, 56, 102, 78, 154, 20, 108, 117, 88, 244, 93, 192, 190, 218, 229, 156, 12, 107, 86, 235, 125, 96, 102, 0, 129, 15, 239, 109, 219, 204, 58, 151, 92, 52, 126, 152, 198, 14, 0]);
+    assert.equal(buf.toString('hex'), bufferExpected.toString('hex'));
+  });
+
+  it('should work with compressed serialization format', () => {
+    const t = new UnicodeTrieBuilder(10, 666);
+    t.setRange(13, 6666, 7788, false);
+    t.setRange(6000, 7000, 9900, true);
+
+    const buf = t.toBuffer();
+    const trie = new UnicodeTrie(buf);
+    assert.equal(trie.get(12), 10);
+    assert.equal(trie.get(13), 7788);
+    assert.equal(trie.get(5999), 7788);
+    assert.equal(trie.get(6000), 9900);
+    assert.equal(trie.get(7000), 9900);
+    assert.equal(trie.get(7001), 10);
+    assert.equal(trie.get(0x110000), 666);
+  });
+
+  const rangeTests = [
+    {
+      ranges: [
+         [ 0,        0,        0,      0 ],
+         [ 0,        0x40,     0,      0 ],
+         [ 0x40,     0xe7,     0x1234, 0 ],
+         [ 0xe7,     0x3400,   0,      0 ],
+         [ 0x3400,   0x9fa6,   0x6162, 0 ],
+         [ 0x9fa6,   0xda9e,   0x3132, 0 ],
+         [ 0xdada,   0xeeee,   0x87ff, 0 ],
+         [ 0xeeee,   0x11111,  1,      0 ],
+         [ 0x11111,  0x44444,  0x6162, 0 ],
+         [ 0x44444,  0x60003,  0,      0 ],
+         [ 0xf0003,  0xf0004,  0xf,    0 ],
+         [ 0xf0004,  0xf0006,  0x10,   0 ],
+         [ 0xf0006,  0xf0007,  0x11,   0 ],
+         [ 0xf0007,  0xf0040,  0x12,   0 ],
+         [ 0xf0040,  0x110000, 0,      0 ]
+      ],
+
+      check: [
+        [ 0,        0      ],
+        [ 0x40,     0      ],
+        [ 0xe7,     0x1234 ],
+        [ 0x3400,   0      ],
+        [ 0x9fa6,   0x6162 ],
+        [ 0xda9e,   0x3132 ],
+        [ 0xdada,   0      ],
+        [ 0xeeee,   0x87ff ],
+        [ 0x11111,  1      ],
+        [ 0x44444,  0x6162 ],
+        [ 0xf0003,  0      ],
+        [ 0xf0004,  0xf    ],
+        [ 0xf0006,  0x10   ],
+        [ 0xf0007,  0x11   ],
+        [ 0xf0040,  0x12   ],
+        [ 0x110000, 0      ]
+      ]
+    },
+    {
+      // set some interesting overlapping ranges
+      ranges: [
+        [ 0,        0,        0,      0 ],
+        [ 0x21,     0x7f,     0x5555, 1 ],
+        [ 0x2f800,  0x2fedc,  0x7a,   1 ],
+        [ 0x72,     0xdd,     3,      1 ],
+        [ 0xdd,     0xde,     4,      0 ],
+        [ 0x201,    0x240,    6,      1 ],  // 3 consecutive blocks with the same pattern but
+        [ 0x241,    0x280,    6,      1 ],  // discontiguous value ranges, testing utrie2_enum()
+        [ 0x281,    0x2c0,    6,      1 ],
+        [ 0x2f987,  0x2fa98,  5,      1 ],
+        [ 0x2f777,  0x2f883,  0,      1 ],
+        [ 0x2f900,  0x2ffaa,  1,      0 ],
+        [ 0x2ffaa,  0x2ffab,  2,      1 ],
+        [ 0x2ffbb,  0x2ffc0,  7,      1 ]
+      ],
+
+      check: [
+        [ 0,        0      ],
+        [ 0x21,     0      ],
+        [ 0x72,     0x5555 ],
+        [ 0xdd,     3      ],
+        [ 0xde,     4      ],
+        [ 0x201,    0      ],
+        [ 0x240,    6      ],
+        [ 0x241,    0      ],
+        [ 0x280,    6      ],
+        [ 0x281,    0      ],
+        [ 0x2c0,    6      ],
+        [ 0x2f883,  0      ],
+        [ 0x2f987,  0x7a   ],
+        [ 0x2fa98,  5      ],
+        [ 0x2fedc,  0x7a   ],
+        [ 0x2ffaa,  1      ],
+        [ 0x2ffab,  2      ],
+        [ 0x2ffbb,  0      ],
+        [ 0x2ffc0,  7      ],
+        [ 0x110000, 0      ]
+      ]
+    },
+    {
+      // use a non-zero initial value
+      ranges: [
+        [ 0,        0,        9, 0 ], // non-zero initial value.
+        [ 0x31,     0xa4,     1, 0 ],
+        [ 0x3400,   0x6789,   2, 0 ],
+        [ 0x8000,   0x89ab,   9, 1 ],
+        [ 0x9000,   0xa000,   4, 1 ],
+        [ 0xabcd,   0xbcde,   3, 1 ],
+        [ 0x55555,  0x110000, 6, 1 ], // highStart<U+ffff with non-initialValue
+        [ 0xcccc,   0x55555,  6, 1 ]
+      ],
+
+      check: [
+        [ 0,        9 ],  // non-zero initialValue
+        [ 0x31,     9 ],
+        [ 0xa4,     1 ],
+        [ 0x3400,   9 ],
+        [ 0x6789,   2 ],
+        [ 0x9000,   9 ],
+        [ 0xa000,   4 ],
+        [ 0xabcd,   9 ],
+        [ 0xbcde,   3 ],
+        [ 0xcccc,   9 ],
+        [ 0x110000, 6 ]
+      ]
+    },
+    {
+      // empty or single-value tries, testing highStart==0
+      ranges: [
+        [ 0,        0,        3, 0 ] // Only the element with the initial value.
+      ],
+
+      check: [
+        [ 0,        3 ],
+        [ 0x110000, 3 ]
+      ]
+    },
+    {
+      ranges: [
+        [ 0,        0,        3,  0 ], // Initial value = 3
+        [ 0,        0x110000, 5, 1  ]
+      ],
+
+      check: [
+        [ 0,        3 ],
+        [ 0x110000, 5 ]
+      ]
+    }
+  ];
+
+  it('should pass range tests', () => {
+    const result = [];
+    for (let test of rangeTests) {
+      let initialValue = 0;
+      let errorValue = 0x0bad;
+      let i = 0;
+      if (test.ranges[i][1] < 0) {
+        errorValue = test.ranges[i][2];
+        i++;
+      }
+
+      initialValue = test.ranges[i++][2];
+      var trie = new UnicodeTrieBuilder(initialValue, errorValue);
+
+      for (let range of test.ranges.slice(i)) {
+        trie.setRange(range[0], range[1] - 1, range[2], range[3] !== 0);
+      }
+
+      var frozen = trie.freeze();
+
+      var start = 0;
+      result.push(test.check.map((check) => {
+        let end;
+        const result1 = [];
+        for (start = start, end = check[0]; start < end; start++) {
+          assert.equal(trie.get(start), check[1]);
+          result1.push(assert.equal(frozen.get(start), check[1]));
+        }
+        return result1;
+      }));
+    }
+  });
+});