decocms 4.113.3 → 4.114.0

package/dist/server/node_modules/satori/dist/standalone.js.LEGAL.txt

@@ -0,0 +1,4 @@
+Bundled license information:
+
+cssesc/cssesc.js:
+  /*! https://mths.be/cssesc v3.0.0 by @mathias */

package/dist/server/node_modules/satori/package.json

@@ -0,0 +1,149 @@
+{
+  "name": "satori",
+  "version": "0.28.2",
+  "description": "Enlightened library to convert HTML and CSS to SVG.",
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "wasm": [
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "type": "module",
+  "license": "MPL-2.0",
+  "files": [
+    "dist/**",
+    "yoga.wasm"
+  ],
+  "imports": {
+    "#satori/jsx/jsx-runtime": "./src/jsx/jsx-runtime.ts",
+    "#satori/jsx/jsx-dev-runtime": "./src/jsx/jsx-runtime.ts"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./yoga.wasm": "./yoga.wasm",
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./standalone": {
+      "import": {
+        "types": "./dist/standalone.d.ts",
+        "default": "./dist/standalone.js"
+      },
+      "require": {
+        "types": "./dist/standalone.d.cts",
+        "default": "./dist/standalone.cjs"
+      }
+    },
+    "./jsx": {
+      "types": "./dist/jsx/index.d.ts",
+      "import": "./dist/jsx/index.js",
+      "require": "./dist/jsx/index.cjs"
+    },
+    "./jsx/jsx-runtime": {
+      "types": "./dist/jsx/jsx-runtime.d.ts",
+      "import": "./dist/jsx/jsx-runtime.js",
+      "require": "./dist/jsx/jsx-runtime.cjs"
+    },
+    "./jsx/jsx-dev-runtime": {
+      "types": "./dist/jsx/jsx-runtime.d.ts",
+      "import": "./dist/jsx/jsx-runtime.js",
+      "require": "./dist/jsx/jsx-runtime.cjs"
+    }
+  },
+  "scripts": {
+    "prepare": "husky install",
+    "dev": "pnpm run dev:default",
+    "dev:default": "NODE_ENV=development tsup src/index.ts --watch --ignore-watch playground",
+    "dev:playground": "turbo dev --filter=satori-playground...",
+    "build": "pnpm run build:default && pnpm run build:standalone && pnpm run test:browser-build",
+    "build:default": "NODE_ENV=production tsup",
+    "build:standalone": "NODE_ENV=production SATORI_STANDALONE=1 tsup",
+    "test": "NODE_ENV=test vitest run",
+    "test:browser-build": "node test/browser-build.mjs",
+    "test:ui": "NODE_ENV=test vitest --ui --coverage.enabled",
+    "test-type": "tsc -p tsconfig.json --noEmit && tsc -p playground/tsconfig.json --noEmit",
+    "dev:test": "NODE_ENV=test vitest --update",
+    "lint": "eslint . --ext .js,.jsx,.ts,.tsx --quiet --cache",
+    "lint:fix": "pnpm lint --fix",
+    "prettier-check": "prettier --check .",
+    "prettier-fix": "prettier --write --list-different . --cache",
+    "ci-check": "concurrently \"pnpm prettier-check\" \"pnpm test-type\" \"pnpm lint\"",
+    "benchmark": "node --experimental-strip-types test/benchmark/index.ts"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "eslint --fix --cache",
+      "prettier --write --cache"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vercel/satori.git"
+  },
+  "keywords": [
+    "HTML",
+    "JSX",
+    "SVG",
+    "converter",
+    "renderer"
+  ],
+  "author": "Shu Ding <g@shud.in>",
+  "bugs": {
+    "url": "https://github.com/vercel/satori/issues"
+  },
+  "homepage": "https://github.com/vercel/satori#readme",
+  "devDependencies": {
+    "@resvg/resvg-js": "^2.1.0",
+    "@types/node": "^16",
+    "@types/opentype.js": "^1.3.3",
+    "@types/react": "^17.0.38",
+    "@typescript-eslint/eslint-plugin": "^5.40.0",
+    "@typescript-eslint/parser": "^5.40.0",
+    "@vitest/coverage-v8": "^0.32.0",
+    "@vitest/ui": "^0.32.0",
+    "concurrently": "^7.3.0",
+    "esbuild-plugin-replace": "^1.2.0",
+    "eslint": "^8.25.0",
+    "eslint-plugin-react": "^7.31.10",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "husky": "8.0.3",
+    "jest-image-snapshot": "^6.1.0",
+    "lint-staged": "13.1.0",
+    "mitata": "^1.0.34",
+    "prettier": "^2.7.1",
+    "react": "^17.0.2",
+    "sharp": "^0.34.3",
+    "tsup": "^7.1.0",
+    "turbo": "^2.9.14",
+    "twrnc": "^3.4.0",
+    "typescript": "^5",
+    "vitest": "^0.32.0"
+  },
+  "dependencies": {
+    "@shuding/opentype.js": "1.4.0-beta.0",
+    "css-background-parser": "^0.1.0",
+    "css-box-shadow": "1.0.0-3",
+    "css-gradient-parser": "^0.0.17",
+    "css-to-react-native": "^3.0.0",
+    "emoji-regex-xs": "^2.0.1",
+    "escape-html": "^1.0.3",
+    "linebreak": "^1.1.0",
+    "parse-css-color": "^0.2.1",
+    "postcss-value-parser": "^4.2.0",
+    "yoga-layout": "^3.2.1"
+  },
+  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319",
+  "engines": {
+    "node": ">=16"
+  },
+  "pnpm": {
+    "patchedDependencies": {
+      "yoga-layout@3.2.1": "patches/yoga-layout@3.2.1.patch"
+    }
+  }
+}

package/dist/server/node_modules/tiny-inflate/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015-present Devon Govett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/server/node_modules/tiny-inflate/index.js

@@ -0,0 +1,375 @@
+var TINF_OK = 0;
+var TINF_DATA_ERROR = -3;
+
+function Tree() {
+  this.table = new Uint16Array(16);   /* table of code length counts */
+  this.trans = new Uint16Array(288);  /* code -> symbol translation table */
+}
+
+function Data(source, dest) {
+  this.source = source;
+  this.sourceIndex = 0;
+  this.tag = 0;
+  this.bitcount = 0;
+  
+  this.dest = dest;
+  this.destLen = 0;
+  
+  this.ltree = new Tree();  /* dynamic length/symbol tree */
+  this.dtree = new Tree();  /* dynamic distance tree */
+}
+
+/* --------------------------------------------------- *
+ * -- uninitialized global data (static structures) -- *
+ * --------------------------------------------------- */
+
+var sltree = new Tree();
+var sdtree = new Tree();
+
+/* extra bits and base tables for length codes */
+var length_bits = new Uint8Array(30);
+var length_base = new Uint16Array(30);
+
+/* extra bits and base tables for distance codes */
+var dist_bits = new Uint8Array(30);
+var dist_base = new Uint16Array(30);
+
+/* special ordering of code length codes */
+var clcidx = new Uint8Array([
+  16, 17, 18, 0, 8, 7, 9, 6,
+  10, 5, 11, 4, 12, 3, 13, 2,
+  14, 1, 15
+]);
+
+/* used by tinf_decode_trees, avoids allocations every call */
+var code_tree = new Tree();
+var lengths = new Uint8Array(288 + 32);
+
+/* ----------------------- *
+ * -- utility functions -- *
+ * ----------------------- */
+
+/* build extra bits and base tables */
+function tinf_build_bits_base(bits, base, delta, first) {
+  var i, sum;
+
+  /* build bits table */
+  for (i = 0; i < delta; ++i) bits[i] = 0;
+  for (i = 0; i < 30 - delta; ++i) bits[i + delta] = i / delta | 0;
+
+  /* build base table */
+  for (sum = first, i = 0; i < 30; ++i) {
+    base[i] = sum;
+    sum += 1 << bits[i];
+  }
+}
+
+/* build the fixed huffman trees */
+function tinf_build_fixed_trees(lt, dt) {
+  var i;
+
+  /* build fixed length tree */
+  for (i = 0; i < 7; ++i) lt.table[i] = 0;
+
+  lt.table[7] = 24;
+  lt.table[8] = 152;
+  lt.table[9] = 112;
+
+  for (i = 0; i < 24; ++i) lt.trans[i] = 256 + i;
+  for (i = 0; i < 144; ++i) lt.trans[24 + i] = i;
+  for (i = 0; i < 8; ++i) lt.trans[24 + 144 + i] = 280 + i;
+  for (i = 0; i < 112; ++i) lt.trans[24 + 144 + 8 + i] = 144 + i;
+
+  /* build fixed distance tree */
+  for (i = 0; i < 5; ++i) dt.table[i] = 0;
+
+  dt.table[5] = 32;
+
+  for (i = 0; i < 32; ++i) dt.trans[i] = i;
+}
+
+/* given an array of code lengths, build a tree */
+var offs = new Uint16Array(16);
+
+function tinf_build_tree(t, lengths, off, num) {
+  var i, sum;
+
+  /* clear code length count table */
+  for (i = 0; i < 16; ++i) t.table[i] = 0;
+
+  /* scan symbol lengths, and sum code length counts */
+  for (i = 0; i < num; ++i) t.table[lengths[off + i]]++;
+
+  t.table[0] = 0;
+
+  /* compute offset table for distribution sort */
+  for (sum = 0, i = 0; i < 16; ++i) {
+    offs[i] = sum;
+    sum += t.table[i];
+  }
+
+  /* create code->symbol translation table (symbols sorted by code) */
+  for (i = 0; i < num; ++i) {
+    if (lengths[off + i]) t.trans[offs[lengths[off + i]]++] = i;
+  }
+}
+
+/* ---------------------- *
+ * -- decode functions -- *
+ * ---------------------- */
+
+/* get one bit from source stream */
+function tinf_getbit(d) {
+  /* check if tag is empty */
+  if (!d.bitcount--) {
+    /* load next tag */
+    d.tag = d.source[d.sourceIndex++];
+    d.bitcount = 7;
+  }
+
+  /* shift bit out of tag */
+  var bit = d.tag & 1;
+  d.tag >>>= 1;
+
+  return bit;
+}
+
+/* read a num bit value from a stream and add base */
+function tinf_read_bits(d, num, base) {
+  if (!num)
+    return base;
+
+  while (d.bitcount < 24) {
+    d.tag |= d.source[d.sourceIndex++] << d.bitcount;
+    d.bitcount += 8;
+  }
+
+  var val = d.tag & (0xffff >>> (16 - num));
+  d.tag >>>= num;
+  d.bitcount -= num;
+  return val + base;
+}
+
+/* given a data stream and a tree, decode a symbol */
+function tinf_decode_symbol(d, t) {
+  while (d.bitcount < 24) {
+    d.tag |= d.source[d.sourceIndex++] << d.bitcount;
+    d.bitcount += 8;
+  }
+  
+  var sum = 0, cur = 0, len = 0;
+  var tag = d.tag;
+
+  /* get more bits while code value is above sum */
+  do {
+    cur = 2 * cur + (tag & 1);
+    tag >>>= 1;
+    ++len;
+
+    sum += t.table[len];
+    cur -= t.table[len];
+  } while (cur >= 0);
+  
+  d.tag = tag;
+  d.bitcount -= len;
+
+  return t.trans[sum + cur];
+}
+
+/* given a data stream, decode dynamic trees from it */
+function tinf_decode_trees(d, lt, dt) {
+  var hlit, hdist, hclen;
+  var i, num, length;
+
+  /* get 5 bits HLIT (257-286) */
+  hlit = tinf_read_bits(d, 5, 257);
+
+  /* get 5 bits HDIST (1-32) */
+  hdist = tinf_read_bits(d, 5, 1);
+
+  /* get 4 bits HCLEN (4-19) */
+  hclen = tinf_read_bits(d, 4, 4);
+
+  for (i = 0; i < 19; ++i) lengths[i] = 0;
+
+  /* read code lengths for code length alphabet */
+  for (i = 0; i < hclen; ++i) {
+    /* get 3 bits code length (0-7) */
+    var clen = tinf_read_bits(d, 3, 0);
+    lengths[clcidx[i]] = clen;
+  }
+
+  /* build code length tree */
+  tinf_build_tree(code_tree, lengths, 0, 19);
+
+  /* decode code lengths for the dynamic trees */
+  for (num = 0; num < hlit + hdist;) {
+    var sym = tinf_decode_symbol(d, code_tree);
+
+    switch (sym) {
+      case 16:
+        /* copy previous code length 3-6 times (read 2 bits) */
+        var prev = lengths[num - 1];
+        for (length = tinf_read_bits(d, 2, 3); length; --length) {
+          lengths[num++] = prev;
+        }
+        break;
+      case 17:
+        /* repeat code length 0 for 3-10 times (read 3 bits) */
+        for (length = tinf_read_bits(d, 3, 3); length; --length) {
+          lengths[num++] = 0;
+        }
+        break;
+      case 18:
+        /* repeat code length 0 for 11-138 times (read 7 bits) */
+        for (length = tinf_read_bits(d, 7, 11); length; --length) {
+          lengths[num++] = 0;
+        }
+        break;
+      default:
+        /* values 0-15 represent the actual code lengths */
+        lengths[num++] = sym;
+        break;
+    }
+  }
+
+  /* build dynamic trees */
+  tinf_build_tree(lt, lengths, 0, hlit);
+  tinf_build_tree(dt, lengths, hlit, hdist);
+}
+
+/* ----------------------------- *
+ * -- block inflate functions -- *
+ * ----------------------------- */
+
+/* given a stream and two trees, inflate a block of data */
+function tinf_inflate_block_data(d, lt, dt) {
+  while (1) {
+    var sym = tinf_decode_symbol(d, lt);
+
+    /* check for end of block */
+    if (sym === 256) {
+      return TINF_OK;
+    }
+
+    if (sym < 256) {
+      d.dest[d.destLen++] = sym;
+    } else {
+      var length, dist, offs;
+      var i;
+
+      sym -= 257;
+
+      /* possibly get more bits from length code */
+      length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
+
+      dist = tinf_decode_symbol(d, dt);
+
+      /* possibly get more bits from distance code */
+      offs = d.destLen - tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
+
+      /* copy match */
+      for (i = offs; i < offs + length; ++i) {
+        d.dest[d.destLen++] = d.dest[i];
+      }
+    }
+  }
+}
+
+/* inflate an uncompressed block of data */
+function tinf_inflate_uncompressed_block(d) {
+  var length, invlength;
+  var i;
+  
+  /* unread from bitbuffer */
+  while (d.bitcount > 8) {
+    d.sourceIndex--;
+    d.bitcount -= 8;
+  }
+
+  /* get length */
+  length = d.source[d.sourceIndex + 1];
+  length = 256 * length + d.source[d.sourceIndex];
+
+  /* get one's complement of length */
+  invlength = d.source[d.sourceIndex + 3];
+  invlength = 256 * invlength + d.source[d.sourceIndex + 2];
+
+  /* check length */
+  if (length !== (~invlength & 0x0000ffff))
+    return TINF_DATA_ERROR;
+
+  d.sourceIndex += 4;
+
+  /* copy block */
+  for (i = length; i; --i)
+    d.dest[d.destLen++] = d.source[d.sourceIndex++];
+
+  /* make sure we start next block on a byte boundary */
+  d.bitcount = 0;
+
+  return TINF_OK;
+}
+
+/* inflate stream from source to dest */
+function tinf_uncompress(source, dest) {
+  var d = new Data(source, dest);
+  var bfinal, btype, res;
+
+  do {
+    /* read final block flag */
+    bfinal = tinf_getbit(d);
+
+    /* read block type (2 bits) */
+    btype = tinf_read_bits(d, 2, 0);
+
+    /* decompress block */
+    switch (btype) {
+      case 0:
+        /* decompress uncompressed block */
+        res = tinf_inflate_uncompressed_block(d);
+        break;
+      case 1:
+        /* decompress block with fixed huffman trees */
+        res = tinf_inflate_block_data(d, sltree, sdtree);
+        break;
+      case 2:
+        /* decompress block with dynamic huffman trees */
+        tinf_decode_trees(d, d.ltree, d.dtree);
+        res = tinf_inflate_block_data(d, d.ltree, d.dtree);
+        break;
+      default:
+        res = TINF_DATA_ERROR;
+    }
+
+    if (res !== TINF_OK)
+      throw new Error('Data error');
+
+  } while (!bfinal);
+
+  if (d.destLen < d.dest.length) {
+    if (typeof d.dest.slice === 'function')
+      return d.dest.slice(0, d.destLen);
+    else
+      return d.dest.subarray(0, d.destLen);
+  }
+  
+  return d.dest;
+}
+
+/* -------------------- *
+ * -- initialization -- *
+ * -------------------- */
+
+/* build fixed huffman trees */
+tinf_build_fixed_trees(sltree, sdtree);
+
+/* build extra bits and base tables */
+tinf_build_bits_base(length_bits, length_base, 4, 3);
+tinf_build_bits_base(dist_bits, dist_base, 2, 1);
+
+/* fix a special case */
+length_bits[28] = 0;
+length_base[28] = 258;
+
+module.exports = tinf_uncompress;

package/dist/server/node_modules/tiny-inflate/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "tiny-inflate",
+  "version": "1.0.3",
+  "description": "A tiny inflate implementation",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/devongovett/tiny-inflate.git"
+  },
+  "keywords": [
+    "inflate",
+    "zlib",
+    "gzip",
+    "zip"
+  ],
+  "author": "Devon Govett <devongovett@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/devongovett/tiny-inflate/issues"
+  },
+  "homepage": "https://github.com/devongovett/tiny-inflate",
+  "devDependencies": {
+    "mocha": "^2.1.0"
+  }
+}

package/dist/server/node_modules/tiny-inflate/readme.md

@@ -0,0 +1,31 @@
+# tiny-inflate
+
+This is a port of Joergen Ibsen's [tiny inflate](https://bitbucket.org/jibsen/tinf) to JavaScript.
+Minified it is about 3KB, or 1.3KB gzipped. While being very small, it is also reasonably fast
+(about 30% - 50% slower than [pako](https://github.com/nodeca/pako) on average), and should be 
+good enough for many applications. If you need the absolute best performance, however, you'll
+need to use a larger library such as pako that contains additional optimizations.
+
+## Installation
+
+    npm install tiny-inflate
+
+## Example
+
+To use tiny-inflate, you need two things: a buffer of data compressed with deflate,
+and the decompressed size (often stored in a file header) to allocate your output buffer.
+Input and output buffers can be either node `Buffer`s, or `Uint8Array`s.
+
+```javascript
+var inflate = require('tiny-inflate');
+
+var compressedBuffer = new Bufer([ ... ]);
+var decompressedSize = ...;
+var outputBuffer = new Buffer(decompressedSize);
+
+inflate(compressedBuffer, outputBuffer);
+```
+
+## License
+
+MIT

package/dist/server/node_modules/tiny-inflate/test/index.js

@@ -0,0 +1,75 @@
+var inflate = require('../');
+var zlib = require('zlib');
+var fs = require('fs');
+var assert = require('assert');
+var uncompressed = fs.readFileSync(__dirname + '/lorem.txt');
+
+describe('tiny-inflate', function() {
+  var compressed, noCompression, fixed;
+  
+  function deflate(buf, options, fn) {    
+    var chunks = [];
+    zlib.createDeflateRaw(options)
+      .on('data', function(chunk) {
+        chunks.push(chunk);
+      })
+      .on('error', fn)
+      .on('end', function() {
+        fn(null, Buffer.concat(chunks));
+      })
+      .end(buf);
+  }
+  
+  before(function(done) {
+    zlib.deflateRaw(uncompressed, function(err, data) {
+      compressed = data;
+      done();
+    });
+  });
+  
+  before(function(done) {
+    deflate(uncompressed, { level: zlib.Z_NO_COMPRESSION }, function(err, data) {
+      noCompression = data;
+      done();
+    });
+  });
+  
+  before(function(done) {
+    deflate(uncompressed, { strategy: zlib.Z_FIXED }, function(err, data) {
+      fixed = data;
+      done();
+    });
+  });
+  
+  it('should inflate some data', function() {
+    var out = Buffer.alloc(uncompressed.length);
+    inflate(compressed, out);
+    assert.deepEqual(out, uncompressed);
+  });
+  
+  it('should slice output buffer', function() {
+    var out = Buffer.alloc(uncompressed.length + 1024);
+    var res = inflate(compressed, out);
+    assert.deepEqual(res, uncompressed);
+    assert.equal(res.length, uncompressed.length);
+  });
+  
+  it('should handle uncompressed blocks', function() {
+    var out = Buffer.alloc(uncompressed.length);
+    inflate(noCompression, out);
+    assert.deepEqual(out, uncompressed);
+  });
+  
+  it('should handle fixed huffman blocks', function() {
+    var out = Buffer.alloc(uncompressed.length);
+    inflate(fixed, out);
+    assert.deepEqual(out, uncompressed);
+  });
+  
+  it('should handle typed arrays', function() {
+    var input = new Uint8Array(compressed);
+    var out = new Uint8Array(uncompressed.length);
+    inflate(input, out);
+    assert.deepEqual(out, new Uint8Array(uncompressed));
+  });
+});